Programmation de FIFO

**KenT2004** · 17/08/2008, 12h01

Bonjour,

je dois créer un programme en C sous linux pour ma seconde session d'un de mes cours.
Je ne suis pas très alaise en programmation, de plus je n'ai pas été souvent a mes cours (problèmes personnel, et non pas du manque volontaire des cours).

Je ne demande pas qu'on fasse l'exercice a ma place, juste de l'aide pour la compréhension, des tutos ou autres, qu'on me mette sur la voix :-)

Voici l'énoncé :

Réaliser un programme d'envoi/réception de messages codés (en ROT13, c-a-d décaler les lettres de 13 positions, de sorte que A->N, B-O, ...).

L'envoi et la réception se fera dans une paire FIFOs comme sur la figure suivante :

La figure montre deux instances du programme en cours d'exécution ; une a gauche et une a droite. Les deux FIFOs au centre permettent aux deux instances de communiquer.

Le programme doit être constituer d'un seul fichier source (.c), mais composé de deux processus (fork).
Le processus "envoi" est une boucle infinie qui lit les messages entrés par l'utilisateur, les encodent et les écris dans le FIFO d'envoi.
Le processus "reception" récupère les messages dans le FIFO, les décodent, et les affichent a l'écran.

Le noms des FIFOs ne peuvent pas être codés en dur dans le programme, vu que, comme l'illuste la figure, pour que les deux instances du programme communiquent le role de chaque FIFO est inversé pour chaque instance. Il faut passer le nom des FIFOs comme argument du programme.

Voila, je vous avoue que pour moi c'est pas très clair dans la manière de codé, je ne sais vraiment pas par ou commencer... j'ai donc besoin d'aide.

Pour rappel, c'est de l'aide que je demande et je ne veux bien entendu pas profiter et que la réponse me tombe tel quel (sauf si une âme charitable ^^ loool)

Merci a tous

PS: j'ai déja posté sur un autre forum ou on ma bien aidé pour le rot13 (partie facile) et on m'a conseillé de venir ici pour la suite que je n'arrive pas du tout a faire

**nicolas.sitbon** · 17/08/2008, 14h32

J'ai juste une petite incompréhension par rapport à ton énoncé, peut tu clarifier ce qu'est le "nom d'une FIFO"? est ce que par la, tu entends un "tube nommé" (voir mkfifo()) ou bien s'agit il d'une spécification dont tu n'aurais pas parlé?
Cordialement.

**Sve@r** · 17/08/2008, 15h09

Envoyé par KenT2004

Bonjour,

je dois créer un programme en C sous linux pour ma seconde session d'un de mes cours.
Je ne suis pas très alaise en programmation, de plus je n'ai pas été souvent a mes cours (problèmes personnel, et non pas du manque volontaire des cours).

Je ne demande pas qu'on fasse l'exercice a ma place, juste de l'aide pour la compréhension, des tutos ou autres, qu'on me mette sur la voix :-)

Voici un exemple de communication simple à travers un pipe mémoire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
#include <sys/mode.h>				// Modes et droits fichiers
#include <sys/wait.h>				// Attente fin de process
#include <stdio.h>				// I/O fichiers classiques
#include <signal.h>				// Signaux de communication
#include <errno.h>				// Erreurs système               
 
static void trt_sig(int);			// Détournement de signal         
 
extern const char* const sys_errlist[];	// Liste messages erreurs
 
#define SZ_STRING		(100)	// Taille message                 
 
// Fonction principale 
int main()
{
	// Déclaration des variables 
	int pid;								// No process                     
	int fin_fils;							// No fils fini                   
	int status;								// Etat fin fils                  
	int tube[2];							// Tableau extrémités tube        
 
	char chaine[SZ_STRING];				// Chaine stockage message        
 
	// Création tube memoire 
	if (pipe(tube) != 0)
	{
		fprintf(stderr, "ligne %u - pipe() - %s\n", __LINE__, sys_errlist[errno]);
		exit(errno);
	}
 
	// Création du process fils 
	switch(pid=fork())
	{
		case (-1): // Erreur de fork 
			fprintf(stderr, "ligne %u - fork() - %s\n", __LINE__, sys_errlist[errno]); 
			exit(errno);
 
		case 0: // Fils 
			// Fermeture coté inutilisé 
			close(tube[1]);
 
			// Attente que le père ait commençé 
			sleep(1);
 
			// Boucle de lecture 
			while (strcmp(chaine, "EOT\n") != 0)
			{
				// Lecture du tube 
				read(tube[0], chaine, SZ_STRING);
				printf("\tFils(%u) - J'ai reçu '%s'\n", getpid(), chaine);
 
				// Signal au père qu'il peut continuer 
				kill(getppid(), SIGALRM);
			}
 
			// Fermeture coté utilisé 
			close(tube[0]);
 
			// Arret du fils 
			printf("\tFils(%d) - Je m'arrête\n", getpid());
			exit(0);
 
		default: // Père 
			// Inhibition signal SIGALRM 
			signal(SIGALRM, trt_sig);
 
			// Fermeture coté inutilisé 
			close(tube[0]);
 
			printf("Je suis le père %u de mon fils %u\n", getpid(), pid);
 
			// Boucle d'écriture 
			while (strcmp(chaine, "EOT\n") != 0)
			{
				// Saisie et envoi de la chaine 
				printf("Père(%u) - Entrez une chaine (EOT pour sortir):", getpid());
				fgets(chaine, SZ_STRING, stdin);
				write(tube[1], chaine, strlen(chaine) + 1);
 
				// Attente que le fils ait traité ma chaine 
				pause();
			}
 
			// Fermeture coté utilisé 
			close(tube[1]);
 
			// Attente mort de mon fils 
			wait(&status);
			printf("Mon fils %u vient de mourir - Mort(%u)\n", pid, WEXITSTATUS(status));
	}
 
	return 0;
}
 
// Fonction de détournement du signal reçu 
static void trt_sig(
	int sig)								// Signal reçu                    
{
	// Repositionnement du détournement du signal 
	signal(sig, trt_sig);
}

Une fois que t'auras bien pigé le fonctionnement, t'auras aucun problème pour faire ton TP.

**KenT2004** · 17/08/2008, 15h56

c'est bien des tube nommée les FIFOs.

Merci, je vais lire ca et tester :-)

**nicolas.sitbon** · 17/08/2008, 17h07

Envoyé par Sve@r

Ensuite voici un exemple de communication simple à travers un pipe mémoire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
#include <sys/mode.h>				// Modes et droits fichiers
#include <sys/wait.h>				// Attente fin de process
#include <stdio.h>				// I/O fichiers classiques
#include <signal.h>				// Signaux de communication
#include <errno.h>				// Erreurs système               
 
static void trt_sig(int);			// Détournement de signal         
 
extern const char* const sys_errlist[];	// Liste messages erreurs
 
#define SZ_STRING		(100)	// Taille message                 
 
// Fonction principale 
int main()
{
	// Déclaration des variables 
	int pid;								// No process                     
	int fin_fils;							// No fils fini                   
	int status;								// Etat fin fils                  
	int tube[2];							// Tableau extrémités tube        
 
	char chaine[SZ_STRING];				// Chaine stockage message        
 
	// Création tube memoire 
	if (pipe(tube) != 0)
	{
		fprintf(stderr, "ligne %u - pipe() - %s\n", __LINE__, sys_errlist[errno]);
		exit(errno);
	}
 
	// Création du process fils 
	switch(pid=fork())
	{
		case (-1): // Erreur de fork 
			fprintf(stderr, "ligne %u - fork() - %s\n", __LINE__, sys_errlist[errno]); 
			exit(errno);
 
		case 0: // Fils 
			// Fermeture coté inutilisé 
			close(tube[1]);
 
			// Attente que le père ait commençé 
			sleep(1);
 
			// Boucle de lecture 
			while (strcmp(chaine, "EOT\n") != 0)
			{
				// Lecture du tube 
				read(tube[0], chaine, SZ_STRING);
				printf("\tFils(%u) - J'ai reçu '%s'\n", getpid(), chaine);
 
				// Signal au père qu'il peut continuer 
				kill(getppid(), SIGALRM);
			}
 
			// Fermeture coté utilisé 
			close(tube[0]);
 
			// Arret du fils 
			printf("\tFils(%d) - Je m'arrête\n", getpid());
			exit(0);
 
		default: // Père 
			// Inhibition signal SIGALRM 
			signal(SIGALRM, trt_sig);
 
			// Fermeture coté inutilisé 
			close(tube[0]);
 
			printf("Je suis le père %u de mon fils %u\n", getpid(), pid);
 
			// Boucle d'écriture 
			while (strcmp(chaine, "EOT\n") != 0)
			{
				// Saisie et envoi de la chaine 
				printf("Père(%u) - Entrez une chaine (EOT pour sortir):", getpid());
				fgets(chaine, SZ_STRING, stdin);
				write(tube[1], chaine, strlen(chaine) + 1);
 
				// Attente que le fils ait traité ma chaine 
				pause();
			}
 
			// Fermeture coté utilisé 
			close(tube[1]);
 
			// Attente mort de mon fils 
			wait(&status);
			printf("Mon fils %u vient de mourir - Mort(%u)\n", pid, WEXITSTATUS(status));
	}
 
	return 0;
}
 
// Fonction de détournement du signal reçu 
static void trt_sig(
	int sig)								// Signal reçu                    
{
	// Repositionnement du détournement du signal 
	signal(sig, trt_sig);
}

ça ne te ressemble pas ce genre de code Frédéric!!!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#include <sys/wait.h>    // Attente fin de process
#include <stdio.h>    // I/O fichiers classiques
#include <signal.h>    // Signaux de communication
#include <errno.h>    // Erreurs système
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
 
#define SZ_STRING 100 // Taille message
 
// Fonction de détournement du signal reçu
static void trt_sig (int sig)// Signal reçu
{
   // Repositionnement du détournement du signal
   signal(sig, trt_sig);
}
 
// Fonction principale
int main (void)
{
   int ret = 0;
   int tube[2];       // Tableau extrémités tube
 
   // Création tube memoire
   if (pipe (tube) != 0)
   {
      fprintf (stderr, "ligne %u - pipe() - %s\n", __LINE__, strerror (errno));
      ret = EXIT_FAILURE;
   }
   else
   {
      char chaine[SZ_STRING];    // Chaine stockage message
      pid_t pid = fork();
      // Création du process fils
      switch (pid)
      {
         case -1: // Erreur de fork
            fprintf (stderr, "ligne %u - fork() - %s\n", __LINE__,
                     strerror(errno));
            ret = EXIT_FAILURE;
 
         case 0: // Fils
            // Fermeture coté inutilisé
            close (tube[1]);
 
            // Attente que le père ait commençé
            sleep (1);
 
            // Boucle de lecture
            while (strcmp (chaine, "EOT\n") != 0)
            {
               // Lecture du tube
               read (tube[0], chaine, sizeof chaine);
               printf ("\tFils(%ld) - J'ai reçu '%s'\n", (long)getpid (), 
                       chaine);
 
               // Signal au père qu'il peut continuer
               kill (getppid (), SIGALRM);
            }
 
            // Fermeture coté utilisé
            close (tube[0]);
 
            // Arret du fils
            printf ("\tFils(%ld) - Je m'arrête\n", (long)getpid ());
            break;
 
         default: // Père
         {
            int status;        // Etat fin fils
            // Inhibition signal SIGALRM
            signal (SIGALRM, trt_sig);
 
            // Fermeture coté inutilisé
            close (tube[0]);
 
            printf ("Je suis le père %ld de mon fils %ld\n", (long)getpid (),
                    (long)pid);
 
            // Boucle d'écriture
            while (strcmp (chaine, "EOT\n") != 0)
            {
               // Saisie et envoi de la chaine
               printf ("Père(%ld) - Entrez une chaine (EOT pour sortir):",
                       (long)getpid ());
               fgets (chaine, SZ_STRING, stdin);
               write (tube[1], chaine, strlen (chaine) + 1);
 
               // Attente que le fils ait traité ma chaine
               pause ();
            }
 
            // Fermeture coté utilisé
            close (tube[1]);
 
            // Attente mort de mon fils
            wait (&status);
            printf ("Mon fils %ld vient de mourir - Mort(%u)\n", (long)pid,
                    WEXITSTATUS (status));
         }
      }
   }
 
   return ret;
}

**Sve@r** · 17/08/2008, 18h23

Envoyé par nicolas.sitbon

ça ne te ressemble pas ce genre de code Frédéric!!!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#include <sys/wait.h>    // Attente fin de process
#include <stdio.h>    // I/O fichiers classiques
#include <signal.h>    // Signaux de communication
#include <errno.h>    // Erreurs système
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
 
#define SZ_STRING 100 // Taille message
 
// Fonction de détournement du signal reçu
static void trt_sig (int sig)// Signal reçu
{
   // Repositionnement du détournement du signal
   signal(sig, trt_sig);
}
 
// Fonction principale
int main (void)
{
   int ret = 0;
   int tube[2];       // Tableau extrémités tube
 
   // Création tube memoire
   if (pipe (tube) != 0)
   {
      fprintf (stderr, "ligne %u - pipe() - %s\n", __LINE__, strerror (errno));
      ret = EXIT_FAILURE;
   }
   else
   {
      char chaine[SZ_STRING];    // Chaine stockage message
      pid_t pid = fork();
      // Création du process fils
      switch (pid)
      {
         case -1: // Erreur de fork
            fprintf (stderr, "ligne %u - fork() - %s\n", __LINE__,
                     strerror(errno));
            ret = EXIT_FAILURE;
 
         case 0: // Fils
            // Fermeture coté inutilisé
            close (tube[1]);
 
            // Attente que le père ait commençé
            sleep (1);
 
            // Boucle de lecture
            while (strcmp (chaine, "EOT\n") != 0)
            {
               // Lecture du tube
               read (tube[0], chaine, sizeof chaine);
               printf ("\tFils(%ld) - J'ai reçu '%s'\n", (long)getpid (), 
                       chaine);
 
               // Signal au père qu'il peut continuer
               kill (getppid (), SIGALRM);
            }
 
            // Fermeture coté utilisé
            close (tube[0]);
 
            // Arret du fils
            printf ("\tFils(%ld) - Je m'arrête\n", (long)getpid ());
            break;
 
         default: // Père
         {
            int status;        // Etat fin fils
            // Inhibition signal SIGALRM
            signal (SIGALRM, trt_sig);
 
            // Fermeture coté inutilisé
            close (tube[0]);
 
            printf ("Je suis le père %ld de mon fils %ld\n", (long)getpid (),
                    (long)pid);
 
            // Boucle d'écriture
            while (strcmp (chaine, "EOT\n") != 0)
            {
               // Saisie et envoi de la chaine
               printf ("Père(%ld) - Entrez une chaine (EOT pour sortir):",
                       (long)getpid ());
               fgets (chaine, SZ_STRING, stdin);
               write (tube[1], chaine, strlen (chaine) + 1);
 
               // Attente que le fils ait traité ma chaine
               pause ();
            }
 
            // Fermeture coté utilisé
            close (tube[1]);
 
            // Attente mort de mon fils
            wait (&status);
            printf ("Mon fils %ld vient de mourir - Mort(%u)\n", (long)pid,
                    WEXITSTATUS (status));
         }
      }
   }
 
   return ret;
}

Sisi c'est bien le mien mais il s'agit d'un code vieux de 1999 qui tournait sur un vrai Unix (et non un Linux) que j'ai retrouvé. A l'époque j'utilisais sys_errlist[] car strerror() soit n'existait pas, soit je ne le connaissais pas. J'ai pas eu envie de le corriger (mais j'ai quand-même remplacé les /* ... */ d'origine par des // ...)
Sinon je vois pas trop de différence. Bon tu préfères éviter les exit() multiples (mais ça c'est plus une habitude d'Emmanuel et non de la mienne) et tu améliores un peu les typages (pid_t au lieu des int) mais là aussi c'est de l'évolution plus ou moins récente

**KenT2004** · 18/08/2008, 09h48

Bonjour,

moi ce que j'ai besoin ce sont des tubes de communication, car les processus doivent communiquer entre deux (je dois ouvrir deux terminaux et envoyer de l'un a l'autre les données).

Les codes que vous me montrez ne permettent pas de faire de la communication (je me trompe ?).

Si vous avez qui traine dans un vieux Unix, des example de tubes de communication (tubes nommés il me semble que j'ai besoin ?) je suis preneur.

merci

**Sve@r** · 18/08/2008, 10h11

Envoyé par KenT2004

Bonjour,

moi ce que j'ai besoin ce sont des tubes de communication, car les processus doivent communiquer entre deux (je dois ouvrir deux terminaux et envoyer de l'un a l'autre les données).

Déjà t'as même pas lu ma doc (pourtant il n'y a que 24 pages et la partie tubes ne fait que 3 pages)

Envoyé par KenT2004

Les codes que vous me montrez ne permettent pas de faire de la communication (je me trompe ?).

Ben si. Il y a 2 processus et le père attend des données tapées au clavier qu'il envoie au fils (via un tube de communication). Le fils lit les données (du tube de communication) et les affiche à l'écran. Si ça c'est pas de la communication...

Envoyé par KenT2004

Si vous avez qui traine dans un vieux Unix, des example de tubes de communication (tubes nommés il me semble que j'ai besoin ?)

Ah ? Tu sembles quand-même avoir pris la peine de chercher un peu par toi-même. Effectivement si les processus ne sont pas liés père/fils tu ne peux passer que par un tube nommé.

Tu veux un exemple ? Commences par ouvrir 2 terminaux et tapes dans chacun d'eux les commandes suivantes
* t1:
mknod /tmp/toto p
date >/tmp/toto => là le curseur se bloque. Tu passes alors au t2

* t2:
cat /tmp/toto => là tu récupères la date issue du premier terminal et le curseur du premier terminal est débloqué

Ensuite t'as plus qu'à refaire l'expérience avec deux programmes C (deux codes sources) qui donneront en final 2 processus

p1:
- créer le tube (mkfifo)
- ouvrir le tube (open ou fopen)
- écrire dans le tube (write ou fputs)
- fermer le tube (close ou fclose)

p2
- ouvrir le tube (open ou fopen)
- lire le tube (read ou fgets)
- fermer le tube (close ou fclose)

Un peu de gestion intelligente des données (boucle d'écriture/lecture qui stoppe par exemple sur une certaine séquence style "EOT" comme "End Of Text") et c'est fini. Le code source donné hier peut même être repris et à peine modifié pour correspondre à ce schéma. Tu lances le premier programme dans un premier terminal, le second programme dans un second terminal et tu as ta comm.

Programmation de FIFO

Linux

Vue hybride

Discussions similaires

Partager

Partager