Support de cours Réseaux EISTI

Annexe 2 :corrigés des TP

automate 1

/* Fichiers a inclure .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/utsname.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* Constantes */
/* Message envoye au serveur */
#define TAILLEMAX 100 /* Pour chaine de caracteres */

/* Prototypages */
int main(int argc, char ** argv);

int main(int argc, char ** argv)
   {
   int Fd; /* Descripteur de fichier (socket) */
   int Fd4; /* Descripteur de fichier (socket) */
   int FdAccept; /* Descripteur de fichier (socket) */
   struct sockaddr_in Sockaddr; /* Descriptif d'un socket */
   struct sockaddr_in Sockaddr4; /* Descriptif d'un socket */
   struct hostent * Machine4; /* Machine ou reside le serveur4 */
   struct servent * Service4; /* Service (ou port) ou le serveur4 est attache */
   struct hostent * Machine; /* Machine ou reside le serveur */
   struct servent * Service; /* Service (ou port) ou le serveur est attache */
   struct utsname Uname;  /* Informations sur la machine (non, version,...) */
   char Message[TAILLEMAX +1];
   char Message4[TAILLEMAX +1];
   char Reponse[TAILLEMAX+1]; /* Reponse a Auto2 */
   char NomMachine[SYS_NMLN +1];
   int Piece;   /* Numero de la piece traitee */
   int Lenght;
   
   /* Verifier l'appel */
   if (argc != 4)
      {
      fprintf(stderr,"Syntaxe : %s Port Machine4 Port4...\n",argv[0]);
      exit (-7);
      }
   
   
 /* Obtenir le nom de la machine sur le reseau */
   if ( uname(&Uname) == -1)
     {
     perror("Auto1 : : uname :");
     exit(-10);
     }
   strcpy(NomMachine,Uname.nodename);
   
   /* le serveur est sur la machine ou on lance le programme */
   Machine = gethostbyname(NomMachine);
   if (Machine == NULL)
      {
      perror("Auto1 :  : gethostbyname");
      exit(-1);
      }
   /* initialisation de la structure */
   memset(&Sockaddr,0,sizeof(struct sockaddr_in));
   /* on travaille sur TCP/IP */
   Sockaddr.sin_family = PF_INET;
   memcpy(&(Sockaddr.sin_addr),Machine->h_addr,Machine->h_length);
   
   /* on ecoute sur quel port ???? */
   Service = getservbyname(argv[1],"tcp");
   if (Service == NULL)
      {
      perror("Auto1 :  : getservbyname");
      exit(-2);
      }
   Sockaddr.sin_port = Service->s_port;



/* Initialisation vers Automat4 */
   Machine4 = gethostbyname(argv[4]);
   if (Machine4 == NULL)
      {
      perror("Auto1 :  : gethostbyname");
      exit(-1);
      }
   /* initialisation de la structure */
   memset(&Sockaddr4,0,sizeof(struct sockaddr_in));
   /* on travaille sur TCP/IP */
   Sockaddr4.sin_family = PF_INET;
   memcpy(&(Sockaddr4.sin_addr),Machine4->h_addr,Machine4->h_length);
   
   /* on ecoute sur quel port ???? */
   Service4 = getservbyname(argv[5],"tcp");
   if (Service4 == NULL)
      {
      perror("Auto1 :  : getservbyname");
      exit(-2);
      }
   Sockaddr4.sin_port = Service4->s_port;
    /* On peut avoir le socket */
   /* PF_INET => socket tcp/ip */
   /* SOCK_STREAM => tcp comme protocol */
   /* 0 => protocole par defaut sur tcp */
   Fd = socket(PF_INET,SOCK_STREAM,0);
   if (Fd == -1)
      {
      perror("Auto1 :  : socket");
      exit(-3);
      }
   
   /* reserver le port sur lequel on veut ecouter */
   if (bind(Fd,(struct sockaddr *) & Sockaddr,sizeof(struct sockaddr_in)) == -1)
      {
      perror("Auto1 :  : bind");
      exit (-4);
      }
   
   /* on attend au maximum une connection a la fois */
   if (listen(Fd,1) == -1)
      {
      perror("Auto1 :  : listen");
      exit (-5);
      }
   
   Piece = 0;
   while (1)
      {
      printf(" Auto1 : Mettre une Piece (puis RETURN) \n");
      getchar();
      Piece +=1; /* On traite une piece en plus ... */
      printf("Auto1 : Traiter Piece numero %d\n",Piece);
      sleep(5);
	/* Informer auto4 */
     /* On peut avoir le socket */
     /* PF_INET => socket tcp/ip */
     /* SOCK_STREAM => tcp comme protocol */
     /* 0 => protocole par defaut sur tcp */
     Fd4 = socket(PF_INET,SOCK_STREAM,0);
     if (Fd4 == -1)
        {
        perror("Auto1 :  : socket");
        exit(-3);
        }
      if (connect ( Fd4,(struct sockaddr *) &Sockaddr4,sizeof(struct sockaddr_in))== -1)
         {
         perror("Auto1 : connect");
         exit(-11);
         }
      sprintf(Message4,"Auto1 a fini la piece numero %d",Piece);
      write(Fd4,Message4,strlen(Message4)+1);
      close(Fd4);

       printf("Auto1 : Attendre Demande...\n");
      /* on accepte la connexion */
      Lenght = sizeof(struct sockaddr_in);
      if ((FdAccept = accept(Fd,(struct sockaddr *) &Sockaddr, &Lenght)) == -1)
         {
         perror("Auto1 :  : accept");
         exit (-6);
         }
      
      /* on tente la lecture du message */
      read(FdAccept,Message,TAILLEMAX);
      /* On devrait testert la validiter de la demande .... */
      sprintf(Reponse,"%d :Voici la piece ",Piece);
      write(FdAccept,Reponse,strlen(Reponse)+1);
      close(FdAccept);
      }
   close(Fd);
   exit(0);
   }

automate2

/* Fichiers a inclure .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/utsname.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* Constantes */
   /* Message envoye au serveur */
#define MESSAGE " Donner une piece ! "
#define TAILLEMAX 100 /* Pour chaine de caracteres */

/* Prototypages */
int main(int argc, char ** argv);

 int main(int argc, char ** argv)
   {
   int Fd4; /* Descripteur de fichier (socket) */
   int Fd21; /* Descripteur de fichier (socket) */
   int Fd23; /* Descripteur de fichier (socket) */
   int FdAccept23; /* Descripteur de fichier (socket) */
   struct sockaddr_in Sockaddr23; /* Descriptif d'un socket */
   struct sockaddr_in Sockaddr4; /* Descriptif d'un socket */
   struct sockaddr_in Sockaddr21; /* Descriptif d'un socket */
   struct hostent * Machine4; /* Machine ou reside auto4 */
   struct hostent * Machine23; /* Machine ou reside le client */
   struct hostent * Machine21; /* Machine ou reside le serveur */
   struct servent * Service21; /* Service (ou port) ou le serveur est attache */
   struct servent * Service4; /* Service (ou port) ou le serveur 4est attache */
   struct servent * Service23; /* Service (ou port) ou le serveur est attache */
   struct utsname Uname;  /* Informations sur la machine (non, version,...) */
   int res; /* pour tester les fonctions */
   char Message4[TAILLEMAX +1];

   char Message[TAILLEMAX +1];
   char Reponse[TAILLEMAX+1]; /* Reponse a Auto3 */
   char NomMachine[SYS_NMLN +1];
   int Piece;   /* Numero de la piece traitee */
   int Lenght;
   
   /* Verifier l'appel */
   if (argc != 6)
      {
      fprintf(stderr,"Syntaxe : %s PortServeur MachineClinet PortClient Machine4 port4\n",
                                       argv[0]);
      exit (-7);
      }
   
   /* Obtenir le nom de la machine sur le reseau */
   if ( uname(&Uname) == -1)
     {
     perror("Auto2 : : uname :");
     exit(-10);
     }
   strcpy(NomMachine,Uname.nodename);
   
   /* le serveur est sur la machine ou on lance le programme */
   Machine23 = gethostbyname(NomMachine);
   if (Machine23 == NULL)
      {
      perror("Auto2 :  : gethostbyname");
      exit(-1);
      }
   /* initialisation de la structure */
   memset(&Sockaddr23,0,sizeof(struct sockaddr_in));
   /* on travaille sur TCP/IP */
   Sockaddr23.sin_family = PF_INET;
   memcpy(&(Sockaddr23.sin_addr),Machine23->h_addr,Machine23->h_length);
   
   /* on ecoute sur quel port ???? */
   Service23 = getservbyname(argv[1],"tcp");
   if (Service23 == NULL)
      {
      perror("Auto2 :  : getservbyname");
      exit(-2);
      }
   Sockaddr23.sin_port = Service23->s_port;
   
   /* On peut avoir le socket */
   /* PF_INET => socket tcp/ip */
   /* SOCK_STREAM => tcp comme protocol */
   /* 0 => protocole par defaut sur tcp */
   Fd23 = socket(PF_INET,SOCK_STREAM,0);
   if (Fd23 == -1)
      {
      perror("Auto2 :  : socket");
      exit(-3);
      }
   
   /* reserver le port sur lequel on veut ecouter */
   if (bind(Fd23,(struct sockaddr *) & Sockaddr23,sizeof(struct sockaddr_in)) == -1)
      {
      perror("Auto2 :  : bind");
      exit (-4);
      }
   
   /* on attend au maximum une connection a la fois */
   if (listen(Fd23,1) == -1)
      {
      perror("Auto2 :  : listen");
      exit (-5);
      }

  /* Initialisation de la partie Client */
   

   /* addresse de la machine du serveur */
   Machine21 = gethostbyname(argv[2]);
   if (Machine21 == NULL)
      {
      perror("Auto2 : gethostbyname");
      exit(-1);
      }
   /* initialisation de la structure */
   memset(&Sockaddr21,0,sizeof(struct sockaddr_in));
   /* on travaille sur TCP/IP */
   Sockaddr21.sin_family = PF_INET;
   memcpy(&Sockaddr21.sin_addr,Machine21->h_addr,Machine21->h_length);
   
    /* on ecoute sur quel port ???? */
   Service21 = getservbyname(argv[3],"tcp");
   if (Service21 == NULL)
      {
      perror("Auto2 : getservbyname");
      exit(-2);
      }
   Sockaddr21.sin_port = Service21->s_port;
/* Initialisation vers Automat4 */
   Machine4 = gethostbyname(argv[4]);
   if (Machine4 == NULL)
      {
      perror("Auto1 :  : gethostbyname");
      exit(-1);
      }
   /* initialisation de la structure */
   memset(&Sockaddr4,0,sizeof(struct sockaddr_in));
   /* on travaille sur TCP/IP */
   Sockaddr4.sin_family = PF_INET;
   memcpy(&(Sockaddr4.sin_addr),Machine4->h_addr,Machine4->h_length);

   /* on ecoute sur quel port ???? */
   Service4 = getservbyname(argv[5],"tcp");
   if (Service4 == NULL)
      {
      perror("Auto1 :  : getservbyname");
      exit(-2);
      }
   Sockaddr4.sin_port = Service4->s_port;

   Piece = 0;
   while (1)
      {
      printf("Auto2 : demander piece ... \n");
      res = -1;
      while (res == -1)
           {
           /* On peut avoir le socket */
           /* PF_INET => socket tcp/ip */
           /* SOCK_STREAM => tcp comme protocol */
           /* 0 => protocole par defaut sur tcp */
           Fd21 = socket(PF_INET,SOCK_STREAM,0);
           if (Fd21 == -1)
              {
              perror("Auto2 : socket");
              exit(-3);
              }
             res=connect(Fd21,(struct sockaddr *) &Sockaddr21,sizeof(struct sockaddr_in));
             if ( res < 0)
              {
              perror("Auto2 : connect");
              close(Fd21);
              sleep(1);
              }
             }
      /* on Demande la piece ... */
      write(Fd21,MESSAGE,strlen(MESSAGE) +1 );
      read(Fd21,Reponse,TAILLEMAX +1 );
      sscanf(Reponse,"%d",&Piece);
      close(Fd21);
      printf("Auto2 : Traiter piece numero %d \n",Piece);
      sleep(5);
	/* Informer Auto4 */
     /* On peut avoir le socket */
     /* PF_INET => socket tcp/ip */
     /* SOCK_STREAM => tcp comme protocol */
     /* 0 => protocole par defaut sur tcp */
     Fd4 = socket(PF_INET,SOCK_STREAM,0);
     if (Fd4 == -1)
        {
        perror("Auto1 :  : socket");
        exit(-3);
        }
      if (connect ( Fd4,(struct sockaddr *) &Sockaddr4,sizeof(struct sockaddr_in))== -1)
         {
         perror("Auto2 : connect");
         exit(-11);
         }
      sprintf(Message4,"Auto2 a fini la piece numero %d",Piece);
      write(Fd4,Message4,strlen(Message4)+1);
      close(Fd4);

      printf("Auto2 : Attendre Demande...\n");
      /* on accepte la connexion */
      Lenght = sizeof(struct sockaddr_in);
      if ((FdAccept23= accept(Fd23,(struct sockaddr *) &Sockaddr23, &Lenght)) == -1)
         {
         perror("Auto2 :  : accept");
         exit (-6);
         }
      
      /* on tente la lecture du message */
      read(FdAccept23,Message,TAILLEMAX);
      /* On devrait testert la validiter de la demande .... */
      sprintf(Reponse,"%d :Voici la piece ",Piece);
      write(FdAccept23,Reponse,strlen(Reponse)+1);
      close(FdAccept23);
      }
   close(Fd23);
   exit(0);
   }

automate 3

/* Fichiers a inclure .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* Constantes */
/* Message envoye au serveur */
#define MESSAGE " Message du client .... "
#define TAILLEMAX 100

/* Prototypages */
int main(int argc, char ** argv);

int main(int argc, char ** argv)
   {
   int Fd; /* Descripteur de fichier (socket) */
   int Fd4; /* Descripteur de fichier (socket) */
   struct sockaddr_in Sockaddr; /* Descriptif d'un socket */
   struct sockaddr_in Sockaddr4; /* Descriptif d'un socket */
   struct hostent * Machine4; /* Machine ou reside le serveur4 */
   struct servent * Service4; /* Service (ou port) ou le serveur4 est attache */
   struct hostent * Machine; /* Machine ou reside le serveur */
   struct servent * Service; /* Service (ou port) ou le serveur est attache */
   int res;              /* pour tester le connect */
   char Reponse[TAILLEMAX +1];/* Reponse du serveur */
   char Message4[TAILLEMAX +1];/* Reponse du serveur */
   int Piece ; /* numero de la piece a traiter */
   
   /* verifier le lancement */
   if ( argc != 5)
      {
      fprintf(stderr," Auto3 : Syntaxe : %s : Machine Port Machine4 Port4...\n",argv[0]);
      exit(-10);
      }
   /* addresse de la machine du serveur */
   Machine = gethostbyname(argv[1]);
   if (Machine == NULL)
      {
      perror("Auto3 : gethostbyname");
      exit(-1);
      }
   /* initialisation de la structure */
   memset(&Sockaddr,0,sizeof(struct sockaddr_in));
   /* on travaille sur TCP/IP */
   Sockaddr.sin_family = PF_INET;
   memcpy(&Sockaddr.sin_addr,Machine->h_addr,Machine->h_length);
   
    /* on ecoute sur quel port ???? */
   Service = getservbyname(argv[2],"tcp");
   if (Service == NULL)
      {
      perror("Auto3 : getservbyname");
      exit(-2);
      }
   Sockaddr.sin_port = Service->s_port;
/* Initialisation vers Automat4 */
   Machine4 = gethostbyname(argv[3]);
   if (Machine4 == NULL)
      {
      perror("Auto3 :  : gethostbyname");
      exit(-1);
      }
   /* initialisation de la structure */
   memset(&Sockaddr4,0,sizeof(struct sockaddr_in));
   /* on travaille sur TCP/IP */
   Sockaddr4.sin_family = PF_INET;
   memcpy(&(Sockaddr4.sin_addr),Machine4->h_addr,Machine4->h_length);
  
   /* on ecoute sur quel port ???? */
   Service4 = getservbyname(argv[4],"tcp");
   if (Service4 == NULL)
      {
      perror("Auto3 :  : getservbyname");
      exit(-2);
      }
   Sockaddr4.sin_port = Service4->s_port;
   while (1)
      {
      printf("Auto3 : demander piece ... \n");
      res = -1;
      while (res == -1)
           {
           /* On peut avoir le socket */
           /* PF_INET => socket tcp/ip */
           /* SOCK_STREAM => tcp comme protocol */
           /* 0 => protocole par defaut sur tcp */
           Fd = socket(PF_INET,SOCK_STREAM,0);
           if (Fd == -1)
              {
              perror("Auto3 : socket");
              exit(-3);
              }
             res=connect(Fd,(struct sockaddr *) &Sockaddr,sizeof(struct sockaddr_in));
             if ( res < 0)
              {
              perror("Auto3 : connect");
              close(Fd);
              sleep(1);
              }
             }
       
      /* on Demande la piece ... */
      write(Fd,MESSAGE,strlen(MESSAGE) +1 );
      read(Fd,Reponse,TAILLEMAX +1 );
      sscanf(Reponse,"%d",&Piece);
      close(Fd);
      printf("Auto3 : Traiter piece numero %d \n",Piece);
      sleep(5);
      /* Informer auto4 */
     /* On peut avoir le socket */
     /* PF_INET => socket tcp/ip */
     /* SOCK_STREAM => tcp comme protocol */
     /* 0 => protocole par defaut sur tcp */
     Fd4 = socket(PF_INET,SOCK_STREAM,0);
     if (Fd4 == -1)
        {
        perror("Auto3 :  : socket");
        exit(-3);
        }
      if (connect ( Fd4,(struct sockaddr *) &Sockaddr4,sizeof(struct sockaddr_in))== -1)
         {
         perror("Auto3 : connect");
         exit(-11);
         }
      sprintf(Message4,"Auto3 a fini la piece numero %d",Piece);
      write(Fd4,Message4,strlen(Message4)+1);
      close(Fd4);

      printf("Auto3 : Enlvevez la piece puis RETURN \n");
      getchar();
      }
   exit(0);
   }

automate 4

/* Fichiers a inclure .... */
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/utsname.h>
#include <netdb.h>
#include <signal.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* Constantes */
	/* Message envoye au serveur */
#define TAILLEMAX 100 /* Pour chaine de caracteres */


/* Prototypages */
int main(int argc, char ** argv);
void Repondeur(int Fd);

int main(int argc, char ** argv)
{
pid_t Pid;
int Fd; /* Descripteur de fichier (socket) */
int FdAccept; /* Descripteur de fichier (socket) */
struct sockaddr_in Sockaddr; /* Descriptif d'un socket */
struct hostent * Machine; /* Machine ou reside le serveur */
struct servent * Service; /* Service (ou port) ou le serveur est attache */
struct utsname Uname;  /* Informations sur la machine (non, version,...) */
char Message[TAILLEMAX +1];
char NomMachine[SYS_NMLN +1];
int Lenght;
struct sigaction Action; /* Gestion des signaux */

/* Verifier l'appel */
if (argc != 2)
	{
	fprintf(stderr,"Syntaxe : %s Port...\n",argv[0]);
	exit (-7);
	}

/* Obtenir le nom de la machine sur le reseau */
if ( uname(&Uname) == -1)
  {
  perror("Serveur: uname :");
  exit(-10);
  }
strcpy(NomMachine,Uname.nodename);

 /* le serveur est sur la machine ou on lance le programme */
Machine = gethostbyname(NomMachine);
if (Machine == NULL)
	{
	perror("Serveur : gethostbyname");
	exit(-1);
	}
/* initialisation de la structure */
memset(&Sockaddr,0,sizeof(struct sockaddr_in));
/* on travaille sur TCP/IP */
Sockaddr.sin_family = PF_INET;
memcpy(&(Sockaddr.sin_addr),Machine->h_addr,Machine->h_length);

/* on ecoute sur quel port ???? */
Service = getservbyname(argv[1],"tcp");
if (Service == NULL)
	{
	perror("Serveur : getservbyname");
	exit(-2);
	}
Sockaddr.sin_port = Service->s_port;

/* On peut avoir le socket */
/* PF_INET => socket tcp/ip */
/* SOCK_STREAM => tcp comme protocol */
/* 0 => protocole par defaut sur tcp */
Fd = socket(PF_INET,SOCK_STREAM,0);
if (Fd == -1)
	{
	perror("Serveur : socket");
	exit(-3);
	}

/* reserver le port sur lequel on veut ecouter */
if (bind(Fd,(struct sockaddr *) & Sockaddr,sizeof(struct sockaddr_in)) == -1)
	{
	perror("Serveur : bind");
	exit (-4);
	}

/* on attend au maximum une connection a la fois */
if (listen(Fd,10) == -1)
	{
	perror("Serveur : listen");
	exit (-5);
	}

 while (1)
	{
	/* on accepte la connexion */
	Lenght = sizeof(struct sockaddr_in);
	if ((FdAccept = accept(Fd,(struct sockaddr *) &Sockaddr, &Lenght)) == -1)
		{
		perror("Serveur : accept");
		exit (-6);
		}
	/* On ignore la mort des repondeurs */
	Action.sa_handler = SIG_IGN;
	Action.sa_flags = SA_NOCLDWAIT;
	if (sigaction(SIGCHLD,&Action,NULL) == -1)
		{
		perror("Automat4 sigaction");
		exit(-30);
		}
	/* On lance le repondeur */
	Pid = fork();
	switch(Pid)
		{
		case -1 : /* Erreur */
			perror("Fork");
			exit(-1);	
			break;
		case 0:	/* Le fils qui va etre le repondeur */
			/* fermer le socket du bind */
			close(Fd);
			/* Apeller le repondeur */
			Repondeur(FdAccept);
			exit(0);
			break;
		default : /* le pere */
			/* rien a dire don fermer le fdaccept */
			close(FdAccept);
			break;
		}
	}
close(Fd);
exit(0);
}
/********************************************/
/* Le repondeur recoit le socket de dialoque*/
/********************************************/
void Repondeur(int Fd)
{
char Message[TAILLEMAX+1];

memset(Message,'\0',TAILLEMAX+1);
read(Fd,Message,TAILLEMAX);
printf("%s\n",Message);
close(Fd);
}

Support de cours Réseaux EISTI