*/
class Server
{
- /**
- * Array defining php functions exposed as xmlrpc methods by this server.
- */
- protected $dmap = array();
+ protected static $logger;
+ protected static $parser;
+ protected static $charsetEncoder;
/**
* Defines how functions in dmap will be invoked: either using an xmlrpc request object
public $response_charset_encoding = '';
/**
- * Storage for internal debug info.
+ * Extra data passed at runtime to method handling functions. Used only by EPI layer
*/
- protected $debug_info = '';
+ public $user_data = null;
/**
- * Extra data passed at runtime to method handling functions. Used only by EPI layer
+ * Array defining php functions exposed as xmlrpc methods by this server.
+ * @var array[] $dmap
*/
- public $user_data = null;
+ protected $dmap = array();
+
+ /**
+ * Storage for internal debug info.
+ */
+ protected $debug_info = '';
protected static $_xmlrpc_debuginfo = '';
protected static $_xmlrpcs_occurred_errors = '';
protected static $_xmlrpcs_prev_ehandler = '';
+ public function getLogger()
+ {
+ if (self::$logger === null) {
+ self::$logger = Logger::instance();
+ }
+ return self::$logger;
+ }
+
+ public static function setLogger($logger)
+ {
+ self::$logger = $logger;
+ }
+
+ public function getParser()
+ {
+ if (self::$parser === null) {
+ self::$parser = new XMLParser();
+ }
+ return self::$parser;
+ }
+
+ public static function setParser($parser)
+ {
+ self::$parser = $parser;
+ }
+
+ public function getCharsetEncoder()
+ {
+ if (self::$charsetEncoder === null) {
+ self::$charsetEncoder = Charset::instance();
+ }
+ return self::$charsetEncoder;
+ }
+
+ public function setCharsetEncoder($charsetEncoder)
+ {
+ self::$charsetEncoder = $charsetEncoder;
+ }
+
/**
- * @param array $dispatchMap the dispatch map with definition of exposed services
+ * @param array[] $dispatchMap the dispatch map with definition of exposed services
+ * Array keys are the names of the method names.
+ * Each array value is an array with the following members:
+ * - function (callable)
+ * - docstring (optional)
+ * - signature (array, optional)
+ * - signature_docs (array, optional)
+ * - parameters_type (string, optional)
* @param boolean $serviceNow set to false to prevent the server from running upon construction
*/
public function __construct($dispatchMap = null, $serviceNow = true)
* character set.
*
* @param string $msg
- * @access public
*/
public static function xmlrpc_debugmsg($msg)
{
}
/**
+ * Add a string to the debug info that will be later serialized by the server as part of the response message
+ * (base64 encoded, only when debug level >= 2)
+ *
+ * character set.
* @param string $msg
*/
public static function error_occurred($msg)
$out .= "<!-- SERVER DEBUG INFO (BASE64 ENCODED):\n" . base64_encode($this->debug_info) . "\n-->\n";
}
if (static::$_xmlrpc_debuginfo != '') {
- $out .= "<!-- DEBUG INFO:\n" . Charset::instance()->encodeEntities(str_replace('--', '_-', static::$_xmlrpc_debuginfo), PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "\n-->\n";
+ $out .= "<!-- DEBUG INFO:\n" . $this->getCharsetEncoder()->encodeEntities(str_replace('--', '_-', static::$_xmlrpc_debuginfo), PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "\n-->\n";
// NB: a better solution MIGHT be to use CDATA, but we need to insert it
// into return payload AFTER the beginning tag
//$out .= "<![CDATA[ DEBUG INFO:\n\n" . str_replace(']]>', ']_]_>', static::$_xmlrpc_debuginfo) . "\n]]>\n";
// http compression of output: only
// if we can do it, and we want to do it, and client asked us to,
// and php ini settings do not force it already
+ /// @todo check separately for gzencode and gzcompress functions, in case of polyfills
$phpNoSelfCompress = !ini_get('zlib.output_compression') && (ini_get('output_handler') != 'ob_gzhandler');
if ($this->compress_response && function_exists('gzencode') && $respEncoding != ''
&& $phpNoSelfCompress
header('Content-Length: ' . (int)strlen($payload));
}
} else {
- Logger::instance()->errorLog('XML-RPC: ' . __METHOD__ . ': http headers already sent before response is fully generated. Check for php warning or error messages');
+ $this->getLogger()->errorLog('XML-RPC: ' . __METHOD__ . ': http headers already sent before response is fully generated. Check for php warning or error messages');
}
print $payload;
*
* @param string $methodName the name with which the method will be made available
* @param callable $function the php function that will get invoked
- * @param array $sig the array of valid method signatures
+ * @param array[] $sig the array of valid method signatures.
+ * Each element is one signature: an array of strings with at least one element
+ * First element = type of returned value. Elements 2..N = types of parameters 1..N
* @param string $doc method documentation
- * @param array $sigDoc the array of valid method signatures docs (one string per param, one for return type)
+ * @param array[] $sigDoc the array of valid method signatures docs, following the format of $sig but with
+ * descriptions instead of types (one string for return type, one per param)
*
* @todo raise a warning if the user tries to register a 'system.' method
+ * @todo allow setting parameters_type
*/
public function add_to_map($methodName, $function, $sig = null, $doc = false, $sigDoc = false)
{
// check if $_SERVER is populated: it might have been disabled via ini file
// (this is true even when in CLI mode)
if (count($_SERVER) == 0) {
- Logger::instance()->errorLog('XML-RPC: ' . __METHOD__ . ': cannot parse request headers as $_SERVER is not populated');
+ $this->getLogger()->errorLog('XML-RPC: ' . __METHOD__ . ': cannot parse request headers as $_SERVER is not populated');
}
if ($this->debug > 1) {
* @return Response
*
* @throws \Exception in case the executed method does throw an exception (and depending on server configuration)
+ *
+ * @internal this function will become protected in the future
+ * @todo either rename this function or move the 'execute' part out of it...
*/
public function parseRequest($data, $reqEncoding = '')
{
if (extension_loaded('mbstring')) {
$data = mb_convert_encoding($data, 'UTF-8', $reqEncoding);
} else {
- Logger::instance()->errorLog('XML-RPC: ' . __METHOD__ . ': invalid charset encoding of received request: ' . $reqEncoding);
+ $this->getLogger()->errorLog('XML-RPC: ' . __METHOD__ . ': invalid charset encoding of received request: ' . $reqEncoding);
}
}
}
// This allows to send data which is native in various charset,
// by extending xmlrpc_encode_entities() and setting xmlrpc_internalencoding
if (!in_array(PhpXmlRpc::$xmlrpc_internalencoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII'))) {
+ /// @todo emit a warning
$options = array(XML_OPTION_TARGET_ENCODING => 'UTF-8');
} else {
$options = array(XML_OPTION_TARGET_ENCODING => PhpXmlRpc::$xmlrpc_internalencoding);
}
- $xmlRpcParser = new XMLParser($options);
- $xmlRpcParser->parse($data, $this->functions_parameters_type, XMLParser::ACCEPT_REQUEST);
+ $xmlRpcParser = $this->getParser();
+ $xmlRpcParser->parse($data, $this->functions_parameters_type, XMLParser::ACCEPT_REQUEST, $options);
if ($xmlRpcParser->_xh['isf'] > 2) {
// (BC) we return XML error as a faultCode
preg_match('/^XML error ([0-9]+)/', $xmlRpcParser->_xh['isf_reason'], $matches);
// registered as phpvals) that would mean a useless encode+decode pass
if ($this->functions_parameters_type != 'xmlrpcvals' ||
(isset($this->dmap[$xmlRpcParser->_xh['method']]['parameters_type']) &&
- ($this->dmap[$xmlRpcParser->_xh['method']]['parameters_type'] == 'phpvals')
+ ($this->dmap[$xmlRpcParser->_xh['method']]['parameters_type'] != 'xmlrpcvals')
)
) {
if ($this->debug > 1) {
/**
* Execute a method invoked by the client, checking parameters used.
*
- * @param mixed $req either a Request obj or a method name
- * @param array $params array with method parameters as php types (if m is method name only)
- * @param array $paramTypes array with xmlrpc types of method parameters (if m is method name only)
+ * @param Request|string $req either a Request obj or a method name
+ * @param mixed[] $params array with method parameters as php types (only if m is method name)
+ * @param string[] $paramTypes array with xmlrpc types of method parameters (only if m is method name)
*
* @return Response
*
// verify that function to be invoked is in fact callable
if (!is_callable($func)) {
- Logger::instance()->errorLog("XML-RPC: " . __METHOD__ . ": function '$funcName' registered as method handler is not callable");
+ $this->getLogger()->errorLog("XML-RPC: " . __METHOD__ . ": function '$funcName' registered as method handler is not callable");
return new Response(
0,
PhpXmlRpc::$xmlrpcerr['server_error'],
$r = call_user_func($func, $req);
}
if (!is_a($r, 'PhpXmlRpc\Response')) {
- Logger::instance()->errorLog("XML-RPC: " . __METHOD__ . ": function '$funcName' registered as method handler does not return an xmlrpc response object but a " . gettype($r));
+ $this->getLogger()->errorLog("XML-RPC: " . __METHOD__ . ": function '$funcName' registered as method handler does not return an xmlrpc response object but a " . gettype($r));
if (is_a($r, 'PhpXmlRpc\Value')) {
$r = new Response($r);
} else {
return (strpos($methName, "system.") === 0);
}
- /* Functions that implement system.XXX methods of xmlrpc servers */
+ /**
+ * @return array[]
+ */
+ public function getDispatchMap()
+ {
+ return $this->dmap;
+ }
/**
* @return array[]
);
}
+ /* Functions that implement system.XXX methods of xmlrpc servers */
+
/**
* @return array[]
*/
// The previous error handler was the default: all we should do is log error
// to the default error log (if level high enough)
if (ini_get('log_errors') && (intval(ini_get('error_reporting')) & $errCode)) {
- Logger::instance()->errorLog($errString);
+ if (self::$logger === null) {
+ self::$logger = Logger::instance();
+ }
+ self::$logger->errorLog($errString);
}
} else {
// Pass control on to previous error handler, trying to avoid loops...
git://git.onelab.eu / plcapi.git / blobdiff