aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/web/phpxmlrpclib
diff options
context:
space:
mode:
authorDavid Walter Seikel2016-11-03 21:44:39 +1000
committerDavid Walter Seikel2016-11-03 21:44:39 +1000
commit134f86e8d5c414409631b25b8c6f0ee45fbd8631 (patch)
tree216b89d3fb89acfb81be1e440c25c41ab09fa96d /web/phpxmlrpclib
parentMore changing to production grid. Double oops. (diff)
downloadopensim-SC-134f86e8d5c414409631b25b8c6f0ee45fbd8631.zip
opensim-SC-134f86e8d5c414409631b25b8c6f0ee45fbd8631.tar.gz
opensim-SC-134f86e8d5c414409631b25b8c6f0ee45fbd8631.tar.bz2
opensim-SC-134f86e8d5c414409631b25b8c6f0ee45fbd8631.tar.xz
Initial update to OpenSim 0.8.2.1 source code.
Diffstat (limited to 'web/phpxmlrpclib')
-rw-r--r--web/phpxmlrpclib/compat/array_key_exists.php55
-rw-r--r--web/phpxmlrpclib/compat/is_a.php47
-rw-r--r--web/phpxmlrpclib/compat/is_callable.php53
-rw-r--r--web/phpxmlrpclib/compat/is_scalar.php38
-rw-r--r--web/phpxmlrpclib/compat/var_export.php105
-rw-r--r--web/phpxmlrpclib/compat/version_compare.php179
-rw-r--r--web/phpxmlrpclib/xmlrpc.inc3718
-rw-r--r--web/phpxmlrpclib/xmlrpc_wrappers.inc944
-rw-r--r--web/phpxmlrpclib/xmlrpcs.inc1198
9 files changed, 0 insertions, 6337 deletions
diff --git a/web/phpxmlrpclib/compat/array_key_exists.php b/web/phpxmlrpclib/compat/array_key_exists.php
deleted file mode 100644
index 4a93ce4..0000000
--- a/web/phpxmlrpclib/compat/array_key_exists.php
+++ /dev/null
@@ -1,55 +0,0 @@
1<?php
2// +----------------------------------------------------------------------+
3// | PHP Version 4 |
4// +----------------------------------------------------------------------+
5// | Copyright (c) 1997-2004 The PHP Group |
6// +----------------------------------------------------------------------+
7// | This source file is subject to version 3.0 of the PHP license, |
8// | that is bundled with this package in the file LICENSE, and is |
9// | available at through the world-wide-web at |
10// | http://www.php.net/license/3_0.txt. |
11// | If you did not receive a copy of the PHP license and are unable to |
12// | obtain it through the world-wide-web, please send a note to |
13// | license@php.net so we can mail you a copy immediately. |
14// +----------------------------------------------------------------------+
15// | Authors: Aidan Lister <aidan@php.net> |
16// +----------------------------------------------------------------------+
17//
18// $Id: array_key_exists.php 2 2009-03-16 20:22:51Z ggiunta $
19
20
21/**
22 * Replace array_key_exists()
23 *
24 * @category PHP
25 * @package PHP_Compat
26 * @link http://php.net/function.array_key_exists
27 * @author Aidan Lister <aidan@php.net>
28 * @version $Revision: 1.1 $
29 * @since PHP 4.1.0
30 * @require PHP 4.0.0 (user_error)
31 */
32if (!function_exists('array_key_exists')) {
33 function array_key_exists($key, $search)
34 {
35 if (!is_scalar($key)) {
36 user_error('array_key_exists() The first argument should be either a string or an integer',
37 E_USER_WARNING);
38 return false;
39 }
40
41 if (is_object($search)) {
42 $search = get_object_vars($search);
43 }
44
45 if (!is_array($search)) {
46 user_error('array_key_exists() The second argument should be either an array or an object',
47 E_USER_WARNING);
48 return false;
49 }
50
51 return in_array($key, array_keys($search));
52 }
53}
54
55?> \ No newline at end of file
diff --git a/web/phpxmlrpclib/compat/is_a.php b/web/phpxmlrpclib/compat/is_a.php
deleted file mode 100644
index 2c5c129..0000000
--- a/web/phpxmlrpclib/compat/is_a.php
+++ /dev/null
@@ -1,47 +0,0 @@
1<?php
2// +----------------------------------------------------------------------+
3// | PHP Version 4 |
4// +----------------------------------------------------------------------+
5// | Copyright (c) 1997-2004 The PHP Group |
6// +----------------------------------------------------------------------+
7// | This source file is subject to version 3.0 of the PHP license, |
8// | that is bundled with this package in the file LICENSE, and is |
9// | available at through the world-wide-web at |
10// | http://www.php.net/license/3_0.txt. |
11// | If you did not receive a copy of the PHP license and are unable to |
12// | obtain it through the world-wide-web, please send a note to |
13// | license@php.net so we can mail you a copy immediately. |
14// +----------------------------------------------------------------------+
15// | Authors: Aidan Lister <aidan@php.net> |
16// +----------------------------------------------------------------------+
17//
18// $Id: is_a.php 2 2009-03-16 20:22:51Z ggiunta $
19
20
21/**
22 * Replace function is_a()
23 *
24 * @category PHP
25 * @package PHP_Compat
26 * @link http://php.net/function.is_a
27 * @author Aidan Lister <aidan@php.net>
28 * @version $Revision: 1.2 $
29 * @since PHP 4.2.0
30 * @require PHP 4.0.0 (user_error) (is_subclass_of)
31 */
32if (!function_exists('is_a')) {
33 function is_a($object, $class)
34 {
35 if (!is_object($object)) {
36 return false;
37 }
38
39 if (get_class($object) == strtolower($class)) {
40 return true;
41 } else {
42 return is_subclass_of($object, $class);
43 }
44 }
45}
46
47?> \ No newline at end of file
diff --git a/web/phpxmlrpclib/compat/is_callable.php b/web/phpxmlrpclib/compat/is_callable.php
deleted file mode 100644
index 419697a..0000000
--- a/web/phpxmlrpclib/compat/is_callable.php
+++ /dev/null
@@ -1,53 +0,0 @@
1<?php
2/**
3 * Replace function is_callable()
4 *
5 * @category PHP
6 * @package PHP_Compat
7 * @link http://php.net/function.is_callable
8 * @author Gaetano Giunta <giunta.gaetano@sea-aeroportimilano.it>
9 * @version $Id: is_callable.php 2 2009-03-16 20:22:51Z ggiunta $
10 * @since PHP 4.0.6
11 * @require PHP 4.0.0 (true, false, etc...)
12 * @todo add the 3rd parameter syntax...
13 */
14if (!function_exists('is_callable')) {
15 function is_callable($var, $syntax_only=false)
16 {
17 if ($syntax_only)
18 {
19 /* from The Manual:
20 * If the syntax_only argument is TRUE the function only verifies
21 * that var might be a function or method. It will only reject simple
22 * variables that are not strings, or an array that does not have a
23 * valid structure to be used as a callback. The valid ones are
24 * supposed to have only 2 entries, the first of which is an object
25 * or a string, and the second a string
26 */
27 return (is_string($var) || (is_array($var) && count($var) == 2 && is_string(end($var)) && (is_string(reset($var)) || is_object(reset($var)))));
28 }
29 else
30 {
31 if (is_string($var))
32 {
33 return function_exists($var);
34 }
35 else if (is_array($var) && count($var) == 2 && is_string($method = end($var)))
36 {
37 $obj = reset($var);
38 if (is_string($obj))
39 {
40 $methods = get_class_methods($obj);
41 return (bool)(is_array($methods) && in_array(strtolower($method), $methods));
42 }
43 else if (is_object($obj))
44 {
45 return method_exists($obj, $method);
46 }
47 }
48 return false;
49 }
50 }
51}
52
53?> \ No newline at end of file
diff --git a/web/phpxmlrpclib/compat/is_scalar.php b/web/phpxmlrpclib/compat/is_scalar.php
deleted file mode 100644
index dd87730..0000000
--- a/web/phpxmlrpclib/compat/is_scalar.php
+++ /dev/null
@@ -1,38 +0,0 @@
1<?php
2// +----------------------------------------------------------------------+
3// | PHP Version 4 |
4// +----------------------------------------------------------------------+
5// | Copyright (c) 1997-2004 The PHP Group |
6// +----------------------------------------------------------------------+
7// | This source file is subject to version 3.0 of the PHP license, |
8// | that is bundled with this package in the file LICENSE, and is |
9// | available at through the world-wide-web at |
10// | http://www.php.net/license/3_0.txt. |
11// | If you did not receive a copy of the PHP license and are unable to |
12// | obtain it through the world-wide-web, please send a note to |
13// | license@php.net so we can mail you a copy immediately. |
14// +----------------------------------------------------------------------+
15//
16// $Id: is_scalar.php 2 2009-03-16 20:22:51Z ggiunta $
17
18
19/**
20 * Replace is_scalar()
21 *
22 * @category PHP
23 * @package PHP_Compat
24 * @link http://php.net/function.is_scalar
25 * @author Gaetano Giunta
26 * @version $Revision: 1.2 $
27 * @since PHP 4.0.5
28 * @require PHP 4 (is_bool)
29 */
30if (!function_exists('is_scalar')) {
31 function is_scalar($val)
32 {
33 // Check input
34 return (is_bool($val) || is_int($val) || is_float($val) || is_string($val));
35 }
36}
37
38?> \ No newline at end of file
diff --git a/web/phpxmlrpclib/compat/var_export.php b/web/phpxmlrpclib/compat/var_export.php
deleted file mode 100644
index 7273a1e..0000000
--- a/web/phpxmlrpclib/compat/var_export.php
+++ /dev/null
@@ -1,105 +0,0 @@
1<?php
2// +----------------------------------------------------------------------+
3// | PHP Version 4 |
4// +----------------------------------------------------------------------+
5// | Copyright (c) 1997-2004 The PHP Group |
6// +----------------------------------------------------------------------+
7// | This source file is subject to version 3.0 of the PHP license, |
8// | that is bundled with this package in the file LICENSE, and is |
9// | available at through the world-wide-web at |
10// | http://www.php.net/license/3_0.txt. |
11// | If you did not receive a copy of the PHP license and are unable to |
12// | obtain it through the world-wide-web, please send a note to |
13// | license@php.net so we can mail you a copy immediately. |
14// +----------------------------------------------------------------------+
15// | Authors: Aidan Lister <aidan@php.net> |
16// +----------------------------------------------------------------------+
17//
18// $Id: var_export.php 2 2009-03-16 20:22:51Z ggiunta $
19
20
21/**
22 * Replace var_export()
23 *
24 * @category PHP
25 * @package PHP_Compat
26 * @link http://php.net/function.var_export
27 * @author Aidan Lister <aidan@php.net>
28 * @version $Revision: 1.2 $
29 * @since PHP 4.2.0
30 * @require PHP 4.0.0 (user_error)
31 */
32if (!function_exists('var_export')) {
33 function var_export($array, $return = false, $lvl=0)
34 {
35 // Common output variables
36 $indent = ' ';
37 $doublearrow = ' => ';
38 $lineend = ",\n";
39 $stringdelim = '\'';
40
41 // Check the export isn't a simple string / int
42 if (is_string($array)) {
43 $out = $stringdelim . str_replace('\'', '\\\'', str_replace('\\', '\\\\', $array)) . $stringdelim;
44 } elseif (is_int($array) || is_float($array)) {
45 $out = (string)$array;
46 } elseif (is_bool($array)) {
47 $out = $array ? 'true' : 'false';
48 } elseif (is_null($array)) {
49 $out = 'NULL';
50 } elseif (is_resource($array)) {
51 $out = 'resource';
52 } else {
53 // Begin the array export
54 // Start the string
55 $out = "array (\n";
56
57 // Loop through each value in array
58 foreach ($array as $key => $value) {
59 // If the key is a string, delimit it
60 if (is_string($key)) {
61 $key = str_replace('\'', '\\\'', str_replace('\\', '\\\\', $key));
62 $key = $stringdelim . $key . $stringdelim;
63 }
64
65 $val = var_export($value, true, $lvl+1);
66 // Delimit value
67 /*if (is_array($value)) {
68 // We have an array, so do some recursion
69 // Do some basic recursion while increasing the indent
70 $recur_array = explode($newline, var_export($value, true));
71 $temp_array = array();
72 foreach ($recur_array as $recur_line) {
73 $temp_array[] = $indent . $recur_line;
74 }
75 $recur_array = implode($newline, $temp_array);
76 $value = $newline . $recur_array;
77 } elseif (is_null($value)) {
78 $value = 'NULL';
79 } else {
80 $value = str_replace($find, $replace, $value);
81 $value = $stringdelim . $value . $stringdelim;
82 }*/
83
84 // Piece together the line
85 for ($i = 0; $i < $lvl; $i++)
86 $out .= $indent;
87 $out .= $key . $doublearrow . $val . $lineend;
88 }
89
90 // End our string
91 for ($i = 0; $i < $lvl; $i++)
92 $out .= $indent;
93 $out .= ")";
94 }
95
96 // Decide method of output
97 if ($return === true) {
98 return $out;
99 } else {
100 echo $out;
101 return;
102 }
103 }
104}
105?> \ No newline at end of file
diff --git a/web/phpxmlrpclib/compat/version_compare.php b/web/phpxmlrpclib/compat/version_compare.php
deleted file mode 100644
index a1211ea..0000000
--- a/web/phpxmlrpclib/compat/version_compare.php
+++ /dev/null
@@ -1,179 +0,0 @@
1<?php
2// +----------------------------------------------------------------------+
3// | PHP Version 4 |
4// +----------------------------------------------------------------------+
5// | Copyright (c) 1997-2004 The PHP Group |
6// +----------------------------------------------------------------------+
7// | This source file is subject to version 3.0 of the PHP license, |
8// | that is bundled with this package in the file LICENSE, and is |
9// | available at through the world-wide-web at |
10// | http://www.php.net/license/3_0.txt. |
11// | If you did not receive a copy of the PHP license and are unable to |
12// | obtain it through the world-wide-web, please send a note to |
13// | license@php.net so we can mail you a copy immediately. |
14// +----------------------------------------------------------------------+
15// | Authors: Philippe Jausions <Philippe.Jausions@11abacus.com> |
16// | Aidan Lister <aidan@php.net> |
17// +----------------------------------------------------------------------+
18//
19// $Id: version_compare.php 2 2009-03-16 20:22:51Z ggiunta $
20
21
22/**
23 * Replace version_compare()
24 *
25 * @category PHP
26 * @package PHP_Compat
27 * @link http://php.net/function.version_compare
28 * @author Philippe Jausions <Philippe.Jausions@11abacus.com>
29 * @author Aidan Lister <aidan@php.net>
30 * @version $Revision: 1.1 $
31 * @since PHP 4.1.0
32 * @require PHP 4.0.0 (user_error)
33 */
34if (!function_exists('version_compare')) {
35 function version_compare($version1, $version2, $operator = '<')
36 {
37 // Check input
38 if (!is_scalar($version1)) {
39 user_error('version_compare() expects parameter 1 to be string, ' .
40 gettype($version1) . ' given', E_USER_WARNING);
41 return;
42 }
43
44 if (!is_scalar($version2)) {
45 user_error('version_compare() expects parameter 2 to be string, ' .
46 gettype($version2) . ' given', E_USER_WARNING);
47 return;
48 }
49
50 if (!is_scalar($operator)) {
51 user_error('version_compare() expects parameter 3 to be string, ' .
52 gettype($operator) . ' given', E_USER_WARNING);
53 return;
54 }
55
56 // Standardise versions
57 $v1 = explode('.',
58 str_replace('..', '.',
59 preg_replace('/([^0-9\.]+)/', '.$1.',
60 str_replace(array('-', '_', '+'), '.',
61 trim($version1)))));
62
63 $v2 = explode('.',
64 str_replace('..', '.',
65 preg_replace('/([^0-9\.]+)/', '.$1.',
66 str_replace(array('-', '_', '+'), '.',
67 trim($version2)))));
68
69 // Replace empty entries at the start of the array
70 while (empty($v1[0]) && array_shift($v1)) {}
71 while (empty($v2[0]) && array_shift($v2)) {}
72
73 // Release state order
74 // '#' stands for any number
75 $versions = array(
76 'dev' => 0,
77 'alpha' => 1,
78 'a' => 1,
79 'beta' => 2,
80 'b' => 2,
81 'RC' => 3,
82 '#' => 4,
83 'p' => 5,
84 'pl' => 5);
85
86 // Loop through each segment in the version string
87 $compare = 0;
88 for ($i = 0, $x = min(count($v1), count($v2)); $i < $x; $i++) {
89 if ($v1[$i] == $v2[$i]) {
90 continue;
91 }
92 $i1 = $v1[$i];
93 $i2 = $v2[$i];
94 if (is_numeric($i1) && is_numeric($i2)) {
95 $compare = ($i1 < $i2) ? -1 : 1;
96 break;
97 }
98 // We use the position of '#' in the versions list
99 // for numbers... (so take care of # in original string)
100 if ($i1 == '#') {
101 $i1 = '';
102 } elseif (is_numeric($i1)) {
103 $i1 = '#';
104 }
105 if ($i2 == '#') {
106 $i2 = '';
107 } elseif (is_numeric($i2)) {
108 $i2 = '#';
109 }
110 if (isset($versions[$i1]) && isset($versions[$i2])) {
111 $compare = ($versions[$i1] < $versions[$i2]) ? -1 : 1;
112 } elseif (isset($versions[$i1])) {
113 $compare = 1;
114 } elseif (isset($versions[$i2])) {
115 $compare = -1;
116 } else {
117 $compare = 0;
118 }
119
120 break;
121 }
122
123 // If previous loop didn't find anything, compare the "extra" segments
124 if ($compare == 0) {
125 if (count($v2) > count($v1)) {
126 if (isset($versions[$v2[$i]])) {
127 $compare = ($versions[$v2[$i]] < 4) ? 1 : -1;
128 } else {
129 $compare = -1;
130 }
131 } elseif (count($v2) < count($v1)) {
132 if (isset($versions[$v1[$i]])) {
133 $compare = ($versions[$v1[$i]] < 4) ? -1 : 1;
134 } else {
135 $compare = 1;
136 }
137 }
138 }
139
140 // Compare the versions
141 if (func_num_args() > 2) {
142 switch ($operator) {
143 case '>':
144 case 'gt':
145 return (bool) ($compare > 0);
146 break;
147 case '>=':
148 case 'ge':
149 return (bool) ($compare >= 0);
150 break;
151 case '<=':
152 case 'le':
153 return (bool) ($compare <= 0);
154 break;
155 case '==':
156 case '=':
157 case 'eq':
158 return (bool) ($compare == 0);
159 break;
160 case '<>':
161 case '!=':
162 case 'ne':
163 return (bool) ($compare != 0);
164 break;
165 case '':
166 case '<':
167 case 'lt':
168 return (bool) ($compare < 0);
169 break;
170 default:
171 return;
172 }
173 }
174
175 return $compare;
176 }
177}
178
179?> \ No newline at end of file
diff --git a/web/phpxmlrpclib/xmlrpc.inc b/web/phpxmlrpclib/xmlrpc.inc
deleted file mode 100644
index a050d35..0000000
--- a/web/phpxmlrpclib/xmlrpc.inc
+++ /dev/null
@@ -1,3718 +0,0 @@
1<?php
2// by Edd Dumbill (C) 1999-2002
3// <edd@usefulinc.com>
4// $Id: xmlrpc.inc,v 1.174 2009/03/16 19:36:38 ggiunta Exp $
5
6// Copyright (c) 1999,2000,2002 Edd Dumbill.
7// All rights reserved.
8//
9// Redistribution and use in source and binary forms, with or without
10// modification, are permitted provided that the following conditions
11// are met:
12//
13// * Redistributions of source code must retain the above copyright
14// notice, this list of conditions and the following disclaimer.
15//
16// * Redistributions in binary form must reproduce the above
17// copyright notice, this list of conditions and the following
18// disclaimer in the documentation and/or other materials provided
19// with the distribution.
20//
21// * Neither the name of the "XML-RPC for PHP" nor the names of its
22// contributors may be used to endorse or promote products derived
23// from this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
28// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
29// REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
30// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
31// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
32// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
34// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
36// OF THE POSSIBILITY OF SUCH DAMAGE.
37
38 if(!function_exists('xml_parser_create'))
39 {
40 // For PHP 4 onward, XML functionality is always compiled-in on windows:
41 // no more need to dl-open it. It might have been compiled out on *nix...
42 if(strtoupper(substr(PHP_OS, 0, 3) != 'WIN'))
43 {
44 dl('xml.so');
45 }
46 }
47
48 // Try to be backward compat with php < 4.2 (are we not being nice ?)
49 $phpversion = phpversion();
50 if($phpversion[0] == '4' && $phpversion[2] < 2)
51 {
52 // give an opportunity to user to specify where to include other files from
53 if(!defined('PHP_XMLRPC_COMPAT_DIR'))
54 {
55 define('PHP_XMLRPC_COMPAT_DIR',dirname(__FILE__).'/compat/');
56 }
57 if($phpversion[2] == '0')
58 {
59 if($phpversion[4] < 6)
60 {
61 include(PHP_XMLRPC_COMPAT_DIR.'is_callable.php');
62 }
63 include(PHP_XMLRPC_COMPAT_DIR.'is_scalar.php');
64 include(PHP_XMLRPC_COMPAT_DIR.'array_key_exists.php');
65 include(PHP_XMLRPC_COMPAT_DIR.'version_compare.php');
66 }
67 include(PHP_XMLRPC_COMPAT_DIR.'var_export.php');
68 include(PHP_XMLRPC_COMPAT_DIR.'is_a.php');
69 }
70
71 // G. Giunta 2005/01/29: declare global these variables,
72 // so that xmlrpc.inc will work even if included from within a function
73 // Milosch: 2005/08/07 - explicitly request these via $GLOBALS where used.
74 $GLOBALS['xmlrpcI4']='i4';
75 $GLOBALS['xmlrpcInt']='int';
76 $GLOBALS['xmlrpcBoolean']='boolean';
77 $GLOBALS['xmlrpcDouble']='double';
78 $GLOBALS['xmlrpcString']='string';
79 $GLOBALS['xmlrpcDateTime']='dateTime.iso8601';
80 $GLOBALS['xmlrpcBase64']='base64';
81 $GLOBALS['xmlrpcArray']='array';
82 $GLOBALS['xmlrpcStruct']='struct';
83 $GLOBALS['xmlrpcValue']='undefined';
84
85 $GLOBALS['xmlrpcTypes']=array(
86 $GLOBALS['xmlrpcI4'] => 1,
87 $GLOBALS['xmlrpcInt'] => 1,
88 $GLOBALS['xmlrpcBoolean'] => 1,
89 $GLOBALS['xmlrpcString'] => 1,
90 $GLOBALS['xmlrpcDouble'] => 1,
91 $GLOBALS['xmlrpcDateTime'] => 1,
92 $GLOBALS['xmlrpcBase64'] => 1,
93 $GLOBALS['xmlrpcArray'] => 2,
94 $GLOBALS['xmlrpcStruct'] => 3
95 );
96
97 $GLOBALS['xmlrpc_valid_parents'] = array(
98 'VALUE' => array('MEMBER', 'DATA', 'PARAM', 'FAULT'),
99 'BOOLEAN' => array('VALUE'),
100 'I4' => array('VALUE'),
101 'INT' => array('VALUE'),
102 'STRING' => array('VALUE'),
103 'DOUBLE' => array('VALUE'),
104 'DATETIME.ISO8601' => array('VALUE'),
105 'BASE64' => array('VALUE'),
106 'MEMBER' => array('STRUCT'),
107 'NAME' => array('MEMBER'),
108 'DATA' => array('ARRAY'),
109 'ARRAY' => array('VALUE'),
110 'STRUCT' => array('VALUE'),
111 'PARAM' => array('PARAMS'),
112 'METHODNAME' => array('METHODCALL'),
113 'PARAMS' => array('METHODCALL', 'METHODRESPONSE'),
114 'FAULT' => array('METHODRESPONSE'),
115 'NIL' => array('VALUE') // only used when extension activated
116 );
117
118 // define extra types for supporting NULL (useful for json or <NIL/>)
119 $GLOBALS['xmlrpcNull']='null';
120 $GLOBALS['xmlrpcTypes']['null']=1;
121
122 // Not in use anymore since 2.0. Shall we remove it?
123 /// @deprecated
124 $GLOBALS['xmlEntities']=array(
125 'amp' => '&',
126 'quot' => '"',
127 'lt' => '<',
128 'gt' => '>',
129 'apos' => "'"
130 );
131
132 // tables used for transcoding different charsets into us-ascii xml
133
134 $GLOBALS['xml_iso88591_Entities']=array();
135 $GLOBALS['xml_iso88591_Entities']['in'] = array();
136 $GLOBALS['xml_iso88591_Entities']['out'] = array();
137 for ($i = 0; $i < 32; $i++)
138 {
139 $GLOBALS['xml_iso88591_Entities']['in'][] = chr($i);
140 $GLOBALS['xml_iso88591_Entities']['out'][] = '&#'.$i.';';
141 }
142 for ($i = 160; $i < 256; $i++)
143 {
144 $GLOBALS['xml_iso88591_Entities']['in'][] = chr($i);
145 $GLOBALS['xml_iso88591_Entities']['out'][] = '&#'.$i.';';
146 }
147
148 /// @todo add to iso table the characters from cp_1252 range, i.e. 128 to 159?
149 /// These will NOT be present in true ISO-8859-1, but will save the unwary
150 /// windows user from sending junk (though no luck when reciving them...)
151 /*
152 $GLOBALS['xml_cp1252_Entities']=array();
153 for ($i = 128; $i < 160; $i++)
154 {
155 $GLOBALS['xml_cp1252_Entities']['in'][] = chr($i);
156 }
157 $GLOBALS['xml_cp1252_Entities']['out'] = array(
158 '&#x20AC;', '?', '&#x201A;', '&#x0192;',
159 '&#x201E;', '&#x2026;', '&#x2020;', '&#x2021;',
160 '&#x02C6;', '&#x2030;', '&#x0160;', '&#x2039;',
161 '&#x0152;', '?', '&#x017D;', '?',
162 '?', '&#x2018;', '&#x2019;', '&#x201C;',
163 '&#x201D;', '&#x2022;', '&#x2013;', '&#x2014;',
164 '&#x02DC;', '&#x2122;', '&#x0161;', '&#x203A;',
165 '&#x0153;', '?', '&#x017E;', '&#x0178;'
166 );
167 */
168
169 $GLOBALS['xmlrpcerr'] = array(
170 'unknown_method'=>1,
171 'invalid_return'=>2,
172 'incorrect_params'=>3,
173 'introspect_unknown'=>4,
174 'http_error'=>5,
175 'no_data'=>6,
176 'no_ssl'=>7,
177 'curl_fail'=>8,
178 'invalid_request'=>15,
179 'no_curl'=>16,
180 'server_error'=>17,
181 'multicall_error'=>18,
182 'multicall_notstruct'=>9,
183 'multicall_nomethod'=>10,
184 'multicall_notstring'=>11,
185 'multicall_recursion'=>12,
186 'multicall_noparams'=>13,
187 'multicall_notarray'=>14,
188
189 'cannot_decompress'=>103,
190 'decompress_fail'=>104,
191 'dechunk_fail'=>105,
192 'server_cannot_decompress'=>106,
193 'server_decompress_fail'=>107
194 );
195
196 $GLOBALS['xmlrpcstr'] = array(
197 'unknown_method'=>'Unknown method',
198 'invalid_return'=>'Invalid return payload: enable debugging to examine incoming payload',
199 'incorrect_params'=>'Incorrect parameters passed to method',
200 'introspect_unknown'=>"Can't introspect: method unknown",
201 'http_error'=>"Didn't receive 200 OK from remote server.",
202 'no_data'=>'No data received from server.',
203 'no_ssl'=>'No SSL support compiled in.',
204 'curl_fail'=>'CURL error',
205 'invalid_request'=>'Invalid request payload',
206 'no_curl'=>'No CURL support compiled in.',
207 'server_error'=>'Internal server error',
208 'multicall_error'=>'Received from server invalid multicall response',
209 'multicall_notstruct'=>'system.multicall expected struct',
210 'multicall_nomethod'=>'missing methodName',
211 'multicall_notstring'=>'methodName is not a string',
212 'multicall_recursion'=>'recursive system.multicall forbidden',
213 'multicall_noparams'=>'missing params',
214 'multicall_notarray'=>'params is not an array',
215
216 'cannot_decompress'=>'Received from server compressed HTTP and cannot decompress',
217 'decompress_fail'=>'Received from server invalid compressed HTTP',
218 'dechunk_fail'=>'Received from server invalid chunked HTTP',
219 'server_cannot_decompress'=>'Received from client compressed HTTP request and cannot decompress',
220 'server_decompress_fail'=>'Received from client invalid compressed HTTP request'
221 );
222
223 // The charset encoding used by the server for received messages and
224 // by the client for received responses when received charset cannot be determined
225 // or is not supported
226 $GLOBALS['xmlrpc_defencoding']='UTF-8';
227
228 // The encoding used internally by PHP.
229 // String values received as xml will be converted to this, and php strings will be converted to xml
230 // as if having been coded with this
231 $GLOBALS['xmlrpc_internalencoding']='ISO-8859-1';
232
233 $GLOBALS['xmlrpcName']='XML-RPC for PHP';
234 $GLOBALS['xmlrpcVersion']='2.2.2';
235
236 // let user errors start at 800
237 $GLOBALS['xmlrpcerruser']=800;
238 // let XML parse errors start at 100
239 $GLOBALS['xmlrpcerrxml']=100;
240
241 // formulate backslashes for escaping regexp
242 // Not in use anymore since 2.0. Shall we remove it?
243 /// @deprecated
244 $GLOBALS['xmlrpc_backslash']=chr(92).chr(92);
245
246 // set to TRUE to enable correct decoding of <NIL/> values
247 $GLOBALS['xmlrpc_null_extension']=false;
248
249 // used to store state during parsing
250 // quick explanation of components:
251 // ac - used to accumulate values
252 // isf - used to indicate a parsing fault (2) or xmlrpcresp fault (1)
253 // isf_reason - used for storing xmlrpcresp fault string
254 // lv - used to indicate "looking for a value": implements
255 // the logic to allow values with no types to be strings
256 // params - used to store parameters in method calls
257 // method - used to store method name
258 // stack - array with genealogy of xml elements names:
259 // used to validate nesting of xmlrpc elements
260 $GLOBALS['_xh']=null;
261
262 /**
263 * Convert a string to the correct XML representation in a target charset
264 * To help correct communication of non-ascii chars inside strings, regardless
265 * of the charset used when sending requests, parsing them, sending responses
266 * and parsing responses, an option is to convert all non-ascii chars present in the message
267 * into their equivalent 'charset entity'. Charset entities enumerated this way
268 * are independent of the charset encoding used to transmit them, and all XML
269 * parsers are bound to understand them.
270 * Note that in the std case we are not sending a charset encoding mime type
271 * along with http headers, so we are bound by RFC 3023 to emit strict us-ascii.
272 *
273 * @todo do a bit of basic benchmarking (strtr vs. str_replace)
274 * @todo make usage of iconv() or recode_string() or mb_string() where available
275 */
276 function xmlrpc_encode_entitites($data, $src_encoding='', $dest_encoding='')
277 {
278 if ($src_encoding == '')
279 {
280 // lame, but we know no better...
281 $src_encoding = $GLOBALS['xmlrpc_internalencoding'];
282 }
283
284 switch(strtoupper($src_encoding.'_'.$dest_encoding))
285 {
286 case 'ISO-8859-1_':
287 case 'ISO-8859-1_US-ASCII':
288 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&amp;', '&quot;', '&apos;', '&lt;', '&gt;'), $data);
289 $escaped_data = str_replace($GLOBALS['xml_iso88591_Entities']['in'], $GLOBALS['xml_iso88591_Entities']['out'], $escaped_data);
290 break;
291 case 'ISO-8859-1_UTF-8':
292 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&amp;', '&quot;', '&apos;', '&lt;', '&gt;'), $data);
293 $escaped_data = utf8_encode($escaped_data);
294 break;
295 case 'ISO-8859-1_ISO-8859-1':
296 case 'US-ASCII_US-ASCII':
297 case 'US-ASCII_UTF-8':
298 case 'US-ASCII_':
299 case 'US-ASCII_ISO-8859-1':
300 case 'UTF-8_UTF-8':
301 //case 'CP1252_CP1252':
302 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&amp;', '&quot;', '&apos;', '&lt;', '&gt;'), $data);
303 break;
304 case 'UTF-8_':
305 case 'UTF-8_US-ASCII':
306 case 'UTF-8_ISO-8859-1':
307 // NB: this will choke on invalid UTF-8, going most likely beyond EOF
308 $escaped_data = '';
309 // be kind to users creating string xmlrpcvals out of different php types
310 $data = (string) $data;
311 $ns = strlen ($data);
312 for ($nn = 0; $nn < $ns; $nn++)
313 {
314 $ch = $data[$nn];
315 $ii = ord($ch);
316 //1 7 0bbbbbbb (127)
317 if ($ii < 128)
318 {
319 /// @todo shall we replace this with a (supposedly) faster str_replace?
320 switch($ii){
321 case 34:
322 $escaped_data .= '&quot;';
323 break;
324 case 38:
325 $escaped_data .= '&amp;';
326 break;
327 case 39:
328 $escaped_data .= '&apos;';
329 break;
330 case 60:
331 $escaped_data .= '&lt;';
332 break;
333 case 62:
334 $escaped_data .= '&gt;';
335 break;
336 default:
337 $escaped_data .= $ch;
338 } // switch
339 }
340 //2 11 110bbbbb 10bbbbbb (2047)
341 else if ($ii>>5 == 6)
342 {
343 $b1 = ($ii & 31);
344 $ii = ord($data[$nn+1]);
345 $b2 = ($ii & 63);
346 $ii = ($b1 * 64) + $b2;
347 $ent = sprintf ('&#%d;', $ii);
348 $escaped_data .= $ent;
349 $nn += 1;
350 }
351 //3 16 1110bbbb 10bbbbbb 10bbbbbb
352 else if ($ii>>4 == 14)
353 {
354 $b1 = ($ii & 15);
355 $ii = ord($data[$nn+1]);
356 $b2 = ($ii & 63);
357 $ii = ord($data[$nn+2]);
358 $b3 = ($ii & 63);
359 $ii = ((($b1 * 64) + $b2) * 64) + $b3;
360 $ent = sprintf ('&#%d;', $ii);
361 $escaped_data .= $ent;
362 $nn += 2;
363 }
364 //4 21 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
365 else if ($ii>>3 == 30)
366 {
367 $b1 = ($ii & 7);
368 $ii = ord($data[$nn+1]);
369 $b2 = ($ii & 63);
370 $ii = ord($data[$nn+2]);
371 $b3 = ($ii & 63);
372 $ii = ord($data[$nn+3]);
373 $b4 = ($ii & 63);
374 $ii = ((((($b1 * 64) + $b2) * 64) + $b3) * 64) + $b4;
375 $ent = sprintf ('&#%d;', $ii);
376 $escaped_data .= $ent;
377 $nn += 3;
378 }
379 }
380 break;
381/*
382 case 'CP1252_':
383 case 'CP1252_US-ASCII':
384 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&amp;', '&quot;', '&apos;', '&lt;', '&gt;'), $data);
385 $escaped_data = str_replace($GLOBALS['xml_iso88591_Entities']['in'], $GLOBALS['xml_iso88591_Entities']['out'], $escaped_data);
386 $escaped_data = str_replace($GLOBALS['xml_cp1252_Entities']['in'], $GLOBALS['xml_cp1252_Entities']['out'], $escaped_data);
387 break;
388 case 'CP1252_UTF-8':
389 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&amp;', '&quot;', '&apos;', '&lt;', '&gt;'), $data);
390 /// @todo we could use real UTF8 chars here instead of xml entities... (note that utf_8 encode all allone will NOT convert them)
391 $escaped_data = str_replace($GLOBALS['xml_cp1252_Entities']['in'], $GLOBALS['xml_cp1252_Entities']['out'], $escaped_data);
392 $escaped_data = utf8_encode($escaped_data);
393 break;
394 case 'CP1252_ISO-8859-1':
395 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&amp;', '&quot;', '&apos;', '&lt;', '&gt;'), $data);
396 // 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...
397 $escaped_data = str_replace($GLOBALS['xml_cp1252_Entities']['in'], $GLOBALS['xml_cp1252_Entities']['out'], $escaped_data);
398 break;
399*/
400 default:
401 $escaped_data = '';
402 error_log("Converting from $src_encoding to $dest_encoding: not supported...");
403 }
404 return $escaped_data;
405 }
406
407 /// xml parser handler function for opening element tags
408 function xmlrpc_se($parser, $name, $attrs, $accept_single_vals=false)
409 {
410 // if invalid xmlrpc already detected, skip all processing
411 if ($GLOBALS['_xh']['isf'] < 2)
412 {
413 // check for correct element nesting
414 // top level element can only be of 2 types
415 /// @todo optimization creep: save this check into a bool variable, instead of using count() every time:
416 /// there is only a single top level element in xml anyway
417 if (count($GLOBALS['_xh']['stack']) == 0)
418 {
419 if ($name != 'METHODRESPONSE' && $name != 'METHODCALL' && (
420 $name != 'VALUE' && !$accept_single_vals))
421 {
422 $GLOBALS['_xh']['isf'] = 2;
423 $GLOBALS['_xh']['isf_reason'] = 'missing top level xmlrpc element';
424 return;
425 }
426 else
427 {
428 $GLOBALS['_xh']['rt'] = strtolower($name);
429 }
430 }
431 else
432 {
433 // not top level element: see if parent is OK
434 $parent = end($GLOBALS['_xh']['stack']);
435 if (!array_key_exists($name, $GLOBALS['xmlrpc_valid_parents']) || !in_array($parent, $GLOBALS['xmlrpc_valid_parents'][$name]))
436 {
437 $GLOBALS['_xh']['isf'] = 2;
438 $GLOBALS['_xh']['isf_reason'] = "xmlrpc element $name cannot be child of $parent";
439 return;
440 }
441 }
442
443 switch($name)
444 {
445 // optimize for speed switch cases: most common cases first
446 case 'VALUE':
447 /// @todo we could check for 2 VALUE elements inside a MEMBER or PARAM element
448 $GLOBALS['_xh']['vt']='value'; // indicator: no value found yet
449 $GLOBALS['_xh']['ac']='';
450 $GLOBALS['_xh']['lv']=1;
451 $GLOBALS['_xh']['php_class']=null;
452 break;
453 case 'I4':
454 case 'INT':
455 case 'STRING':
456 case 'BOOLEAN':
457 case 'DOUBLE':
458 case 'DATETIME.ISO8601':
459 case 'BASE64':
460 if ($GLOBALS['_xh']['vt']!='value')
461 {
462 //two data elements inside a value: an error occurred!
463 $GLOBALS['_xh']['isf'] = 2;
464 $GLOBALS['_xh']['isf_reason'] = "$name element following a {$GLOBALS['_xh']['vt']} element inside a single value";
465 return;
466 }
467 $GLOBALS['_xh']['ac']=''; // reset the accumulator
468 break;
469 case 'STRUCT':
470 case 'ARRAY':
471 if ($GLOBALS['_xh']['vt']!='value')
472 {
473 //two data elements inside a value: an error occurred!
474 $GLOBALS['_xh']['isf'] = 2;
475 $GLOBALS['_xh']['isf_reason'] = "$name element following a {$GLOBALS['_xh']['vt']} element inside a single value";
476 return;
477 }
478 // create an empty array to hold child values, and push it onto appropriate stack
479 $cur_val = array();
480 $cur_val['values'] = array();
481 $cur_val['type'] = $name;
482 // check for out-of-band information to rebuild php objs
483 // and in case it is found, save it
484 if (@isset($attrs['PHP_CLASS']))
485 {
486 $cur_val['php_class'] = $attrs['PHP_CLASS'];
487 }
488 $GLOBALS['_xh']['valuestack'][] = $cur_val;
489 $GLOBALS['_xh']['vt']='data'; // be prepared for a data element next
490 break;
491 case 'DATA':
492 if ($GLOBALS['_xh']['vt']!='data')
493 {
494 //two data elements inside a value: an error occurred!
495 $GLOBALS['_xh']['isf'] = 2;
496 $GLOBALS['_xh']['isf_reason'] = "found two data elements inside an array element";
497 return;
498 }
499 case 'METHODCALL':
500 case 'METHODRESPONSE':
501 case 'PARAMS':
502 // valid elements that add little to processing
503 break;
504 case 'METHODNAME':
505 case 'NAME':
506 /// @todo we could check for 2 NAME elements inside a MEMBER element
507 $GLOBALS['_xh']['ac']='';
508 break;
509 case 'FAULT':
510 $GLOBALS['_xh']['isf']=1;
511 break;
512 case 'MEMBER':
513 $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
514 //$GLOBALS['_xh']['ac']='';
515 // Drop trough intentionally
516 case 'PARAM':
517 // clear value type, so we can check later if no value has been passed for this param/member
518 $GLOBALS['_xh']['vt']=null;
519 break;
520 case 'NIL':
521 if ($GLOBALS['xmlrpc_null_extension'])
522 {
523 if ($GLOBALS['_xh']['vt']!='value')
524 {
525 //two data elements inside a value: an error occurred!
526 $GLOBALS['_xh']['isf'] = 2;
527 $GLOBALS['_xh']['isf_reason'] = "$name element following a {$GLOBALS['_xh']['vt']} element inside a single value";
528 return;
529 }
530 $GLOBALS['_xh']['ac']=''; // reset the accumulator
531 break;
532 }
533 // we do not support the <NIL/> extension, so
534 // drop through intentionally
535 default:
536 /// INVALID ELEMENT: RAISE ISF so that it is later recognized!!!
537 $GLOBALS['_xh']['isf'] = 2;
538 $GLOBALS['_xh']['isf_reason'] = "found not-xmlrpc xml element $name";
539 break;
540 }
541
542 // Save current element name to stack, to validate nesting
543 $GLOBALS['_xh']['stack'][] = $name;
544
545 /// @todo optimization creep: move this inside the big switch() above
546 if($name!='VALUE')
547 {
548 $GLOBALS['_xh']['lv']=0;
549 }
550 }
551 }
552
553 /// Used in decoding xml chunks that might represent single xmlrpc values
554 function xmlrpc_se_any($parser, $name, $attrs)
555 {
556 xmlrpc_se($parser, $name, $attrs, true);
557 }
558
559 /// xml parser handler function for close element tags
560 function xmlrpc_ee($parser, $name, $rebuild_xmlrpcvals = true)
561 {
562 if ($GLOBALS['_xh']['isf'] < 2)
563 {
564 // push this element name from stack
565 // NB: if XML validates, correct opening/closing is guaranteed and
566 // we do not have to check for $name == $curr_elem.
567 // we also checked for proper nesting at start of elements...
568 $curr_elem = array_pop($GLOBALS['_xh']['stack']);
569
570 switch($name)
571 {
572 case 'VALUE':
573 // This if() detects if no scalar was inside <VALUE></VALUE>
574 if ($GLOBALS['_xh']['vt']=='value')
575 {
576 $GLOBALS['_xh']['value']=$GLOBALS['_xh']['ac'];
577 $GLOBALS['_xh']['vt']=$GLOBALS['xmlrpcString'];
578 }
579
580 if ($rebuild_xmlrpcvals)
581 {
582 // build the xmlrpc val out of the data received, and substitute it
583 $temp = new xmlrpcval($GLOBALS['_xh']['value'], $GLOBALS['_xh']['vt']);
584 // in case we got info about underlying php class, save it
585 // in the object we're rebuilding
586 if (isset($GLOBALS['_xh']['php_class']))
587 $temp->_php_class = $GLOBALS['_xh']['php_class'];
588 // check if we are inside an array or struct:
589 // if value just built is inside an array, let's move it into array on the stack
590 $vscount = count($GLOBALS['_xh']['valuestack']);
591 if ($vscount && $GLOBALS['_xh']['valuestack'][$vscount-1]['type']=='ARRAY')
592 {
593 $GLOBALS['_xh']['valuestack'][$vscount-1]['values'][] = $temp;
594 }
595 else
596 {
597 $GLOBALS['_xh']['value'] = $temp;
598 }
599 }
600 else
601 {
602 /// @todo this needs to treat correctly php-serialized objects,
603 /// since std deserializing is done by php_xmlrpc_decode,
604 /// which we will not be calling...
605 if (isset($GLOBALS['_xh']['php_class']))
606 {
607 }
608
609 // check if we are inside an array or struct:
610 // if value just built is inside an array, let's move it into array on the stack
611 $vscount = count($GLOBALS['_xh']['valuestack']);
612 if ($vscount && $GLOBALS['_xh']['valuestack'][$vscount-1]['type']=='ARRAY')
613 {
614 $GLOBALS['_xh']['valuestack'][$vscount-1]['values'][] = $GLOBALS['_xh']['value'];
615 }
616 }
617 break;
618 case 'BOOLEAN':
619 case 'I4':
620 case 'INT':
621 case 'STRING':
622 case 'DOUBLE':
623 case 'DATETIME.ISO8601':
624 case 'BASE64':
625 $GLOBALS['_xh']['vt']=strtolower($name);
626 /// @todo: optimization creep - remove the if/elseif cycle below
627 /// since the case() in which we are already did that
628 if ($name=='STRING')
629 {
630 $GLOBALS['_xh']['value']=$GLOBALS['_xh']['ac'];
631 }
632 elseif ($name=='DATETIME.ISO8601')
633 {
634 if (!preg_match('/^[0-9]{8}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/', $GLOBALS['_xh']['ac']))
635 {
636 error_log('XML-RPC: invalid value received in DATETIME: '.$GLOBALS['_xh']['ac']);
637 }
638 $GLOBALS['_xh']['vt']=$GLOBALS['xmlrpcDateTime'];
639 $GLOBALS['_xh']['value']=$GLOBALS['_xh']['ac'];
640 }
641 elseif ($name=='BASE64')
642 {
643 /// @todo check for failure of base64 decoding / catch warnings
644 $GLOBALS['_xh']['value']=base64_decode($GLOBALS['_xh']['ac']);
645 }
646 elseif ($name=='BOOLEAN')
647 {
648 // special case here: we translate boolean 1 or 0 into PHP
649 // constants true or false.
650 // Strings 'true' and 'false' are accepted, even though the
651 // spec never mentions them (see eg. Blogger api docs)
652 // NB: this simple checks helps a lot sanitizing input, ie no
653 // security problems around here
654 if ($GLOBALS['_xh']['ac']=='1' || strcasecmp($GLOBALS['_xh']['ac'], 'true') == 0)
655 {
656 $GLOBALS['_xh']['value']=true;
657 }
658 else
659 {
660 // log if receiveing something strange, even though we set the value to false anyway
661 if ($GLOBALS['_xh']['ac']!='0' && strcasecmp($GLOBALS['_xh']['ac'], 'false') != 0)
662 error_log('XML-RPC: invalid value received in BOOLEAN: '.$GLOBALS['_xh']['ac']);
663 $GLOBALS['_xh']['value']=false;
664 }
665 }
666 elseif ($name=='DOUBLE')
667 {
668 // we have a DOUBLE
669 // we must check that only 0123456789-.<space> are characters here
670 // NOTE: regexp could be much stricter than this...
671 if (!preg_match('/^[+-eE0123456789 \t.]+$/', $GLOBALS['_xh']['ac']))
672 {
673 /// @todo: find a better way of throwing an error than this!
674 error_log('XML-RPC: non numeric value received in DOUBLE: '.$GLOBALS['_xh']['ac']);
675 $GLOBALS['_xh']['value']='ERROR_NON_NUMERIC_FOUND';
676 }
677 else
678 {
679 // it's ok, add it on
680 $GLOBALS['_xh']['value']=(double)$GLOBALS['_xh']['ac'];
681 }
682 }
683 else
684 {
685 // we have an I4/INT
686 // we must check that only 0123456789-<space> are characters here
687 if (!preg_match('/^[+-]?[0123456789 \t]+$/', $GLOBALS['_xh']['ac']))
688 {
689 /// @todo find a better way of throwing an error than this!
690 error_log('XML-RPC: non numeric value received in INT: '.$GLOBALS['_xh']['ac']);
691 $GLOBALS['_xh']['value']='ERROR_NON_NUMERIC_FOUND';
692 }
693 else
694 {
695 // it's ok, add it on
696 $GLOBALS['_xh']['value']=(int)$GLOBALS['_xh']['ac'];
697 }
698 }
699 //$GLOBALS['_xh']['ac']=''; // is this necessary?
700 $GLOBALS['_xh']['lv']=3; // indicate we've found a value
701 break;
702 case 'NAME':
703 $GLOBALS['_xh']['valuestack'][count($GLOBALS['_xh']['valuestack'])-1]['name'] = $GLOBALS['_xh']['ac'];
704 break;
705 case 'MEMBER':
706 //$GLOBALS['_xh']['ac']=''; // is this necessary?
707 // add to array in the stack the last element built,
708 // unless no VALUE was found
709 if ($GLOBALS['_xh']['vt'])
710 {
711 $vscount = count($GLOBALS['_xh']['valuestack']);
712 $GLOBALS['_xh']['valuestack'][$vscount-1]['values'][$GLOBALS['_xh']['valuestack'][$vscount-1]['name']] = $GLOBALS['_xh']['value'];
713 } else
714 error_log('XML-RPC: missing VALUE inside STRUCT in received xml');
715 break;
716 case 'DATA':
717 //$GLOBALS['_xh']['ac']=''; // is this necessary?
718 $GLOBALS['_xh']['vt']=null; // reset this to check for 2 data elements in a row - even if they're empty
719 break;
720 case 'STRUCT':
721 case 'ARRAY':
722 // fetch out of stack array of values, and promote it to current value
723 $curr_val = array_pop($GLOBALS['_xh']['valuestack']);
724 $GLOBALS['_xh']['value'] = $curr_val['values'];
725 $GLOBALS['_xh']['vt']=strtolower($name);
726 if (isset($curr_val['php_class']))
727 {
728 $GLOBALS['_xh']['php_class'] = $curr_val['php_class'];
729 }
730 break;
731 case 'PARAM':
732 // add to array of params the current value,
733 // unless no VALUE was found
734 if ($GLOBALS['_xh']['vt'])
735 {
736 $GLOBALS['_xh']['params'][]=$GLOBALS['_xh']['value'];
737 $GLOBALS['_xh']['pt'][]=$GLOBALS['_xh']['vt'];
738 }
739 else
740 error_log('XML-RPC: missing VALUE inside PARAM in received xml');
741 break;
742 case 'METHODNAME':
743 $GLOBALS['_xh']['method']=preg_replace('/^[\n\r\t ]+/', '', $GLOBALS['_xh']['ac']);
744 break;
745 case 'NIL':
746 if ($GLOBALS['xmlrpc_null_extension'])
747 {
748 $GLOBALS['_xh']['vt']='null';
749 $GLOBALS['_xh']['value']=null;
750 $GLOBALS['_xh']['lv']=3;
751 break;
752 }
753 // drop through intentionally if nil extension not enabled
754 case 'PARAMS':
755 case 'FAULT':
756 case 'METHODCALL':
757 case 'METHORESPONSE':
758 break;
759 default:
760 // End of INVALID ELEMENT!
761 // shall we add an assert here for unreachable code???
762 break;
763 }
764 }
765 }
766
767 /// Used in decoding xmlrpc requests/responses without rebuilding xmlrpc values
768 function xmlrpc_ee_fast($parser, $name)
769 {
770 xmlrpc_ee($parser, $name, false);
771 }
772
773 /// xml parser handler function for character data
774 function xmlrpc_cd($parser, $data)
775 {
776 // skip processing if xml fault already detected
777 if ($GLOBALS['_xh']['isf'] < 2)
778 {
779 // "lookforvalue==3" means that we've found an entire value
780 // and should discard any further character data
781 if($GLOBALS['_xh']['lv']!=3)
782 {
783 // G. Giunta 2006-08-23: useless change of 'lv' from 1 to 2
784 //if($GLOBALS['_xh']['lv']==1)
785 //{
786 // if we've found text and we're just in a <value> then
787 // say we've found a value
788 //$GLOBALS['_xh']['lv']=2;
789 //}
790 // we always initialize the accumulator before starting parsing, anyway...
791 //if(!@isset($GLOBALS['_xh']['ac']))
792 //{
793 // $GLOBALS['_xh']['ac'] = '';
794 //}
795 $GLOBALS['_xh']['ac'].=$data;
796 }
797 }
798 }
799
800 /// xml parser handler function for 'other stuff', ie. not char data or
801 /// element start/end tag. In fact it only gets called on unknown entities...
802 function xmlrpc_dh($parser, $data)
803 {
804 // skip processing if xml fault already detected
805 if ($GLOBALS['_xh']['isf'] < 2)
806 {
807 if(substr($data, 0, 1) == '&' && substr($data, -1, 1) == ';')
808 {
809 // G. Giunta 2006-08-25: useless change of 'lv' from 1 to 2
810 //if($GLOBALS['_xh']['lv']==1)
811 //{
812 // $GLOBALS['_xh']['lv']=2;
813 //}
814 $GLOBALS['_xh']['ac'].=$data;
815 }
816 }
817 return true;
818 }
819
820 class xmlrpc_client
821 {
822 var $path;
823 var $server;
824 var $port=0;
825 var $method='http';
826 var $errno;
827 var $errstr;
828 var $debug=0;
829 var $username='';
830 var $password='';
831 var $authtype=1;
832 var $cert='';
833 var $certpass='';
834 var $cacert='';
835 var $cacertdir='';
836 var $key='';
837 var $keypass='';
838 var $verifypeer=true;
839 var $verifyhost=1;
840 var $no_multicall=false;
841 var $proxy='';
842 var $proxyport=0;
843 var $proxy_user='';
844 var $proxy_pass='';
845 var $proxy_authtype=1;
846 var $cookies=array();
847 /**
848 * List of http compression methods accepted by the client for responses.
849 * NB: PHP supports deflate, gzip compressions out of the box if compiled w. zlib
850 *
851 * NNB: you can set it to any non-empty array for HTTP11 and HTTPS, since
852 * in those cases it will be up to CURL to decide the compression methods
853 * it supports. You might check for the presence of 'zlib' in the output of
854 * curl_version() to determine wheter compression is supported or not
855 */
856 var $accepted_compression = array();
857 /**
858 * Name of compression scheme to be used for sending requests.
859 * Either null, gzip or deflate
860 */
861 var $request_compression = '';
862 /**
863 * CURL handle: used for keep-alive connections (PHP 4.3.8 up, see:
864 * http://curl.haxx.se/docs/faq.html#7.3)
865 */
866 var $xmlrpc_curl_handle = null;
867 /// Wheter to use persistent connections for http 1.1 and https
868 var $keepalive = false;
869 /// Charset encodings that can be decoded without problems by the client
870 var $accepted_charset_encodings = array();
871 /// Charset encoding to be used in serializing request. NULL = use ASCII
872 var $request_charset_encoding = '';
873 /**
874 * Decides the content of xmlrpcresp objects returned by calls to send()
875 * valid strings are 'xmlrpcvals', 'phpvals' or 'xml'
876 */
877 var $return_type = 'xmlrpcvals';
878
879 /**
880 * @param string $path either the complete server URL or the PATH part of the xmlrc server URL, e.g. /xmlrpc/server.php
881 * @param string $server the server name / ip address
882 * @param integer $port the port the server is listening on, defaults to 80 or 443 depending on protocol used
883 * @param string $method the http protocol variant: defaults to 'http', 'https' and 'http11' can be used if CURL is installed
884 */
885 function xmlrpc_client($path, $server='', $port='', $method='')
886 {
887 // allow user to specify all params in $path
888 if($server == '' and $port == '' and $method == '')
889 {
890 $parts = parse_url($path);
891 $server = $parts['host'];
892 $path = isset($parts['path']) ? $parts['path'] : '';
893 if(isset($parts['query']))
894 {
895 $path .= '?'.$parts['query'];
896 }
897 if(isset($parts['fragment']))
898 {
899 $path .= '#'.$parts['fragment'];
900 }
901 if(isset($parts['port']))
902 {
903 $port = $parts['port'];
904 }
905 if(isset($parts['scheme']))
906 {
907 $method = $parts['scheme'];
908 }
909 if(isset($parts['user']))
910 {
911 $this->username = $parts['user'];
912 }
913 if(isset($parts['pass']))
914 {
915 $this->password = $parts['pass'];
916 }
917 }
918 if($path == '' || $path[0] != '/')
919 {
920 $this->path='/'.$path;
921 }
922 else
923 {
924 $this->path=$path;
925 }
926 $this->server=$server;
927 if($port != '')
928 {
929 $this->port=$port;
930 }
931 if($method != '')
932 {
933 $this->method=$method;
934 }
935
936 // if ZLIB is enabled, let the client by default accept compressed responses
937 if(function_exists('gzinflate') || (
938 function_exists('curl_init') && (($info = curl_version()) &&
939 ((is_string($info) && strpos($info, 'zlib') !== null) || isset($info['libz_version'])))
940 ))
941 {
942 $this->accepted_compression = array('gzip', 'deflate');
943 }
944
945 // keepalives: enabled by default ONLY for PHP >= 4.3.8
946 // (see http://curl.haxx.se/docs/faq.html#7.3)
947 if(version_compare(phpversion(), '4.3.8') >= 0)
948 {
949 $this->keepalive = true;
950 }
951
952 // by default the xml parser can support these 3 charset encodings
953 $this->accepted_charset_encodings = array('UTF-8', 'ISO-8859-1', 'US-ASCII');
954 }
955
956 /**
957 * Enables/disables the echoing to screen of the xmlrpc responses received
958 * @param integer $debug values 0, 1 and 2 are supported (2 = echo sent msg too, before received response)
959 * @access public
960 */
961 function setDebug($in)
962 {
963 $this->debug=$in;
964 }
965
966 /**
967 * Add some http BASIC AUTH credentials, used by the client to authenticate
968 * @param string $u username
969 * @param string $p password
970 * @param integer $t auth type. See curl_setopt man page for supported auth types. Defaults to CURLAUTH_BASIC (basic auth)
971 * @access public
972 */
973 function setCredentials($u, $p, $t=1)
974 {
975 $this->username=$u;
976 $this->password=$p;
977 $this->authtype=$t;
978 }
979
980 /**
981 * Add a client-side https certificate
982 * @param string $cert
983 * @param string $certpass
984 * @access public
985 */
986 function setCertificate($cert, $certpass)
987 {
988 $this->cert = $cert;
989 $this->certpass = $certpass;
990 }
991
992 /**
993 * Add a CA certificate to verify server with (see man page about
994 * CURLOPT_CAINFO for more details
995 * @param string $cacert certificate file name (or dir holding certificates)
996 * @param bool $is_dir set to true to indicate cacert is a dir. defaults to false
997 * @access public
998 */
999 function setCaCertificate($cacert, $is_dir=false)
1000 {
1001 if ($is_dir)
1002 {
1003 $this->cacertdir = $cacert;
1004 }
1005 else
1006 {
1007 $this->cacert = $cacert;
1008 }
1009 }
1010
1011 /**
1012 * Set attributes for SSL communication: private SSL key
1013 * NB: does not work in older php/curl installs
1014 * Thanks to Daniel Convissor
1015 * @param string $key The name of a file containing a private SSL key
1016 * @param string $keypass The secret password needed to use the private SSL key
1017 * @access public
1018 */
1019 function setKey($key, $keypass)
1020 {
1021 $this->key = $key;
1022 $this->keypass = $keypass;
1023 }
1024
1025 /**
1026 * Set attributes for SSL communication: verify server certificate
1027 * @param bool $i enable/disable verification of peer certificate
1028 * @access public
1029 */
1030 function setSSLVerifyPeer($i)
1031 {
1032 $this->verifypeer = $i;
1033 }
1034
1035 /**
1036 * Set attributes for SSL communication: verify match of server cert w. hostname
1037 * @param int $i
1038 * @access public
1039 */
1040 function setSSLVerifyHost($i)
1041 {
1042 $this->verifyhost = $i;
1043 }
1044
1045 /**
1046 * Set proxy info
1047 * @param string $proxyhost
1048 * @param string $proxyport Defaults to 8080 for HTTP and 443 for HTTPS
1049 * @param string $proxyusername Leave blank if proxy has public access
1050 * @param string $proxypassword Leave blank if proxy has public access
1051 * @param int $proxyauthtype set to constant CURLAUTH_NTLM to use NTLM auth with proxy
1052 * @access public
1053 */
1054 function setProxy($proxyhost, $proxyport, $proxyusername = '', $proxypassword = '', $proxyauthtype = 1)
1055 {
1056 $this->proxy = $proxyhost;
1057 $this->proxyport = $proxyport;
1058 $this->proxy_user = $proxyusername;
1059 $this->proxy_pass = $proxypassword;
1060 $this->proxy_authtype = $proxyauthtype;
1061 }
1062
1063 /**
1064 * Enables/disables reception of compressed xmlrpc responses.
1065 * Note that enabling reception of compressed responses merely adds some standard
1066 * http headers to xmlrpc requests. It is up to the xmlrpc server to return
1067 * compressed responses when receiving such requests.
1068 * @param string $compmethod either 'gzip', 'deflate', 'any' or ''
1069 * @access public
1070 */
1071 function setAcceptedCompression($compmethod)
1072 {
1073 if ($compmethod == 'any')
1074 $this->accepted_compression = array('gzip', 'deflate');
1075 else
1076 $this->accepted_compression = array($compmethod);
1077 }
1078
1079 /**
1080 * Enables/disables http compression of xmlrpc request.
1081 * Take care when sending compressed requests: servers might not support them
1082 * (and automatic fallback to uncompressed requests is not yet implemented)
1083 * @param string $compmethod either 'gzip', 'deflate' or ''
1084 * @access public
1085 */
1086 function setRequestCompression($compmethod)
1087 {
1088 $this->request_compression = $compmethod;
1089 }
1090
1091 /**
1092 * Adds a cookie to list of cookies that will be sent to server.
1093 * NB: setting any param but name and value will turn the cookie into a 'version 1' cookie:
1094 * do not do it unless you know what you are doing
1095 * @param string $name
1096 * @param string $value
1097 * @param string $path
1098 * @param string $domain
1099 * @param int $port
1100 * @access public
1101 *
1102 * @todo check correctness of urlencoding cookie value (copied from php way of doing it...)
1103 */
1104 function setCookie($name, $value='', $path='', $domain='', $port=null)
1105 {
1106 $this->cookies[$name]['value'] = urlencode($value);
1107 if ($path || $domain || $port)
1108 {
1109 $this->cookies[$name]['path'] = $path;
1110 $this->cookies[$name]['domain'] = $domain;
1111 $this->cookies[$name]['port'] = $port;
1112 $this->cookies[$name]['version'] = 1;
1113 }
1114 else
1115 {
1116 $this->cookies[$name]['version'] = 0;
1117 }
1118 }
1119
1120 /**
1121 * Send an xmlrpc request
1122 * @param mixed $msg The message object, or an array of messages for using multicall, or the complete xml representation of a request
1123 * @param integer $timeout Connection timeout, in seconds, If unspecified, a platform specific timeout will apply
1124 * @param string $method if left unspecified, the http protocol chosen during creation of the object will be used
1125 * @return xmlrpcresp
1126 * @access public
1127 */
1128 function& send($msg, $timeout=0, $method='')
1129 {
1130 // if user deos not specify http protocol, use native method of this client
1131 // (i.e. method set during call to constructor)
1132 if($method == '')
1133 {
1134 $method = $this->method;
1135 }
1136
1137 if(is_array($msg))
1138 {
1139 // $msg is an array of xmlrpcmsg's
1140 $r = $this->multicall($msg, $timeout, $method);
1141 return $r;
1142 }
1143 elseif(is_string($msg))
1144 {
1145 $n = new xmlrpcmsg('');
1146 $n->payload = $msg;
1147 $msg = $n;
1148 }
1149
1150 // where msg is an xmlrpcmsg
1151 $msg->debug=$this->debug;
1152
1153 if($method == 'https')
1154 {
1155 $r =& $this->sendPayloadHTTPS(
1156 $msg,
1157 $this->server,
1158 $this->port,
1159 $timeout,
1160 $this->username,
1161 $this->password,
1162 $this->authtype,
1163 $this->cert,
1164 $this->certpass,
1165 $this->cacert,
1166 $this->cacertdir,
1167 $this->proxy,
1168 $this->proxyport,
1169 $this->proxy_user,
1170 $this->proxy_pass,
1171 $this->proxy_authtype,
1172 $this->keepalive,
1173 $this->key,
1174 $this->keypass
1175 );
1176 }
1177 elseif($method == 'http11')
1178 {
1179 $r =& $this->sendPayloadCURL(
1180 $msg,
1181 $this->server,
1182 $this->port,
1183 $timeout,
1184 $this->username,
1185 $this->password,
1186 $this->authtype,
1187 null,
1188 null,
1189 null,
1190 null,
1191 $this->proxy,
1192 $this->proxyport,
1193 $this->proxy_user,
1194 $this->proxy_pass,
1195 $this->proxy_authtype,
1196 'http',
1197 $this->keepalive
1198 );
1199 }
1200 else
1201 {
1202 $r =& $this->sendPayloadHTTP10(
1203 $msg,
1204 $this->server,
1205 $this->port,
1206 $timeout,
1207 $this->username,
1208 $this->password,
1209 $this->authtype,
1210 $this->proxy,
1211 $this->proxyport,
1212 $this->proxy_user,
1213 $this->proxy_pass,
1214 $this->proxy_authtype
1215 );
1216 }
1217
1218 return $r;
1219 }
1220
1221 /**
1222 * @access private
1223 */
1224 function &sendPayloadHTTP10($msg, $server, $port, $timeout=0,
1225 $username='', $password='', $authtype=1, $proxyhost='',
1226 $proxyport=0, $proxyusername='', $proxypassword='', $proxyauthtype=1)
1227 {
1228 if($port==0)
1229 {
1230 $port=80;
1231 }
1232
1233 // Only create the payload if it was not created previously
1234 if(empty($msg->payload))
1235 {
1236 $msg->createPayload($this->request_charset_encoding);
1237 }
1238
1239 $payload = $msg->payload;
1240 // Deflate request body and set appropriate request headers
1241 if(function_exists('gzdeflate') && ($this->request_compression == 'gzip' || $this->request_compression == 'deflate'))
1242 {
1243 if($this->request_compression == 'gzip')
1244 {
1245 $a = @gzencode($payload);
1246 if($a)
1247 {
1248 $payload = $a;
1249 $encoding_hdr = "Content-Encoding: gzip\r\n";
1250 }
1251 }
1252 else
1253 {
1254 $a = @gzcompress($payload);
1255 if($a)
1256 {
1257 $payload = $a;
1258 $encoding_hdr = "Content-Encoding: deflate\r\n";
1259 }
1260 }
1261 }
1262 else
1263 {
1264 $encoding_hdr = '';
1265 }
1266
1267 // thanks to Grant Rauscher <grant7@firstworld.net> for this
1268 $credentials='';
1269 if($username!='')
1270 {
1271 $credentials='Authorization: Basic ' . base64_encode($username . ':' . $password) . "\r\n";
1272 if ($authtype != 1)
1273 {
1274 error_log('XML-RPC: xmlrpc_client::send: warning. Only Basic auth is supported with HTTP 1.0');
1275 }
1276 }
1277
1278 $accepted_encoding = '';
1279 if(is_array($this->accepted_compression) && count($this->accepted_compression))
1280 {
1281 $accepted_encoding = 'Accept-Encoding: ' . implode(', ', $this->accepted_compression) . "\r\n";
1282 }
1283
1284 $proxy_credentials = '';
1285 if($proxyhost)
1286 {
1287 if($proxyport == 0)
1288 {
1289 $proxyport = 8080;
1290 }
1291 $connectserver = $proxyhost;
1292 $connectport = $proxyport;
1293 $uri = 'http://'.$server.':'.$port.$this->path;
1294 if($proxyusername != '')
1295 {
1296 if ($proxyauthtype != 1)
1297 {
1298 error_log('XML-RPC: xmlrpc_client::send: warning. Only Basic auth to proxy is supported with HTTP 1.0');
1299 }
1300 $proxy_credentials = 'Proxy-Authorization: Basic ' . base64_encode($proxyusername.':'.$proxypassword) . "\r\n";
1301 }
1302 }
1303 else
1304 {
1305 $connectserver = $server;
1306 $connectport = $port;
1307 $uri = $this->path;
1308 }
1309
1310 // Cookie generation, as per rfc2965 (version 1 cookies) or
1311 // netscape's rules (version 0 cookies)
1312 $cookieheader='';
1313 if (count($this->cookies))
1314 {
1315 $version = '';
1316 foreach ($this->cookies as $name => $cookie)
1317 {
1318 if ($cookie['version'])
1319 {
1320 $version = ' $Version="' . $cookie['version'] . '";';
1321 $cookieheader .= ' ' . $name . '="' . $cookie['value'] . '";';
1322 if ($cookie['path'])
1323 $cookieheader .= ' $Path="' . $cookie['path'] . '";';
1324 if ($cookie['domain'])
1325 $cookieheader .= ' $Domain="' . $cookie['domain'] . '";';
1326 if ($cookie['port'])
1327 $cookieheader .= ' $Port="' . $cookie['port'] . '";';
1328 }
1329 else
1330 {
1331 $cookieheader .= ' ' . $name . '=' . $cookie['value'] . ";";
1332 }
1333 }
1334 $cookieheader = 'Cookie:' . $version . substr($cookieheader, 0, -1) . "\r\n";
1335 }
1336
1337 $op= 'POST ' . $uri. " HTTP/1.0\r\n" .
1338 'User-Agent: ' . $GLOBALS['xmlrpcName'] . ' ' . $GLOBALS['xmlrpcVersion'] . "\r\n" .
1339 'Host: '. $server . ':' . $port . "\r\n" .
1340 $credentials .
1341 $proxy_credentials .
1342 $accepted_encoding .
1343 $encoding_hdr .
1344 'Accept-Charset: ' . implode(',', $this->accepted_charset_encodings) . "\r\n" .
1345 $cookieheader .
1346 'Content-Type: ' . $msg->content_type . "\r\nContent-Length: " .
1347 strlen($payload) . "\r\n\r\n" .
1348 $payload;
1349
1350 if($this->debug > 1)
1351 {
1352 print "<PRE>\n---SENDING---\n" . htmlentities($op) . "\n---END---\n</PRE>";
1353 // let the client see this now in case http times out...
1354 flush();
1355 }
1356
1357 if($timeout>0)
1358 {
1359 $fp=@fsockopen($connectserver, $connectport, $this->errno, $this->errstr, $timeout);
1360 }
1361 else
1362 {
1363 $fp=@fsockopen($connectserver, $connectport, $this->errno, $this->errstr);
1364 }
1365 if($fp)
1366 {
1367 if($timeout>0 && function_exists('stream_set_timeout'))
1368 {
1369 stream_set_timeout($fp, $timeout);
1370 }
1371 }
1372 else
1373 {
1374 $this->errstr='Connect error: '.$this->errstr;
1375 $r= new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['http_error'], $this->errstr . ' (' . $this->errno . ')');
1376 return $r;
1377 }
1378
1379 if(!fputs($fp, $op, strlen($op)))
1380 {
1381 fclose($fp);
1382 $this->errstr='Write error';
1383 $r= new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['http_error'], $this->errstr);
1384 return $r;
1385 }
1386 else
1387 {
1388 // reset errno and errstr on succesful socket connection
1389 $this->errstr = '';
1390 }
1391 // G. Giunta 2005/10/24: close socket before parsing.
1392 // should yeld slightly better execution times, and make easier recursive calls (e.g. to follow http redirects)
1393 $ipd='';
1394 do
1395 {
1396 // shall we check for $data === FALSE?
1397 // as per the manual, it signals an error
1398 $ipd.=fread($fp, 32768);
1399 } while(!feof($fp));
1400 fclose($fp);
1401 $r =& $msg->parseResponse($ipd, false, $this->return_type);
1402 return $r;
1403
1404 }
1405
1406 /**
1407 * @access private
1408 */
1409 function &sendPayloadHTTPS($msg, $server, $port, $timeout=0, $username='',
1410 $password='', $authtype=1, $cert='',$certpass='', $cacert='', $cacertdir='',
1411 $proxyhost='', $proxyport=0, $proxyusername='', $proxypassword='', $proxyauthtype=1,
1412 $keepalive=false, $key='', $keypass='')
1413 {
1414 $r =& $this->sendPayloadCURL($msg, $server, $port, $timeout, $username,
1415 $password, $authtype, $cert, $certpass, $cacert, $cacertdir, $proxyhost, $proxyport,
1416 $proxyusername, $proxypassword, $proxyauthtype, 'https', $keepalive, $key, $keypass);
1417 return $r;
1418 }
1419
1420 /**
1421 * Contributed by Justin Miller <justin@voxel.net>
1422 * Requires curl to be built into PHP
1423 * NB: CURL versions before 7.11.10 cannot use proxy to talk to https servers!
1424 * @access private
1425 */
1426 function &sendPayloadCURL($msg, $server, $port, $timeout=0, $username='',
1427 $password='', $authtype=1, $cert='', $certpass='', $cacert='', $cacertdir='',
1428 $proxyhost='', $proxyport=0, $proxyusername='', $proxypassword='', $proxyauthtype=1, $method='https',
1429 $keepalive=false, $key='', $keypass='')
1430 {
1431 if(!function_exists('curl_init'))
1432 {
1433 $this->errstr='CURL unavailable on this install';
1434 $r= new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['no_curl'], $GLOBALS['xmlrpcstr']['no_curl']);
1435 return $r;
1436 }
1437 if($method == 'https')
1438 {
1439 if(($info = curl_version()) &&
1440 ((is_string($info) && strpos($info, 'OpenSSL') === null) || (is_array($info) && !isset($info['ssl_version']))))
1441 {
1442 $this->errstr='SSL unavailable on this install';
1443 $r= new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['no_ssl'], $GLOBALS['xmlrpcstr']['no_ssl']);
1444 return $r;
1445 }
1446 }
1447
1448 if($port == 0)
1449 {
1450 if($method == 'http')
1451 {
1452 $port = 80;
1453 }
1454 else
1455 {
1456 $port = 443;
1457 }
1458 }
1459
1460 // Only create the payload if it was not created previously
1461 if(empty($msg->payload))
1462 {
1463 $msg->createPayload($this->request_charset_encoding);
1464 }
1465
1466 // Deflate request body and set appropriate request headers
1467 $payload = $msg->payload;
1468 if(function_exists('gzdeflate') && ($this->request_compression == 'gzip' || $this->request_compression == 'deflate'))
1469 {
1470 if($this->request_compression == 'gzip')
1471 {
1472 $a = @gzencode($payload);
1473 if($a)
1474 {
1475 $payload = $a;
1476 $encoding_hdr = 'Content-Encoding: gzip';
1477 }
1478 }
1479 else
1480 {
1481 $a = @gzcompress($payload);
1482 if($a)
1483 {
1484 $payload = $a;
1485 $encoding_hdr = 'Content-Encoding: deflate';
1486 }
1487 }
1488 }
1489 else
1490 {
1491 $encoding_hdr = '';
1492 }
1493
1494 if($this->debug > 1)
1495 {
1496 print "<PRE>\n---SENDING---\n" . htmlentities($payload) . "\n---END---\n</PRE>";
1497 // let the client see this now in case http times out...
1498 flush();
1499 }
1500
1501 if(!$keepalive || !$this->xmlrpc_curl_handle)
1502 {
1503 $curl = curl_init($method . '://' . $server . ':' . $port . $this->path);
1504 if($keepalive)
1505 {
1506 $this->xmlrpc_curl_handle = $curl;
1507 }
1508 }
1509 else
1510 {
1511 $curl = $this->xmlrpc_curl_handle;
1512 }
1513
1514 // results into variable
1515 curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
1516
1517 if($this->debug)
1518 {
1519 curl_setopt($curl, CURLOPT_VERBOSE, 1);
1520 }
1521 curl_setopt($curl, CURLOPT_USERAGENT, $GLOBALS['xmlrpcName'].' '.$GLOBALS['xmlrpcVersion']);
1522 // required for XMLRPC: post the data
1523 curl_setopt($curl, CURLOPT_POST, 1);
1524 // the data
1525 curl_setopt($curl, CURLOPT_POSTFIELDS, $payload);
1526
1527 // return the header too
1528 curl_setopt($curl, CURLOPT_HEADER, 1);
1529
1530 // will only work with PHP >= 5.0
1531 // NB: if we set an empty string, CURL will add http header indicating
1532 // ALL methods it is supporting. This is possibly a better option than
1533 // letting the user tell what curl can / cannot do...
1534 if(is_array($this->accepted_compression) && count($this->accepted_compression))
1535 {
1536 //curl_setopt($curl, CURLOPT_ENCODING, implode(',', $this->accepted_compression));
1537 // empty string means 'any supported by CURL' (shall we catch errors in case CURLOPT_SSLKEY undefined ?)
1538 if (count($this->accepted_compression) == 1)
1539 {
1540 curl_setopt($curl, CURLOPT_ENCODING, $this->accepted_compression[0]);
1541 }
1542 else
1543 curl_setopt($curl, CURLOPT_ENCODING, '');
1544 }
1545 // extra headers
1546 $headers = array('Content-Type: ' . $msg->content_type , 'Accept-Charset: ' . implode(',', $this->accepted_charset_encodings));
1547 // if no keepalive is wanted, let the server know it in advance
1548 if(!$keepalive)
1549 {
1550 $headers[] = 'Connection: close';
1551 }
1552 // request compression header
1553 if($encoding_hdr)
1554 {
1555 $headers[] = $encoding_hdr;
1556 }
1557
1558 curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
1559 // timeout is borked
1560 if($timeout)
1561 {
1562 curl_setopt($curl, CURLOPT_TIMEOUT, $timeout == 1 ? 1 : $timeout - 1);
1563 }
1564
1565 if($username && $password)
1566 {
1567 curl_setopt($curl, CURLOPT_USERPWD, $username.':'.$password);
1568 if (defined('CURLOPT_HTTPAUTH'))
1569 {
1570 curl_setopt($curl, CURLOPT_HTTPAUTH, $authtype);
1571 }
1572 else if ($authtype != 1)
1573 {
1574 error_log('XML-RPC: xmlrpc_client::send: warning. Only Basic auth is supported by the current PHP/curl install');
1575 }
1576 }
1577
1578 if($method == 'https')
1579 {
1580 // set cert file
1581 if($cert)
1582 {
1583 curl_setopt($curl, CURLOPT_SSLCERT, $cert);
1584 }
1585 // set cert password
1586 if($certpass)
1587 {
1588 curl_setopt($curl, CURLOPT_SSLCERTPASSWD, $certpass);
1589 }
1590 // whether to verify remote host's cert
1591 curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, $this->verifypeer);
1592 // set ca certificates file/dir
1593 if($cacert)
1594 {
1595 curl_setopt($curl, CURLOPT_CAINFO, $cacert);
1596 }
1597 if($cacertdir)
1598 {
1599 curl_setopt($curl, CURLOPT_CAPATH, $cacertdir);
1600 }
1601 // set key file (shall we catch errors in case CURLOPT_SSLKEY undefined ?)
1602 if($key)
1603 {
1604 curl_setopt($curl, CURLOPT_SSLKEY, $key);
1605 }
1606 // set key password (shall we catch errors in case CURLOPT_SSLKEY undefined ?)
1607 if($keypass)
1608 {
1609 curl_setopt($curl, CURLOPT_SSLKEYPASSWD, $keypass);
1610 }
1611 // 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
1612 curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, $this->verifyhost);
1613 }
1614
1615 // proxy info
1616 if($proxyhost)
1617 {
1618 if($proxyport == 0)
1619 {
1620 $proxyport = 8080; // NB: even for HTTPS, local connection is on port 8080
1621 }
1622 curl_setopt($curl, CURLOPT_PROXY, $proxyhost.':'.$proxyport);
1623 //curl_setopt($curl, CURLOPT_PROXYPORT,$proxyport);
1624 if($proxyusername)
1625 {
1626 curl_setopt($curl, CURLOPT_PROXYUSERPWD, $proxyusername.':'.$proxypassword);
1627 if (defined('CURLOPT_PROXYAUTH'))
1628 {
1629 curl_setopt($curl, CURLOPT_PROXYAUTH, $proxyauthtype);
1630 }
1631 else if ($proxyauthtype != 1)
1632 {
1633 error_log('XML-RPC: xmlrpc_client::send: warning. Only Basic auth to proxy is supported by the current PHP/curl install');
1634 }
1635 }
1636 }
1637
1638 // NB: should we build cookie http headers by hand rather than let CURL do it?
1639 // the following code does not honour 'expires', 'path' and 'domain' cookie attributes
1640 // set to client obj the the user...
1641 if (count($this->cookies))
1642 {
1643 $cookieheader = '';
1644 foreach ($this->cookies as $name => $cookie)
1645 {
1646 $cookieheader .= $name . '=' . $cookie['value'] . '; ';
1647 }
1648 curl_setopt($curl, CURLOPT_COOKIE, substr($cookieheader, 0, -2));
1649 }
1650
1651 $result = curl_exec($curl);
1652
1653 if ($this->debug > 1)
1654 {
1655 print "<PRE>\n---CURL INFO---\n";
1656 foreach(curl_getinfo($curl) as $name => $val)
1657 print $name . ': ' . htmlentities($val). "\n";
1658 print "---END---\n</PRE>";
1659 }
1660
1661 if(!$result) /// @todo we should use a better check here - what if we get back '' or '0'?
1662 {
1663 $this->errstr='no response';
1664 $resp= new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['curl_fail'], $GLOBALS['xmlrpcstr']['curl_fail']. ': '. curl_error($curl));
1665 curl_close($curl);
1666 if($keepalive)
1667 {
1668 $this->xmlrpc_curl_handle = null;
1669 }
1670 }
1671 else
1672 {
1673 if(!$keepalive)
1674 {
1675 curl_close($curl);
1676 }
1677 $resp =& $msg->parseResponse($result, true, $this->return_type);
1678 }
1679 return $resp;
1680 }
1681
1682 /**
1683 * Send an array of request messages and return an array of responses.
1684 * Unless $this->no_multicall has been set to true, it will try first
1685 * to use one single xmlrpc call to server method system.multicall, and
1686 * revert to sending many successive calls in case of failure.
1687 * This failure is also stored in $this->no_multicall for subsequent calls.
1688 * Unfortunately, there is no server error code universally used to denote
1689 * the fact that multicall is unsupported, so there is no way to reliably
1690 * distinguish between that and a temporary failure.
1691 * If you are sure that server supports multicall and do not want to
1692 * fallback to using many single calls, set the fourth parameter to FALSE.
1693 *
1694 * NB: trying to shoehorn extra functionality into existing syntax has resulted
1695 * in pretty much convoluted code...
1696 *
1697 * @param array $msgs an array of xmlrpcmsg objects
1698 * @param integer $timeout connection timeout (in seconds)
1699 * @param string $method the http protocol variant to be used
1700 * @param boolean fallback When true, upon receiveing an error during multicall, multiple single calls will be attempted
1701 * @return array
1702 * @access public
1703 */
1704 function multicall($msgs, $timeout=0, $method='', $fallback=true)
1705 {
1706 if ($method == '')
1707 {
1708 $method = $this->method;
1709 }
1710 if(!$this->no_multicall)
1711 {
1712 $results = $this->_try_multicall($msgs, $timeout, $method);
1713 if(is_array($results))
1714 {
1715 // System.multicall succeeded
1716 return $results;
1717 }
1718 else
1719 {
1720 // either system.multicall is unsupported by server,
1721 // or call failed for some other reason.
1722 if ($fallback)
1723 {
1724 // Don't try it next time...
1725 $this->no_multicall = true;
1726 }
1727 else
1728 {
1729 if (is_a($results, 'xmlrpcresp'))
1730 {
1731 $result = $results;
1732 }
1733 else
1734 {
1735 $result = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['multicall_error'], $GLOBALS['xmlrpcstr']['multicall_error']);
1736 }
1737 }
1738 }
1739 }
1740 else
1741 {
1742 // override fallback, in case careless user tries to do two
1743 // opposite things at the same time
1744 $fallback = true;
1745 }
1746
1747 $results = array();
1748 if ($fallback)
1749 {
1750 // system.multicall is (probably) unsupported by server:
1751 // emulate multicall via multiple requests
1752 foreach($msgs as $msg)
1753 {
1754 $results[] =& $this->send($msg, $timeout, $method);
1755 }
1756 }
1757 else
1758 {
1759 // user does NOT want to fallback on many single calls:
1760 // since we should always return an array of responses,
1761 // return an array with the same error repeated n times
1762 foreach($msgs as $msg)
1763 {
1764 $results[] = $result;
1765 }
1766 }
1767 return $results;
1768 }
1769
1770 /**
1771 * Attempt to boxcar $msgs via system.multicall.
1772 * Returns either an array of xmlrpcreponses, an xmlrpc error response
1773 * or false (when received response does not respect valid multicall syntax)
1774 * @access private
1775 */
1776 function _try_multicall($msgs, $timeout, $method)
1777 {
1778 // Construct multicall message
1779 $calls = array();
1780 foreach($msgs as $msg)
1781 {
1782 $call['methodName'] = new xmlrpcval($msg->method(),'string');
1783 $numParams = $msg->getNumParams();
1784 $params = array();
1785 for($i = 0; $i < $numParams; $i++)
1786 {
1787 $params[$i] = $msg->getParam($i);
1788 }
1789 $call['params'] = new xmlrpcval($params, 'array');
1790 $calls[] = new xmlrpcval($call, 'struct');
1791 }
1792 $multicall = new xmlrpcmsg('system.multicall');
1793 $multicall->addParam(new xmlrpcval($calls, 'array'));
1794
1795 // Attempt RPC call
1796 $result =& $this->send($multicall, $timeout, $method);
1797
1798 if($result->faultCode() != 0)
1799 {
1800 // call to system.multicall failed
1801 return $result;
1802 }
1803
1804 // Unpack responses.
1805 $rets = $result->value();
1806
1807 if ($this->return_type == 'xml')
1808 {
1809 return $rets;
1810 }
1811 else if ($this->return_type == 'phpvals')
1812 {
1813 ///@todo test this code branch...
1814 $rets = $result->value();
1815 if(!is_array($rets))
1816 {
1817 return false; // bad return type from system.multicall
1818 }
1819 $numRets = count($rets);
1820 if($numRets != count($msgs))
1821 {
1822 return false; // wrong number of return values.
1823 }
1824
1825 $response = array();
1826 for($i = 0; $i < $numRets; $i++)
1827 {
1828 $val = $rets[$i];
1829 if (!is_array($val)) {
1830 return false;
1831 }
1832 switch(count($val))
1833 {
1834 case 1:
1835 if(!isset($val[0]))
1836 {
1837 return false; // Bad value
1838 }
1839 // Normal return value
1840 $response[$i] = new xmlrpcresp($val[0], 0, '', 'phpvals');
1841 break;
1842 case 2:
1843 /// @todo remove usage of @: it is apparently quite slow
1844 $code = @$val['faultCode'];
1845 if(!is_int($code))
1846 {
1847 return false;
1848 }
1849 $str = @$val['faultString'];
1850 if(!is_string($str))
1851 {
1852 return false;
1853 }
1854 $response[$i] = new xmlrpcresp(0, $code, $str);
1855 break;
1856 default:
1857 return false;
1858 }
1859 }
1860 return $response;
1861 }
1862 else // return type == 'xmlrpcvals'
1863 {
1864 $rets = $result->value();
1865 if($rets->kindOf() != 'array')
1866 {
1867 return false; // bad return type from system.multicall
1868 }
1869 $numRets = $rets->arraysize();
1870 if($numRets != count($msgs))
1871 {
1872 return false; // wrong number of return values.
1873 }
1874
1875 $response = array();
1876 for($i = 0; $i < $numRets; $i++)
1877 {
1878 $val = $rets->arraymem($i);
1879 switch($val->kindOf())
1880 {
1881 case 'array':
1882 if($val->arraysize() != 1)
1883 {
1884 return false; // Bad value
1885 }
1886 // Normal return value
1887 $response[$i] = new xmlrpcresp($val->arraymem(0));
1888 break;
1889 case 'struct':
1890 $code = $val->structmem('faultCode');
1891 if($code->kindOf() != 'scalar' || $code->scalartyp() != 'int')
1892 {
1893 return false;
1894 }
1895 $str = $val->structmem('faultString');
1896 if($str->kindOf() != 'scalar' || $str->scalartyp() != 'string')
1897 {
1898 return false;
1899 }
1900 $response[$i] = new xmlrpcresp(0, $code->scalarval(), $str->scalarval());
1901 break;
1902 default:
1903 return false;
1904 }
1905 }
1906 return $response;
1907 }
1908 }
1909 } // end class xmlrpc_client
1910
1911 class xmlrpcresp
1912 {
1913 var $val = 0;
1914 var $valtyp;
1915 var $errno = 0;
1916 var $errstr = '';
1917 var $payload;
1918 var $hdrs = array();
1919 var $_cookies = array();
1920 var $content_type = 'text/xml';
1921 var $raw_data = '';
1922
1923 /**
1924 * @param mixed $val either an xmlrpcval obj, a php value or the xml serialization of an xmlrpcval (a string)
1925 * @param integer $fcode set it to anything but 0 to create an error response
1926 * @param string $fstr the error string, in case of an error response
1927 * @param string $valtyp either 'xmlrpcvals', 'phpvals' or 'xml'
1928 *
1929 * @todo add check that $val / $fcode / $fstr is of correct type???
1930 * NB: as of now we do not do it, since it might be either an xmlrpcval or a plain
1931 * php val, or a complete xml chunk, depending on usage of xmlrpc_client::send() inside which creator is called...
1932 */
1933 function xmlrpcresp($val, $fcode = 0, $fstr = '', $valtyp='')
1934 {
1935 if($fcode != 0)
1936 {
1937 // error response
1938 $this->errno = $fcode;
1939 $this->errstr = $fstr;
1940 //$this->errstr = htmlspecialchars($fstr); // XXX: encoding probably shouldn't be done here; fix later.
1941 }
1942 else
1943 {
1944 // successful response
1945 $this->val = $val;
1946 if ($valtyp == '')
1947 {
1948 // user did not declare type of response value: try to guess it
1949 if (is_object($this->val) && is_a($this->val, 'xmlrpcval'))
1950 {
1951 $this->valtyp = 'xmlrpcvals';
1952 }
1953 else if (is_string($this->val))
1954 {
1955 $this->valtyp = 'xml';
1956
1957 }
1958 else
1959 {
1960 $this->valtyp = 'phpvals';
1961 }
1962 }
1963 else
1964 {
1965 // user declares type of resp value: believe him
1966 $this->valtyp = $valtyp;
1967 }
1968 }
1969 }
1970
1971 /**
1972 * Returns the error code of the response.
1973 * @return integer the error code of this response (0 for not-error responses)
1974 * @access public
1975 */
1976 function faultCode()
1977 {
1978 return $this->errno;
1979 }
1980
1981 /**
1982 * Returns the error code of the response.
1983 * @return string the error string of this response ('' for not-error responses)
1984 * @access public
1985 */
1986 function faultString()
1987 {
1988 return $this->errstr;
1989 }
1990
1991 /**
1992 * Returns the value received by the server.
1993 * @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
1994 * @access public
1995 */
1996 function value()
1997 {
1998 return $this->val;
1999 }
2000
2001 /**
2002 * Returns an array with the cookies received from the server.
2003 * Array has the form: $cookiename => array ('value' => $val, $attr1 => $val1, $attr2 = $val2, ...)
2004 * with attributes being e.g. 'expires', 'path', domain'.
2005 * NB: cookies sent as 'expired' by the server (i.e. with an expiry date in the past)
2006 * are still present in the array. It is up to the user-defined code to decide
2007 * how to use the received cookies, and wheter they have to be sent back with the next
2008 * request to the server (using xmlrpc_client::setCookie) or not
2009 * @return array array of cookies received from the server
2010 * @access public
2011 */
2012 function cookies()
2013 {
2014 return $this->_cookies;
2015 }
2016
2017 /**
2018 * Returns xml representation of the response. XML prologue not included
2019 * @param string $charset_encoding the charset to be used for serialization. if null, US-ASCII is assumed
2020 * @return string the xml representation of the response
2021 * @access public
2022 */
2023 function serialize($charset_encoding='')
2024 {
2025 if ($charset_encoding != '')
2026 $this->content_type = 'text/xml; charset=' . $charset_encoding;
2027 else
2028 $this->content_type = 'text/xml';
2029 $result = "<methodResponse>\n";
2030 if($this->errno)
2031 {
2032 // G. Giunta 2005/2/13: let non-ASCII response messages be tolerated by clients
2033 // by xml-encoding non ascii chars
2034 $result .= "<fault>\n" .
2035"<value>\n<struct><member><name>faultCode</name>\n<value><int>" . $this->errno .
2036"</int></value>\n</member>\n<member>\n<name>faultString</name>\n<value><string>" .
2037xmlrpc_encode_entitites($this->errstr, $GLOBALS['xmlrpc_internalencoding'], $charset_encoding) . "</string></value>\n</member>\n" .
2038"</struct>\n</value>\n</fault>";
2039 }
2040 else
2041 {
2042 if(!is_object($this->val) || !is_a($this->val, 'xmlrpcval'))
2043 {
2044 if (is_string($this->val) && $this->valtyp == 'xml')
2045 {
2046 $result .= "<params>\n<param>\n" .
2047 $this->val .
2048 "</param>\n</params>";
2049 }
2050 else
2051 {
2052 /// @todo try to build something serializable?
2053 die('cannot serialize xmlrpcresp objects whose content is native php values');
2054 }
2055 }
2056 else
2057 {
2058 $result .= "<params>\n<param>\n" .
2059 $this->val->serialize($charset_encoding) .
2060 "</param>\n</params>";
2061 }
2062 }
2063 $result .= "\n</methodResponse>";
2064 $this->payload = $result;
2065 return $result;
2066 }
2067 }
2068
2069 class xmlrpcmsg
2070 {
2071 var $payload;
2072 var $methodname;
2073 var $params=array();
2074 var $debug=0;
2075 var $content_type = 'text/xml';
2076
2077 /**
2078 * @param string $meth the name of the method to invoke
2079 * @param array $pars array of parameters to be paased to the method (xmlrpcval objects)
2080 */
2081 function xmlrpcmsg($meth, $pars=0)
2082 {
2083 $this->methodname=$meth;
2084 if(is_array($pars) && count($pars)>0)
2085 {
2086 for($i=0; $i<count($pars); $i++)
2087 {
2088 $this->addParam($pars[$i]);
2089 }
2090 }
2091 }
2092
2093 /**
2094 * @access private
2095 */
2096 function xml_header($charset_encoding='')
2097 {
2098 if ($charset_encoding != '')
2099 {
2100 return "<?xml version=\"1.0\" encoding=\"$charset_encoding\" ?" . ">\n<methodCall>\n";
2101 }
2102 else
2103 {
2104 return "<?xml version=\"1.0\"?" . ">\n<methodCall>\n";
2105 }
2106 }
2107
2108 /**
2109 * @access private
2110 */
2111 function xml_footer()
2112 {
2113 return '</methodCall>';
2114 }
2115
2116 /**
2117 * @access private
2118 */
2119 function kindOf()
2120 {
2121 return 'msg';
2122 }
2123
2124 /**
2125 * @access private
2126 */
2127 function createPayload($charset_encoding='')
2128 {
2129 if ($charset_encoding != '')
2130 $this->content_type = 'text/xml; charset=' . $charset_encoding;
2131 else
2132 $this->content_type = 'text/xml';
2133 $this->payload=$this->xml_header($charset_encoding);
2134 $this->payload.='<methodName>' . $this->methodname . "</methodName>\n";
2135 $this->payload.="<params>\n";
2136 for($i=0; $i<count($this->params); $i++)
2137 {
2138 $p=$this->params[$i];
2139 $this->payload.="<param>\n" . $p->serialize($charset_encoding) .
2140 "</param>\n";
2141 }
2142 $this->payload.="</params>\n";
2143 $this->payload.=$this->xml_footer();
2144 }
2145
2146 /**
2147 * Gets/sets the xmlrpc method to be invoked
2148 * @param string $meth the method to be set (leave empty not to set it)
2149 * @return string the method that will be invoked
2150 * @access public
2151 */
2152 function method($meth='')
2153 {
2154 if($meth!='')
2155 {
2156 $this->methodname=$meth;
2157 }
2158 return $this->methodname;
2159 }
2160
2161 /**
2162 * Returns xml representation of the message. XML prologue included
2163 * @return string the xml representation of the message, xml prologue included
2164 * @access public
2165 */
2166 function serialize($charset_encoding='')
2167 {
2168 $this->createPayload($charset_encoding);
2169 return $this->payload;
2170 }
2171
2172 /**
2173 * Add a parameter to the list of parameters to be used upon method invocation
2174 * @param xmlrpcval $par
2175 * @return boolean false on failure
2176 * @access public
2177 */
2178 function addParam($par)
2179 {
2180 // add check: do not add to self params which are not xmlrpcvals
2181 if(is_object($par) && is_a($par, 'xmlrpcval'))
2182 {
2183 $this->params[]=$par;
2184 return true;
2185 }
2186 else
2187 {
2188 return false;
2189 }
2190 }
2191
2192 /**
2193 * Returns the nth parameter in the message. The index zero-based.
2194 * @param integer $i the index of the parameter to fetch (zero based)
2195 * @return xmlrpcval the i-th parameter
2196 * @access public
2197 */
2198 function getParam($i) { return $this->params[$i]; }
2199
2200 /**
2201 * Returns the number of parameters in the messge.
2202 * @return integer the number of parameters currently set
2203 * @access public
2204 */
2205 function getNumParams() { return count($this->params); }
2206
2207 /**
2208 * Given an open file handle, read all data available and parse it as axmlrpc response.
2209 * NB: the file handle is not closed by this function.
2210 * NNB: might have trouble in rare cases to work on network streams, as we
2211 * check for a read of 0 bytes instead of feof($fp).
2212 * But since checking for feof(null) returns false, we would risk an
2213 * infinite loop in that case, because we cannot trust the caller
2214 * to give us a valid pointer to an open file...
2215 * @access public
2216 * @return xmlrpcresp
2217 * @todo add 2nd & 3rd param to be passed to ParseResponse() ???
2218 */
2219 function &parseResponseFile($fp)
2220 {
2221 $ipd='';
2222 while($data=fread($fp, 32768))
2223 {
2224 $ipd.=$data;
2225 }
2226 //fclose($fp);
2227 $r =& $this->parseResponse($ipd);
2228 return $r;
2229 }
2230
2231 /**
2232 * Parses HTTP headers and separates them from data.
2233 * @access private
2234 */
2235 function &parseResponseHeaders(&$data, $headers_processed=false)
2236 {
2237 // Support "web-proxy-tunelling" connections for https through proxies
2238 if(preg_match('/^HTTP\/1\.[0-1] 200 Connection established/', $data))
2239 {
2240 // Look for CR/LF or simple LF as line separator,
2241 // (even though it is not valid http)
2242 $pos = strpos($data,"\r\n\r\n");
2243 if($pos || is_int($pos))
2244 {
2245 $bd = $pos+4;
2246 }
2247 else
2248 {
2249 $pos = strpos($data,"\n\n");
2250 if($pos || is_int($pos))
2251 {
2252 $bd = $pos+2;
2253 }
2254 else
2255 {
2256 // No separation between response headers and body: fault?
2257 $bd = 0;
2258 }
2259 }
2260 if ($bd)
2261 {
2262 // this filters out all http headers from proxy.
2263 // maybe we could take them into account, too?
2264 $data = substr($data, $bd);
2265 }
2266 else
2267 {
2268 error_log('XML-RPC: xmlrpcmsg::parseResponse: HTTPS via proxy error, tunnel connection possibly failed');
2269 $r= new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['http_error'], $GLOBALS['xmlrpcstr']['http_error']. ' (HTTPS via proxy error, tunnel connection possibly failed)');
2270 return $r;
2271 }
2272 }
2273
2274 // Strip HTTP 1.1 100 Continue header if present
2275 while(preg_match('/^HTTP\/1\.1 1[0-9]{2} /', $data))
2276 {
2277 $pos = strpos($data, 'HTTP', 12);
2278 // server sent a Continue header without any (valid) content following...
2279 // give the client a chance to know it
2280 if(!$pos && !is_int($pos)) // works fine in php 3, 4 and 5
2281 {
2282 break;
2283 }
2284 $data = substr($data, $pos);
2285 }
2286 if(!preg_match('/^HTTP\/[0-9.]+ 200 /', $data))
2287 {
2288 $errstr= substr($data, 0, strpos($data, "\n")-1);
2289 error_log('XML-RPC: xmlrpcmsg::parseResponse: HTTP error, got response: ' .$errstr);
2290 $r= new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['http_error'], $GLOBALS['xmlrpcstr']['http_error']. ' (' . $errstr . ')');
2291 return $r;
2292 }
2293
2294 $GLOBALS['_xh']['headers'] = array();
2295 $GLOBALS['_xh']['cookies'] = array();
2296
2297 // be tolerant to usage of \n instead of \r\n to separate headers and data
2298 // (even though it is not valid http)
2299 $pos = strpos($data,"\r\n\r\n");
2300 if($pos || is_int($pos))
2301 {
2302 $bd = $pos+4;
2303 }
2304 else
2305 {
2306 $pos = strpos($data,"\n\n");
2307 if($pos || is_int($pos))
2308 {
2309 $bd = $pos+2;
2310 }
2311 else
2312 {
2313 // No separation between response headers and body: fault?
2314 // we could take some action here instead of going on...
2315 $bd = 0;
2316 }
2317 }
2318 // be tolerant to line endings, and extra empty lines
2319 $ar = split("\r?\n", trim(substr($data, 0, $pos)));
2320 while(list(,$line) = @each($ar))
2321 {
2322 // take care of multi-line headers and cookies
2323 $arr = explode(':',$line,2);
2324 if(count($arr) > 1)
2325 {
2326 $header_name = strtolower(trim($arr[0]));
2327 /// @todo some other headers (the ones that allow a CSV list of values)
2328 /// do allow many values to be passed using multiple header lines.
2329 /// We should add content to $GLOBALS['_xh']['headers'][$header_name]
2330 /// instead of replacing it for those...
2331 if ($header_name == 'set-cookie' || $header_name == 'set-cookie2')
2332 {
2333 if ($header_name == 'set-cookie2')
2334 {
2335 // version 2 cookies:
2336 // there could be many cookies on one line, comma separated
2337 $cookies = explode(',', $arr[1]);
2338 }
2339 else
2340 {
2341 $cookies = array($arr[1]);
2342 }
2343 foreach ($cookies as $cookie)
2344 {
2345 // glue together all received cookies, using a comma to separate them
2346 // (same as php does with getallheaders())
2347 if (isset($GLOBALS['_xh']['headers'][$header_name]))
2348 $GLOBALS['_xh']['headers'][$header_name] .= ', ' . trim($cookie);
2349 else
2350 $GLOBALS['_xh']['headers'][$header_name] = trim($cookie);
2351 // parse cookie attributes, in case user wants to correctly honour them
2352 // feature creep: only allow rfc-compliant cookie attributes?
2353 // @todo support for server sending multiple time cookie with same name, but using different PATHs
2354 $cookie = explode(';', $cookie);
2355 foreach ($cookie as $pos => $val)
2356 {
2357 $val = explode('=', $val, 2);
2358 $tag = trim($val[0]);
2359 $val = trim(@$val[1]);
2360 /// @todo with version 1 cookies, we should strip leading and trailing " chars
2361 if ($pos == 0)
2362 {
2363 $cookiename = $tag;
2364 $GLOBALS['_xh']['cookies'][$tag] = array();
2365 $GLOBALS['_xh']['cookies'][$cookiename]['value'] = urldecode($val);
2366 }
2367 else
2368 {
2369 if ($tag != 'value')
2370 {
2371 $GLOBALS['_xh']['cookies'][$cookiename][$tag] = $val;
2372 }
2373 }
2374 }
2375 }
2376 }
2377 else
2378 {
2379 $GLOBALS['_xh']['headers'][$header_name] = trim($arr[1]);
2380 }
2381 }
2382 elseif(isset($header_name))
2383 {
2384 /// @todo version1 cookies might span multiple lines, thus breaking the parsing above
2385 $GLOBALS['_xh']['headers'][$header_name] .= ' ' . trim($line);
2386 }
2387 }
2388
2389 $data = substr($data, $bd);
2390
2391 if($this->debug && count($GLOBALS['_xh']['headers']))
2392 {
2393 print '<PRE>';
2394 foreach($GLOBALS['_xh']['headers'] as $header => $value)
2395 {
2396 print htmlentities("HEADER: $header: $value\n");
2397 }
2398 foreach($GLOBALS['_xh']['cookies'] as $header => $value)
2399 {
2400 print htmlentities("COOKIE: $header={$value['value']}\n");
2401 }
2402 print "</PRE>\n";
2403 }
2404
2405 // if CURL was used for the call, http headers have been processed,
2406 // and dechunking + reinflating have been carried out
2407 if(!$headers_processed)
2408 {
2409 // Decode chunked encoding sent by http 1.1 servers
2410 if(isset($GLOBALS['_xh']['headers']['transfer-encoding']) && $GLOBALS['_xh']['headers']['transfer-encoding'] == 'chunked')
2411 {
2412 if(!$data = decode_chunked($data))
2413 {
2414 error_log('XML-RPC: xmlrpcmsg::parseResponse: errors occurred when trying to rebuild the chunked data received from server');
2415 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['dechunk_fail'], $GLOBALS['xmlrpcstr']['dechunk_fail']);
2416 return $r;
2417 }
2418 }
2419
2420 // Decode gzip-compressed stuff
2421 // code shamelessly inspired from nusoap library by Dietrich Ayala
2422 if(isset($GLOBALS['_xh']['headers']['content-encoding']))
2423 {
2424 $GLOBALS['_xh']['headers']['content-encoding'] = str_replace('x-', '', $GLOBALS['_xh']['headers']['content-encoding']);
2425 if($GLOBALS['_xh']['headers']['content-encoding'] == 'deflate' || $GLOBALS['_xh']['headers']['content-encoding'] == 'gzip')
2426 {
2427 // if decoding works, use it. else assume data wasn't gzencoded
2428 if(function_exists('gzinflate'))
2429 {
2430 if($GLOBALS['_xh']['headers']['content-encoding'] == 'deflate' && $degzdata = @gzuncompress($data))
2431 {
2432 $data = $degzdata;
2433 if($this->debug)
2434 print "<PRE>---INFLATED RESPONSE---[".strlen($data)." chars]---\n" . htmlentities($data) . "\n---END---</PRE>";
2435 }
2436 elseif($GLOBALS['_xh']['headers']['content-encoding'] == 'gzip' && $degzdata = @gzinflate(substr($data, 10)))
2437 {
2438 $data = $degzdata;
2439 if($this->debug)
2440 print "<PRE>---INFLATED RESPONSE---[".strlen($data)." chars]---\n" . htmlentities($data) . "\n---END---</PRE>";
2441 }
2442 else
2443 {
2444 error_log('XML-RPC: xmlrpcmsg::parseResponse: errors occurred when trying to decode the deflated data received from server');
2445 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['decompress_fail'], $GLOBALS['xmlrpcstr']['decompress_fail']);
2446 return $r;
2447 }
2448 }
2449 else
2450 {
2451 error_log('XML-RPC: xmlrpcmsg::parseResponse: the server sent deflated data. Your php install must have the Zlib extension compiled in to support this.');
2452 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['cannot_decompress'], $GLOBALS['xmlrpcstr']['cannot_decompress']);
2453 return $r;
2454 }
2455 }
2456 }
2457 } // end of 'if needed, de-chunk, re-inflate response'
2458
2459 // real stupid hack to avoid PHP 4 complaining about returning NULL by ref
2460 $r = null;
2461 $r =& $r;
2462 return $r;
2463 }
2464
2465 /**
2466 * Parse the xmlrpc response contained in the string $data and return an xmlrpcresp object.
2467 * @param string $data the xmlrpc response, eventually including http headers
2468 * @param bool $headers_processed when true prevents parsing HTTP headers for interpretation of content-encoding and consequent decoding
2469 * @param string $return_type decides return type, i.e. content of response->value(). Either 'xmlrpcvals', 'xml' or 'phpvals'
2470 * @return xmlrpcresp
2471 * @access public
2472 */
2473 function &parseResponse($data='', $headers_processed=false, $return_type='xmlrpcvals')
2474 {
2475 if($this->debug)
2476 {
2477 //by maHo, replaced htmlspecialchars with htmlentities
2478 print "<PRE>---GOT---\n" . htmlentities($data) . "\n---END---\n</PRE>";
2479 }
2480
2481 if($data == '')
2482 {
2483 error_log('XML-RPC: xmlrpcmsg::parseResponse: no response received from server.');
2484 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['no_data'], $GLOBALS['xmlrpcstr']['no_data']);
2485 return $r;
2486 }
2487
2488 $GLOBALS['_xh']=array();
2489
2490 $raw_data = $data;
2491 // parse the HTTP headers of the response, if present, and separate them from data
2492 if(substr($data, 0, 4) == 'HTTP')
2493 {
2494 $r =& $this->parseResponseHeaders($data, $headers_processed);
2495 if ($r)
2496 {
2497 // failed processing of HTTP response headers
2498 // save into response obj the full payload received, for debugging
2499 $r->raw_data = $data;
2500 return $r;
2501 }
2502 }
2503 else
2504 {
2505 $GLOBALS['_xh']['headers'] = array();
2506 $GLOBALS['_xh']['cookies'] = array();
2507 }
2508
2509 if($this->debug)
2510 {
2511 $start = strpos($data, '<!-- SERVER DEBUG INFO (BASE64 ENCODED):');
2512 if ($start)
2513 {
2514 $start += strlen('<!-- SERVER DEBUG INFO (BASE64 ENCODED):');
2515 $end = strpos($data, '-->', $start);
2516 $comments = substr($data, $start, $end-$start);
2517 print "<PRE>---SERVER DEBUG INFO (DECODED) ---\n\t".htmlentities(str_replace("\n", "\n\t", base64_decode($comments)))."\n---END---\n</PRE>";
2518 }
2519 }
2520
2521 // be tolerant of extra whitespace in response body
2522 $data = trim($data);
2523
2524 /// @todo return an error msg if $data=='' ?
2525
2526 // be tolerant of junk after methodResponse (e.g. javascript ads automatically inserted by free hosts)
2527 // idea from Luca Mariano <luca.mariano@email.it> originally in PEARified version of the lib
2528 $bd = false;
2529 // Poor man's version of strrpos for php 4...
2530 $pos = strpos($data, '</methodResponse>');
2531 while($pos || is_int($pos))
2532 {
2533 $bd = $pos+17;
2534 $pos = strpos($data, '</methodResponse>', $bd);
2535 }
2536 if($bd)
2537 {
2538 $data = substr($data, 0, $bd);
2539 }
2540
2541 // if user wants back raw xml, give it to him
2542 if ($return_type == 'xml')
2543 {
2544 $r = new xmlrpcresp($data, 0, '', 'xml');
2545 $r->hdrs = $GLOBALS['_xh']['headers'];
2546 $r->_cookies = $GLOBALS['_xh']['cookies'];
2547 $r->raw_data = $raw_data;
2548 return $r;
2549 }
2550
2551 // try to 'guestimate' the character encoding of the received response
2552 $resp_encoding = guess_encoding(@$GLOBALS['_xh']['headers']['content-type'], $data);
2553
2554 $GLOBALS['_xh']['ac']='';
2555 //$GLOBALS['_xh']['qt']=''; //unused...
2556 $GLOBALS['_xh']['stack'] = array();
2557 $GLOBALS['_xh']['valuestack'] = array();
2558 $GLOBALS['_xh']['isf']=0; // 0 = OK, 1 for xmlrpc fault responses, 2 = invalid xmlrpc
2559 $GLOBALS['_xh']['isf_reason']='';
2560 $GLOBALS['_xh']['rt']=''; // 'methodcall or 'methodresponse'
2561
2562 // if response charset encoding is not known / supported, try to use
2563 // the default encoding and parse the xml anyway, but log a warning...
2564 if (!in_array($resp_encoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
2565 // the following code might be better for mb_string enabled installs, but
2566 // makes the lib about 200% slower...
2567 //if (!is_valid_charset($resp_encoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
2568 {
2569 error_log('XML-RPC: xmlrpcmsg::parseResponse: invalid charset encoding of received response: '.$resp_encoding);
2570 $resp_encoding = $GLOBALS['xmlrpc_defencoding'];
2571 }
2572 $parser = xml_parser_create($resp_encoding);
2573 xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, true);
2574 // G. Giunta 2005/02/13: PHP internally uses ISO-8859-1, so we have to tell
2575 // the xml parser to give us back data in the expected charset.
2576 // What if internal encoding is not in one of the 3 allowed?
2577 // we use the broadest one, ie. utf8
2578 // This allows to send data which is native in various charset,
2579 // by extending xmlrpc_encode_entitites() and setting xmlrpc_internalencoding
2580 if (!in_array($GLOBALS['xmlrpc_internalencoding'], array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
2581 {
2582 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
2583 }
2584 else
2585 {
2586 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $GLOBALS['xmlrpc_internalencoding']);
2587 }
2588
2589 if ($return_type == 'phpvals')
2590 {
2591 xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee_fast');
2592 }
2593 else
2594 {
2595 xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee');
2596 }
2597
2598 xml_set_character_data_handler($parser, 'xmlrpc_cd');
2599 xml_set_default_handler($parser, 'xmlrpc_dh');
2600
2601 // first error check: xml not well formed
2602 if(!xml_parse($parser, $data, count($data)))
2603 {
2604 // thanks to Peter Kocks <peter.kocks@baygate.com>
2605 if((xml_get_current_line_number($parser)) == 1)
2606 {
2607 $errstr = 'XML error at line 1, check URL';
2608 }
2609 else
2610 {
2611 $errstr = sprintf('XML error: %s at line %d, column %d',
2612 xml_error_string(xml_get_error_code($parser)),
2613 xml_get_current_line_number($parser), xml_get_current_column_number($parser));
2614 }
2615 error_log($errstr);
2616 $r= new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['invalid_return'], $GLOBALS['xmlrpcstr']['invalid_return'].' ('.$errstr.')');
2617 xml_parser_free($parser);
2618 if($this->debug)
2619 {
2620 print $errstr;
2621 }
2622 $r->hdrs = $GLOBALS['_xh']['headers'];
2623 $r->_cookies = $GLOBALS['_xh']['cookies'];
2624 $r->raw_data = $raw_data;
2625 return $r;
2626 }
2627 xml_parser_free($parser);
2628 // second error check: xml well formed but not xml-rpc compliant
2629 if ($GLOBALS['_xh']['isf'] > 1)
2630 {
2631 if ($this->debug)
2632 {
2633 /// @todo echo something for user?
2634 }
2635
2636 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['invalid_return'],
2637 $GLOBALS['xmlrpcstr']['invalid_return'] . ' ' . $GLOBALS['_xh']['isf_reason']);
2638 }
2639 // third error check: parsing of the response has somehow gone boink.
2640 // NB: shall we omit this check, since we trust the parsing code?
2641 elseif ($return_type == 'xmlrpcvals' && !is_object($GLOBALS['_xh']['value']))
2642 {
2643 // something odd has happened
2644 // and it's time to generate a client side error
2645 // indicating something odd went on
2646 $r= new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['invalid_return'],
2647 $GLOBALS['xmlrpcstr']['invalid_return']);
2648 }
2649 else
2650 {
2651 if ($this->debug)
2652 {
2653 print "<PRE>---PARSED---\n";
2654 // somehow htmlentities chokes on var_export, and some full html string...
2655 //print htmlentitites(var_export($GLOBALS['_xh']['value'], true));
2656 print htmlspecialchars(var_export($GLOBALS['_xh']['value'], true));
2657 print "\n---END---</PRE>";
2658 }
2659
2660 // note that using =& will raise an error if $GLOBALS['_xh']['st'] does not generate an object.
2661 $v =& $GLOBALS['_xh']['value'];
2662
2663 if($GLOBALS['_xh']['isf'])
2664 {
2665 /// @todo we should test here if server sent an int and a string,
2666 /// and/or coerce them into such...
2667 if ($return_type == 'xmlrpcvals')
2668 {
2669 $errno_v = $v->structmem('faultCode');
2670 $errstr_v = $v->structmem('faultString');
2671 $errno = $errno_v->scalarval();
2672 $errstr = $errstr_v->scalarval();
2673 }
2674 else
2675 {
2676 $errno = $v['faultCode'];
2677 $errstr = $v['faultString'];
2678 }
2679
2680 if($errno == 0)
2681 {
2682 // FAULT returned, errno needs to reflect that
2683 $errno = -1;
2684 }
2685
2686 $r = new xmlrpcresp(0, $errno, $errstr);
2687 }
2688 else
2689 {
2690 $r= new xmlrpcresp($v, 0, '', $return_type);
2691 }
2692 }
2693
2694 $r->hdrs = $GLOBALS['_xh']['headers'];
2695 $r->_cookies = $GLOBALS['_xh']['cookies'];
2696 $r->raw_data = $raw_data;
2697 return $r;
2698 }
2699 }
2700
2701 class xmlrpcval
2702 {
2703 var $me=array();
2704 var $mytype=0;
2705 var $_php_class=null;
2706
2707 /**
2708 * @param mixed $val
2709 * @param string $type any valid xmlrpc type name (lowercase). If null, 'string' is assumed
2710 */
2711 function xmlrpcval($val=-1, $type='')
2712 {
2713 /// @todo: optimization creep - do not call addXX, do it all inline.
2714 /// downside: booleans will not be coerced anymore
2715 if($val!==-1 || $type!='')
2716 {
2717 // optimization creep: inlined all work done by constructor
2718 switch($type)
2719 {
2720 case '':
2721 $this->mytype=1;
2722 $this->me['string']=$val;
2723 break;
2724 case 'i4':
2725 case 'int':
2726 case 'double':
2727 case 'string':
2728 case 'boolean':
2729 case 'dateTime.iso8601':
2730 case 'base64':
2731 case 'null':
2732 $this->mytype=1;
2733 $this->me[$type]=$val;
2734 break;
2735 case 'array':
2736 $this->mytype=2;
2737 $this->me['array']=$val;
2738 break;
2739 case 'struct':
2740 $this->mytype=3;
2741 $this->me['struct']=$val;
2742 break;
2743 default:
2744 error_log("XML-RPC: xmlrpcval::xmlrpcval: not a known type ($type)");
2745 }
2746 /*if($type=='')
2747 {
2748 $type='string';
2749 }
2750 if($GLOBALS['xmlrpcTypes'][$type]==1)
2751 {
2752 $this->addScalar($val,$type);
2753 }
2754 elseif($GLOBALS['xmlrpcTypes'][$type]==2)
2755 {
2756 $this->addArray($val);
2757 }
2758 elseif($GLOBALS['xmlrpcTypes'][$type]==3)
2759 {
2760 $this->addStruct($val);
2761 }*/
2762 }
2763 }
2764
2765 /**
2766 * Add a single php value to an (unitialized) xmlrpcval
2767 * @param mixed $val
2768 * @param string $type
2769 * @return int 1 or 0 on failure
2770 */
2771 function addScalar($val, $type='string')
2772 {
2773 $typeof=@$GLOBALS['xmlrpcTypes'][$type];
2774 if($typeof!=1)
2775 {
2776 error_log("XML-RPC: xmlrpcval::addScalar: not a scalar type ($type)");
2777 return 0;
2778 }
2779
2780 // coerce booleans into correct values
2781 // NB: we should iether do it for datetimes, integers and doubles, too,
2782 // or just plain remove this check, implemnted on booleans only...
2783 if($type==$GLOBALS['xmlrpcBoolean'])
2784 {
2785 if(strcasecmp($val,'true')==0 || $val==1 || ($val==true && strcasecmp($val,'false')))
2786 {
2787 $val=true;
2788 }
2789 else
2790 {
2791 $val=false;
2792 }
2793 }
2794
2795 switch($this->mytype)
2796 {
2797 case 1:
2798 error_log('XML-RPC: xmlrpcval::addScalar: scalar xmlrpcval can have only one value');
2799 return 0;
2800 case 3:
2801 error_log('XML-RPC: xmlrpcval::addScalar: cannot add anonymous scalar to struct xmlrpcval');
2802 return 0;
2803 case 2:
2804 // we're adding a scalar value to an array here
2805 //$ar=$this->me['array'];
2806 //$ar[]= new xmlrpcval($val, $type);
2807 //$this->me['array']=$ar;
2808 // Faster (?) avoid all the costly array-copy-by-val done here...
2809 $this->me['array'][]= new xmlrpcval($val, $type);
2810 return 1;
2811 default:
2812 // a scalar, so set the value and remember we're scalar
2813 $this->me[$type]=$val;
2814 $this->mytype=$typeof;
2815 return 1;
2816 }
2817 }
2818
2819 /**
2820 * Add an array of xmlrpcval objects to an xmlrpcval
2821 * @param array $vals
2822 * @return int 1 or 0 on failure
2823 * @access public
2824 *
2825 * @todo add some checking for $vals to be an array of xmlrpcvals?
2826 */
2827 function addArray($vals)
2828 {
2829 if($this->mytype==0)
2830 {
2831 $this->mytype=$GLOBALS['xmlrpcTypes']['array'];
2832 $this->me['array']=$vals;
2833 return 1;
2834 }
2835 elseif($this->mytype==2)
2836 {
2837 // we're adding to an array here
2838 $this->me['array'] = array_merge($this->me['array'], $vals);
2839 return 1;
2840 }
2841 else
2842 {
2843 error_log('XML-RPC: xmlrpcval::addArray: already initialized as a [' . $this->kindOf() . ']');
2844 return 0;
2845 }
2846 }
2847
2848 /**
2849 * Add an array of named xmlrpcval objects to an xmlrpcval
2850 * @param array $vals
2851 * @return int 1 or 0 on failure
2852 * @access public
2853 *
2854 * @todo add some checking for $vals to be an array?
2855 */
2856 function addStruct($vals)
2857 {
2858 if($this->mytype==0)
2859 {
2860 $this->mytype=$GLOBALS['xmlrpcTypes']['struct'];
2861 $this->me['struct']=$vals;
2862 return 1;
2863 }
2864 elseif($this->mytype==3)
2865 {
2866 // we're adding to a struct here
2867 $this->me['struct'] = array_merge($this->me['struct'], $vals);
2868 return 1;
2869 }
2870 else
2871 {
2872 error_log('XML-RPC: xmlrpcval::addStruct: already initialized as a [' . $this->kindOf() . ']');
2873 return 0;
2874 }
2875 }
2876
2877 // poor man's version of print_r ???
2878 // DEPRECATED!
2879 function dump($ar)
2880 {
2881 foreach($ar as $key => $val)
2882 {
2883 echo "$key => $val<br />";
2884 if($key == 'array')
2885 {
2886 while(list($key2, $val2) = each($val))
2887 {
2888 echo "-- $key2 => $val2<br />";
2889 }
2890 }
2891 }
2892 }
2893
2894 /**
2895 * Returns a string containing "struct", "array" or "scalar" describing the base type of the value
2896 * @return string
2897 * @access public
2898 */
2899 function kindOf()
2900 {
2901 switch($this->mytype)
2902 {
2903 case 3:
2904 return 'struct';
2905 break;
2906 case 2:
2907 return 'array';
2908 break;
2909 case 1:
2910 return 'scalar';
2911 break;
2912 default:
2913 return 'undef';
2914 }
2915 }
2916
2917 /**
2918 * @access private
2919 */
2920 function serializedata($typ, $val, $charset_encoding='')
2921 {
2922 $rs='';
2923 switch(@$GLOBALS['xmlrpcTypes'][$typ])
2924 {
2925 case 1:
2926 switch($typ)
2927 {
2928 case $GLOBALS['xmlrpcBase64']:
2929 $rs.="<${typ}>" . base64_encode($val) . "</${typ}>";
2930 break;
2931 case $GLOBALS['xmlrpcBoolean']:
2932 $rs.="<${typ}>" . ($val ? '1' : '0') . "</${typ}>";
2933 break;
2934 case $GLOBALS['xmlrpcString']:
2935 // G. Giunta 2005/2/13: do NOT use htmlentities, since
2936 // it will produce named html entities, which are invalid xml
2937 $rs.="<${typ}>" . xmlrpc_encode_entitites($val, $GLOBALS['xmlrpc_internalencoding'], $charset_encoding). "</${typ}>";
2938 break;
2939 case $GLOBALS['xmlrpcInt']:
2940 case $GLOBALS['xmlrpcI4']:
2941 $rs.="<${typ}>".(int)$val."</${typ}>";
2942 break;
2943 case $GLOBALS['xmlrpcDouble']:
2944 // avoid using standard conversion of float to string because it is locale-dependent,
2945 // and also because the xmlrpc spec forbids exponential notation
2946 // sprintf('%F') would be most likely ok but it is only available since PHP 4.3.10 and PHP 5.0.3.
2947 // The code below tries its best at keeping max precision while avoiding exp notation,
2948 // but there is of course no limit in the number of decimal places to be used...
2949 $rs.="<${typ}>".preg_replace('/\\.?0+$/','',number_format((double)$val, 128, '.', ''))."</${typ}>";
2950 break;
2951 case $GLOBALS['xmlrpcNull']:
2952 $rs.="<nil/>";
2953 break;
2954 default:
2955 // no standard type value should arrive here, but provide a possibility
2956 // for xmlrpcvals of unknown type...
2957 $rs.="<${typ}>${val}</${typ}>";
2958 }
2959 break;
2960 case 3:
2961 // struct
2962 if ($this->_php_class)
2963 {
2964 $rs.='<struct php_class="' . $this->_php_class . "\">\n";
2965 }
2966 else
2967 {
2968 $rs.="<struct>\n";
2969 }
2970 foreach($val as $key2 => $val2)
2971 {
2972 $rs.='<member><name>'.xmlrpc_encode_entitites($key2, $GLOBALS['xmlrpc_internalencoding'], $charset_encoding)."</name>\n";
2973 //$rs.=$this->serializeval($val2);
2974 $rs.=$val2->serialize($charset_encoding);
2975 $rs.="</member>\n";
2976 }
2977 $rs.='</struct>';
2978 break;
2979 case 2:
2980 // array
2981 $rs.="<array>\n<data>\n";
2982 for($i=0; $i<count($val); $i++)
2983 {
2984 //$rs.=$this->serializeval($val[$i]);
2985 $rs.=$val[$i]->serialize($charset_encoding);
2986 }
2987 $rs.="</data>\n</array>";
2988 break;
2989 default:
2990 break;
2991 }
2992 return $rs;
2993 }
2994
2995 /**
2996 * Returns xml representation of the value. XML prologue not included
2997 * @param string $charset_encoding the charset to be used for serialization. if null, US-ASCII is assumed
2998 * @return string
2999 * @access public
3000 */
3001 function serialize($charset_encoding='')
3002 {
3003 // add check? slower, but helps to avoid recursion in serializing broken xmlrpcvals...
3004 //if (is_object($o) && (get_class($o) == 'xmlrpcval' || is_subclass_of($o, 'xmlrpcval')))
3005 //{
3006 reset($this->me);
3007 list($typ, $val) = each($this->me);
3008 return '<value>' . $this->serializedata($typ, $val, $charset_encoding) . "</value>\n";
3009 //}
3010 }
3011
3012 // DEPRECATED
3013 function serializeval($o)
3014 {
3015 // add check? slower, but helps to avoid recursion in serializing broken xmlrpcvals...
3016 //if (is_object($o) && (get_class($o) == 'xmlrpcval' || is_subclass_of($o, 'xmlrpcval')))
3017 //{
3018 $ar=$o->me;
3019 reset($ar);
3020 list($typ, $val) = each($ar);
3021 return '<value>' . $this->serializedata($typ, $val) . "</value>\n";
3022 //}
3023 }
3024
3025 /**
3026 * Checks wheter a struct member with a given name is present.
3027 * Works only on xmlrpcvals of type struct.
3028 * @param string $m the name of the struct member to be looked up
3029 * @return boolean
3030 * @access public
3031 */
3032 function structmemexists($m)
3033 {
3034 return array_key_exists($m, $this->me['struct']);
3035 }
3036
3037 /**
3038 * Returns the value of a given struct member (an xmlrpcval object in itself).
3039 * Will raise a php warning if struct member of given name does not exist
3040 * @param string $m the name of the struct member to be looked up
3041 * @return xmlrpcval
3042 * @access public
3043 */
3044 function structmem($m)
3045 {
3046 return $this->me['struct'][$m];
3047 }
3048
3049 /**
3050 * Reset internal pointer for xmlrpcvals of type struct.
3051 * @access public
3052 */
3053 function structreset()
3054 {
3055 reset($this->me['struct']);
3056 }
3057
3058 /**
3059 * Return next member element for xmlrpcvals of type struct.
3060 * @return xmlrpcval
3061 * @access public
3062 */
3063 function structeach()
3064 {
3065 return each($this->me['struct']);
3066 }
3067
3068 // DEPRECATED! this code looks like it is very fragile and has not been fixed
3069 // for a long long time. Shall we remove it for 2.0?
3070 function getval()
3071 {
3072 // UNSTABLE
3073 reset($this->me);
3074 list($a,$b)=each($this->me);
3075 // contributed by I Sofer, 2001-03-24
3076 // add support for nested arrays to scalarval
3077 // i've created a new method here, so as to
3078 // preserve back compatibility
3079
3080 if(is_array($b))
3081 {
3082 @reset($b);
3083 while(list($id,$cont) = @each($b))
3084 {
3085 $b[$id] = $cont->scalarval();
3086 }
3087 }
3088
3089 // add support for structures directly encoding php objects
3090 if(is_object($b))
3091 {
3092 $t = get_object_vars($b);
3093 @reset($t);
3094 while(list($id,$cont) = @each($t))
3095 {
3096 $t[$id] = $cont->scalarval();
3097 }
3098 @reset($t);
3099 while(list($id,$cont) = @each($t))
3100 {
3101 @$b->$id = $cont;
3102 }
3103 }
3104 // end contrib
3105 return $b;
3106 }
3107
3108 /**
3109 * Returns the value of a scalar xmlrpcval
3110 * @return mixed
3111 * @access public
3112 */
3113 function scalarval()
3114 {
3115 reset($this->me);
3116 list(,$b)=each($this->me);
3117 return $b;
3118 }
3119
3120 /**
3121 * Returns the type of the xmlrpcval.
3122 * For integers, 'int' is always returned in place of 'i4'
3123 * @return string
3124 * @access public
3125 */
3126 function scalartyp()
3127 {
3128 reset($this->me);
3129 list($a,)=each($this->me);
3130 if($a==$GLOBALS['xmlrpcI4'])
3131 {
3132 $a=$GLOBALS['xmlrpcInt'];
3133 }
3134 return $a;
3135 }
3136
3137 /**
3138 * Returns the m-th member of an xmlrpcval of struct type
3139 * @param integer $m the index of the value to be retrieved (zero based)
3140 * @return xmlrpcval
3141 * @access public
3142 */
3143 function arraymem($m)
3144 {
3145 return $this->me['array'][$m];
3146 }
3147
3148 /**
3149 * Returns the number of members in an xmlrpcval of array type
3150 * @return integer
3151 * @access public
3152 */
3153 function arraysize()
3154 {
3155 return count($this->me['array']);
3156 }
3157
3158 /**
3159 * Returns the number of members in an xmlrpcval of struct type
3160 * @return integer
3161 * @access public
3162 */
3163 function structsize()
3164 {
3165 return count($this->me['struct']);
3166 }
3167 }
3168
3169
3170 // date helpers
3171
3172 /**
3173 * Given a timestamp, return the corresponding ISO8601 encoded string.
3174 *
3175 * Really, timezones ought to be supported
3176 * but the XML-RPC spec says:
3177 *
3178 * "Don't assume a timezone. It should be specified by the server in its
3179 * documentation what assumptions it makes about timezones."
3180 *
3181 * These routines always assume localtime unless
3182 * $utc is set to 1, in which case UTC is assumed
3183 * and an adjustment for locale is made when encoding
3184 *
3185 * @param int $timet (timestamp)
3186 * @param int $utc (0 or 1)
3187 * @return string
3188 */
3189 function iso8601_encode($timet, $utc=0)
3190 {
3191 if(!$utc)
3192 {
3193 $t=strftime("%Y%m%dT%H:%M:%S", $timet);
3194 }
3195 else
3196 {
3197 if(function_exists('gmstrftime'))
3198 {
3199 // gmstrftime doesn't exist in some versions
3200 // of PHP
3201 $t=gmstrftime("%Y%m%dT%H:%M:%S", $timet);
3202 }
3203 else
3204 {
3205 $t=strftime("%Y%m%dT%H:%M:%S", $timet-date('Z'));
3206 }
3207 }
3208 return $t;
3209 }
3210
3211 /**
3212 * Given an ISO8601 date string, return a timet in the localtime, or UTC
3213 * @param string $idate
3214 * @param int $utc either 0 or 1
3215 * @return int (datetime)
3216 */
3217 function iso8601_decode($idate, $utc=0)
3218 {
3219 $t=0;
3220 if(preg_match('/([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})/', $idate, $regs))
3221 {
3222 if($utc)
3223 {
3224 $t=gmmktime($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);
3225 }
3226 else
3227 {
3228 $t=mktime($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);
3229 }
3230 }
3231 return $t;
3232 }
3233
3234 /**
3235 * Takes an xmlrpc value in PHP xmlrpcval object format and translates it into native PHP types.
3236 *
3237 * Works with xmlrpc message objects as input, too.
3238 *
3239 * Given proper options parameter, can rebuild generic php object instances
3240 * (provided those have been encoded to xmlrpc format using a corresponding
3241 * option in php_xmlrpc_encode())
3242 * PLEASE NOTE that rebuilding php objects involves calling their constructor function.
3243 * This means that the remote communication end can decide which php code will
3244 * get executed on your server, leaving the door possibly open to 'php-injection'
3245 * style of attacks (provided you have some classes defined on your server that
3246 * might wreak havoc if instances are built outside an appropriate context).
3247 * Make sure you trust the remote server/client before eanbling this!
3248 *
3249 * @author Dan Libby (dan@libby.com)
3250 *
3251 * @param xmlrpcval $xmlrpc_val
3252 * @param array $options if 'decode_php_objs' is set in the options array, xmlrpc structs can be decoded into php objects
3253 * @return mixed
3254 */
3255 function php_xmlrpc_decode($xmlrpc_val, $options=array())
3256 {
3257 switch($xmlrpc_val->kindOf())
3258 {
3259 case 'scalar':
3260 if (in_array('extension_api', $options))
3261 {
3262 reset($xmlrpc_val->me);
3263 list($typ,$val) = each($xmlrpc_val->me);
3264 switch ($typ)
3265 {
3266 case 'dateTime.iso8601':
3267 $xmlrpc_val->scalar = $val;
3268 $xmlrpc_val->xmlrpc_type = 'datetime';
3269 $xmlrpc_val->timestamp = iso8601_decode($val);
3270 return $xmlrpc_val;
3271 case 'base64':
3272 $xmlrpc_val->scalar = $val;
3273 $xmlrpc_val->type = $typ;
3274 return $xmlrpc_val;
3275 default:
3276 return $xmlrpc_val->scalarval();
3277 }
3278 }
3279 return $xmlrpc_val->scalarval();
3280 case 'array':
3281 $size = $xmlrpc_val->arraysize();
3282 $arr = array();
3283 for($i = 0; $i < $size; $i++)
3284 {
3285 $arr[] = php_xmlrpc_decode($xmlrpc_val->arraymem($i), $options);
3286 }
3287 return $arr;
3288 case 'struct':
3289 $xmlrpc_val->structreset();
3290 // If user said so, try to rebuild php objects for specific struct vals.
3291 /// @todo should we raise a warning for class not found?
3292 // shall we check for proper subclass of xmlrpcval instead of
3293 // presence of _php_class to detect what we can do?
3294 if (in_array('decode_php_objs', $options) && $xmlrpc_val->_php_class != ''
3295 && class_exists($xmlrpc_val->_php_class))
3296 {
3297 $obj = @new $xmlrpc_val->_php_class;
3298 while(list($key,$value)=$xmlrpc_val->structeach())
3299 {
3300 $obj->$key = php_xmlrpc_decode($value, $options);
3301 }
3302 return $obj;
3303 }
3304 else
3305 {
3306 $arr = array();
3307 while(list($key,$value)=$xmlrpc_val->structeach())
3308 {
3309 $arr[$key] = php_xmlrpc_decode($value, $options);
3310 }
3311 return $arr;
3312 }
3313 case 'msg':
3314 $paramcount = $xmlrpc_val->getNumParams();
3315 $arr = array();
3316 for($i = 0; $i < $paramcount; $i++)
3317 {
3318 $arr[] = php_xmlrpc_decode($xmlrpc_val->getParam($i));
3319 }
3320 return $arr;
3321 }
3322 }
3323
3324 // This constant left here only for historical reasons...
3325 // it was used to decide if we have to define xmlrpc_encode on our own, but
3326 // we do not do it anymore
3327 if(function_exists('xmlrpc_decode'))
3328 {
3329 define('XMLRPC_EPI_ENABLED','1');
3330 }
3331 else
3332 {
3333 define('XMLRPC_EPI_ENABLED','0');
3334 }
3335
3336 /**
3337 * Takes native php types and encodes them into xmlrpc PHP object format.
3338 * It will not re-encode xmlrpcval objects.
3339 *
3340 * Feature creep -- could support more types via optional type argument
3341 * (string => datetime support has been added, ??? => base64 not yet)
3342 *
3343 * If given a proper options parameter, php object instances will be encoded
3344 * into 'special' xmlrpc values, that can later be decoded into php objects
3345 * by calling php_xmlrpc_decode() with a corresponding option
3346 *
3347 * @author Dan Libby (dan@libby.com)
3348 *
3349 * @param mixed $php_val the value to be converted into an xmlrpcval object
3350 * @param array $options can include 'encode_php_objs', 'auto_dates', 'null_extension' or 'extension_api'
3351 * @return xmlrpcval
3352 */
3353 function &php_xmlrpc_encode($php_val, $options=array())
3354 {
3355 $type = gettype($php_val);
3356 switch($type)
3357 {
3358 case 'string':
3359 if (in_array('auto_dates', $options) && preg_match('/^[0-9]{8}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/', $php_val))
3360 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcDateTime']);
3361 else
3362 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcString']);
3363 break;
3364 case 'integer':
3365 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcInt']);
3366 break;
3367 case 'double':
3368 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcDouble']);
3369 break;
3370 // <G_Giunta_2001-02-29>
3371 // Add support for encoding/decoding of booleans, since they are supported in PHP
3372 case 'boolean':
3373 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcBoolean']);
3374 break;
3375 // </G_Giunta_2001-02-29>
3376 case 'array':
3377 // PHP arrays can be encoded to either xmlrpc structs or arrays,
3378 // depending on wheter they are hashes or plain 0..n integer indexed
3379 // A shorter one-liner would be
3380 // $tmp = array_diff(array_keys($php_val), range(0, count($php_val)-1));
3381 // but execution time skyrockets!
3382 $j = 0;
3383 $arr = array();
3384 $ko = false;
3385 foreach($php_val as $key => $val)
3386 {
3387 $arr[$key] =& php_xmlrpc_encode($val, $options);
3388 if(!$ko && $key !== $j)
3389 {
3390 $ko = true;
3391 }
3392 $j++;
3393 }
3394 if($ko)
3395 {
3396 $xmlrpc_val = new xmlrpcval($arr, $GLOBALS['xmlrpcStruct']);
3397 }
3398 else
3399 {
3400 $xmlrpc_val = new xmlrpcval($arr, $GLOBALS['xmlrpcArray']);
3401 }
3402 break;
3403 case 'object':
3404 if(is_a($php_val, 'xmlrpcval'))
3405 {
3406 $xmlrpc_val = $php_val;
3407 }
3408 else
3409 {
3410 $arr = array();
3411 while(list($k,$v) = each($php_val))
3412 {
3413 $arr[$k] = php_xmlrpc_encode($v, $options);
3414 }
3415 $xmlrpc_val = new xmlrpcval($arr, $GLOBALS['xmlrpcStruct']);
3416 if (in_array('encode_php_objs', $options))
3417 {
3418 // let's save original class name into xmlrpcval:
3419 // might be useful later on...
3420 $xmlrpc_val->_php_class = get_class($php_val);
3421 }
3422 }
3423 break;
3424 case 'NULL':
3425 if (in_array('extension_api', $options))
3426 {
3427 $xmlrpc_val = new xmlrpcval('', $GLOBALS['xmlrpcString']);
3428 }
3429 if (in_array('null_extension', $options))
3430 {
3431 $xmlrpc_val = new xmlrpcval('', $GLOBALS['xmlrpcNull']);
3432 }
3433 else
3434 {
3435 $xmlrpc_val = new xmlrpcval();
3436 }
3437 break;
3438 case 'resource':
3439 if (in_array('extension_api', $options))
3440 {
3441 $xmlrpc_val = new xmlrpcval((int)$php_val, $GLOBALS['xmlrpcInt']);
3442 }
3443 else
3444 {
3445 $xmlrpc_val = new xmlrpcval();
3446 }
3447 // catch "user function", "unknown type"
3448 default:
3449 // giancarlo pinerolo <ping@alt.it>
3450 // it has to return
3451 // an empty object in case, not a boolean.
3452 $xmlrpc_val = new xmlrpcval();
3453 break;
3454 }
3455 return $xmlrpc_val;
3456 }
3457
3458 /**
3459 * Convert the xml representation of a method response, method request or single
3460 * xmlrpc value into the appropriate object (a.k.a. deserialize)
3461 * @param string $xml_val
3462 * @param array $options
3463 * @return mixed false on error, or an instance of either xmlrpcval, xmlrpcmsg or xmlrpcresp
3464 */
3465 function php_xmlrpc_decode_xml($xml_val, $options=array())
3466 {
3467 $GLOBALS['_xh'] = array();
3468 $GLOBALS['_xh']['ac'] = '';
3469 $GLOBALS['_xh']['stack'] = array();
3470 $GLOBALS['_xh']['valuestack'] = array();
3471 $GLOBALS['_xh']['params'] = array();
3472 $GLOBALS['_xh']['pt'] = array();
3473 $GLOBALS['_xh']['isf'] = 0;
3474 $GLOBALS['_xh']['isf_reason'] = '';
3475 $GLOBALS['_xh']['method'] = false;
3476 $GLOBALS['_xh']['rt'] = '';
3477 /// @todo 'guestimate' encoding
3478 $parser = xml_parser_create();
3479 xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, true);
3480 // What if internal encoding is not in one of the 3 allowed?
3481 // we use the broadest one, ie. utf8!
3482 if (!in_array($GLOBALS['xmlrpc_internalencoding'], array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
3483 {
3484 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
3485 }
3486 else
3487 {
3488 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $GLOBALS['xmlrpc_internalencoding']);
3489 }
3490 xml_set_element_handler($parser, 'xmlrpc_se_any', 'xmlrpc_ee');
3491 xml_set_character_data_handler($parser, 'xmlrpc_cd');
3492 xml_set_default_handler($parser, 'xmlrpc_dh');
3493 if(!xml_parse($parser, $xml_val, 1))
3494 {
3495 $errstr = sprintf('XML error: %s at line %d, column %d',
3496 xml_error_string(xml_get_error_code($parser)),
3497 xml_get_current_line_number($parser), xml_get_current_column_number($parser));
3498 error_log($errstr);
3499 xml_parser_free($parser);
3500 return false;
3501 }
3502 xml_parser_free($parser);
3503 if ($GLOBALS['_xh']['isf'] > 1) // test that $GLOBALS['_xh']['value'] is an obj, too???
3504 {
3505 error_log($GLOBALS['_xh']['isf_reason']);
3506 return false;
3507 }
3508 switch ($GLOBALS['_xh']['rt'])
3509 {
3510 case 'methodresponse':
3511 $v =& $GLOBALS['_xh']['value'];
3512 if ($GLOBALS['_xh']['isf'] == 1)
3513 {
3514 $vc = $v->structmem('faultCode');
3515 $vs = $v->structmem('faultString');
3516 $r = new xmlrpcresp(0, $vc->scalarval(), $vs->scalarval());
3517 }
3518 else
3519 {
3520 $r = new xmlrpcresp($v);
3521 }
3522 return $r;
3523 case 'methodcall':
3524 $m = new xmlrpcmsg($GLOBALS['_xh']['method']);
3525 for($i=0; $i < count($GLOBALS['_xh']['params']); $i++)
3526 {
3527 $m->addParam($GLOBALS['_xh']['params'][$i]);
3528 }
3529 return $m;
3530 case 'value':
3531 return $GLOBALS['_xh']['value'];
3532 default:
3533 return false;
3534 }
3535 }
3536
3537 /**
3538 * decode a string that is encoded w/ "chunked" transfer encoding
3539 * as defined in rfc2068 par. 19.4.6
3540 * code shamelessly stolen from nusoap library by Dietrich Ayala
3541 *
3542 * @param string $buffer the string to be decoded
3543 * @return string
3544 */
3545 function decode_chunked($buffer)
3546 {
3547 // length := 0
3548 $length = 0;
3549 $new = '';
3550
3551 // read chunk-size, chunk-extension (if any) and crlf
3552 // get the position of the linebreak
3553 $chunkend = strpos($buffer,"\r\n") + 2;
3554 $temp = substr($buffer,0,$chunkend);
3555 $chunk_size = hexdec( trim($temp) );
3556 $chunkstart = $chunkend;
3557 while($chunk_size > 0)
3558 {
3559 $chunkend = strpos($buffer, "\r\n", $chunkstart + $chunk_size);
3560
3561 // just in case we got a broken connection
3562 if($chunkend == false)
3563 {
3564 $chunk = substr($buffer,$chunkstart);
3565 // append chunk-data to entity-body
3566 $new .= $chunk;
3567 $length += strlen($chunk);
3568 break;
3569 }
3570
3571 // read chunk-data and crlf
3572 $chunk = substr($buffer,$chunkstart,$chunkend-$chunkstart);
3573 // append chunk-data to entity-body
3574 $new .= $chunk;
3575 // length := length + chunk-size
3576 $length += strlen($chunk);
3577 // read chunk-size and crlf
3578 $chunkstart = $chunkend + 2;
3579
3580 $chunkend = strpos($buffer,"\r\n",$chunkstart)+2;
3581 if($chunkend == false)
3582 {
3583 break; //just in case we got a broken connection
3584 }
3585 $temp = substr($buffer,$chunkstart,$chunkend-$chunkstart);
3586 $chunk_size = hexdec( trim($temp) );
3587 $chunkstart = $chunkend;
3588 }
3589 return $new;
3590 }
3591
3592 /**
3593 * xml charset encoding guessing helper function.
3594 * Tries to determine the charset encoding of an XML chunk received over HTTP.
3595 * NB: according to the spec (RFC 3023), if text/xml content-type is received over HTTP without a content-type,
3596 * we SHOULD assume it is strictly US-ASCII. But we try to be more tolerant of unconforming (legacy?) clients/servers,
3597 * which will be most probably using UTF-8 anyway...
3598 *
3599 * @param string $httpheaders the http Content-type header
3600 * @param string $xmlchunk xml content buffer
3601 * @param string $encoding_prefs comma separated list of character encodings to be used as default (when mb extension is enabled)
3602 *
3603 * @todo explore usage of mb_http_input(): does it detect http headers + post data? if so, use it instead of hand-detection!!!
3604 */
3605 function guess_encoding($httpheader='', $xmlchunk='', $encoding_prefs=null)
3606 {
3607 // discussion: see http://www.yale.edu/pclt/encoding/
3608 // 1 - test if encoding is specified in HTTP HEADERS
3609
3610 //Details:
3611 // LWS: (\13\10)?( |\t)+
3612 // token: (any char but excluded stuff)+
3613 // quoted string: " (any char but double quotes and cointrol chars)* "
3614 // header: Content-type = ...; charset=value(; ...)*
3615 // where value is of type token, no LWS allowed between 'charset' and value
3616 // Note: we do not check for invalid chars in VALUE:
3617 // this had better be done using pure ereg as below
3618 // Note 2: we might be removing whitespace/tabs that ought to be left in if
3619 // the received charset is a quoted string. But nobody uses such charset names...
3620
3621 /// @todo this test will pass if ANY header has charset specification, not only Content-Type. Fix it?
3622 $matches = array();
3623 if(preg_match('/;\s*charset\s*=([^;]+)/i', $httpheader, $matches))
3624 {
3625 return strtoupper(trim($matches[1], " \t\""));
3626 }
3627
3628 // 2 - scan the first bytes of the data for a UTF-16 (or other) BOM pattern
3629 // (source: http://www.w3.org/TR/2000/REC-xml-20001006)
3630 // NOTE: actually, according to the spec, even if we find the BOM and determine
3631 // an encoding, we should check if there is an encoding specified
3632 // in the xml declaration, and verify if they match.
3633 /// @todo implement check as described above?
3634 /// @todo implement check for first bytes of string even without a BOM? (It sure looks harder than for cases WITH a BOM)
3635 if(preg_match('/^(\x00\x00\xFE\xFF|\xFF\xFE\x00\x00|\x00\x00\xFF\xFE|\xFE\xFF\x00\x00)/', $xmlchunk))
3636 {
3637 return 'UCS-4';
3638 }
3639 elseif(preg_match('/^(\xFE\xFF|\xFF\xFE)/', $xmlchunk))
3640 {
3641 return 'UTF-16';
3642 }
3643 elseif(preg_match('/^(\xEF\xBB\xBF)/', $xmlchunk))
3644 {
3645 return 'UTF-8';
3646 }
3647
3648 // 3 - test if encoding is specified in the xml declaration
3649 // Details:
3650 // SPACE: (#x20 | #x9 | #xD | #xA)+ === [ \x9\xD\xA]+
3651 // EQ: SPACE?=SPACE? === [ \x9\xD\xA]*=[ \x9\xD\xA]*
3652 if (preg_match('/^<\?xml\s+version\s*=\s*'. "((?:\"[a-zA-Z0-9_.:-]+\")|(?:'[a-zA-Z0-9_.:-]+'))".
3653 '\s+encoding\s*=\s*' . "((?:\"[A-Za-z][A-Za-z0-9._-]*\")|(?:'[A-Za-z][A-Za-z0-9._-]*'))/",
3654 $xmlchunk, $matches))
3655 {
3656 return strtoupper(substr($matches[2], 1, -1));
3657 }
3658
3659 // 4 - if mbstring is available, let it do the guesswork
3660 // NB: we favour finding an encoding that is compatible with what we can process
3661 if(extension_loaded('mbstring'))
3662 {
3663 if($encoding_prefs)
3664 {
3665 $enc = mb_detect_encoding($xmlchunk, $encoding_prefs);
3666 }
3667 else
3668 {
3669 $enc = mb_detect_encoding($xmlchunk);
3670 }
3671 // NB: mb_detect likes to call it ascii, xml parser likes to call it US_ASCII...
3672 // IANA also likes better US-ASCII, so go with it
3673 if($enc == 'ASCII')
3674 {
3675 $enc = 'US-'.$enc;
3676 }
3677 return $enc;
3678 }
3679 else
3680 {
3681 // no encoding specified: as per HTTP1.1 assume it is iso-8859-1?
3682 // Both RFC 2616 (HTTP 1.1) and 1945 (HTTP 1.0) clearly state that for text/xxx content types
3683 // this should be the standard. And we should be getting text/xml as request and response.
3684 // BUT we have to be backward compatible with the lib, which always used UTF-8 as default...
3685 return $GLOBALS['xmlrpc_defencoding'];
3686 }
3687 }
3688
3689 /**
3690 * Checks if a given charset encoding is present in a list of encodings or
3691 * if it is a valid subset of any encoding in the list
3692 * @param string $encoding charset to be tested
3693 * @param mixed $validlist comma separated list of valid charsets (or array of charsets)
3694 */
3695 function is_valid_charset($encoding, $validlist)
3696 {
3697 $charset_supersets = array(
3698 'US-ASCII' => array ('ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4',
3699 'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8',
3700 'ISO-8859-9', 'ISO-8859-10', 'ISO-8859-11', 'ISO-8859-12',
3701 'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'UTF-8',
3702 'EUC-JP', 'EUC-', 'EUC-KR', 'EUC-CN')
3703 );
3704 if (is_string($validlist))
3705 $validlist = explode(',', $validlist);
3706 if (@in_array(strtoupper($encoding), $validlist))
3707 return true;
3708 else
3709 {
3710 if (array_key_exists($encoding, $charset_supersets))
3711 foreach ($validlist as $allowed)
3712 if (in_array($allowed, $charset_supersets[$encoding]))
3713 return true;
3714 return false;
3715 }
3716 }
3717
3718?> \ No newline at end of file
diff --git a/web/phpxmlrpclib/xmlrpc_wrappers.inc b/web/phpxmlrpclib/xmlrpc_wrappers.inc
deleted file mode 100644
index cb0c6e8..0000000
--- a/web/phpxmlrpclib/xmlrpc_wrappers.inc
+++ /dev/null
@@ -1,944 +0,0 @@
1<?php
2/**
3 * PHP-XMLRPC "wrapper" functions
4 * Generate stubs to transparently access xmlrpc methods as php functions and viceversa
5 *
6 * @version $Id: xmlrpc_wrappers.inc,v 1.13 2008/09/20 01:23:47 ggiunta Exp $
7 * @author Gaetano Giunta
8 * @copyright (C) 2006-2008 G. Giunta
9 * @license code licensed under the BSD License: http://phpxmlrpc.sourceforge.net/license.txt
10 *
11 * @todo separate introspection from code generation for func-2-method wrapping
12 * @todo use some better templating system for code generation?
13 * @todo implement method wrapping with preservation of php objs in calls
14 * @todo when wrapping methods without obj rebuilding, use return_type = 'phpvals' (faster)
15 * @todo implement self-parsing of php code for PHP <= 4
16 */
17
18 // requires: xmlrpc.inc
19
20 /**
21 * Given a string defining a php type or phpxmlrpc type (loosely defined: strings
22 * accepted come from javadoc blocks), return corresponding phpxmlrpc type.
23 * NB: for php 'resource' types returns empty string, since resources cannot be serialized;
24 * for php class names returns 'struct', since php objects can be serialized as xmlrpc structs
25 * @param string $phptype
26 * @return string
27 */
28 function php_2_xmlrpc_type($phptype)
29 {
30 switch(strtolower($phptype))
31 {
32 case 'string':
33 return $GLOBALS['xmlrpcString'];
34 case 'integer':
35 case $GLOBALS['xmlrpcInt']: // 'int'
36 case $GLOBALS['xmlrpcI4']:
37 return $GLOBALS['xmlrpcInt'];
38 case 'double':
39 return $GLOBALS['xmlrpcDouble'];
40 case 'boolean':
41 return $GLOBALS['xmlrpcBoolean'];
42 case 'array':
43 return $GLOBALS['xmlrpcArray'];
44 case 'object':
45 return $GLOBALS['xmlrpcStruct'];
46 case $GLOBALS['xmlrpcBase64']:
47 case $GLOBALS['xmlrpcStruct']:
48 return strtolower($phptype);
49 case 'resource':
50 return '';
51 default:
52 if(class_exists($phptype))
53 {
54 return $GLOBALS['xmlrpcStruct'];
55 }
56 else
57 {
58 // unknown: might be any 'extended' xmlrpc type
59 return $GLOBALS['xmlrpcValue'];
60 }
61 }
62 }
63
64 /**
65 * Given a string defining a phpxmlrpc type return corresponding php type.
66 * @param string $xmlrpctype
67 * @return string
68 */
69 function xmlrpc_2_php_type($xmlrpctype)
70 {
71 switch(strtolower($xmlrpctype))
72 {
73 case 'base64':
74 case 'datetime.iso8601':
75 case 'string':
76 return $GLOBALS['xmlrpcString'];
77 case 'int':
78 case 'i4':
79 return 'integer';
80 case 'struct':
81 case 'array':
82 return 'array';
83 case 'double':
84 return 'float';
85 case 'undefined':
86 return 'mixed';
87 case 'boolean':
88 case 'null':
89 default:
90 // unknown: might be any xmlrpc type
91 return strtolower($xmlrpctype);
92 }
93 }
94
95 /**
96 * Given a user-defined PHP function, create a PHP 'wrapper' function that can
97 * be exposed as xmlrpc method from an xmlrpc_server object and called from remote
98 * clients (as well as its corresponding signature info).
99 *
100 * Since php is a typeless language, to infer types of input and output parameters,
101 * it relies on parsing the javadoc-style comment block associated with the given
102 * function. Usage of xmlrpc native types (such as datetime.dateTime.iso8601 and base64)
103 * in the @param tag is also allowed, if you need the php function to receive/send
104 * data in that particular format (note that base64 encoding/decoding is transparently
105 * carried out by the lib, while datetime vals are passed around as strings)
106 *
107 * Known limitations:
108 * - requires PHP 5.0.3 +
109 * - only works for user-defined functions, not for PHP internal functions
110 * (reflection does not support retrieving number/type of params for those)
111 * - functions returning php objects will generate special xmlrpc responses:
112 * when the xmlrpc decoding of those responses is carried out by this same lib, using
113 * the appropriate param in php_xmlrpc_decode, the php objects will be rebuilt.
114 * In short: php objects can be serialized, too (except for their resource members),
115 * using this function.
116 * Other libs might choke on the very same xml that will be generated in this case
117 * (i.e. it has a nonstandard attribute on struct element tags)
118 * - usage of javadoc @param tags using param names in a different order from the
119 * function prototype is not considered valid (to be fixed?)
120 *
121 * Note that since rel. 2.0RC3 the preferred method to have the server call 'standard'
122 * php functions (ie. functions not expecting a single xmlrpcmsg obj as parameter)
123 * is by making use of the functions_parameters_type class member.
124 *
125 * @param string $funcname the name of the PHP user function to be exposed as xmlrpc method; array($obj, 'methodname') and array('class', 'methodname') are ok too
126 * @param string $newfuncname (optional) name for function to be created
127 * @param array $extra_options (optional) array of options for conversion. valid values include:
128 * bool return_source when true, php code w. function definition will be returned, not evaluated
129 * bool encode_php_objs let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
130 * bool decode_php_objs --- WARNING !!! possible security hazard. only use it with trusted servers ---
131 * bool suppress_warnings remove from produced xml any runtime warnings due to the php function being invoked
132 * @return false on error, or an array containing the name of the new php function,
133 * its signature and docs, to be used in the server dispatch map
134 *
135 * @todo decide how to deal with params passed by ref: bomb out or allow?
136 * @todo finish using javadoc info to build method sig if all params are named but out of order
137 * @todo add a check for params of 'resource' type
138 * @todo add some trigger_errors / error_log when returning false?
139 * @todo what to do when the PHP function returns NULL? we are currently returning an empty string value...
140 * @todo add an option to suppress php warnings in invocation of user function, similar to server debug level 3?
141 * @todo if $newfuncname is empty, we could use create_user_func instead of eval, as it is possibly faster
142 * @todo add a verbatim_object_copy parameter to allow avoiding the same obj instance?
143 */
144 function wrap_php_function($funcname, $newfuncname='', $extra_options=array())
145 {
146 $buildit = isset($extra_options['return_source']) ? !($extra_options['return_source']) : true;
147 $prefix = isset($extra_options['prefix']) ? $extra_options['prefix'] : 'xmlrpc';
148 $encode_php_objects = isset($extra_options['encode_php_objs']) ? (bool)$extra_options['encode_php_objs'] : false;
149 $decode_php_objects = isset($extra_options['decode_php_objs']) ? (bool)$extra_options['decode_php_objs'] : false;
150 $catch_warnings = isset($extra_options['suppress_warnings']) && $extra_options['suppress_warnings'] ? '@' : '';
151
152 if(version_compare(phpversion(), '5.0.3') == -1)
153 {
154 // up to php 5.0.3 some useful reflection methods were missing
155 error_log('XML-RPC: cannot not wrap php functions unless running php version bigger than 5.0.3');
156 return false;
157 }
158
159 $exists = false;
160 if(is_array($funcname))
161 {
162 if(count($funcname) < 2 || (!is_string($funcname[0]) && !is_object($funcname[0])))
163 {
164 error_log('XML-RPC: syntax for function to be wrapped is wrong');
165 return false;
166 }
167 if(is_string($funcname[0]))
168 {
169 $plainfuncname = implode('::', $funcname);
170 }
171 elseif(is_object($funcname[0]))
172 {
173 $plainfuncname = get_class($funcname[0]) . '->' . $funcname[1];
174 }
175 $exists = method_exists($funcname[0], $funcname[1]);
176 }
177 else
178 {
179 $plainfuncname = $funcname;
180 $exists = function_exists($funcname);
181 }
182
183 if(!$exists)
184 {
185 error_log('XML-RPC: function to be wrapped is not defined: '.$plainfuncname);
186 return false;
187 }
188 else
189 {
190 // determine name of new php function
191 if($newfuncname == '')
192 {
193 if(is_array($funcname))
194 {
195 if(is_string($funcname[0]))
196 $xmlrpcfuncname = "{$prefix}_".implode('_', $funcname);
197 else
198 $xmlrpcfuncname = "{$prefix}_".get_class($funcname[0]) . '_' . $funcname[1];
199 }
200 else
201 {
202 $xmlrpcfuncname = "{$prefix}_$funcname";
203 }
204 }
205 else
206 {
207 $xmlrpcfuncname = $newfuncname;
208 }
209 while($buildit && function_exists($xmlrpcfuncname))
210 {
211 $xmlrpcfuncname .= 'x';
212 }
213
214 // start to introspect PHP code
215 if(is_array($funcname))
216 {
217 $func =& new ReflectionMethod($funcname[0], $funcname[1]);
218 if($func->isPrivate())
219 {
220 error_log('XML-RPC: method to be wrapped is private: '.$plainfuncname);
221 return false;
222 }
223 if($func->isProtected())
224 {
225 error_log('XML-RPC: method to be wrapped is protected: '.$plainfuncname);
226 return false;
227 }
228 if($func->isConstructor())
229 {
230 error_log('XML-RPC: method to be wrapped is the constructor: '.$plainfuncname);
231 return false;
232 }
233 if($func->isDestructor())
234 {
235 error_log('XML-RPC: method to be wrapped is the destructor: '.$plainfuncname);
236 return false;
237 }
238 if($func->isAbstract())
239 {
240 error_log('XML-RPC: method to be wrapped is abstract: '.$plainfuncname);
241 return false;
242 }
243 /// @todo add more checks for static vs. nonstatic?
244 }
245 else
246 {
247 $func =& new ReflectionFunction($funcname);
248 }
249 if($func->isInternal())
250 {
251 // Note: from PHP 5.1.0 onward, we will possibly be able to use invokeargs
252 // instead of getparameters to fully reflect internal php functions ?
253 error_log('XML-RPC: function to be wrapped is internal: '.$plainfuncname);
254 return false;
255 }
256
257 // retrieve parameter names, types and description from javadoc comments
258
259 // function description
260 $desc = '';
261 // type of return val: by default 'any'
262 $returns = $GLOBALS['xmlrpcValue'];
263 // desc of return val
264 $returnsDocs = '';
265 // type + name of function parameters
266 $paramDocs = array();
267
268 $docs = $func->getDocComment();
269 if($docs != '')
270 {
271 $docs = explode("\n", $docs);
272 $i = 0;
273 foreach($docs as $doc)
274 {
275 $doc = trim($doc, " \r\t/*");
276 if(strlen($doc) && strpos($doc, '@') !== 0 && !$i)
277 {
278 if($desc)
279 {
280 $desc .= "\n";
281 }
282 $desc .= $doc;
283 }
284 elseif(strpos($doc, '@param') === 0)
285 {
286 // syntax: @param type [$name] desc
287 if(preg_match('/@param\s+(\S+)(\s+\$\S+)?\s+(.+)/', $doc, $matches))
288 {
289 if(strpos($matches[1], '|'))
290 {
291 //$paramDocs[$i]['type'] = explode('|', $matches[1]);
292 $paramDocs[$i]['type'] = 'mixed';
293 }
294 else
295 {
296 $paramDocs[$i]['type'] = $matches[1];
297 }
298 $paramDocs[$i]['name'] = trim($matches[2]);
299 $paramDocs[$i]['doc'] = $matches[3];
300 }
301 $i++;
302 }
303 elseif(strpos($doc, '@return') === 0)
304 {
305 // syntax: @return type desc
306 //$returns = preg_split('/\s+/', $doc);
307 if(preg_match('/@return\s+(\S+)\s+(.+)/', $doc, $matches))
308 {
309 $returns = php_2_xmlrpc_type($matches[1]);
310 if(isset($matches[2]))
311 {
312 $returnsDocs = $matches[2];
313 }
314 }
315 }
316 }
317 }
318
319 // execute introspection of actual function prototype
320 $params = array();
321 $i = 0;
322 foreach($func->getParameters() as $paramobj)
323 {
324 $params[$i] = array();
325 $params[$i]['name'] = '$'.$paramobj->getName();
326 $params[$i]['isoptional'] = $paramobj->isOptional();
327 $i++;
328 }
329
330
331 // start building of PHP code to be eval'd
332 $innercode = '';
333 $i = 0;
334 $parsvariations = array();
335 $pars = array();
336 $pnum = count($params);
337 foreach($params as $param)
338 {
339 if (isset($paramDocs[$i]['name']) && $paramDocs[$i]['name'] && strtolower($paramDocs[$i]['name']) != strtolower($param['name']))
340 {
341 // param name from phpdoc info does not match param definition!
342 $paramDocs[$i]['type'] = 'mixed';
343 }
344
345 if($param['isoptional'])
346 {
347 // this particular parameter is optional. save as valid previous list of parameters
348 $innercode .= "if (\$paramcount > $i) {\n";
349 $parsvariations[] = $pars;
350 }
351 $innercode .= "\$p$i = \$msg->getParam($i);\n";
352 if ($decode_php_objects)
353 {
354 $innercode .= "if (\$p{$i}->kindOf() == 'scalar') \$p$i = \$p{$i}->scalarval(); else \$p$i = php_{$prefix}_decode(\$p$i, array('decode_php_objs'));\n";
355 }
356 else
357 {
358 $innercode .= "if (\$p{$i}->kindOf() == 'scalar') \$p$i = \$p{$i}->scalarval(); else \$p$i = php_{$prefix}_decode(\$p$i);\n";
359 }
360
361 $pars[] = "\$p$i";
362 $i++;
363 if($param['isoptional'])
364 {
365 $innercode .= "}\n";
366 }
367 if($i == $pnum)
368 {
369 // last allowed parameters combination
370 $parsvariations[] = $pars;
371 }
372 }
373
374 $sigs = array();
375 $psigs = array();
376 if(count($parsvariations) == 0)
377 {
378 // only known good synopsis = no parameters
379 $parsvariations[] = array();
380 $minpars = 0;
381 }
382 else
383 {
384 $minpars = count($parsvariations[0]);
385 }
386
387 if($minpars)
388 {
389 // add to code the check for min params number
390 // NB: this check needs to be done BEFORE decoding param values
391 $innercode = "\$paramcount = \$msg->getNumParams();\n" .
392 "if (\$paramcount < $minpars) return new {$prefix}resp(0, {$GLOBALS['xmlrpcerr']['incorrect_params']}, '{$GLOBALS['xmlrpcstr']['incorrect_params']}');\n" . $innercode;
393 }
394 else
395 {
396 $innercode = "\$paramcount = \$msg->getNumParams();\n" . $innercode;
397 }
398
399 $innercode .= "\$np = false;\n";
400 // since there are no closures in php, if we are given an object instance,
401 // we store a pointer to it in a global var...
402 if ( is_array($funcname) && is_object($funcname[0]) )
403 {
404 $GLOBALS['xmlrpcWPFObjHolder'][$xmlrpcfuncname] =& $funcname[0];
405 $innercode .= "\$obj =& \$GLOBALS['xmlrpcWPFObjHolder']['$xmlrpcfuncname'];\n";
406 $realfuncname = '$obj->'.$funcname[1];
407 }
408 else
409 {
410 $realfuncname = $plainfuncname;
411 }
412 foreach($parsvariations as $pars)
413 {
414 $innercode .= "if (\$paramcount == " . count($pars) . ") \$retval = {$catch_warnings}$realfuncname(" . implode(',', $pars) . "); else\n";
415 // build a 'generic' signature (only use an appropriate return type)
416 $sig = array($returns);
417 $psig = array($returnsDocs);
418 for($i=0; $i < count($pars); $i++)
419 {
420 if (isset($paramDocs[$i]['type']))
421 {
422 $sig[] = php_2_xmlrpc_type($paramDocs[$i]['type']);
423 }
424 else
425 {
426 $sig[] = $GLOBALS['xmlrpcValue'];
427 }
428 $psig[] = isset($paramDocs[$i]['doc']) ? $paramDocs[$i]['doc'] : '';
429 }
430 $sigs[] = $sig;
431 $psigs[] = $psig;
432 }
433 $innercode .= "\$np = true;\n";
434 $innercode .= "if (\$np) return new {$prefix}resp(0, {$GLOBALS['xmlrpcerr']['incorrect_params']}, '{$GLOBALS['xmlrpcstr']['incorrect_params']}'); else {\n";
435 //$innercode .= "if (\$_xmlrpcs_error_occurred) return new xmlrpcresp(0, $GLOBALS['xmlrpcerr']user, \$_xmlrpcs_error_occurred); else\n";
436 $innercode .= "if (is_a(\$retval, '{$prefix}resp')) return \$retval; else\n";
437 if($returns == $GLOBALS['xmlrpcDateTime'] || $returns == $GLOBALS['xmlrpcBase64'])
438 {
439 $innercode .= "return new {$prefix}resp(new {$prefix}val(\$retval, '$returns'));";
440 }
441 else
442 {
443 if ($encode_php_objects)
444 $innercode .= "return new {$prefix}resp(php_{$prefix}_encode(\$retval, array('encode_php_objs')));\n";
445 else
446 $innercode .= "return new {$prefix}resp(php_{$prefix}_encode(\$retval));\n";
447 }
448 // shall we exclude functions returning by ref?
449 // if($func->returnsReference())
450 // return false;
451 $code = "function $xmlrpcfuncname(\$msg) {\n" . $innercode . "}\n}";
452 //print_r($code);
453 if ($buildit)
454 {
455 $allOK = 0;
456 eval($code.'$allOK=1;');
457 // alternative
458 //$xmlrpcfuncname = create_function('$m', $innercode);
459
460 if(!$allOK)
461 {
462 error_log('XML-RPC: could not create function '.$xmlrpcfuncname.' to wrap php function '.$plainfuncname);
463 return false;
464 }
465 }
466
467 /// @todo examine if $paramDocs matches $parsvariations and build array for
468 /// usage as method signature, plus put together a nice string for docs
469
470 $ret = array('function' => $xmlrpcfuncname, 'signature' => $sigs, 'docstring' => $desc, 'signature_docs' => $psigs, 'source' => $code);
471 return $ret;
472 }
473 }
474
475 /**
476 * Given a user-defined PHP class or php object, map its methods onto a list of
477 * PHP 'wrapper' functions that can be exposed as xmlrpc methods from an xmlrpc_server
478 * object and called from remote clients (as well as their corresponding signature info).
479 *
480 * @param mixed $classname the name of the class whose methods are to be exposed as xmlrpc methods, or an object instance of that class
481 * @param array $extra_options see the docs for wrap_php_method for more options
482 * string method_type 'static', 'nonstatic', 'all' and 'auto' (default); the latter will switch between static and non-static depending on wheter $classname is a class name or object instance
483 * @return array or false on failure
484 *
485 * @todo get_class_methods will return both static and non-static methods.
486 * we have to differentiate the action, depending on wheter we recived a class name or object
487 */
488 function wrap_php_class($classname, $extra_options=array())
489 {
490 $methodfilter = isset($extra_options['method_filter']) ? $extra_options['method_filter'] : '';
491 $methodtype = isset($extra_options['method_type']) ? $extra_options['method_type'] : 'auto';
492
493 if(version_compare(phpversion(), '5.0.3') == -1)
494 {
495 // up to php 5.0.3 some useful reflection methods were missing
496 error_log('XML-RPC: cannot not wrap php functions unless running php version bigger than 5.0.3');
497 return false;
498 }
499
500 $result = array();
501 $mlist = get_class_methods($classname);
502 foreach($mlist as $mname)
503 {
504 if ($methodfilter == '' || preg_match($methodfilter, $mname))
505 {
506 // echo $mlist."\n";
507 $func =& new ReflectionMethod($classname, $mname);
508 if(!$func->isPrivate() && !$func->isProtected() && !$func->isConstructor() && !$func->isDestructor() && !$func->isAbstract())
509 {
510 if(($func->isStatic && ($methodtype == 'all' || $methodtype == 'static' || ($methodtype == 'auto' && is_string($classname)))) ||
511 (!$func->isStatic && ($methodtype == 'all' || $methodtype == 'nonstatic' || ($methodtype == 'auto' && is_object($classname)))))
512 {
513 $methodwrap = wrap_php_function(array($classname, $mname), '', $extra_options);
514 if ( $methodwrap )
515 {
516 $result[$methodwrap['function']] = $methodwrap['function'];
517 }
518 }
519 }
520 }
521 }
522 return $result;
523 }
524
525 /**
526 * Given an xmlrpc client and a method name, register a php wrapper function
527 * that will call it and return results using native php types for both
528 * params and results. The generated php function will return an xmlrpcresp
529 * oject for failed xmlrpc calls
530 *
531 * Known limitations:
532 * - server must support system.methodsignature for the wanted xmlrpc method
533 * - for methods that expose many signatures, only one can be picked (we
534 * could in priciple check if signatures differ only by number of params
535 * and not by type, but it would be more complication than we can spare time)
536 * - nested xmlrpc params: the caller of the generated php function has to
537 * encode on its own the params passed to the php function if these are structs
538 * or arrays whose (sub)members include values of type datetime or base64
539 *
540 * Notes: the connection properties of the given client will be copied
541 * and reused for the connection used during the call to the generated
542 * php function.
543 * Calling the generated php function 'might' be slow: a new xmlrpc client
544 * is created on every invocation and an xmlrpc-connection opened+closed.
545 * An extra 'debug' param is appended to param list of xmlrpc method, useful
546 * for debugging purposes.
547 *
548 * @param xmlrpc_client $client an xmlrpc client set up correctly to communicate with target server
549 * @param string $methodname the xmlrpc method to be mapped to a php function
550 * @param array $extra_options array of options that specify conversion details. valid ptions include
551 * integer signum the index of the method signature to use in mapping (if method exposes many sigs)
552 * integer timeout timeout (in secs) to be used when executing function/calling remote method
553 * string protocol 'http' (default), 'http11' or 'https'
554 * string new_function_name the name of php function to create. If unsepcified, lib will pick an appropriate name
555 * string return_source if true return php code w. function definition instead fo function name
556 * bool encode_php_objs let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
557 * bool decode_php_objs --- WARNING !!! possible security hazard. only use it with trusted servers ---
558 * mixed return_on_fault a php value to be returned when the xmlrpc call fails/returns a fault response (by default the xmlrpcresp object is returned in this case). If a string is used, '%faultCode%' and '%faultString%' tokens will be substituted with actual error values
559 * bool debug set it to 1 or 2 to see debug results of querying server for method synopsis
560 * @return string the name of the generated php function (or false) - OR AN ARRAY...
561 */
562 function wrap_xmlrpc_method($client, $methodname, $extra_options=0, $timeout=0, $protocol='', $newfuncname='')
563 {
564 // mind numbing: let caller use sane calling convention (as per javadoc, 3 params),
565 // OR the 2.0 calling convention (no options) - we really love backward compat, don't we?
566 if (!is_array($extra_options))
567 {
568 $signum = $extra_options;
569 $extra_options = array();
570 }
571 else
572 {
573 $signum = isset($extra_options['signum']) ? (int)$extra_options['signum'] : 0;
574 $timeout = isset($extra_options['timeout']) ? (int)$extra_options['timeout'] : 0;
575 $protocol = isset($extra_options['protocol']) ? $extra_options['protocol'] : '';
576 $newfuncname = isset($extra_options['new_function_name']) ? $extra_options['new_function_name'] : '';
577 }
578 //$encode_php_objects = in_array('encode_php_objects', $extra_options);
579 //$verbatim_client_copy = in_array('simple_client_copy', $extra_options) ? 1 :
580 // in_array('build_class_code', $extra_options) ? 2 : 0;
581
582 $encode_php_objects = isset($extra_options['encode_php_objs']) ? (bool)$extra_options['encode_php_objs'] : false;
583 $decode_php_objects = isset($extra_options['decode_php_objs']) ? (bool)$extra_options['decode_php_objs'] : false;
584 $simple_client_copy = isset($extra_options['simple_client_copy']) ? (int)($extra_options['simple_client_copy']) : 0;
585 $buildit = isset($extra_options['return_source']) ? !($extra_options['return_source']) : true;
586 $prefix = isset($extra_options['prefix']) ? $extra_options['prefix'] : 'xmlrpc';
587 if (isset($extra_options['return_on_fault']))
588 {
589 $decode_fault = true;
590 $fault_response = $extra_options['return_on_fault'];
591 }
592 else
593 {
594 $decode_fault = false;
595 $fault_response = '';
596 }
597 $debug = isset($extra_options['debug']) ? ($extra_options['debug']) : 0;
598
599 $msgclass = $prefix.'msg';
600 $valclass = $prefix.'val';
601 $decodefunc = 'php_'.$prefix.'_decode';
602
603 $msg =& new $msgclass('system.methodSignature');
604 $msg->addparam(new $valclass($methodname));
605 $client->setDebug($debug);
606 $response =& $client->send($msg, $timeout, $protocol);
607 if($response->faultCode())
608 {
609 error_log('XML-RPC: could not retrieve method signature from remote server for method '.$methodname);
610 return false;
611 }
612 else
613 {
614 $msig = $response->value();
615 if ($client->return_type != 'phpvals')
616 {
617 $msig = $decodefunc($msig);
618 }
619 if(!is_array($msig) || count($msig) <= $signum)
620 {
621 error_log('XML-RPC: could not retrieve method signature nr.'.$signum.' from remote server for method '.$methodname);
622 return false;
623 }
624 else
625 {
626 // pick a suitable name for the new function, avoiding collisions
627 if($newfuncname != '')
628 {
629 $xmlrpcfuncname = $newfuncname;
630 }
631 else
632 {
633 // take care to insure that methodname is translated to valid
634 // php function name
635 $xmlrpcfuncname = $prefix.'_'.preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
636 array('_', ''), $methodname);
637 }
638 while($buildit && function_exists($xmlrpcfuncname))
639 {
640 $xmlrpcfuncname .= 'x';
641 }
642
643 $msig = $msig[$signum];
644 $mdesc = '';
645 // if in 'offline' mode, get method description too.
646 // in online mode, favour speed of operation
647 if(!$buildit)
648 {
649 $msg =& new $msgclass('system.methodHelp');
650 $msg->addparam(new $valclass($methodname));
651 $response =& $client->send($msg, $timeout, $protocol);
652 if (!$response->faultCode())
653 {
654 $mdesc = $response->value();
655 if ($client->return_type != 'phpvals')
656 {
657 $mdesc = $mdesc->scalarval();
658 }
659 }
660 }
661
662 $results = build_remote_method_wrapper_code($client, $methodname,
663 $xmlrpcfuncname, $msig, $mdesc, $timeout, $protocol, $simple_client_copy,
664 $prefix, $decode_php_objects, $encode_php_objects, $decode_fault,
665 $fault_response);
666
667 //print_r($code);
668 if ($buildit)
669 {
670 $allOK = 0;
671 eval($results['source'].'$allOK=1;');
672 // alternative
673 //$xmlrpcfuncname = create_function('$m', $innercode);
674 if($allOK)
675 {
676 return $xmlrpcfuncname;
677 }
678 else
679 {
680 error_log('XML-RPC: could not create function '.$xmlrpcfuncname.' to wrap remote method '.$methodname);
681 return false;
682 }
683 }
684 else
685 {
686 $results['function'] = $xmlrpcfuncname;
687 return $results;
688 }
689 }
690 }
691 }
692
693 /**
694 * Similar to wrap_xmlrpc_method, but will generate a php class that wraps
695 * all xmlrpc methods exposed by the remote server as own methods.
696 * For more details see wrap_xmlrpc_method.
697 * @param xmlrpc_client $client the client obj all set to query the desired server
698 * @param array $extra_options list of options for wrapped code
699 * @return mixed false on error, the name of the created class if all ok or an array with code, class name and comments (if the appropriatevoption is set in extra_options)
700 */
701 function wrap_xmlrpc_server($client, $extra_options=array())
702 {
703 $methodfilter = isset($extra_options['method_filter']) ? $extra_options['method_filter'] : '';
704 //$signum = isset($extra_options['signum']) ? (int)$extra_options['signum'] : 0;
705 $timeout = isset($extra_options['timeout']) ? (int)$extra_options['timeout'] : 0;
706 $protocol = isset($extra_options['protocol']) ? $extra_options['protocol'] : '';
707 $newclassname = isset($extra_options['new_class_name']) ? $extra_options['new_class_name'] : '';
708 $encode_php_objects = isset($extra_options['encode_php_objs']) ? (bool)$extra_options['encode_php_objs'] : false;
709 $decode_php_objects = isset($extra_options['decode_php_objs']) ? (bool)$extra_options['decode_php_objs'] : false;
710 $verbatim_client_copy = isset($extra_options['simple_client_copy']) ? !($extra_options['simple_client_copy']) : true;
711 $buildit = isset($extra_options['return_source']) ? !($extra_options['return_source']) : true;
712 $prefix = isset($extra_options['prefix']) ? $extra_options['prefix'] : 'xmlrpc';
713
714 $msgclass = $prefix.'msg';
715 //$valclass = $prefix.'val';
716 $decodefunc = 'php_'.$prefix.'_decode';
717
718 $msg =& new $msgclass('system.listMethods');
719 $response =& $client->send($msg, $timeout, $protocol);
720 if($response->faultCode())
721 {
722 error_log('XML-RPC: could not retrieve method list from remote server');
723 return false;
724 }
725 else
726 {
727 $mlist = $response->value();
728 if ($client->return_type != 'phpvals')
729 {
730 $mlist = $decodefunc($mlist);
731 }
732 if(!is_array($mlist) || !count($mlist))
733 {
734 error_log('XML-RPC: could not retrieve meaningful method list from remote server');
735 return false;
736 }
737 else
738 {
739 // pick a suitable name for the new function, avoiding collisions
740 if($newclassname != '')
741 {
742 $xmlrpcclassname = $newclassname;
743 }
744 else
745 {
746 $xmlrpcclassname = $prefix.'_'.preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
747 array('_', ''), $client->server).'_client';
748 }
749 while($buildit && class_exists($xmlrpcclassname))
750 {
751 $xmlrpcclassname .= 'x';
752 }
753
754 /// @todo add function setdebug() to new class, to enable/disable debugging
755 $source = "class $xmlrpcclassname\n{\nvar \$client;\n\n";
756 $source .= "function $xmlrpcclassname()\n{\n";
757 $source .= build_client_wrapper_code($client, $verbatim_client_copy, $prefix);
758 $source .= "\$this->client =& \$client;\n}\n\n";
759 $opts = array('simple_client_copy' => 2, 'return_source' => true,
760 'timeout' => $timeout, 'protocol' => $protocol,
761 'encode_php_objs' => $encode_php_objects, 'prefix' => $prefix,
762 'decode_php_objs' => $decode_php_objects
763 );
764 /// @todo build javadoc for class definition, too
765 foreach($mlist as $mname)
766 {
767 if ($methodfilter == '' || preg_match($methodfilter, $mname))
768 {
769 $opts['new_function_name'] = preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
770 array('_', ''), $mname);
771 $methodwrap = wrap_xmlrpc_method($client, $mname, $opts);
772 if ($methodwrap)
773 {
774 if (!$buildit)
775 {
776 $source .= $methodwrap['docstring'];
777 }
778 $source .= $methodwrap['source']."\n";
779 }
780 else
781 {
782 error_log('XML-RPC: will not create class method to wrap remote method '.$mname);
783 }
784 }
785 }
786 $source .= "}\n";
787 if ($buildit)
788 {
789 $allOK = 0;
790 eval($source.'$allOK=1;');
791 // alternative
792 //$xmlrpcfuncname = create_function('$m', $innercode);
793 if($allOK)
794 {
795 return $xmlrpcclassname;
796 }
797 else
798 {
799 error_log('XML-RPC: could not create class '.$xmlrpcclassname.' to wrap remote server '.$client->server);
800 return false;
801 }
802 }
803 else
804 {
805 return array('class' => $xmlrpcclassname, 'code' => $source, 'docstring' => '');
806 }
807 }
808 }
809 }
810
811 /**
812 * Given the necessary info, build php code that creates a new function to
813 * invoke a remote xmlrpc method.
814 * Take care that no full checking of input parameters is done to ensure that
815 * valid php code is emitted.
816 * Note: real spaghetti code follows...
817 * @access private
818 */
819 function build_remote_method_wrapper_code($client, $methodname, $xmlrpcfuncname,
820 $msig, $mdesc='', $timeout=0, $protocol='', $client_copy_mode=0, $prefix='xmlrpc',
821 $decode_php_objects=false, $encode_php_objects=false, $decode_fault=false,
822 $fault_response='')
823 {
824 $code = "function $xmlrpcfuncname (";
825 if ($client_copy_mode < 2)
826 {
827 // client copy mode 0 or 1 == partial / full client copy in emitted code
828 $innercode = build_client_wrapper_code($client, $client_copy_mode, $prefix);
829 $innercode .= "\$client->setDebug(\$debug);\n";
830 $this_ = '';
831 }
832 else
833 {
834 // client copy mode 2 == no client copy in emitted code
835 $innercode = '';
836 $this_ = 'this->';
837 }
838 $innercode .= "\$msg =& new {$prefix}msg('$methodname');\n";
839
840 if ($mdesc != '')
841 {
842 // take care that PHP comment is not terminated unwillingly by method description
843 $mdesc = "/**\n* ".str_replace('*/', '* /', $mdesc)."\n";
844 }
845 else
846 {
847 $mdesc = "/**\nFunction $xmlrpcfuncname\n";
848 }
849
850 // param parsing
851 $plist = array();
852 $pcount = count($msig);
853 for($i = 1; $i < $pcount; $i++)
854 {
855 $plist[] = "\$p$i";
856 $ptype = $msig[$i];
857 if($ptype == 'i4' || $ptype == 'int' || $ptype == 'boolean' || $ptype == 'double' ||
858 $ptype == 'string' || $ptype == 'dateTime.iso8601' || $ptype == 'base64' || $ptype == 'null')
859 {
860 // only build directly xmlrpcvals when type is known and scalar
861 $innercode .= "\$p$i =& new {$prefix}val(\$p$i, '$ptype');\n";
862 }
863 else
864 {
865 if ($encode_php_objects)
866 {
867 $innercode .= "\$p$i =& php_{$prefix}_encode(\$p$i, array('encode_php_objs'));\n";
868 }
869 else
870 {
871 $innercode .= "\$p$i =& php_{$prefix}_encode(\$p$i);\n";
872 }
873 }
874 $innercode .= "\$msg->addparam(\$p$i);\n";
875 $mdesc .= '* @param '.xmlrpc_2_php_type($ptype)." \$p$i\n";
876 }
877 if ($client_copy_mode < 2)
878 {
879 $plist[] = '$debug=0';
880 $mdesc .= "* @param int \$debug when 1 (or 2) will enable debugging of the underlying {$prefix} call (defaults to 0)\n";
881 }
882 $plist = implode(', ', $plist);
883 $mdesc .= '* @return '.xmlrpc_2_php_type($msig[0])." (or an {$prefix}resp obj instance if call fails)\n*/\n";
884
885 $innercode .= "\$res =& \${$this_}client->send(\$msg, $timeout, '$protocol');\n";
886 if ($decode_fault)
887 {
888 if (is_string($fault_response) && ((strpos($fault_response, '%faultCode%') !== false) || (strpos($fault_response, '%faultString%') !== false)))
889 {
890 $respcode = "str_replace(array('%faultCode%', '%faultString%'), array(\$res->faultCode(), \$res->faultString()), '".str_replace("'", "''", $fault_response)."')";
891 }
892 else
893 {
894 $respcode = var_export($fault_response, true);
895 }
896 }
897 else
898 {
899 $respcode = '$res';
900 }
901 if ($decode_php_objects)
902 {
903 $innercode .= "if (\$res->faultcode()) return $respcode; else return php_{$prefix}_decode(\$res->value(), array('decode_php_objs'));";
904 }
905 else
906 {
907 $innercode .= "if (\$res->faultcode()) return $respcode; else return php_{$prefix}_decode(\$res->value());";
908 }
909
910 $code = $code . $plist. ") {\n" . $innercode . "\n}\n";
911
912 return array('source' => $code, 'docstring' => $mdesc);
913 }
914
915 /**
916 * Given necessary info, generate php code that will rebuild a client object
917 * Take care that no full checking of input parameters is done to ensure that
918 * valid php code is emitted.
919 * @access private
920 */
921 function build_client_wrapper_code($client, $verbatim_client_copy, $prefix='xmlrpc')
922 {
923 $code = "\$client =& new {$prefix}_client('".str_replace("'", "\'", $client->path).
924 "', '" . str_replace("'", "\'", $client->server) . "', $client->port);\n";
925
926 // copy all client fields to the client that will be generated runtime
927 // (this provides for future expansion or subclassing of client obj)
928 if ($verbatim_client_copy)
929 {
930 foreach($client as $fld => $val)
931 {
932 if($fld != 'debug' && $fld != 'return_type')
933 {
934 $val = var_export($val, true);
935 $code .= "\$client->$fld = $val;\n";
936 }
937 }
938 }
939 // only make sure that client always returns the correct data type
940 $code .= "\$client->return_type = '{$prefix}vals';\n";
941 //$code .= "\$client->setDebug(\$debug);\n";
942 return $code;
943 }
944?> \ No newline at end of file
diff --git a/web/phpxmlrpclib/xmlrpcs.inc b/web/phpxmlrpclib/xmlrpcs.inc
deleted file mode 100644
index 7b47ca0..0000000
--- a/web/phpxmlrpclib/xmlrpcs.inc
+++ /dev/null
@@ -1,1198 +0,0 @@
1<?php
2// by Edd Dumbill (C) 1999-2002
3// <edd@usefulinc.com>
4// $Id: xmlrpcs.inc,v 1.71 2008/10/29 23:41:28 ggiunta Exp $
5
6// Copyright (c) 1999,2000,2002 Edd Dumbill.
7// All rights reserved.
8//
9// Redistribution and use in source and binary forms, with or without
10// modification, are permitted provided that the following conditions
11// are met:
12//
13// * Redistributions of source code must retain the above copyright
14// notice, this list of conditions and the following disclaimer.
15//
16// * Redistributions in binary form must reproduce the above
17// copyright notice, this list of conditions and the following
18// disclaimer in the documentation and/or other materials provided
19// with the distribution.
20//
21// * Neither the name of the "XML-RPC for PHP" nor the names of its
22// contributors may be used to endorse or promote products derived
23// from this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
28// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
29// REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
30// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
31// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
32// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
34// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
36// OF THE POSSIBILITY OF SUCH DAMAGE.
37
38 // XML RPC Server class
39 // requires: xmlrpc.inc
40
41 $GLOBALS['xmlrpcs_capabilities'] = array(
42 // xmlrpc spec: always supported
43 'xmlrpc' => new xmlrpcval(array(
44 'specUrl' => new xmlrpcval('http://www.xmlrpc.com/spec', 'string'),
45 'specVersion' => new xmlrpcval(1, 'int')
46 ), 'struct'),
47 // if we support system.xxx functions, we always support multicall, too...
48 // Note that, as of 2006/09/17, the following URL does not respond anymore
49 'system.multicall' => new xmlrpcval(array(
50 'specUrl' => new xmlrpcval('http://www.xmlrpc.com/discuss/msgReader$1208', 'string'),
51 'specVersion' => new xmlrpcval(1, 'int')
52 ), 'struct'),
53 // introspection: version 2! we support 'mixed', too
54 'introspection' => new xmlrpcval(array(
55 'specUrl' => new xmlrpcval('http://phpxmlrpc.sourceforge.net/doc-2/ch10.html', 'string'),
56 'specVersion' => new xmlrpcval(2, 'int')
57 ), 'struct')
58 );
59
60 /* Functions that implement system.XXX methods of xmlrpc servers */
61 $_xmlrpcs_getCapabilities_sig=array(array($GLOBALS['xmlrpcStruct']));
62 $_xmlrpcs_getCapabilities_doc='This method lists all the capabilites that the XML-RPC server has: the (more or less standard) extensions to the xmlrpc spec that it adheres to';
63 $_xmlrpcs_getCapabilities_sdoc=array(array('list of capabilities, described as structs with a version number and url for the spec'));
64 function _xmlrpcs_getCapabilities($server, $m=null)
65 {
66 $outAr = $GLOBALS['xmlrpcs_capabilities'];
67 // NIL extension
68 if ($GLOBALS['xmlrpc_null_extension']) {
69 $outAr['nil'] = new xmlrpcval(array(
70 'specUrl' => new xmlrpcval('http://www.ontosys.com/xml-rpc/extensions.php', 'string'),
71 'specVersion' => new xmlrpcval(1, 'int')
72 ), 'struct');
73 }
74 return new xmlrpcresp(new xmlrpcval($outAr, 'struct'));
75 }
76
77 // listMethods: signature was either a string, or nothing.
78 // The useless string variant has been removed
79 $_xmlrpcs_listMethods_sig=array(array($GLOBALS['xmlrpcArray']));
80 $_xmlrpcs_listMethods_doc='This method lists all the methods that the XML-RPC server knows how to dispatch';
81 $_xmlrpcs_listMethods_sdoc=array(array('list of method names'));
82 function _xmlrpcs_listMethods($server, $m=null) // if called in plain php values mode, second param is missing
83 {
84
85 $outAr=array();
86 foreach($server->dmap as $key => $val)
87 {
88 $outAr[]= new xmlrpcval($key, 'string');
89 }
90 if($server->allow_system_funcs)
91 {
92 foreach($GLOBALS['_xmlrpcs_dmap'] as $key => $val)
93 {
94 $outAr[]= new xmlrpcval($key, 'string');
95 }
96 }
97 return new xmlrpcresp(new xmlrpcval($outAr, 'array'));
98 }
99
100 $_xmlrpcs_methodSignature_sig=array(array($GLOBALS['xmlrpcArray'], $GLOBALS['xmlrpcString']));
101 $_xmlrpcs_methodSignature_doc='Returns an array of known signatures (an array of arrays) for the method name passed. If no signatures are known, returns a none-array (test for type != array to detect missing signature)';
102 $_xmlrpcs_methodSignature_sdoc=array(array('list of known signatures, each sig being an array of xmlrpc type names', 'name of method to be described'));
103 function _xmlrpcs_methodSignature($server, $m)
104 {
105 // let accept as parameter both an xmlrpcval or string
106 if (is_object($m))
107 {
108 $methName=$m->getParam(0);
109 $methName=$methName->scalarval();
110 }
111 else
112 {
113 $methName=$m;
114 }
115 if(strpos($methName, "system.") === 0)
116 {
117 $dmap=$GLOBALS['_xmlrpcs_dmap']; $sysCall=1;
118 }
119 else
120 {
121 $dmap=$server->dmap; $sysCall=0;
122 }
123 if(isset($dmap[$methName]))
124 {
125 if(isset($dmap[$methName]['signature']))
126 {
127 $sigs=array();
128 foreach($dmap[$methName]['signature'] as $inSig)
129 {
130 $cursig=array();
131 foreach($inSig as $sig)
132 {
133 $cursig[]= new xmlrpcval($sig, 'string');
134 }
135 $sigs[]= new xmlrpcval($cursig, 'array');
136 }
137 $r= new xmlrpcresp(new xmlrpcval($sigs, 'array'));
138 }
139 else
140 {
141 // NB: according to the official docs, we should be returning a
142 // "none-array" here, which means not-an-array
143 $r= new xmlrpcresp(new xmlrpcval('undef', 'string'));
144 }
145 }
146 else
147 {
148 $r= new xmlrpcresp(0,$GLOBALS['xmlrpcerr']['introspect_unknown'], $GLOBALS['xmlrpcstr']['introspect_unknown']);
149 }
150 return $r;
151 }
152
153 $_xmlrpcs_methodHelp_sig=array(array($GLOBALS['xmlrpcString'], $GLOBALS['xmlrpcString']));
154 $_xmlrpcs_methodHelp_doc='Returns help text if defined for the method passed, otherwise returns an empty string';
155 $_xmlrpcs_methodHelp_sdoc=array(array('method description', 'name of the method to be described'));
156 function _xmlrpcs_methodHelp($server, $m)
157 {
158 // let accept as parameter both an xmlrpcval or string
159 if (is_object($m))
160 {
161 $methName=$m->getParam(0);
162 $methName=$methName->scalarval();
163 }
164 else
165 {
166 $methName=$m;
167 }
168 if(strpos($methName, "system.") === 0)
169 {
170 $dmap=$GLOBALS['_xmlrpcs_dmap']; $sysCall=1;
171 }
172 else
173 {
174 $dmap=$server->dmap; $sysCall=0;
175 }
176 if(isset($dmap[$methName]))
177 {
178 if(isset($dmap[$methName]['docstring']))
179 {
180 $r= new xmlrpcresp(new xmlrpcval($dmap[$methName]['docstring']), 'string');
181 }
182 else
183 {
184 $r= new xmlrpcresp(new xmlrpcval('', 'string'));
185 }
186 }
187 else
188 {
189 $r=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['introspect_unknown'], $GLOBALS['xmlrpcstr']['introspect_unknown']);
190 }
191 return $r;
192 }
193
194 $_xmlrpcs_multicall_sig = array(array($GLOBALS['xmlrpcArray'], $GLOBALS['xmlrpcArray']));
195 $_xmlrpcs_multicall_doc = 'Boxcar multiple RPC calls in one request. See http://www.xmlrpc.com/discuss/msgReader$1208 for details';
196 $_xmlrpcs_multicall_sdoc = array(array('list of response structs, where each struct has the usual members', 'list of calls, with each call being represented as a struct, with members "methodname" and "params"'));
197 function _xmlrpcs_multicall_error($err)
198 {
199 if(is_string($err))
200 {
201 $str = $GLOBALS['xmlrpcstr']["multicall_${err}"];
202 $code = $GLOBALS['xmlrpcerr']["multicall_${err}"];
203 }
204 else
205 {
206 $code = $err->faultCode();
207 $str = $err->faultString();
208 }
209 $struct = array();
210 $struct['faultCode'] = new xmlrpcval($code, 'int');
211 $struct['faultString'] = new xmlrpcval($str, 'string');
212 return new xmlrpcval($struct, 'struct');
213 }
214
215 function _xmlrpcs_multicall_do_call($server, $call)
216 {
217 if($call->kindOf() != 'struct')
218 {
219 return _xmlrpcs_multicall_error('notstruct');
220 }
221 $methName = @$call->structmem('methodName');
222 if(!$methName)
223 {
224 return _xmlrpcs_multicall_error('nomethod');
225 }
226 if($methName->kindOf() != 'scalar' || $methName->scalartyp() != 'string')
227 {
228 return _xmlrpcs_multicall_error('notstring');
229 }
230 if($methName->scalarval() == 'system.multicall')
231 {
232 return _xmlrpcs_multicall_error('recursion');
233 }
234
235 $params = @$call->structmem('params');
236 if(!$params)
237 {
238 return _xmlrpcs_multicall_error('noparams');
239 }
240 if($params->kindOf() != 'array')
241 {
242 return _xmlrpcs_multicall_error('notarray');
243 }
244 $numParams = $params->arraysize();
245
246 $msg = new xmlrpcmsg($methName->scalarval());
247 for($i = 0; $i < $numParams; $i++)
248 {
249 if(!$msg->addParam($params->arraymem($i)))
250 {
251 $i++;
252 return _xmlrpcs_multicall_error(new xmlrpcresp(0,
253 $GLOBALS['xmlrpcerr']['incorrect_params'],
254 $GLOBALS['xmlrpcstr']['incorrect_params'] . ": probable xml error in param " . $i));
255 }
256 }
257
258 $result = $server->execute($msg);
259
260 if($result->faultCode() != 0)
261 {
262 return _xmlrpcs_multicall_error($result); // Method returned fault.
263 }
264
265 return new xmlrpcval(array($result->value()), 'array');
266 }
267
268 function _xmlrpcs_multicall_do_call_phpvals($server, $call)
269 {
270 if(!is_array($call))
271 {
272 return _xmlrpcs_multicall_error('notstruct');
273 }
274 if(!array_key_exists('methodName', $call))
275 {
276 return _xmlrpcs_multicall_error('nomethod');
277 }
278 if (!is_string($call['methodName']))
279 {
280 return _xmlrpcs_multicall_error('notstring');
281 }
282 if($call['methodName'] == 'system.multicall')
283 {
284 return _xmlrpcs_multicall_error('recursion');
285 }
286 if(!array_key_exists('params', $call))
287 {
288 return _xmlrpcs_multicall_error('noparams');
289 }
290 if(!is_array($call['params']))
291 {
292 return _xmlrpcs_multicall_error('notarray');
293 }
294
295 // this is a real dirty and simplistic hack, since we might have received a
296 // base64 or datetime values, but they will be listed as strings here...
297 $numParams = count($call['params']);
298 $pt = array();
299 foreach($call['params'] as $val)
300 $pt[] = php_2_xmlrpc_type(gettype($val));
301
302 $result = $server->execute($call['methodName'], $call['params'], $pt);
303
304 if($result->faultCode() != 0)
305 {
306 return _xmlrpcs_multicall_error($result); // Method returned fault.
307 }
308
309 return new xmlrpcval(array($result->value()), 'array');
310 }
311
312 function _xmlrpcs_multicall($server, $m)
313 {
314 $result = array();
315 // let accept a plain list of php parameters, beside a single xmlrpc msg object
316 if (is_object($m))
317 {
318 $calls = $m->getParam(0);
319 $numCalls = $calls->arraysize();
320 for($i = 0; $i < $numCalls; $i++)
321 {
322 $call = $calls->arraymem($i);
323 $result[$i] = _xmlrpcs_multicall_do_call($server, $call);
324 }
325 }
326 else
327 {
328 $numCalls=count($m);
329 for($i = 0; $i < $numCalls; $i++)
330 {
331 $result[$i] = _xmlrpcs_multicall_do_call_phpvals($server, $m[$i]);
332 }
333 }
334
335 return new xmlrpcresp(new xmlrpcval($result, 'array'));
336 }
337
338 $GLOBALS['_xmlrpcs_dmap']=array(
339 'system.listMethods' => array(
340 'function' => '_xmlrpcs_listMethods',
341 'signature' => $_xmlrpcs_listMethods_sig,
342 'docstring' => $_xmlrpcs_listMethods_doc,
343 'signature_docs' => $_xmlrpcs_listMethods_sdoc),
344 'system.methodHelp' => array(
345 'function' => '_xmlrpcs_methodHelp',
346 'signature' => $_xmlrpcs_methodHelp_sig,
347 'docstring' => $_xmlrpcs_methodHelp_doc,
348 'signature_docs' => $_xmlrpcs_methodHelp_sdoc),
349 'system.methodSignature' => array(
350 'function' => '_xmlrpcs_methodSignature',
351 'signature' => $_xmlrpcs_methodSignature_sig,
352 'docstring' => $_xmlrpcs_methodSignature_doc,
353 'signature_docs' => $_xmlrpcs_methodSignature_sdoc),
354 'system.multicall' => array(
355 'function' => '_xmlrpcs_multicall',
356 'signature' => $_xmlrpcs_multicall_sig,
357 'docstring' => $_xmlrpcs_multicall_doc,
358 'signature_docs' => $_xmlrpcs_multicall_sdoc),
359 'system.getCapabilities' => array(
360 'function' => '_xmlrpcs_getCapabilities',
361 'signature' => $_xmlrpcs_getCapabilities_sig,
362 'docstring' => $_xmlrpcs_getCapabilities_doc,
363 'signature_docs' => $_xmlrpcs_getCapabilities_sdoc)
364 );
365
366 $GLOBALS['_xmlrpcs_occurred_errors'] = '';
367 $GLOBALS['_xmlrpcs_prev_ehandler'] = '';
368 /**
369 * Error handler used to track errors that occur during server-side execution of PHP code.
370 * This allows to report back to the client whether an internal error has occurred or not
371 * using an xmlrpc response object, instead of letting the client deal with the html junk
372 * that a PHP execution error on the server generally entails.
373 *
374 * NB: in fact a user defined error handler can only handle WARNING, NOTICE and USER_* errors.
375 *
376 */
377 function _xmlrpcs_errorHandler($errcode, $errstring, $filename=null, $lineno=null, $context=null)
378 {
379 // obey the @ protocol
380 if (error_reporting() == 0)
381 return;
382
383 //if($errcode != E_NOTICE && $errcode != E_WARNING && $errcode != E_USER_NOTICE && $errcode != E_USER_WARNING)
384 if($errcode != 2048) // do not use E_STRICT by name, since on PHP 4 it will not be defined
385 {
386 $GLOBALS['_xmlrpcs_occurred_errors'] = $GLOBALS['_xmlrpcs_occurred_errors'] . $errstring . "\n";
387 }
388 // Try to avoid as much as possible disruption to the previous error handling
389 // mechanism in place
390 if($GLOBALS['_xmlrpcs_prev_ehandler'] == '')
391 {
392 // The previous error handler was the default: all we should do is log error
393 // to the default error log (if level high enough)
394 if(ini_get('log_errors') && (intval(ini_get('error_reporting')) & $errcode))
395 {
396 error_log($errstring);
397 }
398 }
399 else
400 {
401 // Pass control on to previous error handler, trying to avoid loops...
402 if($GLOBALS['_xmlrpcs_prev_ehandler'] != '_xmlrpcs_errorHandler')
403 {
404 // NB: this code will NOT work on php < 4.0.2: only 2 params were used for error handlers
405 if(is_array($GLOBALS['_xmlrpcs_prev_ehandler']))
406 {
407 // the following works both with static class methods and plain object methods as error handler
408 call_user_func_array($GLOBALS['_xmlrpcs_prev_ehandler'], array($errcode, $errstring, $filename, $lineno, $context));
409 }
410 else
411 {
412 $GLOBALS['_xmlrpcs_prev_ehandler']($errcode, $errstring, $filename, $lineno, $context);
413 }
414 }
415 }
416 }
417
418 $GLOBALS['_xmlrpc_debuginfo']='';
419
420 /**
421 * Add a string to the debug info that can be later seralized by the server
422 * as part of the response message.
423 * Note that for best compatbility, the debug string should be encoded using
424 * the $GLOBALS['xmlrpc_internalencoding'] character set.
425 * @param string $m
426 * @access public
427 */
428 function xmlrpc_debugmsg($m)
429 {
430 $GLOBALS['_xmlrpc_debuginfo'] .= $m . "\n";
431 }
432
433 class xmlrpc_server
434 {
435 /// array defining php functions exposed as xmlrpc methods by this server
436 var $dmap=array();
437 /**
438 * Defines how functions in dmap will be invokde: either using an xmlrpc msg object
439 * or plain php values.
440 * valid strings are 'xmlrpcvals', 'phpvals' or 'epivals'
441 */
442 var $functions_parameters_type='xmlrpcvals';
443 /// controls wether the server is going to echo debugging messages back to the client as comments in response body. valid values: 0,1,2,3
444 var $debug = 1;
445 /**
446 * When set to true, it will enable HTTP compression of the response, in case
447 * the client has declared its support for compression in the request.
448 */
449 var $compress_response = false;
450 /**
451 * List of http compression methods accepted by the server for requests.
452 * NB: PHP supports deflate, gzip compressions out of the box if compiled w. zlib
453 */
454 var $accepted_compression = array();
455 /// shall we serve calls to system.* methods?
456 var $allow_system_funcs = true;
457 /// list of charset encodings natively accepted for requests
458 var $accepted_charset_encodings = array();
459 /**
460 * charset encoding to be used for response.
461 * NB: if we can, we will convert the generated response from internal_encoding to the intended one.
462 * can be: a supported xml encoding (only UTF-8 and ISO-8859-1 at present, unless mbstring is enabled),
463 * null (leave unspecified in response, convert output stream to US_ASCII),
464 * 'default' (use xmlrpc library default as specified in xmlrpc.inc, convert output stream if needed),
465 * or 'auto' (use client-specified charset encoding or same as request if request headers do not specify it (unless request is US-ASCII: then use library default anyway).
466 * NB: pretty dangerous if you accept every charset and do not have mbstring enabled)
467 */
468 var $response_charset_encoding = '';
469 /// storage for internal debug info
470 var $debug_info = '';
471 /// extra data passed at runtime to method handling functions. Used only by EPI layer
472 var $user_data = null;
473
474 /**
475 * @param array $dispmap the dispatch map withd efinition of exposed services
476 * @param boolean $servicenow set to false to prevent the server from runnung upon construction
477 */
478 function xmlrpc_server($dispMap=null, $serviceNow=true)
479 {
480 // if ZLIB is enabled, let the server by default accept compressed requests,
481 // and compress responses sent to clients that support them
482 if(function_exists('gzinflate'))
483 {
484 $this->accepted_compression = array('gzip', 'deflate');
485 $this->compress_response = true;
486 }
487
488 // by default the xml parser can support these 3 charset encodings
489 $this->accepted_charset_encodings = array('UTF-8', 'ISO-8859-1', 'US-ASCII');
490
491 // dispMap is a dispatch array of methods
492 // mapped to function names and signatures
493 // if a method
494 // doesn't appear in the map then an unknown
495 // method error is generated
496 /* milosch - changed to make passing dispMap optional.
497 * instead, you can use the class add_to_map() function
498 * to add functions manually (borrowed from SOAPX4)
499 */
500 if($dispMap)
501 {
502 $this->dmap = $dispMap;
503 if($serviceNow)
504 {
505 $this->service();
506 }
507 }
508 }
509
510 /**
511 * Set debug level of server.
512 * @param integer $in debug lvl: determines info added to xmlrpc responses (as xml comments)
513 * 0 = no debug info,
514 * 1 = msgs set from user with debugmsg(),
515 * 2 = add complete xmlrpc request (headers and body),
516 * 3 = add also all processing warnings happened during method processing
517 * (NB: this involves setting a custom error handler, and might interfere
518 * with the standard processing of the php function exposed as method. In
519 * particular, triggering an USER_ERROR level error will not halt script
520 * execution anymore, but just end up logged in the xmlrpc response)
521 * Note that info added at elevel 2 and 3 will be base64 encoded
522 * @access public
523 */
524 function setDebug($in)
525 {
526 $this->debug=$in;
527 }
528
529 /**
530 * Return a string with the serialized representation of all debug info
531 * @param string $charset_encoding the target charset encoding for the serialization
532 * @return string an XML comment (or two)
533 */
534 function serializeDebug($charset_encoding='')
535 {
536 // Tough encoding problem: which internal charset should we assume for debug info?
537 // It might contain a copy of raw data received from client, ie with unknown encoding,
538 // intermixed with php generated data and user generated data...
539 // so we split it: system debug is base 64 encoded,
540 // user debug info should be encoded by the end user using the INTERNAL_ENCODING
541 $out = '';
542 if ($this->debug_info != '')
543 {
544 $out .= "<!-- SERVER DEBUG INFO (BASE64 ENCODED):\n".base64_encode($this->debug_info)."\n-->\n";
545 }
546 if($GLOBALS['_xmlrpc_debuginfo']!='')
547 {
548
549 $out .= "<!-- DEBUG INFO:\n" . xmlrpc_encode_entitites(str_replace('--', '_-', $GLOBALS['_xmlrpc_debuginfo']), $GLOBALS['xmlrpc_internalencoding'], $charset_encoding) . "\n-->\n";
550 // NB: a better solution MIGHT be to use CDATA, but we need to insert it
551 // into return payload AFTER the beginning tag
552 //$out .= "<![CDATA[ DEBUG INFO:\n\n" . str_replace(']]>', ']_]_>', $GLOBALS['_xmlrpc_debuginfo']) . "\n]]>\n";
553 }
554 return $out;
555 }
556
557 /**
558 * Execute the xmlrpc request, printing the response
559 * @param string $data the request body. If null, the http POST request will be examined
560 * @return xmlrpcresp the response object (usually not used by caller...)
561 * @access public
562 */
563 function service($data=null, $return_payload=false)
564 {
565 if ($data === null)
566 {
567 // workaround for a known bug in php ver. 5.2.2 that broke $HTTP_RAW_POST_DATA
568 $ver = phpversion();
569 if ($ver[0] >= 5)
570 {
571 $data = file_get_contents('php://input');
572 }
573 else
574 {
575 $data = isset($GLOBALS['HTTP_RAW_POST_DATA']) ? $GLOBALS['HTTP_RAW_POST_DATA'] : '';
576 }
577 }
578 $raw_data = $data;
579
580 // reset internal debug info
581 $this->debug_info = '';
582
583 // Echo back what we received, before parsing it
584 if($this->debug > 1)
585 {
586 $this->debugmsg("+++GOT+++\n" . $data . "\n+++END+++");
587 }
588
589 $r = $this->parseRequestHeaders($data, $req_charset, $resp_charset, $resp_encoding);
590 if (!$r)
591 {
592 $r=$this->parseRequest($data, $req_charset);
593 }
594
595 // save full body of request into response, for more debugging usages
596 $r->raw_data = $raw_data;
597
598 if($this->debug > 2 && $GLOBALS['_xmlrpcs_occurred_errors'])
599 {
600 $this->debugmsg("+++PROCESSING ERRORS AND WARNINGS+++\n" .
601 $GLOBALS['_xmlrpcs_occurred_errors'] . "+++END+++");
602 }
603
604 $payload=$this->xml_header($resp_charset);
605 if($this->debug > 0)
606 {
607 $payload = $payload . $this->serializeDebug($resp_charset);
608 }
609
610 // G. Giunta 2006-01-27: do not create response serialization if it has
611 // already happened. Helps building json magic
612 if (empty($r->payload))
613 {
614 $r->serialize($resp_charset);
615 }
616 $payload = $payload . $r->payload;
617
618 if ($return_payload)
619 {
620 return $payload;
621 }
622
623 // if we get a warning/error that has output some text before here, then we cannot
624 // add a new header. We cannot say we are sending xml, either...
625 if(!headers_sent())
626 {
627 header('Content-Type: '.$r->content_type);
628 // we do not know if client actually told us an accepted charset, but if he did
629 // we have to tell him what we did
630 header("Vary: Accept-Charset");
631
632 // http compression of output: only
633 // if we can do it, and we want to do it, and client asked us to,
634 // and php ini settings do not force it already
635 $php_no_self_compress = !ini_get('zlib.output_compression') && (ini_get('output_handler') != 'ob_gzhandler');
636 if($this->compress_response && function_exists('gzencode') && $resp_encoding != ''
637 && $php_no_self_compress)
638 {
639 if(strpos($resp_encoding, 'gzip') !== false)
640 {
641 $payload = gzencode($payload);
642 header("Content-Encoding: gzip");
643 header("Vary: Accept-Encoding");
644 }
645 elseif (strpos($resp_encoding, 'deflate') !== false)
646 {
647 $payload = gzcompress($payload);
648 header("Content-Encoding: deflate");
649 header("Vary: Accept-Encoding");
650 }
651 }
652
653 // do not ouput content-length header if php is compressing output for us:
654 // it will mess up measurements
655 if($php_no_self_compress)
656 {
657 header('Content-Length: ' . (int)strlen($payload));
658 }
659 }
660 else
661 {
662 error_log('XML-RPC: xmlrpc_server::service: http headers already sent before response is fully generated. Check for php warning or error messages');
663 }
664
665 print $payload;
666
667 // return request, in case subclasses want it
668 return $r;
669 }
670
671 /**
672 * Add a method to the dispatch map
673 * @param string $methodname the name with which the method will be made available
674 * @param string $function the php function that will get invoked
675 * @param array $sig the array of valid method signatures
676 * @param string $doc method documentation
677 * @param array $sigdoc the array of valid method signatures docs (one string per param, one for return type)
678 * @access public
679 */
680 function add_to_map($methodname,$function,$sig=null,$doc=false,$sigdoc=false)
681 {
682 $this->dmap[$methodname] = array(
683 'function' => $function,
684 'docstring' => $doc
685 );
686 if ($sig)
687 {
688 $this->dmap[$methodname]['signature'] = $sig;
689 }
690 if ($sigdoc)
691 {
692 $this->dmap[$methodname]['signature_docs'] = $sigdoc;
693 }
694 }
695
696 /**
697 * Verify type and number of parameters received against a list of known signatures
698 * @param array $in array of either xmlrpcval objects or xmlrpc type definitions
699 * @param array $sig array of known signatures to match against
700 * @access private
701 */
702 function verifySignature($in, $sig)
703 {
704 // check each possible signature in turn
705 if (is_object($in))
706 {
707 $numParams = $in->getNumParams();
708 }
709 else
710 {
711 $numParams = count($in);
712 }
713 foreach($sig as $cursig)
714 {
715 if(count($cursig)==$numParams+1)
716 {
717 $itsOK=1;
718 for($n=0; $n<$numParams; $n++)
719 {
720 if (is_object($in))
721 {
722 $p=$in->getParam($n);
723 if($p->kindOf() == 'scalar')
724 {
725 $pt=$p->scalartyp();
726 }
727 else
728 {
729 $pt=$p->kindOf();
730 }
731 }
732 else
733 {
734 $pt= $in[$n] == 'i4' ? 'int' : $in[$n]; // dispatch maps never use i4...
735 }
736
737 // param index is $n+1, as first member of sig is return type
738 if($pt != $cursig[$n+1] && $cursig[$n+1] != $GLOBALS['xmlrpcValue'])
739 {
740 $itsOK=0;
741 $pno=$n+1;
742 $wanted=$cursig[$n+1];
743 $got=$pt;
744 break;
745 }
746 }
747 if($itsOK)
748 {
749 return array(1,'');
750 }
751 }
752 }
753 if(isset($wanted))
754 {
755 return array(0, "Wanted ${wanted}, got ${got} at param ${pno}");
756 }
757 else
758 {
759 return array(0, "No method signature matches number of parameters");
760 }
761 }
762
763 /**
764 * Parse http headers received along with xmlrpc request. If needed, inflate request
765 * @return null on success or an xmlrpcresp
766 * @access private
767 */
768 function parseRequestHeaders(&$data, &$req_encoding, &$resp_encoding, &$resp_compression)
769 {
770 // Play nice to PHP 4.0.x: superglobals were not yet invented...
771 if(!isset($_SERVER))
772 {
773 $_SERVER = $GLOBALS['HTTP_SERVER_VARS'];
774 }
775
776 if($this->debug > 1)
777 {
778 if(function_exists('getallheaders'))
779 {
780 $this->debugmsg(''); // empty line
781 foreach(getallheaders() as $name => $val)
782 {
783 $this->debugmsg("HEADER: $name: $val");
784 }
785 }
786
787 }
788
789 if(isset($_SERVER['HTTP_CONTENT_ENCODING']))
790 {
791 $content_encoding = str_replace('x-', '', $_SERVER['HTTP_CONTENT_ENCODING']);
792 }
793 else
794 {
795 $content_encoding = '';
796 }
797
798 // check if request body has been compressed and decompress it
799 if($content_encoding != '' && strlen($data))
800 {
801 if($content_encoding == 'deflate' || $content_encoding == 'gzip')
802 {
803 // if decoding works, use it. else assume data wasn't gzencoded
804 if(function_exists('gzinflate') && in_array($content_encoding, $this->accepted_compression))
805 {
806 if($content_encoding == 'deflate' && $degzdata = @gzuncompress($data))
807 {
808 $data = $degzdata;
809 if($this->debug > 1)
810 {
811 $this->debugmsg("\n+++INFLATED REQUEST+++[".strlen($data)." chars]+++\n" . $data . "\n+++END+++");
812 }
813 }
814 elseif($content_encoding == 'gzip' && $degzdata = @gzinflate(substr($data, 10)))
815 {
816 $data = $degzdata;
817 if($this->debug > 1)
818 $this->debugmsg("+++INFLATED REQUEST+++[".strlen($data)." chars]+++\n" . $data . "\n+++END+++");
819 }
820 else
821 {
822 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['server_decompress_fail'], $GLOBALS['xmlrpcstr']['server_decompress_fail']);
823 return $r;
824 }
825 }
826 else
827 {
828 //error_log('The server sent deflated data. Your php install must have the Zlib extension compiled in to support this.');
829 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['server_cannot_decompress'], $GLOBALS['xmlrpcstr']['server_cannot_decompress']);
830 return $r;
831 }
832 }
833 }
834
835 // check if client specified accepted charsets, and if we know how to fulfill
836 // the request
837 if ($this->response_charset_encoding == 'auto')
838 {
839 $resp_encoding = '';
840 if (isset($_SERVER['HTTP_ACCEPT_CHARSET']))
841 {
842 // here we should check if we can match the client-requested encoding
843 // with the encodings we know we can generate.
844 /// @todo we should parse q=0.x preferences instead of getting first charset specified...
845 $client_accepted_charsets = explode(',', strtoupper($_SERVER['HTTP_ACCEPT_CHARSET']));
846 // Give preference to internal encoding
847 $known_charsets = array($GLOBALS['xmlrpc_internalencoding'], 'UTF-8', 'ISO-8859-1', 'US-ASCII');
848 foreach ($known_charsets as $charset)
849 {
850 foreach ($client_accepted_charsets as $accepted)
851 if (strpos($accepted, $charset) === 0)
852 {
853 $resp_encoding = $charset;
854 break;
855 }
856 if ($resp_encoding)
857 break;
858 }
859 }
860 }
861 else
862 {
863 $resp_encoding = $this->response_charset_encoding;
864 }
865
866 if (isset($_SERVER['HTTP_ACCEPT_ENCODING']))
867 {
868 $resp_compression = $_SERVER['HTTP_ACCEPT_ENCODING'];
869 }
870 else
871 {
872 $resp_compression = '';
873 }
874
875 // 'guestimate' request encoding
876 /// @todo check if mbstring is enabled and automagic input conversion is on: it might mingle with this check???
877 $req_encoding = guess_encoding(isset($_SERVER['CONTENT_TYPE']) ? $_SERVER['CONTENT_TYPE'] : '',
878 $data);
879
880 return null;
881 }
882
883 /**
884 * Parse an xml chunk containing an xmlrpc request and execute the corresponding
885 * php function registered with the server
886 * @param string $data the xml request
887 * @param string $req_encoding (optional) the charset encoding of the xml request
888 * @return xmlrpcresp
889 * @access private
890 */
891 function parseRequest($data, $req_encoding='')
892 {
893 // 2005/05/07 commented and moved into caller function code
894 //if($data=='')
895 //{
896 // $data=$GLOBALS['HTTP_RAW_POST_DATA'];
897 //}
898
899 // G. Giunta 2005/02/13: we do NOT expect to receive html entities
900 // so we do not try to convert them into xml character entities
901 //$data = xmlrpc_html_entity_xlate($data);
902
903 $GLOBALS['_xh']=array();
904 $GLOBALS['_xh']['ac']='';
905 $GLOBALS['_xh']['stack']=array();
906 $GLOBALS['_xh']['valuestack'] = array();
907 $GLOBALS['_xh']['params']=array();
908 $GLOBALS['_xh']['pt']=array();
909 $GLOBALS['_xh']['isf']=0;
910 $GLOBALS['_xh']['isf_reason']='';
911 $GLOBALS['_xh']['method']=false; // so we can check later if we got a methodname or not
912 $GLOBALS['_xh']['rt']='';
913
914 // decompose incoming XML into request structure
915 if ($req_encoding != '')
916 {
917 if (!in_array($req_encoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
918 // the following code might be better for mb_string enabled installs, but
919 // makes the lib about 200% slower...
920 //if (!is_valid_charset($req_encoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
921 {
922 error_log('XML-RPC: xmlrpc_server::parseRequest: invalid charset encoding of received request: '.$req_encoding);
923 $req_encoding = $GLOBALS['xmlrpc_defencoding'];
924 }
925 /// @BUG this will fail on PHP 5 if charset is not specified in the xml prologue,
926 // the encoding is not UTF8 and there are non-ascii chars in the text...
927 /// @todo use an ampty string for php 5 ???
928 $parser = xml_parser_create($req_encoding);
929 }
930 else
931 {
932 $parser = xml_parser_create();
933 }
934
935 xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, true);
936 // G. Giunta 2005/02/13: PHP internally uses ISO-8859-1, so we have to tell
937 // the xml parser to give us back data in the expected charset
938 // What if internal encoding is not in one of the 3 allowed?
939 // we use the broadest one, ie. utf8
940 // This allows to send data which is native in various charset,
941 // by extending xmlrpc_encode_entitites() and setting xmlrpc_internalencoding
942 if (!in_array($GLOBALS['xmlrpc_internalencoding'], array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
943 {
944 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
945 }
946 else
947 {
948 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $GLOBALS['xmlrpc_internalencoding']);
949 }
950
951 if ($this->functions_parameters_type != 'xmlrpcvals')
952 xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee_fast');
953 else
954 xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee');
955 xml_set_character_data_handler($parser, 'xmlrpc_cd');
956 xml_set_default_handler($parser, 'xmlrpc_dh');
957 if(!xml_parse($parser, $data, 1))
958 {
959 // return XML error as a faultCode
960 $r= new xmlrpcresp(0,
961 $GLOBALS['xmlrpcerrxml']+xml_get_error_code($parser),
962 sprintf('XML error: %s at line %d, column %d',
963 xml_error_string(xml_get_error_code($parser)),
964 xml_get_current_line_number($parser), xml_get_current_column_number($parser)));
965 xml_parser_free($parser);
966 }
967 elseif ($GLOBALS['_xh']['isf'])
968 {
969 xml_parser_free($parser);
970 $r= new xmlrpcresp(0,
971 $GLOBALS['xmlrpcerr']['invalid_request'],
972 $GLOBALS['xmlrpcstr']['invalid_request'] . ' ' . $GLOBALS['_xh']['isf_reason']);
973 }
974 else
975 {
976 xml_parser_free($parser);
977 if ($this->functions_parameters_type != 'xmlrpcvals')
978 {
979 if($this->debug > 1)
980 {
981 $this->debugmsg("\n+++PARSED+++\n".var_export($GLOBALS['_xh']['params'], true)."\n+++END+++");
982 }
983 $r = $this->execute($GLOBALS['_xh']['method'], $GLOBALS['_xh']['params'], $GLOBALS['_xh']['pt']);
984 }
985 else
986 {
987 // build an xmlrpcmsg object with data parsed from xml
988 $m= new xmlrpcmsg($GLOBALS['_xh']['method']);
989 // now add parameters in
990 for($i=0; $i<count($GLOBALS['_xh']['params']); $i++)
991 {
992 $m->addParam($GLOBALS['_xh']['params'][$i]);
993 }
994
995 if($this->debug > 1)
996 {
997 $this->debugmsg("\n+++PARSED+++\n".var_export($m, true)."\n+++END+++");
998 }
999 $r = $this->execute($m);
1000 }
1001 }
1002 return $r;
1003 }
1004
1005 /**
1006 * Execute a method invoked by the client, checking parameters used
1007 * @param mixed $m either an xmlrpcmsg obj or a method name
1008 * @param array $params array with method parameters as php types (if m is method name only)
1009 * @param array $paramtypes array with xmlrpc types of method parameters (if m is method name only)
1010 * @return xmlrpcresp
1011 * @access private
1012 */
1013 function execute($m, $params=null, $paramtypes=null)
1014 {
1015 if (is_object($m))
1016 {
1017 $methName = $m->method();
1018 }
1019 else
1020 {
1021 $methName = $m;
1022 }
1023 $sysCall = $this->allow_system_funcs && (strpos($methName, "system.") === 0);
1024 $dmap = $sysCall ? $GLOBALS['_xmlrpcs_dmap'] : $this->dmap;
1025
1026 if(!isset($dmap[$methName]['function']))
1027 {
1028 // No such method
1029 return new xmlrpcresp(0,
1030 $GLOBALS['xmlrpcerr']['unknown_method'],
1031 $GLOBALS['xmlrpcstr']['unknown_method']);
1032 }
1033
1034 // Check signature
1035 if(isset($dmap[$methName]['signature']))
1036 {
1037 $sig = $dmap[$methName]['signature'];
1038 if (is_object($m))
1039 {
1040 list($ok, $errstr) = $this->verifySignature($m, $sig);
1041 }
1042 else
1043 {
1044 list($ok, $errstr) = $this->verifySignature($paramtypes, $sig);
1045 }
1046 if(!$ok)
1047 {
1048 // Didn't match.
1049 return new xmlrpcresp(
1050 0,
1051 $GLOBALS['xmlrpcerr']['incorrect_params'],
1052 $GLOBALS['xmlrpcstr']['incorrect_params'] . ": ${errstr}"
1053 );
1054 }
1055 }
1056
1057 $func = $dmap[$methName]['function'];
1058 // let the 'class::function' syntax be accepted in dispatch maps
1059 if(is_string($func) && strpos($func, '::'))
1060 {
1061 $func = explode('::', $func);
1062 }
1063 // verify that function to be invoked is in fact callable
1064 if(!is_callable($func))
1065 {
1066 error_log("XML-RPC: xmlrpc_server::execute: function $func registered as method handler is not callable");
1067 return new xmlrpcresp(
1068 0,
1069 $GLOBALS['xmlrpcerr']['server_error'],
1070 $GLOBALS['xmlrpcstr']['server_error'] . ": no function matches method"
1071 );
1072 }
1073
1074 // If debug level is 3, we should catch all errors generated during
1075 // processing of user function, and log them as part of response
1076 if($this->debug > 2)
1077 {
1078 $GLOBALS['_xmlrpcs_prev_ehandler'] = set_error_handler('_xmlrpcs_errorHandler');
1079 }
1080 if (is_object($m))
1081 {
1082 if($sysCall)
1083 {
1084 $r = call_user_func($func, $this, $m);
1085 }
1086 else
1087 {
1088 $r = call_user_func($func, $m);
1089 }
1090 if (!is_a($r, 'xmlrpcresp'))
1091 {
1092 error_log("XML-RPC: xmlrpc_server::execute: function $func registered as method handler does not return an xmlrpcresp object");
1093 if (is_a($r, 'xmlrpcval'))
1094 {
1095 $r = new xmlrpcresp($r);
1096 }
1097 else
1098 {
1099 $r = new xmlrpcresp(
1100 0,
1101 $GLOBALS['xmlrpcerr']['server_error'],
1102 $GLOBALS['xmlrpcstr']['server_error'] . ": function does not return xmlrpcresp object"
1103 );
1104 }
1105 }
1106 }
1107 else
1108 {
1109 // call a 'plain php' function
1110 if($sysCall)
1111 {
1112 array_unshift($params, $this);
1113 $r = call_user_func_array($func, $params);
1114 }
1115 else
1116 {
1117 // 3rd API convention for method-handling functions: EPI-style
1118 if ($this->functions_parameters_type == 'epivals')
1119 {
1120 $r = call_user_func_array($func, array($methName, $params, $this->user_data));
1121 // mimic EPI behaviour: if we get an array that looks like an error, make it
1122 // an eror response
1123 if (is_array($r) && array_key_exists('faultCode', $r) && array_key_exists('faultString', $r))
1124 {
1125 $r = new xmlrpcresp(0, (integer)$r['faultCode'], (string)$r['faultString']);
1126 }
1127 else
1128 {
1129 // functions using EPI api should NOT return resp objects,
1130 // so make sure we encode the return type correctly
1131 $r = new xmlrpcresp(php_xmlrpc_encode($r, array('extension_api')));
1132 }
1133 }
1134 else
1135 {
1136 $r = call_user_func_array($func, $params);
1137 }
1138 }
1139 // the return type can be either an xmlrpcresp object or a plain php value...
1140 if (!is_a($r, 'xmlrpcresp'))
1141 {
1142 // what should we assume here about automatic encoding of datetimes
1143 // and php classes instances???
1144 $r = new xmlrpcresp(php_xmlrpc_encode($r, array('auto_dates')));
1145 }
1146 }
1147 if($this->debug > 2)
1148 {
1149 // note: restore the error handler we found before calling the
1150 // user func, even if it has been changed inside the func itself
1151 if($GLOBALS['_xmlrpcs_prev_ehandler'])
1152 {
1153 set_error_handler($GLOBALS['_xmlrpcs_prev_ehandler']);
1154 }
1155 else
1156 {
1157 restore_error_handler();
1158 }
1159 }
1160 return $r;
1161 }
1162
1163 /**
1164 * add a string to the 'internal debug message' (separate from 'user debug message')
1165 * @param string $strings
1166 * @access private
1167 */
1168 function debugmsg($string)
1169 {
1170 $this->debug_info .= $string."\n";
1171 }
1172
1173 /**
1174 * @access private
1175 */
1176 function xml_header($charset_encoding='')
1177 {
1178 if ($charset_encoding != '')
1179 {
1180 return "<?xml version=\"1.0\" encoding=\"$charset_encoding\"?" . ">\n";
1181 }
1182 else
1183 {
1184 return "<?xml version=\"1.0\"?" . ">\n";
1185 }
1186 }
1187
1188 /**
1189 * A debugging routine: just echoes back the input packet as a string value
1190 * DEPRECATED!
1191 */
1192 function echoInput()
1193 {
1194 $r= new xmlrpcresp(new xmlrpcval( "'Aha said I: '" . $GLOBALS['HTTP_RAW_POST_DATA'], 'string'));
1195 print $r->serialize();
1196 }
1197 }
1198?> \ No newline at end of file
generated by cgit v1.1 at 2024-12-20 20:50:42 +0000