INITIATION AUX TUBES UNIX (PIPE())

/* ---------------------------------------------------------------------------
 *les tubes Unix.
 * 1 : on crée un tube puis un processus fils. Le père envoie un message
 *     au fils dans le tube et le fils répond.
 * Auteur(s) : adesport
 * Groupe TP :
 * Entrées   : aucune
 * Sorties   : traces à l'écran
 * --------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>		/* Pour pid_t (fork, getpid, getppid) */


int main(void)
{
  pid_t ident;
  int tube[2];			/* les deux descripteurs associés au tube */
  char message[20];		/* Une chaîne pour stocker les messages lus
				 * dans le tube */

  
  if (pipe(tube) != 0)		/* Création du tube */
   {
     perror("pipe");
     return EXIT_FAILURE;
   }

  ident = fork();		/* Création du fils */
  switch (ident)
  {
    case -1 :
      perror("fork");
      return EXIT_FAILURE;

    case 0 : /* Fils */
      printf("Fils : je lis 31 caractères dans le tube\n");
      read(tube[0], message, 31);
      printf("Fils : j'ai lu '%s'\n",message);   
      printf("Fils : message1 du père lu, j'envoi message2\n");
      write(tube[1], "message du fils pour le père 2", 31);
      break;
    
    default : /* Père */
      write(tube[1], "message du père pour le fils 1", 31);
    wait(NULL);  
    printf("Père : je lis 31 caractères dans le tube\n");
      read(tube[0], message, 31);
      printf("Père : j'ai lu '%s'\n", message);
   }

   return EXIT_SUCCESS;
}



Trace:

Fils : je lis 31 caractères dans le tube
Fils : j'ai lu 'message du père pour le fils 1'
Fils : message1 du père lu, j'envoi message2
Père : je lis 31 caractères dans le tube
Père : j'ai lu 'message du fils pour le père 2'


Problèmes : le père peut lire ce qu'il a envoyé avant que le fils ne le fasse
--> on force l'attente avec wait(NUll),

	

/* ---------------------------------------------------------------------------
 * les tubes Unix.
 * 1 : on crée un tube puis un processus fils. Le fils envoie un message
 *     au père dans le tube le père répond.
 * Auteur(s) : adesport
 * Groupe TP :
 * Entrées   : aucune
 * Sorties   : traces à l'écran
 * --------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>		/* Pour pid_t (fork, getpid, getppid) */

int main(void)
{
  pid_t ident;
  int tube[2];			/* les deux descripteurs associés au tube */
  char message[20];		/* Une chaîne pour stocker les messages lus
				 * dans le tube */

  if (pipe(tube) != 0)		/* Création du tube */
   {
     perror("pipe");
     return EXIT_FAILURE;
   }

  ident = fork();		/* Création du fils */
  switch (ident)
   {
   case -1:
     perror("fork");
     return EXIT_FAILURE;

   case 0:

     /* Fils */
     write(tube[1], "message du Fils pour le Père 1", 31);
     while (getppid() != 1)	/* attend que le père meurt */
	; /*vide*/
     printf("Fils : je lis 31 caractères dans le tube\n");
     read(tube[0], message, 31);
     printf("Fils : j'ai lu '%s'\n", message);
     break;

   default:

     /* Père */
     printf("Père : je lis 31 caractères dans le tube\n");
     read(tube[0], message, 31);
     printf("Père : j'ai lu '%s'\n", message);
     printf("Père: message1 du Fils lu, j'envoi message2\n");
     write(tube[1], "message du Père pour le Fils 2", 31);
     break;
   }

  return EXIT_SUCCESS;
}

TRACE :

Père : je lis 31 caractères dans le tube
Père : j'ai lu 'message du Fils pour le Père 1'
Père: message1 du Fils lu, j'envoi message2
Fils : je lis 31 caractères dans le tube
Fils : j'ai lu 'message du Père pour le Fils 2'

 La solution n'est pas la même que pour tout a l'heure car la mort du père précède la mort du fils (la primitive
wait() ne peut donc pas s'appliquer).
	    

	
/* ---------------------------------------------------------------------------
 * Entrées   : aucune
 * Sorties   : traces à l'écran
 * --------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>		/* Pour pid_t (fork, getpid, getppid) */

int main(void)
{
  pid_t ident;
  int tube[2];
  int tube2[2];			/* les deux descripteurs associés au tube */
  char message[20];		/* Une chaîne pour stocker les messages lus
				 * dans le tube */

  if (pipe(tube) != 0)		/* Création du tube 1*/
   {
     perror("pipe");
     return EXIT_FAILURE;
   }
   
   
  if (pipe(tube2) != 0)		/* Création du tube 2*/
   {
     perror("pipe");
     return EXIT_FAILURE;
   }

  ident = fork();		/* Création du fils */
  switch (ident)
   {
   case -1:
     perror("fork");
     return EXIT_FAILURE;

   case 0:

     /* Fils */
	   /*on ferme l'entrée du tube 2 le fils ne peut plus lire sur le tube 2*/
           close(tube2[0]);
	   /*on ferme la sortie du tube 1 le fils ne peut plus écrire sur le tube 1*/
	   close(tube[1]);
     printf("Fils :j'écris \"Salut papa\"\n");   	
     write(tube2[1], "Salut papa", 31);
     printf("J'attend une réponse papoupnet\n");
     read(tube[0], message, 31);
     printf("Fils : je lis 31 caractères dans le tube\n");
     printf("Fils : j'ai lu '%s'\n", message);
     break;

   default:

     /* Père */
	 /*on ferme l'entrée du tube 1 le fils ne peut plus lire sur le tube 1*/
           close(tube[0]); 
   	 /*on ferme la sortie du tube 2 le fils ne peut plus écrire sur le tube 2*/
	   close(tube2[1]);
	     
     printf("Père : je lis 31 caractères dans le tube\n");
     read(tube2[0], message, 31);
     printf("Père : j'ai lu '%s'\n", message);
     printf("Père: message1 du Fils lu, j'envoi message2\n");
     write(tube[1], "Salut filston", 31);
     break;
   }

  return EXIT_SUCCESS;
}

TRACE :

Père : je lis 31 caractères dans le tube
Père : j'ai lu 'Salut papa'
Père: message1 du Fils lu, j'envoi message2
Fils :j'écris "Salut papa"
J'attend une réponse papoupnet
Fils : je lis 31 caractères dans le tube
Fils : j'ai lu 'Salut filston'


3 Communication du père avec 2 fils

/* ---------------------------------------------------------------------------
 * communication circulaire :  
		   _______________________ 	
		  |				  |
              v                       ^
		 pere				fils 1
               |                      ^
	         |                      |
     		   |-------> fils 2--------

 * Entrées   : aucune
 * Sorties   : traces à l'écran
 * --------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>		/* Pour pid_t (fork, getpid, getppid) */

int main(void)
{
  pid_t ident, ident2;
  int tube[2];
  int tube2[2];
  int tube3[2];			/* les deux descripteurs associés au tube */
  char message[20];		/* Une chaîne pour stocker les messages lus
				 * dans le tube */

  if (pipe(tube) != 0)		/* Création du tube 1 */
   {
     perror("pipe");
     return EXIT_FAILURE;
   }

  if (pipe(tube2) != 0)		/* Création du tube 2 */
   {
     perror("pipe");
     return EXIT_FAILURE;
   }

  if (pipe(tube3) != 0)		/* Création du tube 3 */
   {
     perror("pipe");
     return EXIT_FAILURE;
   }

  ident = fork();		/* Création du fils1 */

  switch (ident)
   {
   case -1:
     perror("fork");
     return EXIT_FAILURE;

   case 0:
     /* Fils 1 lit sur tube2[0] et écrit sur tube3[1]*/
     close(tube3[0]);
     close(tube2[1]);
     close(tube[0]);
     close(tube[1]);
     write(tube3[1], "salut papa\0", 60);
     read(tube2[0], message, 60);
     printf("FILS1:lit: %s de FILS2\n", message);
     break;

   default:

     /* Père */
     ident2 = fork();		/* Création du fils2 */
     switch (ident2)

      {
      case -1:
	perror("fork");
	return EXIT_FAILURE;

      case 0:
	/* Fils2 */
	close(tube2[0]);
	close(tube[1]);
	close(tube3[0]);
	close(tube3[1]);
	read(tube[0], message,6);
	printf("FILS2:lit: %s de PERE\n", message);
	write(tube2[1], "salut frere papa te dit bonjour",32);

	break;
      default:
	close(tube[0]);
	close(tube3[1]);
	close(tube2[0]);
	close(tube2[1]);
	read(tube3[0], message, 32);
	printf("PERE:lit: %s de FILS1\n", message);
	write(tube[1], "salut",6);
	break;
      }
     break;
   }

  return EXIT_SUCCESS;
}


TRACE :

PERE:lit: salut papa de FILS1
FILS1:lit: salut frere papa te dit bonjour de FILS2
FILS2:lit: salut de PERE

4 E/S

/* ---------------------------------------------------------------------------
 * les tubes Unix.
 *  simulation des pipe UNIX du shell
 * 
 * 
 * Entrées   : aucune
 * Sorties   : traces à l'écran
 * --------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>		/* Pour pid_t (fork, getpid, getppid) */

int main(void)
{
  pid_t pid;
  int tube[2];
 		/* les deux descripteurs associés au tube */
  				
 pipe(tube);
 
 if((pid = fork()) == 0)
 	{/* FILS */
	/*on ferme stdout*/
	fclose(stdout);
	/*on le remplace par tube [1]*/
	dup(tube[1]);
	/*on ferme tube[0] pour ne pas lire dans le tube mais dans stdin*/
	close(tube[0]);
	execlp("who","who",NULL);}
 else
 	{/* PERE */
	/*on ferme stdin*/
	fclose(stdin);
	/*on le remplace par le tube[0]*/
	dup(tube[0]);
	/*on ferme le tube [1] pour ne pas écrire dans le tube mais sur stdout*/
	close(tube[1]);
	execlp("cut","cut","-c","1-10",NULL);}

  return EXIT_SUCCESS;
}

TRACE : $who | cut -c 1-10

tbonin   :
tbonin   p
tbonin   p

tube5 :

tbonin   :
tbonin   p
tbonin   p

4 bis

TRACE :

	$ adesport 
/* ---------------------------------------------------------------------------
 * 
 * Entrées   : aucune
 * Sorties   : traces à l'écran
 * --------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>		/* Pour pid_t (fork, getpid, getppid) */

int main(void)
{
  pid_t pid,pidSort,pidTest;
  int tube[2],tubeSort[2];
 		
  				
 pipe(tube);
 
 
 if((pid = fork()) == 0)
 	{/* FILS */
	/*on ferme stdout*/
	fclose(stdout);
	/*on le remplace par tube [1]*/
	dup(tube[1]);
	/*on ferme tube[0] pour ne pas lire dans le tube mais dans stdin*/
	close(tube[0]);
	execlp("who","who",NULL);}
 else
 	{/* PERE */
	
		pipe(tubeSort);
	
		if((pidSort = fork()) == 0)
 		{/* FILS 2*/
		
			/*on ferme stdin*/
			fclose(stdin);
			/*on le remplace par le tubeSort[0]*/
			dup(tubeSort[0]);
			
			close(tube[0]);
			close(tube[1]);
				
			close(tubeSort[1]);
			execlp("sort","sort","-u",NULL);
		}
		
	/*on ferme stdin*/
	fclose(stdin);
	/*on le remplace par le tube[0]*/
	dup(tube[0]);
	/*on ferme stdout*/
	fclose(stdout);
	dup(tubeSort[1]);
	
	/*on ferme le tube [1] pour ne pas écrire dans le tube mais sur tubeSort[1]*/
	close(tube[1]);
	/*on ferme le tubeSort [0] pour ne pas lire dans le tube mais sur tube[0]*/
	close(tubeSort[0]);	
	execlp("cut","cut","-c","1-9",NULL);}

  return EXIT_SUCCESS;
}