public function __construct()
{
$this->server = xmlrpc_server_create();
//http://www.hixie.ch/specs/pingback/pingback
//https://github.com/tedeh/pingback-php
xmlrpc_server_register_method($this->server, 'pingback.ping', [$this, 'pingback_ping']);
}
/**
* XMLRPC server constructor
*
* @access private
*/
public function __construct($request, $params = array())
{
parent::__construct($request, $params);
$this->_server = xmlrpc_server_create();
foreach ($GLOBALS['registry']->listMethods() as $method) {
xmlrpc_server_register_method($this->_server, str_replace('/', '.', $method), array('Horde_Rpc_Xmlrpc', '_dispatcher'));
}
}
function handlePost()
{
$server = xmlrpc_server_create();
xmlrpc_server_register_method($server, 'pingback.ping', array($this, 'ping'));
echo xmlrpc_server_call_method($server, file_get_contents('php://input'), null, array('encoding' => 'utf-8'));
xmlrpc_server_destroy($server);
return true;
}
public function __construct($options = array())
{
$this->_server = xmlrpc_server_create();
$this->setOptions($options);
if (!xmlrpc_server_register_method($this->_server, 'pingback.ping', array($this, '_ping'))) {
throw new PingbackException('Failed to register method to server');
}
}
/**
* Initialize the XMLRPC server
*
* @return void
*/
protected function init()
{
$this->XmlRpcServer = xmlrpc_server_create();
xmlrpc_server_register_method($this->XmlRpcServer, 'ns1.doSomething', array($this, '_xmlrpc_ns1_doSomething'));
xmlrpc_server_register_method($this->XmlRpcServer, 'ns2.getServerTime', array($this, '_xmlrpc_ns2_getServerTime'));
xmlrpc_server_register_method($this->XmlRpcServer, 'sayHello', array($this, '_xmlrpc_sayHello'));
// TODO how does this work?
//xmlrpc_server_register_introspection_callback($this->XmlRpcServer, array($this, '_xmlrpc_introspection'));
}
/**
* @param string $methodName
* @param Callable $callback
* @return $this
*/
public function registerMethod($methodName, $callback)
{
xmlrpc_server_register_method($this->getHandle(), $methodName, function () use($callback) {
$input = func_get_args();
$output = call_user_func_array($callback, Xmlrpc::decodeValues($input));
return Xmlrpc::encodeValues($output);
});
return $this;
}
/**
* Processes an incoming request, executes it and builds a response.
*
* @since 5.1
* @param ModuleServerRequest $request Incoming request.
* @param ModuleServerResponse $response Outcoming response.
* @return void
*/
public function process(ModuleServerRequest $request, ModuleServerResponse $response)
{
$command = explode(' ', $request->getCommand());
$module_location = $command[1];
if (!strlen($module_location)) {
$response->sendWarning(ModuleServerResponse::SC_NOT_FOUND, 'Module location not defined.', ModuleServerRsponse::ERROR_CLASSNAME_MISSING);
return;
}
try {
$locator = new ModuleLocator('module://' . $request->getHeader('User') . ':' . $request->getHeader('Password') . '@/' . $module_location);
$sessionId = $request->getHeader('Session');
if ($sessionId) {
$this->module = ModuleFactory::getSessionModule($locator, $sessionId);
} else {
$this->module = ModuleFactory::getModule($locator);
}
} catch (ModuleException $e) {
$response->sendWarning(ModuleServerResponse::SC_INTERNAL_SERVER_ERROR, $e->__toString());
return;
} catch (\Exception $e) {
$response->sendWarning(ModuleServerResponse::SC_INTERNAL_SERVER_ERROR, $e->__toString());
return;
}
if (!($xmlrpc_server = xmlrpc_server_create())) {
$response->sendWarning(ModuleServerResponse::SC_INTERNAL_SERVER_ERROR, 'Internal error: Could not create an XML-RPC server.', ModuleServerResponse::ERROR_XMLRPC_ERROR);
return;
}
$theClass = new \ReflectionObject($this->module);
$methods = $theClass->getMethods();
foreach ($methods as $method) {
// Ignore private methods
$theMethod = new \ReflectionMethod($theClass->getName(), $method->getName());
if (!$theMethod->isPublic()) {
continue;
}
// Expose only methods beginning with "module" prefix
if (!(substr($method->getName(), 0, 6) == 'module')) {
continue;
}
xmlrpc_server_register_method($xmlrpc_server, strtolower($method->getName()), array($this, 'xmlrpcGateway'));
}
xmlrpc_server_register_introspection_callback($xmlrpc_server, array($this, 'introspectionGateway'));
try {
$buffer = xmlrpc_server_call_method($xmlrpc_server, $request->getPayload(), '', array('output_type' => 'xml'));
$response->addHeader('Module/1.0 ' . ModuleServerResponse::SC_OK);
$response->setBuffer($buffer);
} catch (\Exception $e) {
$response->addHeader('Module/1.0 ' . ModuleServerResponse::SC_INTERNAL_ERROR);
$response->setBuffer($buffer);
}
xmlrpc_server_destroy($xmlrpc_server);
$context = new ModuleContext($module_location);
$session = new \Innomatic\Module\Session\ModuleSession($context, $sessionId);
$session->save($this->module);
$response->addHeader('Session: ' . $session->getId());
}
function __construct($payload, $payload_signed, $payload_encrypted)
{
$this->payload = $payload;
// xmlrpc_decode_request is defined such that the '$method' string is
// passed in by reference.
$this->params = xmlrpc_decode_request($this->payload, $this->method, 'UTF-8');
// The method name is not allowed to have a dot, except for a single dot
// which preceeds the php extension. It can have slashes but it cannot
// begin with a slash. We specifically don't want .. to be possible.
if (0 == preg_match("@^[A-Za-z0-9]+/[A-Za-z0-9/_-]+(\\.php/)?[A-Za-z0-9_-]+\$@", $this->method)) {
throw new XmlrpcServerException('The function does not exist', 6010);
}
if ($payload_signed && $payload_encrypted || $this->method == 'system/keyswap') {
// The remote server's credentials checked out.
// You might want to enable some methods for unsigned/unencrypted
// transport
} else {
// For now, we throw an exception
throw new XmlrpcServerException('The signature on your message was not valid', 6005);
}
// The system methods are treated differently.
if (array_key_exists($this->method, $this->system_methods)) {
$xmlrpcserver = xmlrpc_server_create();
xmlrpc_server_register_method($xmlrpcserver, $this->method, array(&$this, $this->system_methods[$this->method]));
} else {
// Security: I'm thinking that we should not return separate errors for
// the file not existing, the file not being readable, etc. as
// it might provide an opportunity for outsiders to scan the
// server for random files. So just a single message/code for
// all failures here kthxbye.
if (strpos($this->method, '/') !== false) {
$this->callstack = explode('/', $this->method);
} else {
throw new XmlrpcServerException('The function does not exist', 6011);
}
// Read custom xmlrpc functions from local
if (function_exists('local_xmlrpc_services')) {
foreach (local_xmlrpc_services() as $name => $localservices) {
$this->services[$name] = array_merge($this->services[$name], $localservices);
}
}
foreach ($this->services as $container) {
if (array_key_exists($this->method, $container)) {
$xmlrpcserver = xmlrpc_server_create();
$bool = xmlrpc_server_register_method($xmlrpcserver, $this->method, 'api_dummy_method');
$this->response = xmlrpc_server_call_method($xmlrpcserver, $payload, $container[$this->method], array("encoding" => "utf-8"));
$bool = xmlrpc_server_destroy($xmlrpcserver);
return $this->response;
}
}
throw new XmlrpcServerException('No such method: ' . $this->method);
}
$temp = '';
$this->response = xmlrpc_server_call_method($xmlrpcserver, $payload, $temp, array("encoding" => "utf-8"));
return $this->response;
}
/**
* Create a new XML-RPC Server.
*
* The constructor receives a mandatory parameter: the Call Handler. The call handler executes the actual
* method call. XML_RPC2 server acts as a protocol decoder/encoder between the call handler and the client
*
* @param object $callHandler
* @param array $options associative array of options
*/
function __construct($callHandler, $options = array())
{
parent::__construct($callHandler, $options);
$this->_xmlrpcextServer = xmlrpc_server_create();
foreach ($callHandler->getMethods() as $method) {
if (xmlrpc_server_register_method($this->_xmlrpcextServer, $method->getName(), array($this, 'epiFunctionHandlerAdapter')) !== true) {
throw new XML_RPC2_Exception('Unable to setup XMLRPCext server. xmlrpc_server_register_method returned non-true.');
}
}
}
function add_to_map($methodname, $function, $sig, $doc)
{
xmlrpc_server_register_method($this->server, $methodname, $function);
// xmlrpc_server_register_method($this->server,$methodname,'xmlrpc_call_wrapper');
// $descr = array(
// 'function' => $function,
// 'signature' => $sig,
// 'docstring' => $doc
// );
// xmlrpc_server_set_method_description($this->server,$methodname,$descr);
$this->dmap[$methodname] = array('function' => $function, 'signature' => $sig, 'docstring' => $doc);
}
/**
* XMLRPC server constructor.
*/
function __construct($request, $params = array())
{
parent::__construct($request, $params);
$this->_server = xmlrpc_server_create();
// Register only phpgw services.
foreach ($GLOBALS['registry']->listMethods('phpgw') as $method) {
$methods = explode('/', $method);
array_shift($methods);
$method = implode('.', $methods);
xmlrpc_server_register_method($this->_server, $method, array('Horde_Rpc_Phpgw', '_dispatcher'));
}
}
/**
* register a method
* @param string $pMethod
* @param string $pCallback
*/
public function _registerMethod($pMethod, $pCallback = null)
{
if (!isset($pCallback)) {
$pCallback = array(&$this, $pMethod);
}
if (!\is_callable($pCallback)) {
throw new EXMLRPCServer("method %s is not callable", $pMethod);
}
if (!\xmlrpc_server_register_method($this->server, $pMethod, $pCallback)) {
throw new EXMLRPCServer("method %s could not be registered", $pMethod);
}
}
/**
* This won't ever be called unless there is an error
*/
function serializationAction(&$body)
{
$request_xml = $body->getValue();
$toSerialize = $body->getResults();
$lambdaFunc = 'return $userData;';
$func = create_function('$a,$b,$userData', $lambdaFunc);
$xmlrpc_server = xmlrpc_server_create();
$request_xml = $body->getValue();
xmlrpc_server_register_method($xmlrpc_server, $body->packageClassMethodName, $func);
$response = xmlrpc_server_call_method($xmlrpc_server, $request_xml, $toSerialize);
$body->setResults($response);
}
/**
* Request processor
* @param object $handler
* @param array|bool $methodsList If omitted, handler should contain getMethods() method
* @return string
*/
public function processRequest($handler, $methodsList = false)
{
$server = xmlrpc_server_create();
if (!$methodsList) {
$methodsList = $handler->getMethods();
}
foreach ($methodsList as $method) {
xmlrpc_server_register_method($server, $method, [$handler, $method]);
}
$request = (isset($HTTP_RAW_POST_DATA) and $HTTP_RAW_POST_DATA) ? $HTTP_RAW_POST_DATA : file_get_contents('php://input');
$response = xmlrpc_server_call_method($server, $request, null);
xmlrpc_server_destroy($server);
return $response;
}
function processRequest(&$request_xml)
{
// define XML-RPC server
$server = xmlrpc_server_create();
// log for debuggin
$fp = fopen("/var/tmp/ws_request.log", "a");
fwrite($fp, date("H:i") . "\n");
fwrite($fp, $request_xml);
fwrite($fp, "\n\n");
fclose($fp);
// register methods
xmlrpc_server_register_method($server, "getQueueValues", "rpc_get_queue_values");
xmlrpc_server_register_method($server, "pushValue", "rpc_push_value");
xmlrpc_server_register_method($server, "getStateData", "rpc_get_state_data");
xmlrpc_server_register_method($server, "setStateData", "rpc_set_state_data");
xmlrpc_server_register_method($server, "helloWorld", "rpc_hello_world");
xmlrpc_server_register_method($server, "noop", "rpc_hello_world");
// call the method
$response =& xmlrpc_server_call_method($server, $request_xml, '');
// send back the respond
print $response;
// release resources
xmlrpc_server_destroy($server);
}
/**
* registers xml rpc functions
* @see RpcProvider::registerRpcMethods
*/
public function registerRpcMethods(RpcServer $rpcServer)
{
//xmlrpc_server_register_method($rpcServer->server,__CLASS__.".getTypeList", array(&$this,'getTypeList'));
xmlrpc_server_register_method($rpcServer->server, __CLASS__ . ".getTagList", array(&$this, 'handleRpcRequest'));
}
}
if ($row['category'] == 28) {
$category = "Charity/Support Groups";
}
if ($row['category'] == 29) {
$category = "Miscellaneous";
}
$data[] = array("event_id" => $row["eventid"], "creator" => $row["creatoruuid"], "name" => $row["name"], "category" => $category, "description" => $row["description"], "date" => $date, "dateUTC" => $row["dateUTC"], "duration" => $row["duration"], "covercharge" => $row["covercharge"], "coveramount" => $row["coveramount"], "simname" => $row["simname"], "globalposition" => $row["globalPos"], "eventflags" => $row["eventflags"]);
}
$response_xml = xmlrpc_encode(array('success' => True, 'errorMessage' => "", 'data' => $data));
print $response_xml;
}
#
# Classifieds Info Query
#
xmlrpc_server_register_method($xmlrpc_server, "classifieds_info_query", "classifieds_info_query");
function classifieds_info_query($method_name, $params, $app_data)
{
$req = $params[0];
$classifiedID = $req['classifiedID'];
$sql = "SELECT * FROM classifieds WHERE classifieduuid = '" . mysql_real_escape_string($classifiedID) . "'";
$result = mysql_query($sql);
$data = array();
while ($row = mysql_fetch_assoc($result)) {
$data[] = array("classifieduuid" => $row["classifieduuid"], "creatoruuid" => $row["creatoruuid"], "creationdate" => $row["creationdate"], "expirationdate" => $row["expirationdate"], "category" => $row["category"], "name" => $row["name"], "description" => $row["description"], "parceluuid" => $row["parceluuid"], "parentestate" => $row["parentestate"], "snapshotuuid" => $row["snapshotuuid"], "simname" => $row["simname"], "posglobal" => $row["posglobal"], "parcelname" => $row["parcelname"], "classifiedflags" => $row["classifiedflags"], "priceforlisting" => $row["priceforlisting"]);
}
$response_xml = xmlrpc_encode(array('success' => True, 'errorMessage' => "", 'data' => $data));
print $response_xml;
}
#
# Process the request
/**
* Exporte la fonction/méthode $privateName ou, si non renseigné,
* $publicname comme méthode publique rpc.
*
* @access protected
* @return void
*/
private function _register($publicName, $privateName, $isMethod = false)
{
if (false == $privateName) {
if (($dot = strrpos($publicName, '.')) > 0) {
$privateName = substr($publicName, $dot + 1);
} else {
$privateName = $publicName;
}
}
if ($isMethod) {
$key = 'method';
$func = array($this, $privateName);
$exists = method_exists($this, $privateName);
} else {
$key = 'function';
$func = $privateName;
$exists = function_exists($privateName);
}
if ($exists) {
$this->methodMap[$publicName] = array($key => $privateName);
xmlrpc_server_register_method($this->_server, $publicName, $func);
}
}
/**
* Generate method and type information to add introspection data.
* The information required is generated from annotations.
* All methods are registered with the server, and introspection data
* is added to the server.
*
* @param resource $xmlrpc_server XML RPC server
* @param array $service_description Description
* @param array &$method_aliases Aliases
* @param object $xmlrpc_das Unknown
*
* @return string Method description
*/
public function addIntrospectionData($xmlrpc_server, $service_description, &$method_aliases, $xmlrpc_das = null)
{
if ($xmlrpc_das == null) {
$xsds = SCA_Helper::getAllXsds($service_description->class_name);
$xmlrpc_das = new SCA_Bindings_Xmlrpc_DAS();
foreach ($xsds as $index => $xsds) {
list($namespace, $xsdfile) = $xsds;
if (SCA_Helper::isARelativePath($xsdfile)) {
$xsd = SCA_Helper::constructAbsolutePath($xsdfile, $service_description->class_name);
$xmlrpc_das->addTypesXsdFile($xsd);
}
}
}
$type_list = array();
$methodDesc = <<<END
<?xml version='1.0'?>
<introspection version='1.0'>
<methodList>
END;
foreach ($service_description->operations as $methodName => $methodInfo) {
$methodParams = "";
$methodReturn = "";
if (array_key_exists("name", $methodInfo) && array_key_exists("name", $methodInfo["name"]) && $methodInfo["name"]["name"] != null && strlen($methodInfo["name"]["name"]) > 0) {
$xmlrpcMethodName = $methodInfo["name"]["name"];
$method_aliases[$xmlrpcMethodName] = $methodName;
} else {
$xmlrpcMethodName = $methodName;
}
xmlrpc_server_register_method($xmlrpc_server, $xmlrpcMethodName, $methodName);
if (array_key_exists("parameters", $methodInfo) && $methodInfo["parameters"] != null) {
foreach ($methodInfo["parameters"] as $param) {
$paramName = $param["name"];
if (array_key_exists('objectType', $param)) {
$paramType = $param["objectType"];
$this->generateType($param["namespace"], $param["objectType"], $type_list, $xmlrpc_das);
} else {
$paramType = $this->sdoTypeToXmlRpcType($param["type"]);
}
$methodParams = $methodParams . <<<END
<value type='{$paramType}' desc='{$paramName}'>
</value>
END;
}
}
if (array_key_exists("return", $methodInfo) && $methodInfo["return"] != null) {
foreach ($methodInfo["return"] as $ret) {
if (array_key_exists('objectType', $ret)) {
$retType = $ret["objectType"];
$this->generateType($ret["namespace"], $ret["objectType"], $type_list, $xmlrpc_das);
} else {
$retType = $this->sdoTypeToXmlRpcType($ret["type"]);
}
$methodReturn = $methodReturn . <<<END
<value type='{$retType}' desc='return'>
</value>
END;
}
}
$methodDesc = $methodDesc . <<<END
<methodDescription name='{$xmlrpcMethodName}'>
<author></author>
<purpose></purpose>
<version></version>
<signatures>
<signature>
<params>
{$methodParams}
</params>
<returns>
{$methodReturn}
</returns>
</signature>
</signatures>
</methodDescription>
END;
}
$methodDesc = $methodDesc . "</methodList>\n";
if (count($type_list) > 0) {
$methodDesc = $methodDesc . "<typeList>\n";
foreach ($type_list as $type) {
$methodDesc = $methodDesc . <<<END
<typeDescription name='{$type->name}' basetype='struct' desc='{$type->name}'>
END;
foreach ($type->typedef->properties as $prop) {
$methodDesc = $methodDesc . <<<END
<value type='{$prop->type}' name='{$prop->name}'></value>
END;
}
$methodDesc = $methodDesc . <<<END
</typeDescription>
END;
}
$methodDesc = $methodDesc . "</typeList>\n";
}
$methodDesc = $methodDesc . "</introspection>\n";
$descArray = xmlrpc_parse_method_descriptions($methodDesc);
xmlrpc_server_add_introspection_data($xmlrpc_server, $descArray);
}
/**
* Initialize the object (if necessary), execute the method or function, and
* return the response
*
* @param string $includefile The file that contains the object definition
* @param string $methodname The name of the method to execute
* @param string $method The full path to the method
* @param string $payload The XML-RPC request payload
* @param string $class The name of the class to instantiate (or false)
*
* @throws mnet_server_exception
*
* @return string The XML-RPC response
*/
function mnet_server_invoke_dangerous_method($includefile, $methodname, $method, $payload) {
if (file_exists($CFG->dirroot . $includefile)) {
require_once $CFG->dirroot . $includefile;
// $callprefix matches the rpc convention
// of not having a leading slash
$callprefix = preg_replace('!^/!', '', $includefile);
} else {
throw new mnet_server_exception(705, "nosuchfile");
}
if ($functionname != clean_param($functionname, PARAM_PATH)) {
throw new mnet_server_exception(7012, "nosuchfunction");
}
if (!function_exists($functionname)) {
throw new mnet_server_exception(7012, "nosuchfunction");
}
$xmlrpcserver = xmlrpc_server_create();
xmlrpc_server_register_method($xmlrpcserver, $method, 'mnet_server_dummy_method');
$response = xmlrpc_server_call_method($xmlrpcserver, $payload, $methodname, array("encoding" => "utf-8"));
xmlrpc_server_destroy($xmlrpcserver);
return $response;
}
xmlrpc_server_register_method($server, "validator1.countTheEntities", "validator1_countTheEntities");
xmlrpc_server_register_method($server, "validator1.easyStructTest", "validator1_easyStructTest");
xmlrpc_server_register_method($server, "validator1.echoStructTest", "validator1_echoStructTest");
xmlrpc_server_register_method($server, "validator1.manyTypesTest", "validator1_manyTypesTest");
xmlrpc_server_register_method($server, "validator1.moderateSizeArrayCheck", "validator1_moderateSizeArrayCheck");
xmlrpc_server_register_method($server, "validator1.nestedStructTest", "validator1_nestedStructTest");
xmlrpc_server_register_method($server, "validator1.simpleStructReturnTest", "validator1_simpleStructReturnTest");
// name differently for soap.
xmlrpc_server_register_method($server, "arrayOfStructsTest", "validator1_arrayOfStructsTest");
xmlrpc_server_register_method($server, "countTheEntities", "validator1_countTheEntities");
xmlrpc_server_register_method($server, "easyStructTest", "validator1_easyStructTest");
xmlrpc_server_register_method($server, "echoStructTest", "validator1_echoStructTest");
xmlrpc_server_register_method($server, "manyTypesTest", "validator1_manyTypesTest");
xmlrpc_server_register_method($server, "moderateSizeArrayCheck", "validator1_moderateSizeArrayCheck");
xmlrpc_server_register_method($server, "nestedStructTest", "validator1_nestedStructTest");
xmlrpc_server_register_method($server, "simpleStructReturnTest", "validator1_simpleStructReturnTest");
/* Now, let's get the client's request from the post data.... */
$request_xml = $HTTP_RAW_POST_DATA;
if (!$request_xml) {
$request_xml = $HTTP_GET_VARS[xml];
}
if (!$request_xml) {
echo "<h1>No XML input found!</h1>";
} else {
/* setup some (optional) output options */
$display = array();
if ($HTTP_POST_VARS[verbosity]) {
$display[verbosity] = $HTTP_POST_VARS[verbosity];
}
if ($HTTP_POST_VARS[escaping]) {
$display[escaping] = $HTTP_POST_VARS[escaping];
require_once COMMONPATH . 'SimianGrid.php';
require_once COMMONPATH . 'Scene.php';
require_once COMMONPATH . 'SceneLocation.php';
require_once COMMONPATH . 'Session.php';
// Performance profiling/logging
function shutdown()
{
global $gStartTime;
$elapsed = microtime(true) - $gStartTime;
log_message('debug', "Executed login in {$elapsed} seconds");
}
register_shutdown_function('shutdown');
///////////////////////////////////////////////////////////////////////////////
// XML-RPC Server
$xmlrpc_server = xmlrpc_server_create();
xmlrpc_server_register_method($xmlrpc_server, "login_to_simulator", "process_login");
// Read the request
$request_xml = file_get_contents("php://input");
// Check for a login capability
$authUserID = NULL;
if (!empty($_GET['cap'])) {
$authUserID = get_capability($_GET['cap']);
}
// Build the response
$response = xmlrpc_server_call_method($xmlrpc_server, $request_xml, $authUserID);
header('Content-Type: text/xml');
echo $response;
xmlrpc_server_destroy($xmlrpc_server);
exit;
///////////////////////////////////////////////////////////////////////////////
function make_seed()
$desc = $sourceURI;
$m = array();
if (preg_match('!<title>(.*?)</title>!i', $html, $m)) {
$desc = $m[1];
$desc = preg_replace('/\\s+/', ' ', $desc);
}
// already got this pingback?
if (db_getOne("SELECT id FROM journo_weblink WHERE journo_id=? AND url=? AND approved=true", $journo['id'], $sourceURI)) {
CRAPLOG("0x30\n");
return 0x30;
// "The pingback has already been registered."
}
// OK. time to add it!
$sql = <<<EOT
INSERT INTO journo_weblink
(journo_id, url, description, approved, kind, rank)
VALUES ( ?,?,?,true,'pingback',500)
EOT;
db_do($sql, $journo['id'], $sourceURI, $desc);
db_commit();
CRAPLOG("added.\n");
return "Ping registered - thanks";
}
$svr = xmlrpc_server_create();
xmlrpc_server_register_method($svr, "pingback.ping", "handle_pingback");
$postdata = file_get_contents("php://input");
//CRAPLOG( sprintf( "%s\n--------\n", $postdata ) );
if ($response = xmlrpc_server_call_method($svr, $postdata, null)) {
header("Content-Type: text/xml");
print $response;
}
function register_method($name, $function)
{
$this->methods[$name] = $function;
return xmlrpc_server_register_method($this->_server, $name, 'rpc_method_proxy');
}
/**
* registers xml rpc functions
* @see RpcProvider::registerRpcMethods
*/
public function registerRpcMethods(RpcServer $rpcServer)
{
xmlrpc_server_register_method($rpcServer->server, __CLASS__ . ".subscribe", array(&$this, 'handleRpcRequest'));
}
if ($xmlrpc['pear']) {
// use XML_RPC from pear repository
unset($request_xml);
// save memory
$server = new XML_RPC_Server(array('validatePDF_callback' => array('function' => 'pear_validatePDF_callback')), 1);
return;
// execution end here
}
if ($xmlrpc['internal']) {
// use internal xml-rpc implementation (>php-4.1.0 experimental)
// create server
unset($GLOBALS['HTTP_RAW_POST_DATA']);
// save memory
$xmlrpc_server = xmlrpc_server_create();
if ($xmlrpc_server) {
xmlrpc_server_register_method($xmlrpc_server, "validatePDF_callback", "internal_validatePDF_callback");
$response = '';
echo xmlrpc_server_call_method($xmlrpc_server, $request_xml, $response, array('output_type' => "xml", 'version' => "auto"));
// free server resources
$success = xmlrpc_server_destroy($xmlrpc_server);
}
return;
// execution end here
}
// no useable xml-rpc impl. found
echo 'no useable xml-rpc impl. found';
informAdmin("no useable xml-rpc impl. found");
}
// function for XML_RPC implementation
function pear_validatePDF_callback($params)
{
<?php
/* Наш склад */
$stock = ['a' => 100, 'b' => 200, 'c' => 300];
/* Основная функция */
function get_stock($method_name, $args, $extra)
{
$code = $args[0];
if (isset($GLOBALS['stock'][$code])) {
return "На полке '{$code}' " . $GLOBALS['stock'][$code] . ' товаров';
} else {
return ['faultCode' => 1, 'faultString' => "Полка '{$code}' отсутствует!"];
}
}
/* Создаем XML-RPC сервер и регистрируем функцию */
$server = xmlrpc_server_create();
xmlrpc_server_register_method($server, "getStock", "get_stock");
// Принимаем запрос
$request = file_get_contents("php://input");
/*Отдаем правильный заголовок*/
header('Content-Type: text/xml;charset=utf-8');
/* Отдаем результат */
print xmlrpc_server_call_method($server, $request, null);
/**
* Initialize the object (if necessary), execute the method or function, and
* return the response
*
* @param string $includefile The file that contains the object definition
* @param string $methodname The name of the method to execute
* @param string $method The full path to the method
* @param string $payload The XML-RPC request payload
* @param string $class The name of the class to instantiate (or false)
* @return string The XML-RPC response
*/
function mnet_server_invoke_method($includefile, $methodname, $method, $payload, $class = false)
{
$permission = mnet_permit_rpc_call($includefile, $methodname, $class);
if (RPC_NOSUCHFILE == $permission) {
// Generate error response - unable to locate function
exit(mnet_server_fault(705, 'nosuchfile', $includefile));
}
if (RPC_NOSUCHFUNCTION == $permission) {
// Generate error response - unable to locate function
exit(mnet_server_fault(706, 'nosuchfunction'));
}
if (RPC_FORBIDDENFUNCTION == $permission) {
// Generate error response - unable to locate function
exit(mnet_server_fault(707, 'forbidden-function'));
}
if (RPC_NOSUCHCLASS == $permission) {
// Generate error response - unable to locate function
exit(mnet_server_fault(7013, 'nosuchfunction'));
}
if (RPC_NOSUCHMETHOD == $permission) {
// Generate error response - unable to locate function
exit(mnet_server_fault(7014, 'nosuchmethod'));
}
if (RPC_NOSUCHFUNCTION == $permission) {
// Generate error response - unable to locate function
exit(mnet_server_fault(7014, 'nosuchmethod'));
}
if (RPC_FORBIDDENMETHOD == $permission) {
// Generate error response - unable to locate function
exit(mnet_server_fault(7015, 'nosuchfunction'));
}
if (0 < $permission) {
// Generate error response - unable to locate function
exit(mnet_server_fault(7019, 'unknownerror'));
}
if (RPC_OK == $permission) {
$xmlrpcserver = xmlrpc_server_create();
$bool = xmlrpc_server_register_method($xmlrpcserver, $method, 'mnet_server_dummy_method');
$response = xmlrpc_server_call_method($xmlrpcserver, $payload, $methodname, array("encoding" => "utf-8"));
$bool = xmlrpc_server_destroy($xmlrpcserver);
return $response;
}
}
/**
* Allows you to add a single method to the server after construction.
* @param string $name The name of the method as exposed through the rpc server
* @param callback $method The name of the method to call, or an array with classname or object and method name.
*/
public function addMethod($name, $method)
{
$this->methods[$name] = array('name' => $name, 'call' => $method);
xmlrpc_server_register_method($this->xmlrpc, $name, array($this, 'call'));
}
$date[$name] = $val;
}
$ret = sprintf("%04d%02d%02dT%02d:%02d:%02d", $date["tm_year"] + 1900, $date["tm_mon"] + 1, $date["tm_mday"], $date["tm_hour"], $date["tm_min"], $date["tm_sec"]);
xmlrpc_set_type($ret, "datetime");
return $ret;
}
function echo_($method_name, $params, $app_data)
{
return $params[0];
}
function ping($method_name, $params, $app_data)
{
if (count($params) == 0) {
return "pong";
} else {
return paramfault();
}
}
# Work around xmlrpc-php lossage; otherwise the datetime values
# we return will sometimes get a DST adjustment we do not want.
putenv("TZ=");
$xmlrpc_server = xmlrpc_server_create();
xmlrpc_server_register_method($xmlrpc_server, "sum", "sum");
xmlrpc_server_register_method($xmlrpc_server, "countBools", "countBools");
xmlrpc_server_register_method($xmlrpc_server, "md5sum", "md5sum");
xmlrpc_server_register_method($xmlrpc_server, "dateChange", "dateChange");
xmlrpc_server_register_method($xmlrpc_server, "echo", "echo_");
xmlrpc_server_register_method($xmlrpc_server, "ping", "ping");
$response = xmlrpc_server_call_method($xmlrpc_server, implode("\r\n", file('php://input')), 0, array("output_type" => "xml"));
echo $response;
xmlrpc_server_destroy($xmlrpc_server);
