<?php
  // by Edd Dumbill (C) 1999-2002
  // <edd@usefulinc.com>
  // $Id:\; xmlrpcs.inc,v\; 1.65\; 2006/08/23\; 14:52:33\; ggiunta\; Exp$
  
  // Copyright (c) 1999,2000,2002 Edd Dumbill.
  // All rights reserved.
  //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions
  // are met:
  //
  //    * Redistributions of source code must retain the above copyright
  //      notice, this list of conditions and the following disclaimer.
  //
  //    * Redistributions in binary form must reproduce the above
  //      copyright notice, this list of conditions and the following
  //      disclaimer in the documentation and/or other materials provided
  //      with the distribution.
  //
  //    * Neither the name of the "XML-RPC for PHP" nor the names of its
  //      contributors may be used to endorse or promote products derived
  //      from this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  // REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  // OF THE POSSIBILITY OF SUCH DAMAGE.
  
          // XML RPC Server class
          // requires: xmlrpc.inc
  
          /* Functions that implement system.XXX methods of xmlrpc servers */
  
          // listMethods: signature was either a string, or nothing.
          // The useless string variant has been removed
          $\_xmlrpcs\_listMethods\_sig=array(array($GLOBALS['xmlrpcArray']));
          $\_xmlrpcs\_listMethods\_doc=\text{'}This\; method\; lists\; all\; the\; methods\; that\; the\; XML-RPC\; server\; knows\; how\; to\; dispatch\text{'};$_xmlrpcs_listMethods_sdoc=array(array('list of method names'));
          function _xmlrpcs_listMethods($server,$m=null) // if called in plain php values mode, second param is missing
          {
  
                  $outAr=array();\; foreach($server->dmap as $key\; =>$val)
                  {
                          key, 'string');
                  }
                  if($server->allow\_system\_funcs)\; \{\; foreach($GLOBALS['_xmlrpcs_dmap'] as $key\; =>$val)
                          {
                                  key, 'string');
                          }
                  }
                  outAr, 'array');
                  return new xmlrpcresp($v);\; \}$_xmlrpcs_methodSignature_sig=array(array($GLOBALS[\text{'}xmlrpcArray\text{'}],$GLOBALS['xmlrpcString']));
          $\_xmlrpcs\_methodSignature\_doc=\text{'}Returns\; an\; array\; of\; known\; signatures\; (an\; array\; of\; arrays)\; for\; the\; method\; name\; passed.\; If\; no\; signatures\; are\; known,\; returns\; a\; none-array\; (test\; for\; type\; !=\; array\; to\; detect\; missing\; signature)\text{'};$_xmlrpcs_methodSignature_sdoc=array(array('list of known signatures, each sig being an array of xmlrpc type names', 'name of method to be described'));
          function _xmlrpcs_methodSignature($server,$m)
          {
                  // let accept as parameter both an xmlrpcval or string
                  if (is_object($m))\; \{$methName=$m->getParam(0);$methName=$methName->scalarval();\; \}\; else\; \{$methName=$m;\; \}\; if(strpos($methName, "system.") === 0)
                  {
                          $dmap=$GLOBALS['_xmlrpcs_dmap']; $sysCall=1;\; \}\; else\; \{$dmap=$server->dmap;$sysCall=0;
                  }
                  if(isset($dmap[$methName]))
                  {
                          if(isset($dmap[$methName]['signature']))
                          {
                                  $sigs=array();\; foreach($dmap[$methName][\text{'}signature\text{'}]\; as$inSig)
                                  {
                                          $cursig=array();\; foreach($inSig as $sig)\; \{$cursig[]=&new xmlrpcval($sig,\; \text{'}string\text{'});\; \}$sigs[]=&new xmlrpcval($cursig,\; \text{'}array\text{'});\; \}$r=&new xmlrpcresp(new xmlrpcval($sigs,\; \text{'}array\text{'}));\; \}\; else\; \{\; //\; NB:\; according\; to\; the\; official\; docs,\; we\; should\; be\; returning\; a\; //\; "none-array"\; here,\; which\; means\; not-an-array$r=&new xmlrpcresp(new xmlrpcval('undef', 'string'));
                          }
                  }
                  else
                  {
                          GLOBALS['xmlrpcerr']['introspect_unknown'], $GLOBALS[\text{'}xmlrpcstr\text{'}][\text{'}introspect\_unknown\text{'}]);\; \}\; return$r;
          }
  
          $\_xmlrpcs\_methodHelp\_sig=array(array($GLOBALS['xmlrpcString'], $GLOBALS[\text{'}xmlrpcString\text{'}]));$_xmlrpcs_methodHelp_doc='Returns help text if defined for the method passed, otherwise returns an empty string';
          $\_xmlrpcs\_methodHelp\_sdoc=array(array(\text{'}method\; description\text{'},\; \text{'}name\; of\; the\; method\; to\; be\; described\text{'}));\; function\; \_xmlrpcs\_methodHelp($server, $m)\; \{\; //\; let\; accept\; as\; parameter\; both\; an\; xmlrpcval\; or\; string\; if\; (is\_object($m))
                  {
                          $methName=$m->getParam(0);
                          $methName=$methName->scalarval();
                  }
                  else
                  {
                          $methName=$m;
                  }
                  if(strpos($methName,\; "system.")\; ===\; 0)\; \{$dmap=$GLOBALS[\text{'}\_xmlrpcs\_dmap\text{'}];$sysCall=1;
                  }
                  else
                  {
                          $dmap=$server->dmap; $sysCall=0;\; \}\; if(isset($dmap[$methName]))\; \{\; if(isset($dmap[$methName][\text{'}docstring\text{'}]))\; \{$r=&new xmlrpcresp(new xmlrpcval($dmap[$methName]['docstring']), 'string');
                          }
                          else
                          {
                                  r=&new xmlrpcresp(0, $GLOBALS[\text{'}xmlrpcerr\text{'}][\text{'}introspect\_unknown\text{'}],$GLOBALS['xmlrpcstr']['introspect_unknown']);
                  }
                  return $r;\; \}$_xmlrpcs_multicall_sig = array(array($GLOBALS[\text{'}xmlrpcArray\text{'}],$GLOBALS['xmlrpcArray']));
          $\_xmlrpcs\_multicall\_doc\; =\; \text{'}Boxcar\; multiple\; RPC\; calls\; in\; one\; request.\; Seehttp://www.xmlrpc.com/discuss/msgReader\$1208for\; details\text{'};$_xmlrpcs_multicall_sdoc = array(array('list of response structs, where each struct has the usual members', 'list of calls, with each call being represented as a struct, with members "methodname" and "params"'));
          function _xmlrpcs_multicall_error($err)\; \{\; if(is\_string($err))
                  {
                          $str\; =$GLOBALS['xmlrpcstr']["multicall_$\{err\}"];$code = $GLOBALS[\text{'}xmlrpcerr\text{'}]["multicall\_${err}"];
                  }
                  else
                  {
                          $code\; =$err->faultCode();
                          $str\; =$err->faultString();
                  }
                  $struct\; =\; array();$struct['faultCode'] =& new xmlrpcval($code,\; \text{'}int\text{'});$struct['faultString'] =& new xmlrpcval($str,\; \text{'}string\text{'});\; return\; new\; xmlrpcval($struct, 'struct');
          }
  
          function _xmlrpcs_multicall_do_call($server,$call)
          {
                  if($call->kindOf()\; !=\; \text{'}struct\text{'})\; \{\; return\; \_xmlrpcs\_multicall\_error(\text{'}notstruct\text{'});\; \}$methName = @$call->structmem(\text{'}methodName\text{'});\; if(!$methName)
                  {
                          return _xmlrpcs_multicall_error('nomethod');
                  }
                  if($methName->kindOf()\; !=\; \text{'}scalar\text{'}\; ||$methName->scalartyp() != 'string')
                  {
                          return _xmlrpcs_multicall_error('notstring');
                  }
                  if($methName->scalarval()\; ==\; \text{'}system.multicall\text{'})\; \{\; return\; \_xmlrpcs\_multicall\_error(\text{'}recursion\text{'});\; \}$params = @$call->structmem(\text{'}params\text{'});\; if(!$params)
                  {
                          return _xmlrpcs_multicall_error('noparams');
                  }
                  if($params->kindOf()\; !=\; \text{'}array\text{'})\; \{\; return\; \_xmlrpcs\_multicall\_error(\text{'}notarray\text{'});\; \}$numParams = $params->arraysize();$msg =& new xmlrpcmsg($methName->scalarval());\; for($i = 0; numParams; $i++)\; \{\; if(!$msg->addParam($params->arraymem($i)))
                          {
                                  $i++;\; return\; \_xmlrpcs\_multicall\_error(new\; xmlrpcresp(0,$GLOBALS['xmlrpcerr']['incorrect_params'],
                                          $GLOBALS[\text{'}xmlrpcstr\text{'}][\text{'}incorrect\_params\text{'}]\; .\; ":\; probable\; xml\; error\; in\; param\; "\; .$i));
                          }
                  }
  
                  $result\; =$server->execute($msg);\; if($result->faultCode() != 0)
                  {
                          return _xmlrpcs_multicall_error($result);\; //\; Method\; returned\; fault.\; \}\; return\; new\; xmlrpcval(array($result->value()), 'array');
          }
  
          function _xmlrpcs_multicall_do_call_phpvals($server,$call)
          {
                  if(!is_array($call))\; \{\; return\; \_xmlrpcs\_multicall\_error(\text{'}notstruct\text{'});\; \}\; if(!array\_key\_exists(\text{'}methodName\text{'},$call))
                  {
                          return _xmlrpcs_multicall_error('nomethod');
                  }
                  if (!is_string($call[\text{'}methodName\text{'}]))\; \{\; return\; \_xmlrpcs\_multicall\_error(\text{'}notstring\text{'});\; \}\; if($call['methodName'] == 'system.multicall')
                  {
                          return _xmlrpcs_multicall_error('recursion');
                  }
                  if(!array_key_exists('params', $call))\; \{\; return\; \_xmlrpcs\_multicall\_error(\text{'}noparams\text{'});\; \}\; if(!is\_array($call['params']))
                  {
                          return _xmlrpcs_multicall_error('notarray');
                  }
  
                  // this is a real dirty and simplistic hack, since we might have received a
                  // base64 or datetime values, but they will be listed as strings here...
                  $numParams\; =\; count($call['params']);
                  $pt\; =\; array();\; foreach($call['params'] as $val)$pt[] = php_2_xmlrpc_type(gettype($val));$result = $server->execute($call['methodName'], $call[\text{'}params\text{'}],$pt);
  
                  if($result->faultCode()\; !=\; 0)\; \{\; return\; \_xmlrpcs\_multicall\_error($result);                // Method returned fault.
                  }
  
                  return new xmlrpcval(array($result->value()),\; \text{'}array\text{'});\; \}\; function\; \_xmlrpcs\_multicall($server, $m)\; \{$result = array();
                  // let accept a plain list of php parameters, beside a single xmlrpc msg object
                  if (is_object($m))\; \{$calls = $m->getParam(0);$numCalls = $calls->arraysize();\; for($i = 0; numCalls; $i++)\; \{$call = $calls->arraymem($i);
                                  $result[$i] = _xmlrpcs_multicall_do_call($server,$call);
                          }
                  }
                  else
                  {
                          $numCalls=count($m);
                          for($i\; =\; 0;$i < $numCalls;$i++)
                          {
                                  $result[$i] = _xmlrpcs_multicall_do_call_phpvals($server,$m[$i]);\; \}\; \}\; return\; new\; xmlrpcresp(new\; xmlrpcval($result, 'array'));
          }
  
          $GLOBALS[\text{'}\_xmlrpcs\_dmap\text{'}]=array(\; \text{'}system.listMethods\text{'}\; =>\; array(\; \text{'}function\text{'}\; =>\; \text{'}\_xmlrpcs\_listMethods\text{'},\; \text{'}signature\text{'}\; =>$_xmlrpcs_listMethods_sig,
                          'docstring' => $\_xmlrpcs\_listMethods\_doc,\; \text{'}signature\_docs\text{'}\; =>$_xmlrpcs_listMethods_sdoc),
                  'system.methodHelp' => array(
                          'function' => '_xmlrpcs_methodHelp',
                          'signature' => $\_xmlrpcs\_methodHelp\_sig,\; \text{'}docstring\text{'}\; =>$_xmlrpcs_methodHelp_doc,
                          'signature_docs' => $\_xmlrpcs\_methodHelp\_sdoc),\; \text{'}system.methodSignature\text{'}\; =>\; array(\; \text{'}function\text{'}\; =>\; \text{'}\_xmlrpcs\_methodSignature\text{'},\; \text{'}signature\text{'}\; =>$_xmlrpcs_methodSignature_sig,
                          'docstring' => $\_xmlrpcs\_methodSignature\_doc,\; \text{'}signature\_docs\text{'}\; =>$_xmlrpcs_methodSignature_sdoc),
                  'system.multicall' => array(
                          'function' => '_xmlrpcs_multicall',
                          'signature' => $\_xmlrpcs\_multicall\_sig,\; \text{'}docstring\text{'}\; =>$_xmlrpcs_multicall_doc,
                          'signature_docs' => $\_xmlrpcs\_multicall\_sdoc)\; );$GLOBALS['_xmlrpcs_occurred_errors'] = '';
          $GLOBALS[\text{'}\_xmlrpcs\_prev\_ehandler\text{'}]\; =\; \text{'}\text{'};$