lib/xmlrpc.inc

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