TD-TP - n° 1 : Programmation Distribuée en C avec RPC

1.  Installation et test de l'application rdict

1.1.  Installation de l'archive rdict

Récupérez l'archive td01.zip qui se trouve sur la page web du cours

http://www-sop.inria.fr/oasis/Denis.Caromel/ProgRpt/
					

L'application client-serveur rdict a été initialement conçue par Comer et Stevens pour servir d'exemple dans leur livre Internetworking with TCP/IP Vol 3: Client-Server programming and Applications , Prentice-Hall puis a été par la suite successivement modifiée par Michel Syska, Julien Vayssière (qui a également produit la première version de ce TD) et Denis Caromel.

1.2. Création des programmes client et serveur

L'archive contient tous les fichiers source en C, le fichier RPCL rdict.x ainsi qu'un fichier Makefile .

1. Commencez par regarder le Makefile afin de comprendre l'appel à rpcgen , et la création des exécutables du serveur et du client.
2. Il ne reste plus qu'à lancer make , ce qui a pour effet de
   • faire générer par rpcgen (avec le fichier RPCL rdict.x )
     • le stub côté client rdict_clnt.c ,
     • le skeleton côté serveur rdict_svc.c ,
     • un fichier annexe rdict_xdr.c dont on ne se souciera pas pour ce premier exercice.
   • compiler le programme client rdict et le programme serveur rdictd .

(171) dcaromel@lo .../RPCGEN> make
rpcgen -C -N rdict.x
gcc -ansi  -D_GNU_SOURCE -g     -c -o rdict_clnt.o rdict_clnt.c
gcc -ansi  -D_GNU_SOURCE -g     -c -o rdict_cif.o rdict_cif.c
gcc -ansi  -D_GNU_SOURCE -g     -c -o rdict.o rdict.c
gcc -ansi  -D_GNU_SOURCE -g     -c -o rdict_xdr.o rdict_xdr.c
gcc -ansi  -D_GNU_SOURCE -g  -lnsl -o rdict rdict_clnt.o rdict_cif.o rdict.o rdict_xdr.o
gcc -ansi  -D_GNU_SOURCE -g     -c -o rdict_svc.o rdict_svc.c
gcc -ansi  -D_GNU_SOURCE -g     -c -o rdict_server.o rdict_server.c
gcc -ansi  -D_GNU_SOURCE -g     -c -o rdict_srp.o rdict_srp.c
gcc -ansi  -D_GNU_SOURCE -g  -lnsl -o rdictd rdict_svc.o rdict_server.o rdict_srp.o rdict_xdr.o

1.3. Test

Pour les besoins du TD, nous ferons tourner le serveur sur la machine locale. Le client pourra être lancé depuis n'importe quelle machine, y compris la machine locale.

  > rdictd

  > rdict <nom de la machine sur laquelle tourne le serveur>

1. Vérifiez qu'un programme RPC a bien été enregistré à votre nom sur la machine.
2. Dans le cas de plusieurs serveurs rdictd lequel est choisi ?
3. Vous pouvez ensuite entrer les commandes suivantes dans rdict :
   • I pour vider le dictionnaire
   • i pour insérer un mot
   • s pour supprimer un mot
   • c pour chercher si un mot existe
   • q pour quitter
4. Utilisez à plusieurs le même serveur, et voyez l'effet de vos requêtes concurrentes.

2. Programmation

2.1. Comprendre ce qu'il se passe

Pour la suite du TD, il est important de bien comprendre la manière dont les différentes parties de l'application collaborent entre-elles. En particulier, il est important de faire la différence entre les fichiers générés par rpcgen et ceux fournis dans l'archive rdict.tar.

1. Du côté client, on pourra par exemple suivre la suite des appels de fonction entre l'entrée d'une commande par l'utilisateur (le code correspondant se trouve dans rdict.c et l'appel à la procédure distante correspondante, au niveau du stub client.
2. Du côté serveur, on pourra suivre ce qu'il se passe depuis la réception d'un appel de procédure au niveau du stub serveur jusqu'à l'exécution de la fonction demandée.

Généré: rdict.h rdict_clnt.c rdict_svc.c rdict_xdr.c
Source: rdict.x rdict.c rdict_cif.c rdict_server.c rdict_srp.c 
		
Client:
-------
rdict.c: 
----main (): 
----insertion (Mot)
------------rdict_cif.c:  (Convention )
---------------insertion()   (Convention )
---------------insertion_1(Mot, handle)  (Convention )
-------------------------rdict_clnt.c:  ( Genere )
-------------------------------insertion_1(Mot, handle) ( Genere )
----------------------------------clnt_call ( ---, --- )  ( Genere )
---------------------------------------  Run-Time
Serveur:
--------
rdict_svc.c :
------void insertion_1 (arg, reqstp)(Genere)
-----------------rdict_server.c: (Convention ) 
----------------------insertion_1_svc (arg, reqstp) (Convention ) 
--------------------------------rdict_srp.c:
---------------------------------------insertion (argp) (Implémentation)

Autre fonctions:
suppress_1_svc (argp->arg1, argp->arg2, reqstp) ( Genere ) 
			

2.2. Ajout de fonctions simples

• ajouter une fonction qui retourne le nombre de mots dans le dictionnaire,
• ajouter des traces du côté serveur,
• ajouter une fonction qui retourne le mot suivant un mot donné,
• ...

/*------------------------------------------------------------------------
 * nombre : retourne le nombre de mots dans le Dico
 *------------------------------------------------------------------------
 */
int
nombre ()
{
   return CompteurMots;
}

/*------------------------------------------------------------------------
 * suivant : retourne le mot suivant un mot donne dans le dictionnaire
 *------------------------------------------------------------------------
 */
char *
suivant  (Mot)
char    *Mot;
{
  int i;
  for (i=0 ; i<CompteurMots; i++)
    if (strcmp(Mot, Dictionnaire[i]) == 0) {
      if (i+1 < CompteurMots)
         return Dictionnaire[i+1];
      else
         return "Aucun, dernier mot";
    }
  return "Aucun, Mot non trouve";
}

int* nombre_1_svc(struct svc_req *rqstp)
{
        static int  resultat;
        resultat = nombre();
        return(&resultat);
}

char ** suivant_1_svc(char *argp, struct svc_req *rqstp)
{
        static char * resultat;
        resultat =  (char *) suivant(argp);
        /* Cast (char *) sinon: Warning: assignment makes pointer from integer without a cast */
        return(&resultat);
}

/*------------------------------------------------------------------------
 * nombre - procedure interface client qui appelle nombre_1
 *------------------------------------------------------------------------
 */
int nombre()
{
   return *nombre_1(handle);
}

/*------------------------------------------------------------------------
 * suivant  - procedure interface client qui appelle suivant_1
 *------------------------------------------------------------------------
 */
char * suivant(char* Mot)
{
   return *suivant_1(Mot, handle);
}

    case 'n':       /* "nombre" */
       printf("Nombre de mots actuels dans le Dico: %d \n", nombre ());
       break;
    case 'S':   /* Mot suivant un mot */
       printf("Le mot suivant %s est : %s.\n", Mot, suivant(Mot));
       break;

  int NOMBRE(void) = 5;       /*  5ieme  procedure  NEW            */
  string SUIVANT(string) = 6; /*  6eme procedure   NEW             */

2.3. Passage de types complexes dans l'application rdict

Le but de cet exercice est de montrer comment passer un type complexe en résultat d'une fonction RPC-C. Il est intéressant de voir que cela n'est pas simple alors que d'autres langages comme Java font cela de manière transparente.

Nous voulons écrire une fonction tous() qui retourne tous les mots du dictionnaire. Le résultat de cette fonction sera une liste chaînée de mots. Une liste chaînée n'étant pas un type simple connu de RPCGen. Il faut la décrire dans le fichier rdict.x. Comme la syntaxe n'est pas facile nous la donnons ici

/* Pour lister tous les mots, Exemple de structure de données complexes */
const MAXMOTLONG = 255; /* Taille maxi mot */
typedef string chaine_mot<MAXMOTLONG>; /* Un mot pour chaînage, indispensable */
typedef struct  list_mots* suivant_list; /* Suivant dans la liste */

struct list_mots {
    chaine_mot mot; /* Le mot */
    suivant_list mot_suivant;  /* Pointeur vers le suivant */
};

Ajoutez maintenant dans le fichier rdict.x la fonction TOUS qui retourne un résultat de type suivant_list.

Modifiez ensuite les autres fichiers (rdict.c, rdict_cif.c, rdict_server.c et rdict_srp.c) pour terminer l'implémentation.

/*------------------------------------------------------------------------
 * tous : retourne tous les mots du dictionnaire
 *------------------------------------------------------------------------
 */
suivant_list
tous ()
{
...
}

Tester que ca fonctionne.

/*------------------------------------------------------------------------
 * tous : retourne tous les mots du dictionnaire
 *------------------------------------------------------------------------
 */
suivant_list
tous () {
  int i;
  suivant_list tmp, result = NULL;
  
  for (i=CompteurMots-1 ; i>=0 ; i--) {
    tmp = (suivant_list) malloc (sizeof(list_mots));
    tmp->mot = Dictionnaire[i];
    tmp->mot_suivant = result;
    result = tmp;
  }

  return result;
}

suivant_list* tous_1_svc(struct svc_req *rqstp)
{
  static suivant_list  resultat;
  resultat = (suivant_list) tous();
  return(&resultat);
}

/*------------------------------------------------------------------------
 * tous - procedure interface client qui tous_1
 *------------------------------------------------------------------------
 */
suivant_list tous()
{
   return *tous_1(handle);
}

 case 't':   /* Tous les mots */
   printf("Les mots du dictionnaire sont: \n");
   lm = (suivant_list) tous();
   for ( ; lm != NULL; ) {
     printf ("%s \n", lm->mot);
     lm = lm->mot_suivant;
   }
 break;

  suivant_list TOUS () = 7;      /*  7eme procedure   NEW             */