Client de serveur de calcul grace aux protocoles rpc xdr (execution de procedure a distance)

Soyez le premier à donner votre avis sur cette source.

Snippet vu 11 627 fois - Téléchargée 21 fois

Contenu du snippet

Cette application client serveurillustre l'utilisation des protocoles RPC (remote procedural call) et XDR (external data representation) qui servent à executer une fonctions dans un serveur distant .. le client ne fait qu'envoyer la réf de la fonction et lé argument au serveur qui va lui retourner le résultat ... Nous avons choisi comme exemple des fonction basiques et simples de calcul. PROGRAMME PAR Younes BOUANAN et Yassine CHERKAOUI de l'ECOLE MOHAMMEDIA D'INGENIEURS EMI RABAT/MAROC

Source / Exemple :


/////////////////////////////////////////////////////////
////////////////SERVEUR RPC//////////////////////////////
//// Par Younes Bouanan et Yassine Cherkaoui ////////////
/////////////////////////////////////////////////////////
#include<stdio.h>
#include<rpc/rpc.h>
#include<netdb.h>
#include<errno.h>
#include<rpc/types.h>
#include<rpc/xdr.h>
#include <signal.h>
/* Definition des constantes */
#define PROG 0x20000001 /* numero du programme */
#define VERSION 1
/* numero de version */
#define SOMME 1
/* Fonction somme */
#define MOYENNE 2
/* Fonction moyenne */
#define MIN_MAX 3
/* Fonction min_max */
#define PUISSANCE 4
/* Fonction puissance*/
#define FACTORIEL 5
/* Fonction factoriel*/
/* Definition des structures */
typedef struct {
	int entier1;
	int entier2;
	} couple_entier;
/* Prototype des fonctions */
bool_t xdr_couple_entier(XDR *, couple_entier *);
couple_entier *fonction_min_max(couple_entier *);
int *fonction_moyenne(couple_entier *);
int *fonction_somme(couple_entier *);
void effacement_service(int);

/* Pour traiter la terminaison */
//cette fonction efface toute association entre PROG VERSION ET LES PORTS DE LA MACHINE  
void effacement_service(int sig) {
	fprintf(stderr,"Effacement du service %d version %d\n",PROG, VERSION);
	pmap_unset(PROG, VERSION);
	exit(0);
}
struct sigaction action;
/* Filtre XDR */
bool_t xdr_couple_entier(XDR *xdr, couple_entier *entiers) {
	return(xdr_int(xdr, &entiers->entier1) && xdr_int(xdr, &entiers->entier2));
}
/* Definition des fonctions de service */
//// fonction somme
static int somme;
int *fonction_somme(couple_entier *entiers) {
	somme = entiers->entier1 + entiers->entier2;
	return &somme;
}
//// fonction qui retourne la moyenne
static int moyenne;
int *fonction_moyenne(couple_entier *entiers) {
	moyenne = (entiers->entier1 + entiers->entier2) / 2;
	return &moyenne;
}
////fonction qui retourne une structure Min max
static couple_entier min_max; /* min puis max */
couple_entier *fonction_min_max(couple_entier *entiers) {
	if (entiers->entier1 < entiers->entier2) {
		min_max.entier1 = entiers->entier1;
		min_max.entier2 = entiers->entier2;
	}
	 else {
		min_max.entier1 = entiers->entier2;
		min_max.entier2 = entiers->entier1;
	}
	return &min_max;
}
////fontion puissance
static int puissance;
int *fonction_puissance(couple_entier *entiers){
	int i;
	puissance =1;
	for(i=0;i<entiers->entier2;i++){
		puissance=puissance*entiers->entier1;
	}
	return &puissance;
}
////Fonction qui retourne le factoriel
static int factoriel;
int *fonction_factoriel(couple_entier *entiers){
	int i;
	factoriel=entiers->entier1;
	for(i=1;i<entiers->entier1;i++){
		factoriel=factoriel*(entiers->entier1-i);
		}
	return &factoriel;
}

/* Programme principal */
int main(int argc, char **argv) {
/////La structure sigaction décrit le comportement utilisé pour le traitement d'un signal:
	action.sa_handler= effacement_service;//efface toute association entre PROG VERSION ET LES PORTS DE LA MACHINE 
	sigaction(SIGQUIT, &action, NULL);
	sigaction(SIGINT, &action, NULL);
/////
	fprintf(stderr, "Mise en place du service RPC %d version %d\n", PROG, VERSION);
	fprintf(stderr, "Enregistrment des fonctions de services\n");
	/* Enregistrement des fonctions de service */
	if (registerrpc(PROG, VERSION, SOMME, fonction_somme, xdr_couple_entier,xdr_int) == -1) {
		perror("Enregistement de la fonction 1 (somme)\n");
		}
	if (registerrpc(PROG, VERSION, MOYENNE, fonction_moyenne, xdr_couple_entier,xdr_int) == -1) {
		perror("Enregistement de la fonction 2 (moyenne)\n");
		}
	if (registerrpc(PROG, VERSION, MIN_MAX, fonction_min_max, xdr_couple_entier,xdr_couple_entier) == -1) {
		perror("Enregistement de la fonction 3 (min_max)\n");
		}
	if (registerrpc(PROG, VERSION, PUISSANCE, fonction_puissance,xdr_couple_entier,xdr_int) == -1) {
		perror("Enregistrement de la fonction 4 (puissance)\n");
		}
	if (registerrpc(PROG, VERSION, FACTORIEL, fonction_factoriel,xdr_couple_entier,xdr_int) == -1) {
		perror("Enregistrement de la fonction 5 (factoriel)\n");
		}
	/* Boucle dâ??attente */
	fprintf(stderr, "Lancement de la boucle dâ??attente\n");
	svc_run();
	perror("Erreur dans la boucle dâ??attente\n");
	exit(2);
}
///////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////
////////Client programme par Younes Bouanan    //////////////
////////		     Yassine Cherkaoui	/////////////
/////////////////////////////////////////////////////////////

#include<stdio.h>
#include<rpc/rpc.h>
#include<netdb.h>
#include<errno.h>
#include<rpc/types.h>
#include<rpc/xdr.h>
#include <signal.h>
/* Definition des constantes */
#define PROG 0x20000001 /* numero du programme */
#define VERSION 1
/* numero de version */
#define SOMME 1
/* Fonction somme */
#define MOYENNE 2
/* Fonction moyenne */
#define MIN_MAX 3
/* Fonction min_max */
/* Definition des structures */
typedef struct {
int entier1;
int entier2;
} couple_entier;
/* Prototype des fonctions */
bool_t xdr_couple_entier(XDR *, couple_entier *);
couple_entier *fonction_min_max(couple_entier *);

int *fonction_moyenne(couple_entier *);
int *fonction_somme(couple_entier *);
/* Filtre XDR */
bool_t xdr_couple_entier(XDR *xdr, couple_entier *entiers) {
	return(xdr_int(xdr, &entiers->entier1) && xdr_int(xdr, &entiers->entier2));
}
/* Programme principal */
int main(int argc, char **argv) {
	couple_entier entiers, resultats;
	int numf;
	int resultat;
	if (argc != 2) {//on faite rentrer le nom du serveur comme argument
		perror("Nombre dâ??argument incorrect\n");
		exit(1);
		}
	//MENU
	printf("\n\n_____________________________________________\n");
	printf("**********************************************\n");	
	printf("CLIENT POUR CALCUL GRACE AU PROTOCOLES RPC XDR\n");
	printf("**********************************************\n");
  while(1){
	printf("_____________________________________________\n");	
	printf("                 MENU\n");
	printf("---------------------------------------------\n");		
	printf("|1|SOMME");printf("\t|2|MOYENNE\n");	
	printf("|3|MIN MAX");printf("\t|4|PUISSANCE\n");
	printf("|5|FACTORIEL\t|0|QUITTER\n");
	printf("---------------------------------------------\n");
	do{
		printf("Entrer le numero de l'operation que vous voullez executer : ");
		scanf("%d", &numf);
		if (numf!=0 && numf!=1 && numf!=2 && numf!=3 && numf!=4 && numf!=5){
			printf("\nAucune operation correspondante\n\n");
			}
	}
	while(numf!=0 && numf!=1 && numf!=2 && numf!=3 && numf!=4 && numf!=5);
	//FIN DU MENU
	if (numf==0){
		exit(2);
		}
	/* Initialisation des entiers */
	if(numf==4){
			printf("\nEntier1^Entier2\n");
			}
	printf("Entier 1 : ");
	scanf("%d", &(entiers.entier1));
	if(numf!=5){
		printf("Entier 2 : ");
		scanf("%d", &(entiers.entier2));
		}
	if (numf != MIN_MAX) {//car min max retourne deux entiers
		if (callrpc(argv[1], PROG, VERSION, numf, xdr_couple_entier, &entiers, xdr_int, &resultat) != 0) {
			perror("Appel fonction RPC\n");
			}
		printf("==================================================\n");
		printf("Resultat de lâ??appel de la fonction %d : %d\n", numf, resultat);
		printf("==================================================\n");
	}
	 else {
		if (callrpc(argv[1], PROG, VERSION, numf, xdr_couple_entier, &entiers, xdr_couple_entier, &resultats) != 0) {
			perror("Appel fonction RPC\n");
			}
		printf("==================================================\n");
		printf("Resultat de lâ??appel de la fonction %d :\n", numf);
		printf("==================================================\n");
		printf("\t min = %d\n", resultats.entier1);
		printf("\t max = %d\n", resultats.entier2);
		printf("==================================================\n");
		}
	}
}

A voir également

Ajouter un commentaire

Commentaires

karaochi
Messages postés
18
Date d'inscription
mercredi 16 avril 2008
Statut
Membre
Dernière intervention
26 octobre 2009
-
bjr,
merçi pour ta source.dis moi pour la compilation on a besoin encore du fichier.x ou on peut l'executé directement en l'enrregistrant en un fichier.c ?
merçi de me répondre.
assoump44
Messages postés
2
Date d'inscription
jeudi 5 mars 2009
Statut
Membre
Dernière intervention
22 mars 2010
-
svp
vous pouvez m'expliquer comment compilé et executé ce code???????
assoump44
Messages postés
2
Date d'inscription
jeudi 5 mars 2009
Statut
Membre
Dernière intervention
22 mars 2010
-
j'ai compilé le code mais j'ai trouvé un problème au niveau du client dans le Programme Principal "callrpc" les 4 derniers parametres
erreur: [warning: passing argument 5 of 'callrpc' from incompatible pointer type]
meme erreur pour les paramètres 6,7,8
merci

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.