La bibliothèque XML-RPC trouvée sur Internet est très utile pour développer de petites interfaces de communication externes. Enregistrez ce code sous xml-rpc.inc.php
<?php.
/*
La bibliothèque XML-RPC trouvée sur Internet est très utile pour développer de petites interfaces de communication externes.
*/
fonction & XML_serialize($data, $level = 0, $prior_key = NULL){
#suppose un hachage, les clés sont les noms de variables
$xml_serialized_string = "";
while(list($key, $value) = each($data)){
$en ligne = faux ;
$numeric_array = faux ;
$attributs = "";
#echo "Ma clé actuelle est '$key', appelée avec la clé précédente '$prior_key'<br>";
if(!strstr($key, " attr")){ #si ce n'est pas un attribut
if(array_key_exists("$key attr", $data)){
while(list($attr_name, $attr_value) = each($data["$key attr"])){
#echo "Attribut $attribute_name trouvé avec la valeur $attribute_value<br>" ;
$attr_value = &htmlspecialchars($attr_value, ENT_QUOTES);
$attributes .= " $attr_name="$attr_value"";
}
}
si(is_numeric($clé)){
#echo "Ma clé actuelle ($key) est numérique. Ma clé parent est '$prior_key'<br>";
$clé = $prior_key ;
}autre{
#vous ne pouvez pas avoir de touches numériques sur deux niveaux d'affilée, donc ça va
#echo "Vérifier si une clé numérique existe dans les données.";
if(is_array($value) et array_key_exists(0, $value)){
# echo "C'est vrai ! Je m'appelle à la suite d'un tableau numérique.<br>";
$numeric_array = vrai ;
$xml_serialized_string .= XML_serialize($value, $level, $key);
}
#echo "<br>" ;
}
si(!$numeric_array){
$xml_serialized_string .= str_repeat("t", $level) "<$key$attributes>";
si(is_array($valeur)){
$xml_serialized_string .= "rn" . XML_serialize($value, $level+1);
}autre{
$en ligne = vrai ;
$xml_serialized_string .= htmlspecialchars($value);
}
$xml_serialized_string .= (!$inline ? str_repeat("t", $level) : "") .
}
}autre{
#echo "Sauter l'enregistrement d'attribut pour la clé $key<bR>" ;
}
}
si($niveau == 0){
$xml_serialized_string = "<?xml version="1.0" ?>rn" .
renvoie $xml_serialized_string ;
}autre{
renvoie $xml_serialized_string ;
}
}
classe XML {
var $parser; #une référence à l'analyseur XML
var $document; #la structure XML entière construite jusqu'à présent
var $current; #un pointeur vers l'élément actuel - qu'est-ce que c'est
var $parent; #un pointeur vers le parent actuel - le parent sera un tableau
var $parents; #un tableau du parent le plus récent à chaque niveau
var $last_opened_tag;
fonction XML($data=null){
$this->parser = xml_parser_create();
xml_parser_set_option ($this->analyseur, XML_OPTION_CASE_FOLDING, 0);
xml_set_object($this->parser, $this);
xml_set_element_handler($this->parser, "ouvrir", "fermer");
xml_set_character_data_handler($this->parser, "data");
# register_shutdown_function(array($this, 'destruct'));
}
fonction destruction(){
xml_parser_free($this->parser);
}
fonction analyser ($données){
$this->document = array();
$this->parent = $this->document ;
$this->parents = array();
$this->last_opened_tag = NULL ;
xml_parse($this->analyseur, $data);
retourner $this->document ;
}
fonction ouverte ($parser, $tag, $attributes){
#echo "Balise d'ouverture $tag<br>n";
$this->données = "";
$this->last_opened_tag = $tag; #tag est une chaîne
if(array_key_exists($tag, $this->parent)){
#echo "Il existe déjà une instance de '$tag' au niveau actuel ($level)<br>n";
if(is_array($this->parent[$tag]) and array_key_exists(0, $this->parent[$tag])){ #si les clés sont numériques
#besoin de s'assurer qu'ils sont numériques (tenir compte des attributs)
$key = count_numeric_items($this->parent[$tag]);
#echo "Il existe des instances de $key : les clés sont numériques.<br>n";
}autre{
#echo "Il n'y a qu'une seule instance. Tout déplacer<br>n";
$temp = $this->parent[$tag];
unset($this->parent[$tag]);
$this->parent[$tag][0] = $temp;
if(array_key_exists("$tag attr", $this->parent)){
#décaler également les attributs s'ils existent
$temp = $this->parent["$tag attr"];
unset($this->parent["$tag attr"]);
$this->parent[$tag]["0 attr"] = $temp;
}
$clé = 1 ;
}
$this->parent = $this->parent[$tag];
}autre{
$clé = $balise ;
}
si($attributs){
$this->parent["$key attr"] = $attributs;
}
$this->parent[$key] = array();
$this->parent = $this->parent[$key];
array_unshift($this->parents, $this->parent);
}
données de fonction($analyseur, $data){
#echo "Les données sont '", htmlspecialchars($data), "'<br>n";
if($this->last_opened_tag != NULL){
$this->data .= $data;
}
}
fonction fermer ($parser, $tag){
#echo "Fermer la balise $tag<br>n";
if($this->last_opened_tag == $tag){
$this->parent = $this->data;
$this->last_opened_tag = NULL ;
}
array_shift($this->parents);
$this->parent = $this->parents[0];
}
}
fonction & XML_unserialize($xml){
$xml_parser = nouveau XML();
$data = $xml_parser->parse($xml);
$xml_parser->destruct();
renvoyer $données ;
}
fonction & XMLRPC_parse($request){
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_parse', "<p>Reçu la requête brute suivante :</p>" . XMLRPC_show($request, 'print_r', true));
}
$data = &XML_unserialize($request);
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_parse', "<p>Renvoi de la requête analysée suivante :</p>" . XMLRPC_show($data, 'print_r', true));
}
renvoyer $données ;
}
fonction & XMLRPC_prepare($data, $type = NULL){
si(is_array($data)){
$num_elements = nombre($data);
if((array_key_exists(0, $data) or !$num_elements) and $type != 'struct'){ #c'est un tableau
if(!$num_elements){ #si le tableau est videvide
$returnvalue = array('array' => array('data' => NULL));
}autre{
$returnvalue['array']['data']['value'] = array();
$temp = $returnvalue['array']['data']['value'];
$count = count_numeric_items($data);
pour($n=0; $n<$count; $n++){
$type = NULL ;
if(array_key_exists("$n type", $data)){
$type = $data["$n type"];
}
$temp[$n] = XMLRPC_prepare($data[$n], $type);
}
}
}else{ #c'est une structure
if(!$num_elements){ #si la structure est videvide
$returnvalue = array('struct' => NULL);
}autre{
$returnvalue['struct']['member'] = array();
$temp = $returnvalue['struct']['member'];
while(list($key, $value) = each($data)){
if(substr($key, -5) != ' type'){ #si ce n'est pas un spécificateur de type
$type = NULL ;
if(array_key_exists("$type de clé", $data)){
$type = $data["$type de clé"];
}
$temp[] = array('name' => $key, 'value' => XMLRPC_prepare($value, $type));
}
}
}
}
}else{ #c'est un scalaire
si(!$type){
si(is_int($data)){
$returnvalue['int'] = $données ;
retourner $valeur de retour ;
}elseif(is_float($data)){
$returnvalue['double'] = $données ;
retourner $valeur de retour ;
}elseif(is_bool($data)){
$returnvalue['boolean'] = ($data ? 1 : 0);
retourner $valeur de retour ;
}elseif(preg_match('/^d{8}Td{2}:d{2}:d{2}$/', $data, $matches)){ #c'est un rendez-vous
$returnvalue['dateTime.iso8601'] = $data;
retourner $valeur de retour ;
}elseif(is_string($data)){
$returnvalue['string'] = htmlspecialchars($data);
retourner $valeur de retour ;
}
}autre{
$returnvalue[$type] = htmlspecialchars($data);
}
}
retourner $valeur de retour ;
}
fonction & XMLRPC_adjustValue($current_node){
si(is_array($current_node)){
if(isset($current_node['array'])){
if(!is_array($current_node['array']['data'])){
#S'il n'y a aucun élément, renvoie un tableau vide
return array();
}autre{
#echo "Se débarrasser du tableau -> données -> valeur<br>n";
$temp = $current_node['array']['data']['value'];
if(is_array($temp) et array_key_exists(0, $temp)){
$count = count($temp);
pour($n=0;$n<$count;$n++){
$temp2[$n] = &XMLRPC_adjustValue($temp[$n]);
}
$temp = $temp2;
}autre{
$temp2 = &XMLRPC_adjustValue($temp);
$temp = tableau($temp2);
#Je fais l'intérim car ça évite les copies,
# puisque je peux mettre une référence dans le tableau
Le modèle de référence de #PHP est un peu idiot, et je ne peux pas simplement dire :
# $temp = array(&XMLRPC_adjustValue($temp));
}
}
}elseif(isset($current_node['struct'])){
if(!is_array($current_node['struct'])){
#S'il n'y a aucun membre, renvoie un tableau vide
return array();
}autre{
#echo "Se débarrasser de struct -> member<br>n";
$temp = $current_node['struct']['member'];
if(is_array($temp) et array_key_exists(0, $temp)){
$count = count($temp);
pour($n=0;$n<$count;$n++){
#echo "Nom de passage {$temp[$n][name]}. La valeur est : " . show($temp[$n][value], var_dump, true) "<br>n";
$temp2[$temp[$n]['name']] = &XMLRPC_adjustValue($temp[$n]['value']);
#echo "adjustValue() : Après l'attribution, la valeur est " . show($temp2[$n]['name']], var_dump, true) "<br>n";
}
}autre{
#echo "Passer le nom $temp[name]<br>n";
$temp2[$temp['name']] = &XMLRPC_adjustValue($temp['value']);
}
$temp = $temp2;
}
}autre{
$types = array('string', 'int', 'i4', 'double', 'dateTime.iso8601', 'base64', 'boolean');
$fell_through = vrai ;
foreach($types comme $type){
if(array_key_exists($type, $current_node)){
#echo "Se débarrasser de '$type'<br>n";
$temp = $current_node[$type];
#echo "adjustValue() : Le nœud actuel est défini avec un type de $type<br>n" ;
$fell_through = faux ;
casser;
}
}
si($fell_through){
$type = 'chaîne';
#echo "Échoué ! Le type est $type<br>n" ;
}
changer ($type){
cas 'int' : cas 'i4' : $temp = (int)$temp break;
case 'string' : $temp = (string)$temp break;
cas 'double' : $temp = (double)$temp break;
cas 'booléen' : $temp = (bool)$temp break ;
}
}
}autre{
$temp = (chaîne)$current_node;
}
retourner $temp;
}
fonction XMLRPC_getParams($request){
if(!is_array($request['methodCall']['params'])){
#S'il n'y a pas de paramètres, renvoie un tableau vide
return array();
}autre{
#echo "Se débarrasser de methodCall -> params -> param<br>n";
$temp = $request['methodCall']['params']['param'];
if(is_array($temp) et array_key_exists(0, $temp)){
$count = count($temp);
pour($n = 0; $n < $count; $n++){
#echo "Paramètre de sérialisation $n<br>";
$temp2[$n] = &XMLRPC_adjustValue($temp[$n]['value']);
}
}autre{
$temp2[0] = &XMLRPC_adjustValue($temp['value']);
}
$temp = $temp2;
retourner $temp;
}
}
fonction XMLRPC_getMethodName($methodCall){
#renvoie le nom de la méthode
return $methodCall['methodCall']['methodName'];
}
fonction XMLRPC_request($site, $location, $methodName, $params = NULL, $user_agent = NULL){
$site = exploser(':', $site);
if(isset($site[1]) et is_numeric($site[1])){
$port = $site[1] ;
}autre{
$port = 80 ;
}
$site = $site[0] ;
$data["methodCall"]["methodName"] = $methodName;
$param_count = nombre($params);
si(!$param_count){
$data["methodCall"]["params"] = NULL;
}autre{
pour($n = 0; $n<$param_count; $n++){
$data["methodCall"]["params"]["param"][$n]["value"] = $params[$n];
}
}
$données = XML_serialize($données);
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_request', "<p>Reçu la liste de paramètres suivante à envoyer :</p>" . XMLRPC_show($params, 'print_r', true));
}
$conn = fsockopen ($site, $port); #ouvrir la connexion
if(!$conn){ #si la connexion n'a pas été ouverte avec succès
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_request', "<p>Échec de la connexion : impossible d'établir la connexion à $site.</p>");
}
return array(false, array('faultCode'=>10532, 'faultString'=>"Échec de la connexion : impossible d'établir la connexion à $site."));
}autre{
$en-têtes =
"POST $emplacement HTTP/1.0rn" .
"Hôte : $sitern" .
"Connexion : fermerrn" .
($user_agent ? "User-Agent : $user_agentrn" : '') .
"Type de contenu : text/xmlrn" .
"Contenu-Longueur : " . strlen($data) "rnrn";
fputs($conn, "$headers");
fputs($conn, $data);
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_request', "<p>Envoyé la requête suivante :</p>nn" . XMLRPC_show($headers . $data, 'print_r', true));
}
#socket_set_blocking ($conn, false);
$réponse = "";
tandis que(!feof($conn)){
$response .= fgets($conn, 1024);
}
fclose($conn);
#supprimer les en-têtes de la réponse
$data = XML_unserialize(substr($response, strpos($response, "rnrn")+4));
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_request', "<p>Reçu la réponse suivante :</p>nn" . XMLRPC_show($response, 'print_r', true) . "<p>Qui a été sérialisée dans les données suivantes :< /p>nn" . XMLRPC_show($data, 'print_r', true));
}
if(isset($data['methodResponse']['fault'])){
$return = array(false, XMLRPC_adjustValue($data['methodResponse']['fault']['value']));
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_request', "<p>Retour :</p>nn" . XMLRPC_show($return, 'var_dump', true));
}
retourner $revenir;
}autre{
$return = array(true, XMLRPC_adjustValue($data['methodResponse']['params']['param']['value']));
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_request', "<p>Retour :</p>nn" . XMLRPC_show($return, 'var_dump', true));
}
retourner $revenir;
}
}
}
fonction XMLRPC_response($return_value, $server = NULL){
$data["methodResponse"]["params"]["param"]["value"] = $return_value;
$return = XML_serialize($données);
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_response', "<p>Reçu les données suivantes à renvoyer :</p>nn" . XMLRPC_show($return_value, 'print_r', true));
}
header("Connexion : fermer");
header("Content-Length: " . strlen($return));
header("Type de contenu : texte/xml");
en-tête("Date : " . date("r"));
si($serveur){
en-tête("Serveur : $serveur");
}
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_response', "<p>Envoyé la réponse suivante :</p>nn" . XMLRPC_show($return, 'print_r', true));
}
echo $retour;
}
fonction XMLRPC_error($faultCode, $faultString, $server = NULL){
$array["methodResponse"]["fault"]["value"]["struct"]["member"] = array();
$temp = $array["methodResponse"]["fault"]["value"]["struct"]["member"];
$temp[0]["nom"] = "code défaut";
$temp[0]["value"]["int"] = $faultCode;
$temp[1]["nom"] = "faultString";
$temp[1]["value"]["string"] = $faultString;
$return = XML_serialize($array);
header("Connexion : fermer");
header("Content-Length: " . strlen($return));
header("Type de contenu : texte/xml");
en-tête("Date : " . date("r"));
si($serveur){
en-tête("Serveur : $serveur");
}
if(défini('XMLRPC_DEBUG') et XMLRPC_DEBUG){
XMLRPC_debug('XMLRPC_error', "<p>Envoyé la réponse d'erreur suivante :</p>nn" . XMLRPC_show($return, 'print_r', true));
}
echo $retour;
}
fonction XMLRPC_convert_timestamp_to_iso8601($timestamp){
#prend un horodatage Unix et le convertit en iso8601 requis par XMLRPC
#un exemple de date/heure iso8601 est "20010822T03:14:33"
date de retour("YmdTH:i:s", $timestamp);
}
fonction XMLRPC_convert_iso8601_to_timestamp($iso8601){
return strtotime($iso8601);
}
fonction count_numeric_items($array){
return is_array($array) ? count(array_filter(array_keys($array), 'is_numeric')) : 0;
}
fonction XMLRPC_debug($nom_fonction, $debug_message){
$GLOBALS['XMLRPC_DEBUG_INFO'][] = array($function_name, $debug_message);
}
fonction XMLRPC_debug_print(){
si($GLOBALS['XMLRPC_DEBUG_INFO']){
echo "<table border="1" width="100%">n";
foreach($GLOBALS['XMLRPC_DEBUG_INFO'] comme $debug){
echo "<tr><th style="vertical-align: top">$debug[0]</th><td>$debug[1]</td></tr>n";
}
echo "</table>n";
unset($GLOBALS['XMLRPC_DEBUG_INFO']);
}autre{
echo "<p>Aucune information de débogage disponible pour l'instant.</p>";
}
}
fonction XMLRPC_show($data, $func = "print_r", $return_str = false){
ob_start();
$func($données);
$output = ob_get_contents();
ob_end_clean();
si($return_str){
return "<pre>" . htmlspecialchars($output) .
}autre{
echo "<pre>", htmlspecialchars($output), "</pre>n";
}
}
?>
Exemple de programme serveur, server.php
<?
inclure « xml-rpc.inc.php » ;
//Définit les méthodes pouvant être appelées à distance
$xmlrpc_methods=array();
$xmlrpc_methods['insertRecords']='insertRecords';
// Récupère le nom de la méthode et les paramètres transmis par l'utilisateur
$xmlrpc_request = XMLRPC_parse($HTTP_RAW_POST_DATA);
$methodName = XMLRPC_getMethodName($xmlrpc_request);
$params = XMLRPC_getParams($xmlrpc_request);
if (!isset($xmlrpc_methods[$methodName])){
XMLRPC_error('1',"La méthode que vous avez appelée n'existe pas");
}autre {
$xmlrpc_methods[$methodName]($params);
}
fonction insertRecords($params){
si (videvide($params)){
XMLRPC_error('2',"Erreur de paramètre");
}
XMLRPC_response(XMLRPC_prepare('http://www.emtit.com'));
}
?>
Exemple de client PHP appelant une méthode serveur
<?php
include_once 'xml-rpc.inc';
$params=array(2,3);
$result=XMLRPC_request("127.0.0.1","/services/server.php","insertRecords",$params);//Le fichier du serveur est placé dans le dossier services
print_r($résultat);
?>