TD4 Tubes (Devoire)

Exercice 5:
a) 1. le programme cree un processus fils1

2. Ce processus lit des caracteres et il convertit les lettres minuscules en majuscules

3. Puis il envoie les caracteres modifies a travers un tube au processus fils2

4. le fils2 lit ces caracteres du tube et les affiche

5. le processus principal attend que les deux processus fils se terminent avant d’afficher « fin du
père »

6. Le resumee, Ce programme realise une communication entre les deux processus fils a travers
un tube

b) Le processus parent ne fermera pas le sortie du tube , ce qui pourrait entrainer un blocage lors
de la lecture du tube dans le proccesus enfant .
c) #include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <wait.h>

void parent(int entree, int sortie) {

unsigned int u0 = 2, u1 = 3;
write(sortie, &u0, sizeof(u0));
write(sortie, &u1, sizeof(u1));

unsigned int un;

do {
read(entree, &un, sizeof(un));
printf("%u ", un);

unsigned int un1, un2;

read(entree, &un1, sizeof(un1));
read(entree, &un2, sizeof(un2));

unsigned int next_term = 2 * un2 + 3 * un1;

write(sortie, &un1, sizeof(un1));
write(sortie, &next_term, sizeof(next_term));
} while (un <= 200);

printf("\n");
close(sortie);
wait(NULL);
}

void enfant(int entree, int sortie) {

unsigned int u0, u1;
read(entree, &u0, sizeof(u0));
read(entree, &u1, sizeof(u1));
 write(sortie, &u0, sizeof(u0));
write(sortie, &u1, sizeof(u1));

unsigned int un;

do {
unsigned int un1, un2;
read(entree, &un1, sizeof(un1));
read(entree, &un2, sizeof(un2));

un = 2 * un2 + 3 * un1;
write(sortie, &un1, sizeof(un1));
write(sortie, &un, sizeof(un));
} while (un <= 200);

close(sortie);
}

int main(void) {
int tube_pe[2], tube_ep[2], pid;
printf("[%d]: début du père.\n", getpid());

pipe(tube_pe); /* tube Parent -> Enfant */

pipe(tube_ep); /* tube Enfant -> Parent */

if ((pid = fork()) == -1)

exit(EXIT_FAILURE);

if (pid > 0) { /* parent */

close(tube_pe[0]);
close(tube_ep[1]);
parent(tube_ep[0], tube_pe[1]);
} else { /* enfant */
close(tube_pe[1]);
close(tube_ep[0]);
enfant(tube_pe[0], tube_ep[1]);
}

printf("[%d]: terminaison\n", getpid());

exit(EXIT_SUCCESS);
}

Exercice 6 :

Il y a deux erreurs :
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

static int n = 0;

void erreur(const char *errmess) {

perror(errmess);
exit(EXIT_FAILURE);
}
void interruption(int signum) {
printf("No choisi : %d\n", n);
exit(EXIT_SUCCESS);
}

void init_iteration(int d_ecriture) {

write(d_ecriture, &n, sizeof(int));
}

void iteration(int d_lecture, int d_ecriture) {

while (1) {
read(d_lecture, &n, sizeof(int));
n++;
write(d_ecriture, &n, sizeof(int));
}
}

int main(void) {
int pf[2], fp[2];
struct sigaction action;
action.sa_flags = 0;
sigemptyset(&action.sa_mask);

if (pipe(pf) == -1 || pipe(fp) == -1)

erreur("creation d’un tube");

switch (fork()) {
case -1:
erreur("fork");
case 0: /* Fils */
close(fp[0]);
close(pf[1]);
iteration(pf[0], fp[1]);
break; // Ajout de la ligne break pour éviter l'exécution du code du père par le fils

default: /* Pere */
action.sa_handler = interruption;
sigaction(SIGINT, &action, NULL);
close(pf[0]);
close(fp[1]);
iteration(fp[0], pf[1]);
return 0; // Ajout de la ligne return pour éviter l'exécution du code du père après l'interruption
}

exit(EXIT_FAILURE);
}

ce programme semble mettre en place une boucle infinie de communication entre le père et le
fils, permettant l'incrémentation d'une variable n.