public function query($method, $parameters = null)
{
$request = xmlrpc_encode_request($method, $parameters);
$headers = array("Content-type: text/xml", "Content-length: " . strlen($request));
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $this->url);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $request);
if ($this->timeout) {
curl_setopt($curl, CURLOPT_TIMEOUT, $this->timeout);
}
$rawResponse = curl_exec($curl);
$curlErrno = curl_errno($curl);
$curlError = curl_error($curl);
curl_close($curl);
if ($curlErrno) {
throw new NetworkException($curlError, $curlErrno);
}
$result = xmlrpc_decode($rawResponse);
if (xmlrpc_is_fault($result)) {
throw new NetworkException($result['faultString'], $result['faultCode']);
}
return $result;
}
function callRemote($method)
{
// Curl is required so generate a fault if curl functions cannot be found.
if (!$this->curl) {
return array('faultCode' => -1, 'faultString' => 'Curl functions are unavailable.');
}
// The first argument will always be the method name while all remaining arguments need
// to be passed along with the call.
$args = func_get_args();
array_shift($args);
if ($this->xmlrpc) {
// If php has xmlrpc support use the built in functions.
$request = xmlrpc_encode_request($method, $args);
$result = $this->__xmlrpc_call($request);
$decodedResult = xmlrpc_decode($result);
} else {
// If no xmlrpc support is found, use the phpxmlrpc library. This involves containing
// all variables inside the xmlrpcval class.
$encapArgs = array();
foreach ($args as $arg) {
$encapArgs[] = $this->__phpxmlrpc_encapsulate($arg);
}
$msg = new xmlrpcmsg($method, $encapArgs);
$client = new xmlrpc_client($this->url);
$client->verifypeer = false;
$result = $client->send($msg);
if ($result->errno) {
$decodedResult = array('faultCode' => $result->errno, 'faultString' => $result->errstr);
} else {
$decodedResult = php_xmlrpc_decode($result->value());
}
}
return $decodedResult;
}
function xmlrpc_decode($xmlrpc_val)
{
$kind = $xmlrpc_val->kindOf();
if ($kind == "scalar") {
return $xmlrpc_val->scalarval();
} else {
if ($kind == "array") {
$size = $xmlrpc_val->arraysize();
$arr = array();
for ($i = 0; $i < $size; $i++) {
$arr[] = xmlrpc_decode($xmlrpc_val->arraymem($i));
}
return $arr;
} else {
if ($kind == "struct") {
$xmlrpc_val->structreset();
$arr = array();
while (list($key, $value) = $xmlrpc_val->structeach()) {
$arr[$key] = xmlrpc_decode($value);
}
return $arr;
}
}
}
}
/**
* send xml data to OpenNebula RPC server
* @param $method
* @param $argument
*/
function rpc_send($method, $argument)
{
//Using the XML-RPC extension to format the XML package
$request = xmlrpc_encode_request($method, $argument);
$req = curl_init($this->service_url);
//Using the cURL extension to send it off, first creating a custom header block
$headers = array();
array_push($headers, "Content-Type: text/xml");
array_push($headers, "Content-Length: " . strlen($request));
array_push($headers, "\r\n");
//URL to post to
curl_setopt($req, CURLOPT_URL, $this->service_url);
//Setting options for a secure SSL based xmlrpc server
curl_setopt($req, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($req, CURLOPT_SSL_VERIFYHOST, 2);
curl_setopt($req, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($req, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($req, CURLOPT_HTTPHEADER, $headers);
curl_setopt($req, CURLOPT_POSTFIELDS, $request);
//Finally run
$response = curl_exec($req);
//Close the cURL connection
curl_close($req);
//Decoding the response to be displayed
$result = xmlrpc_decode($response);
return $result;
}
function getcomments($m)
{
$err = '';
$ra = array();
// get the first param
$msgID = xmlrpc_decode($m->getParam(0));
$countID = "{$msgID}_count";
$sql = 'SELECT * FROM phpgw_discuss WHERE msg_id=' . $msgID;
$GLOBALS['phpgw']->db->query($sql, __LINE__, __FILE__);
$count = $GLOBALS['phpgw']->db->num_rows();
while ($data = $GLOBALS['phpgw']->db->next_record()) {
$name = $GLOBALS['phpgw']->db->f('name');
$comment = $GLOBALS['phpgw']->db->f('comment');
// push a new struct onto the return array
$ra[] = CreateObject('phpgwapi.xmlrpcval', array('name' => CreateObject('phpgwapi.xmlrpcval', $name), 'comment' => CreateObject('phpgwapi.xmlrpcval', $comment)), 'struct');
}
// if we generated an error, create an error return response
if ($err) {
return CreateObject('phpgwapi.xmlrpcresp', '', $GLOBALS['xmlrpcerruser'], $err);
} else {
// otherwise, we create the right response
// with the state name
return CreateObject('phpgwapi.xmlrpcresp', CreateObject('phpgwapi.xmlrpcval', $ra, 'array'));
}
}
/**
* Ping Blog Update Services
*
* @param array $options are name, website, url
*/
function ping($options = array())
{
$type = 'REST';
if (function_exists('xmlrpc_encode_request')) {
$type = 'XML-RPC';
}
switch ($type) {
case 'REST':
// construct parameters
$params = array('name' => $options['name'], 'url' => $options['url']);
$params = array_map('rawurlencode', $params);
$paramString = http_build_query($params);
// Rest Update Ping Services
foreach ($this->__services['rest'] as $serviceApi) {
$requestUrl = $serviceApi . '?' . $paramString;
$response = file_get_contents($requestUrl);
}
break;
case 'XML-RPC':
// construct parameters
$params = array($options['name'], $options['website'], $options['url'], $options['feed']);
$request = xmlrpc_encode_request("weblogUpdates.extendedPing", $params);
$context = stream_context_create(array('http' => array('method' => "POST", 'header' => "Content-Type: text/xml", 'content' => $request)));
foreach ($this->__services['rpc'] as $endPoint) {
// Ping the services
$file = file_get_contents($endPoint, false, $context);
$response = xmlrpc_decode($file);
//no need to process the response
}
break;
}
}
function getcomments($m)
{
global $xmlrpcerruser;
$err = "";
$ra = array();
// get the first param
if (XMLRPC_EPI_ENABLED == '1') {
$msgID = xmlrpc_decode($m->getParam(0));
} else {
$msgID = php_xmlrpc_decode($m->getParam(0));
}
$dbh = dba_open("/tmp/comments.db", "r", "db2");
if ($dbh) {
$countID = "{$msgID}_count";
if (dba_exists($countID, $dbh)) {
$count = dba_fetch($countID, $dbh);
for ($i = 0; $i < $count; $i++) {
$name = dba_fetch("{$msgID}_name_{$i}", $dbh);
$comment = dba_fetch("{$msgID}_comment_{$i}", $dbh);
// push a new struct onto the return array
$ra[] = array("name" => $name, "comment" => $comment);
}
}
}
// if we generated an error, create an error return response
if ($err) {
return new xmlrpcresp(0, $xmlrpcerruser, $err);
} else {
// otherwise, we create the right response
// with the state name
return new xmlrpcresp(php_xmlrpc_encode($ra));
}
}
private function _request($request)
{
$context = stream_context_create(array('http' => array('method' => 'POST', 'header' => 'Content-Type: text/xml', 'content' => $request)));
$response = file_get_contents('https://api.loopia.se/RPCSERV', false, $context);
$response = xmlrpc_decode($response);
return $response;
}
/**
* {@inheritdoc}
*/
public function parse($xmlString, &$isFault)
{
$result = xmlrpc_decode($xmlString, 'UTF-8');
$isFault = false;
$toBeVisited = [&$result];
while (isset($toBeVisited[0]) && ($value =& $toBeVisited[0])) {
$type = gettype($value);
if ($type === 'object') {
$xmlRpcType = $value->{'xmlrpc_type'};
if ($xmlRpcType === 'datetime') {
$value = DateTime::createFromFormat('Ymd\\TH:i:s', $value->scalar, isset($timezone) ? $timezone : ($timezone = new DateTimeZone('UTC')));
} elseif ($xmlRpcType === 'base64') {
if ($value->scalar !== '') {
$value = Base64::serialize($value->scalar);
} else {
$value = null;
}
}
} elseif ($type === 'array') {
foreach ($value as &$element) {
$toBeVisited[] =& $element;
}
}
array_shift($toBeVisited);
}
if (is_array($result)) {
reset($result);
$isFault = xmlrpc_is_fault($result);
}
return $result;
}
function onStartNoticeSave($notice)
{
$args = $this->testArgs($notice);
common_debug("Blogspamnet args = " . print_r($args, TRUE));
$request = xmlrpc_encode_request('testComment', array($args));
$context = stream_context_create(array('http' => array('method' => "POST", 'header' => "Content-Type: text/xml\r\n" . "User-Agent: " . $this->userAgent(), 'content' => $request)));
$file = file_get_contents($this->baseUrl, false, $context);
$response = xmlrpc_decode($file);
if (xmlrpc_is_fault($response)) {
throw new ServerException("{$response['faultString']} ({$response['faultCode']})", 500);
} else {
common_debug("Blogspamnet results = " . $response);
if (preg_match('/^ERROR(:(.*))?$/', $response, $match)) {
throw new ServerException(sprintf(_("Error from %s: %s"), $this->baseUrl, $match[2]), 500);
} else {
if (preg_match('/^SPAM(:(.*))?$/', $response, $match)) {
throw new ClientException(sprintf(_("Spam checker results: %s"), $match[2]), 400);
} else {
if (preg_match('/^OK$/', $response)) {
// don't do anything
} else {
throw new ServerException(sprintf(_("Unexpected response from %s: %s"), $this->baseUrl, $response), 500);
}
}
}
}
return true;
}
function xmlrpcCall($url, $method, $params)
{
// xmlrpc encode parameters
for ($i = 0; $i < count($params); $i++) {
if (get_class($params[$i]) != 'xmlrpcval') {
$params[$i] = xmlrpc_encode($params[$i]);
}
}
// send request
$message = new xmlrpcmsg($method, $params);
debug("XML-RPC message", $message->serialize());
$addr = parse_url($url);
$client = new xmlrpc_client($url, $addr['host'], $addr['port']);
//if($debug)
// $client->setDebug(1);
debug("XML-RPC", "call to " . $url);
$response = $client->send($message);
// process response
debug("XML-RPC Response", $response->serialize());
if (!$response) {
debug("No response", "probably host is unreachable");
} elseif ($response->faultCode() != 0) {
// there was an error
debug("Error response: ", $response->faultCode() . " " . $response->faultString());
} else {
$retval = $response->value();
if ($retval) {
$retval = xmlrpc_decode($retval);
}
debug("Response", $retval);
return $retval;
}
return NULL;
}
function onStartNoticeSave($notice)
{
$args = $this->testArgs($notice);
common_debug("Blogspamnet args = " . print_r($args, TRUE));
$requestBody = xmlrpc_encode_request('testComment', array($args));
$request = new HTTPClient($this->baseUrl, HTTPClient::METHOD_POST);
$request->setHeader('Content-Type', 'text/xml');
$request->setBody($requestBody);
$httpResponse = $request->send();
$response = xmlrpc_decode($httpResponse->getBody());
if (xmlrpc_is_fault($response)) {
throw new ServerException("{$response['faultString']} ({$response['faultCode']})", 500);
} else {
common_debug("Blogspamnet results = " . $response);
if (preg_match('/^ERROR(:(.*))?$/', $response, $match)) {
throw new ServerException(sprintf(_("Error from %s: %s"), $this->baseUrl, $match[2]), 500);
} else {
if (preg_match('/^SPAM(:(.*))?$/', $response, $match)) {
throw new ClientException(sprintf(_("Spam checker results: %s"), $match[2]), 400);
} else {
if (preg_match('/^OK$/', $response)) {
// don't do anything
} else {
throw new ServerException(sprintf(_("Unexpected response from %s: %s"), $this->baseUrl, $response), 500);
}
}
}
}
return true;
}
public static function get_response($server, $request, &$error = null, $fresh = false)
{
$ch = vpl_jailserver_manager::get_curl($server, $request, $fresh);
$raw_response = curl_exec($ch);
if ($raw_response === false) {
$error = 'request failed: ' . s(curl_error($ch));
curl_close($ch);
return false;
} else {
curl_close($ch);
$error = '';
$response = xmlrpc_decode($raw_response, "UTF-8");
if (is_array($response)) {
if (xmlrpc_is_fault($response)) {
$error = 'xmlrpc is fault: ' . s($response["faultString"]);
} else {
return $response;
}
} else {
$error = 'http error ' . s(strip_tags($raw_response));
$fail = true;
}
return false;
}
}
private function sendRequest($request)
{
$context = stream_context_create(array('http' => array('method' => "POST", 'header' => "Content-Type: text/xml", 'content' => $request, 'timeout' => $this->timeout)));
$status = @file_get_contents("http://" . $this->host . ":" . $this->port . "/RPC2", false, $context);
$retval = xmlrpc_decode($status);
return $retval;
}
/**
* Sends an XML RPC request to the XML RPC server
* @param $methodName string Name of the XML RPC method to call
* @param $params array Array of parameters to pass to the XML RPC method. Type is detected automatically. For a struct just encode an array within $params.
* @return array Array of returned parameters
*/
public function send($methodName, $params)
{
$request = xmlrpc_encode_request($methodName, $params);
$response = $this->sendRequest($request);
$response = xmlrpc_decode(trim($response));
//Without the trim function returns null
return $response;
}
/**
* Call server RPC method
*
* @param string method name
* @param array arguments
* @return string
*/
function __call($function, $argv)
{
$request = xmlrpc_encode_request($function, $argv);
$headers = array('Content-Type: text/xml', 'Content-Length: ' . strlen($request) . "\r\n\r\n" . $request);
$this->SetHeaders($headers);
$this->Fetch($this->Host, array(), true);
return xmlrpc_decode($this->Result);
}
function do_xmlrpc($request)
{
global $rpc_connect;
$context = stream_context_create(array('http' => array('method' => "POST", 'header' => "Content-Type: text/xml", 'content' => $request)));
$file = file_get_contents($rpc_connect, false, $context);
$file = str_replace("i8", "double", $file);
return xmlrpc_decode($file);
}
public function request($function, array $parameters = null)
{
$request = \xmlrpc_encode_request($function, $parameters);
$context = \stream_context_create(array('http' => array('method' => "POST", 'header' => "Content-Type: text/xml", 'content' => $request)));
$file = \file_get_contents($this->imgSeekUrl . '/RPC', false, $context);
$response = \xmlrpc_decode($file);
return $response;
}
public function call($method, $params = null)
{
$postData = xmlrpc_encode_request($method, $params);
$httpHeader = array('Content-Type: text/xml;charset=UTF-8');
$curlResult = CURL::post($this->url, $postData, $httpHeader);
if ($curlResult === 'Error') {
return [];
}
return xmlrpc_decode($curlResult);
}
/**
* Execute the request. Populates result field.
*/
public function execute()
{
$rr = new RemoteRequest($this->url, 'POST');
$rr->add_header('Content-Type: text/xml;charset=utf-8');
$rr->set_body($this->request_body);
// should throw an error on failure
$rr->execute();
// in that case, we should never get here
$this->result = xmlrpc_decode($rr->get_response_body());
}
public static function sendPingback($endpoint, $source, $target)
{
$payload = xmlrpc_encode_request('pingback.ping', array($source, $target));
$response = static::_post($endpoint, $payload, array('Content-type: application/xml'));
if (is_array(xmlrpc_decode($response))) {
return false;
} elseif (is_string($response) && !empty($response)) {
return true;
}
}
function ping_broadcast_notice($notice)
{
if ($notice->is_local != Notice::LOCAL_PUBLIC && $notice->is_local != Notice::LOCAL_NONPUBLIC) {
return true;
}
# Array of servers, URL => type
$notify = common_config('ping', 'notify');
$profile = $notice->getProfile();
$tags = ping_notice_tags($notice);
foreach ($notify as $notify_url => $type) {
switch ($type) {
case 'xmlrpc':
case 'extended':
$req = xmlrpc_encode_request('weblogUpdates.ping', array($profile->nickname, common_local_url('showstream', array('nickname' => $profile->nickname)), common_local_url('shownotice', array('notice' => $notice->id)), common_local_url('userrss', array('nickname' => $profile->nickname)), $tags));
$request = HTTPClient::start();
$request->setConfig('connect_timeout', common_config('ping', 'timeout'));
$request->setConfig('timeout', common_config('ping', 'timeout'));
try {
$httpResponse = $request->post($notify_url, array('Content-Type: text/xml'), $req);
} catch (Exception $e) {
common_log(LOG_ERR, "Exception pinging {$notify_url}: " . $e->getMessage());
continue;
}
if (!$httpResponse || mb_strlen($httpResponse->getBody()) == 0) {
common_log(LOG_WARNING, "XML-RPC empty results for ping ({$notify_url}, {$notice->id}) ");
continue;
}
$response = xmlrpc_decode($httpResponse->getBody());
if (is_array($response) && xmlrpc_is_fault($response)) {
common_log(LOG_WARNING, "XML-RPC error for ping ({$notify_url}, {$notice->id}) " . "{$response['faultString']} ({$response['faultCode']})");
} else {
common_log(LOG_INFO, "Ping success for {$notify_url} {$notice->id}");
}
break;
case 'get':
case 'post':
$args = array('name' => $profile->nickname, 'url' => common_local_url('showstream', array('nickname' => $profile->nickname)), 'changesURL' => common_local_url('userrss', array('nickname' => $profile->nickname)));
$fetcher = Auth_Yadis_Yadis::getHTTPFetcher();
if ($type === 'get') {
$result = $fetcher->get($notify_url . '?' . http_build_query($args), array('User-Agent: StatusNet/' . STATUSNET_VERSION));
} else {
$result = $fetcher->post($notify_url, http_build_query($args), array('User-Agent: StatusNet/' . STATUSNET_VERSION));
}
if ($result->status != '200') {
common_log(LOG_WARNING, "Ping error for '{$notify_url}' ({$notice->id}): " . "{$result->body}");
} else {
common_log(LOG_INFO, "Ping success for '{$notify_url}' ({$notice->id}): " . "'{$result->body}'");
}
break;
default:
common_log(LOG_WARNING, 'Unknown notify type for ' . $notify_url . ': ' . $type);
}
}
return true;
}
/**
* Get the remote machine's SSL Cert
*
* @param string $uri The URI of a file on the remote computer, including
* its http:// or https:// prefix
* @return string A PEM formatted SSL Certificate.
*/
function mnet_get_public_key($uri, $application = null)
{
global $CFG, $MNET;
// The key may be cached in the mnet_set_public_key function...
// check this first
$key = mnet_set_public_key($uri);
if ($key != false) {
return $key;
}
if (empty($application)) {
$application = get_record('mnet_application', 'name', 'moodle');
}
$rq = xmlrpc_encode_request('system/keyswap', array($CFG->wwwroot, $MNET->public_key, $application->name), array("encoding" => "utf-8"));
$ch = curl_init($uri . $application->xmlrpc_server_url);
curl_setopt($ch, CURLOPT_TIMEOUT, 60);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_USERAGENT, 'Moodle');
curl_setopt($ch, CURLOPT_POSTFIELDS, $rq);
curl_setopt($ch, CURLOPT_HTTPHEADER, array("Content-Type: text/xml charset=UTF-8"));
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
$res = xmlrpc_decode(curl_exec($ch));
// check for curl errors
$curlerrno = curl_errno($ch);
if ($curlerrno != 0) {
debugging("Request for {$uri} failed with curl error {$curlerrno}");
}
// check HTTP error code
$info = curl_getinfo($ch);
if (!empty($info['http_code']) and $info['http_code'] != 200) {
debugging("Request for {$uri} failed with HTTP code " . $info['http_code']);
}
curl_close($ch);
if (!is_array($res)) {
// ! error
$public_certificate = $res;
$credentials = array();
if (strlen(trim($public_certificate))) {
$credentials = openssl_x509_parse($public_certificate);
$host = $credentials['subject']['CN'];
if (strpos($uri, $host) !== false) {
mnet_set_public_key($uri, $public_certificate);
return $public_certificate;
} else {
debugging("Request for {$uri} returned public key for different URI - {$host}");
}
} else {
debugging("Request for {$uri} returned empty response");
}
} else {
debugging("Request for {$uri} returned unexpected result");
}
return false;
}
/**
* Run an XMLRPC command. Name should be a query name and params an array of parameters, eg:
* $this->raw("checkAuthentication", ["adam", "qwerty"]);
* If successful returns back an array of useful information.
*
* Note that $params["id"] is reserved for query ID, you may set it to something if you wish.
* If you do, the same ID will be passed back with the reply from Anope.
*
* @param $name
* @param $params
* @return array|null
*/
public function run($name, $params)
{
$xmlquery = xmlrpc_encode_request($name, $params);
$context = stream_context_create(["http" => ["method" => "POST", "header" => "Content-Type: text/xml", "content" => $xmlquery]]);
$inbuf = file_get_contents($this->host, false, $context);
$response = xmlrpc_decode($inbuf);
if ($response) {
return $response;
}
return null;
}
function normalValidate($command, $la, $code)
{
$request = xmlrpc_encode_request("validate", array($command, $la, AV_LOGIN, AV_PASSWD, $code));
$context = stream_context_create(array('http' => array('method' => "POST", 'header' => "Content-Type: text/xml", 'content' => $request)));
$file = file_get_contents(AV_RPC_URL, false, $context);
$response = xmlrpc_decode($file);
if (xmlrpc_is_fault($response)) {
return false;
}
return $response['status'] == "OK";
}
/**
* Calls the method on the server with the given parameters
*
* @param string $method The method name
* @param array $parameters The argument parameters for the method
*
* @return string
*/
protected function call($method, array $parameters = array())
{
$request = xmlrpc_encode_request($method, $parameters);
$context = stream_context_create(array('http' => array('method' => "POST", 'header' => "Content-Type: text/xml", 'content' => $request)));
$contents = $this->fileRetriever->retrieveContents($this->getDSN(), $context);
$response = xmlrpc_decode($contents);
if ($response && is_array($response) && xmlrpc_is_fault($response)) {
trigger_error("xmlrpc: {$response['faultString']} ({$response['faultCode']})");
}
return $response;
}
public function __call($method, $params)
{
if ($this->namespace) {
$method = $this->namespace . '.' . $method;
}
$this->request->setRawPostData(xmlrpc_encode_request($method, $params));
$response = $this->request->send();
if ($response->getResponseCode() != 200) {
throw new Exception($response->getBody(), $response->getResponseCode());
}
return xmlrpc_decode($response->getBody(), 'utf-8');
}
public function execute($server)
{
$file = file_get_contents($server, false, $this->context);
if ($file == false) {
throw new Exception("Server didn't send an answer!");
}
$response = xmlrpc_decode($file);
if (is_array($response) && xmlrpc_is_fault($response)) {
throw new XMLRPCException($response['faultString'], $response['faultCode']);
}
return $response;
}
protected function commit_rpc()
{
$request = xmlrpc_encode_request($this->method, $this->parms);
$context = stream_context_create(array('http' => array('method' => "POST", 'header' => "Content-Type: text/xml; charset=utf-8\r\n" . "User-Agent: XMLRPC::Client JorgeRPCclient", 'content' => $request)));
$file = file_get_contents("http://{$this->rpc_server}" . ":" . "{$this->rpc_port}", false, $context);
$response = xmlrpc_decode($file, "utf8");
if (xmlrpc_is_fault($response)) {
throw new Exception("XML-RPC Call Failed. Unrecoverable condition", 0);
} else {
return $response;
}
}
function do_xmlrpc($request)
{
global $rpc_connect;
$context = stream_context_create(array('http' => array('method' => "POST", 'header' => "Content-Type: text/xml", 'content' => $request)));
if ($file = @file_get_contents($rpc_connect, false, $context)) {
$file = str_replace("i8", "double", $file);
$file = utf8_encode($file);
return xmlrpc_decode($file);
} else {
die("<h1>Cannot connect to rtorrent :(</h1>");
}
}
