X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=src%2FServer.php;h=e859c7b2ddd9860279e283543acc475e5aeb93f8;hb=d867a3b3e5632755b143b1010cdda17466d21df1;hp=117e71e23b34cf284eb918057d836e51aa91bdd1;hpb=a8f93d5ce43365c83361071a847cb977f3ede519;p=plcapi.git

diff --git a/src/Server.php b/src/Server.php
index 117e71e..e859c7b 100644
--- a/src/Server.php
+++ b/src/Server.php
@@ -2,8 +2,8 @@
 
 namespace PhpXmlRpc;
 
-use PhpXmlRpc\Helper\Logger;
 use PhpXmlRpc\Helper\Charset;
+use PhpXmlRpc\Helper\Logger;
 use PhpXmlRpc\Helper\XMLParser;
 
 /**
@@ -11,15 +11,15 @@ use PhpXmlRpc\Helper\XMLParser;
  */
 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
      * or plain php values.
      * Valid strings are 'xmlrpcvals', 'phpvals' or 'epivals'
+     * @todo create class constants for these
      */
     public $functions_parameters_type = 'xmlrpcvals';
 
@@ -80,21 +80,73 @@ class Server
     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)
@@ -148,7 +200,6 @@ class Server
      * character set.
      *
      * @param string $msg
-     * @access public
      */
     public static function xmlrpc_debugmsg($msg)
     {
@@ -156,6 +207,10 @@ class Server
     }
 
     /**
+     * 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)
@@ -182,7 +237,7 @@ class Server
             $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";
@@ -256,6 +311,7 @@ class Server
             // 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
@@ -279,7 +335,7 @@ class Server
                 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;
@@ -292,12 +348,16 @@ class Server
      * Add a method to the dispatch map.
      *
      * @param string $methodName the name with which the method will be made available
-     * @param string $function the php function that will get invoked
-     * @param array $sig the array of valid method signatures
+     * @param callable $function the php function that will get invoked
+     * @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)
     {
@@ -375,7 +435,7 @@ class Server
         // 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) {
@@ -472,6 +532,9 @@ class Server
      * @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 = '')
     {
@@ -493,7 +556,7 @@ class Server
                     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);
                     }
                 }
             }
@@ -504,13 +567,14 @@ class Server
         // 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);
@@ -528,7 +592,7 @@ class Server
             // 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) {
@@ -556,9 +620,9 @@ class Server
     /**
      * 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
      *
@@ -622,7 +686,7 @@ class Server
 
         // 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'],
@@ -645,7 +709,7 @@ class Server
                     $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 {
@@ -752,7 +816,13 @@ class Server
         return (strpos($methName, "system.") === 0);
     }
 
-    /* Functions that implement system.XXX methods of xmlrpc servers */
+    /**
+     * @return array[]
+     */
+    public function getDispatchMap()
+    {
+        return $this->dmap;
+    }
 
     /**
      * @return array[]
@@ -799,6 +869,8 @@ class Server
         );
     }
 
+    /* Functions that implement system.XXX methods of xmlrpc servers */
+
     /**
      * @return array[]
      */
@@ -1098,7 +1170,10 @@ class Server
             // 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...