CLIENT DE SERVEUR DE CALCUL GRACE AUX PROTOCOLES RPC XDR (EXECUTION DE PROCEDURE A DISTANCE)

/////////////////////////////////////////////////////////
////////////////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");
		}
	}
}