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

Commenter

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

S'inscrire maintenant

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.

Du même auteur (metalicien)