Exemples Tubes

Exemples/05-Signaux/main.c

@@ -0,0 +1,51 @@
+#include <signal.h> 
+#include <stdio.h> 
+#include <stdlib.h>
+#include <unistd.h> 
+#include <sys/wait.h>
+
+void action1 (int signum); /* sur SIGUSR1 */
+void action2 (int signum); /* sur SIGTERM */
+void action3 (int signum);/* sur SIGUSR2 */
+
+int pid;
+
+int main(int argc, char *argv[]) {
+	
+	pid = fork();
+	
+	if (pid == 0) {
+		execl("travailleur", "travailleur", NULL);
+	}
+	
+	printf("PID du père : %d\n", getpid());
+	signal(SIGUSR1, &action1);
+	signal(SIGUSR2, &action3);
+	signal(SIGTERM, &action2);
+	
+	pause();
+
+	return EXIT_SUCCESS;
+}
+
+void action1 (int signum) {
+	/* Le fils a terminé son travail */
+	printf("Mon fils m'a envoyé SIGUSR1\n");
+	kill(pid, SIGUSR2);
+	pause();
+	kill(pid, SIGKILL);
+}
+
+void action2(int signum) {
+	/* on recoit un signal de l'exterieur pour forcer la sauvegarde 
+	du fils */
+	printf("Le shell m'a envoyé SIGTERM\n");
+	kill(pid, SIGUSR2);
+	pause();
+	kill(pid, SIGKILL);
+}
+
+void action3(int signum) {
+	printf(" Recu SIGUSR2 du fils\n");
+	kill(pid, SIGKILL);
+}

Exemples/05-Signaux/main2.c

@@ -0,0 +1,50 @@
+#include <signal.h> 
+#include <stdio.h> 
+#include <stdlib.h>
+#include <unistd.h> 
+#include <sys/wait.h>
+
+
+void action1(int signum);
+void action2(int signum);
+void action3(int signum);
+
+pid_t pid;
+
+int main(int argc, char *argv[]) {
+	
+	printf("Mon PID de pere : %d\n", getpid());
+	
+	signal(SIGUSR2, &action2);
+	
+	pid = fork();
+	
+	if (pid == 0) {
+		execl("travailleur2", "travailleur2", NULL);
+	}
+	
+	signal(SIGUSR1, &action1);
+	
+	signal(SIGTERM, &action3);
+		
+	pause();
+	
+	return EXIT_SUCCESS;
+}
+
+void action1(int signum) {
+	printf("Je tue mon fils\n");
+	kill(pid, SIGKILL);
+}
+
+void action2(int signum) {
+	printf("Mon fils a fini son travail\n");
+	kill(pid, SIGUSR2);
+	pause();
+}
+
+void action3(int signum) {
+	printf("Je force mon fils à la sauvegarde\n");
+	kill(pid, SIGUSR2);
+	pause();
+}

Exemples/05-Signaux/signal-0.c

@@ -0,0 +1,27 @@
+#include <stdio.h> 
+#include <stdlib.h>
+#include <signal.h> 
+#include <unistd.h>
+
+void sighandler (int signum);
+
+
+int main(int argc, char *argv[]) {
+	
+	char buffer[256];
+	
+	if (signal(SIGTERM, &sighandler) == SIG_ERR) {
+		printf("Ne peut pas manipuler le signal\n");
+		exit(1);
+	}
+
+	while (1) {
+		fgets(buffer, sizeof(buffer), stdin);
+		printf("Input : %s", buffer);
+	}
+	return EXIT_SUCCESS;
+}
+
+void sighandler (int signum) {
+	printf("Masquage du signal SIGTERM\n");
+}

Exemples/05-Signaux/signal-1.c

@@ -0,0 +1,55 @@
+#include <signal.h> 
+#include <stdio.h> 
+#include <stdlib.h>
+#include <unistd.h> 
+#include <sys/wait.h>
+
+#define FOREVER for(;;)
+
+static void action (int sig);
+
+int main(int argc, char *argv[]) {
+	
+int i, pid, etat;
+sig_t s1, s2;
+
+s1 = signal(SIGUSR1, action);
+s2 = signal(SIGUSR2, action);
+if (( s1 == SIG_ERR) || (s2 == SIG_ERR)) {
+	perror("Erreur attachement signal");
+	exit(1);
+}	
+
+if ((pid = fork()) == 0) {
+	pause();
+	kill(getppid(), SIGUSR1);
+	sleep(10);
+}
+else {
+	sleep(2);
+	kill(pid, SIGUSR2);
+	pause();
+	printf("Parent : Demande terminaison du fils\n");
+	fflush(stdout);
+	kill(pid, SIGTERM);
+	wait(&etat);
+	printf("Parent : fils terminé\n");
+	fflush(stdout);
+}
+	return EXIT_SUCCESS;
+}
+
+static void action(int sig) {
+	switch (sig) {
+		case SIGUSR1 : 
+			printf("Parent : signal SIGUSR1 recu\n");
+			fflush(stdout);
+			break;
+		case SIGUSR2 : 
+			printf("Fils : signal SIGUSR2 recu\n");
+			fflush(stdout);
+			break;
+		default : 
+			break;
+	}
+}

Exemples/05-Signaux/travailleur.c

@@ -0,0 +1,31 @@
+#include <signal.h> 
+#include <stdio.h> 
+#include <stdlib.h>
+#include <unistd.h> 
+#include <sys/wait.h>
+
+void action_sauvegarde(int signum);
+
+int main(int argc, char *argv[]) {
+	
+	signal(SIGUSR2, &action_sauvegarde);
+	
+	/* Charger des données */
+	printf("Calcul\n");
+	sleep(10);
+	
+	kill (getppid(), SIGUSR1);
+	
+	pause();
+
+	return EXIT_SUCCESS;
+}
+
+void action_sauvegarde(int signum) {
+	printf("Sauvegarde\n");
+	sleep(1);
+	
+	kill(getppid(), SIGUSR2);
+	
+	pause();
+}

Exemples/05-Signaux/travailleur2.c

@@ -0,0 +1,38 @@
+#include <signal.h> 
+#include <stdio.h> 
+#include <stdlib.h>
+#include <unistd.h> 
+#include <sys/wait.h>
+
+void action_sauvegarde(int signum);
+int b;
+
+int main(int argc, char *argv[]) {
+	
+	signal(SIGUSR2, &action_sauvegarde);
+	/* charge des données */
+	
+	/* fait un calcul */
+	b = 1;
+	printf("Je fais un calcul\n"); 
+	sleep (10);
+	b = 0;
+	kill (getppid(), SIGUSR2);
+	
+	pause();
+
+	return EXIT_SUCCESS;
+}
+
+void action_sauvegarde(int signum) {
+	/* sauvegarde */
+	if (b==1) {
+		printf("Je sauvegarde donnée corrompue\n");
+		sleep(2);
+	} else {
+		printf("Je sauvegarde donnée ok\n");
+		sleep(2);
+	}
+	kill(getppid(), SIGUSR1);
+	pause();
+}

Exemples/06-Tubes/ecrivain.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+
+int main (void) {
+	int fd;
+	char message[26];
+	
+	sprintf(message, "bonjour du writer [%d]\n", getpid());
+	
+	fd = open("my_tube", O_WRONLY);
+	printf("Ici writer [%d]\n", getpid());
+	if (fd != -1) {
+		write(fd, message, strlen(message));
+	}
+	else 
+		printf("Désolé, je trouve pas le tube\n");
+	
+	close(fd);
+	return 0;
+}

Exemples/06-Tubes/exTube.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+int tube[2], fcntlLecture, fcntlEcriture;
+char buf[10];
+
+struct stat statLecture, statEcriture;
+
+void noeud (struct stat *statDesc) {
+	printf("Quelques caractérisitques du noeud\n");
+	if (S_ISFIFO(statDesc->st_mode)) printf("\t Type : tube\n");
+	else printf("\t Type : autre que tube\n");
+	printf("\t Numéro : %llu\n", statDesc-> st_ino);
+	printf("\t Numéro de disque : %d\n", statDesc-> st_dev);
+	printf("\t Numéro de liens physiques : %d\n", statDesc-> st_nlink);
+	printf("\t Taille : %lld\n", statDesc-> st_size);
+}
+
+main() {
+	if (pipe(tube) == -1) { perror("Création ratée"), exit(2); }
+	if ((fcntlLecture = fcntl(tube[0], F_GETFL)) == -1) {
+		perror("Fcntl lecture "); exit(2); }
+	if ((fcntlEcriture = fcntl(tube[1], F_GETFL)) == -1) {
+		perror("Fcntl ecriture "); exit(2); }
+	printf("Attributs de %d (tube[0]) : %d\n", tube[0], fcntlLecture);	
+	printf("Attributs de %d (tube[1]) : %d\n", tube[1], fcntlEcriture);	
+	write(tube[1], "0123456789", 10);
+	read(tube[0], buf, 5);
+	printf("Chaine lue : %s\n", buf);
+
+	fstat(tube[0], &statLecture);
+	fstat(tube[1], &statEcriture);
+	if (memcmp(&statLecture, &statEcriture, sizeof(struct stat)) != 0) {
+		fprintf(stderr, "Noeuds en lecture et écriture différents\n");
+		printf("Descripteur en lecture\n"); noeud(&statLecture);
+		printf("Descripteur en ecriture\n"); noeud(&statEcriture);
+	} else {
+		printf("Noeud en lecture et ecriture identique\n");
+		noeud(&statEcriture); }
+}

Exemples/06-Tubes/exo1.c

@@ -0,0 +1,71 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <signal.h>
+
+#define R 0
+#define W 1
+
+void action (int sig) {
+	printf("Je capture le signal\n");
+}
+
+int main() {
+	int fdp[2], // père vers le fils
+		fdf[2]; // fils vers père
+	pid_t pid;
+	
+	char message[100]; // pour récupérer un message
+	char *phrasef = "message envoyé au père par le fils";
+	char *phrasep = "message envoyé au fils par le père";
+
+	if ((pipe(fdp) != 0) || (pipe(fdf) != 0)) {
+		perror("Pipe pas possible");
+		exit(1);
+	}
+	signal( SIGPIPE, &action);
+	
+	if ((pid = fork()) == -1) {
+		perror("Fork pas possible");
+		exit(2);
+	}
+	
+	
+	if (pid == 0) {
+		
+		close(fdf[R]); //
+		close(fdp[W]); //
+		
+		if (write( fdf[W], phrasef, strlen(phrasef)+1) > 0) {
+			sleep(4);
+			int n = read(fdp[R], message, 100); 
+			// Dans ce cas le signal SIGPIPE est recu => processus tué
+			printf("Valeur de n : %d\n", n);
+			if (n > 0) {
+				printf("J'ai lu : %s\n", message);
+			} else {
+				perror("Lecture pas bon"); 
+				exit(2);
+			}
+			close(fdf[W]);
+			exit(0);
+		} else {
+			perror("Write pas bon"); exit(2);
+		}
+	}
+	
+	close(fdp[R]);
+	close(fdf[W]);
+	
+	write (fdp[W], phrasep, strlen(phrasep)+1);
+	sleep(2);
+	read(fdf[R], message, 100);
+	printf("J'ai lu : %s\n", message);
+	// wait(NULL);
+	close(fdp[W]);
+	
+
+return 0;
+}

Exemples/06-Tubes/exo1a.c

@@ -0,0 +1,78 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define R 0
+#define W 1
+
+void action (int sig) {
+	printf("Je capture SIGPIPE\n");
+	// quand les read se font sur des tubes sans écrivain 
+}
+
+int main() {
+	int fdp[2], // père vers le fils
+		fdf[2]; // fils vers père
+	pid_t pid;
+		
+	char message[100]; // pour récupérer un message
+	char *phrasef = "message envoyé au père par le fils";
+	char *phrasep = "message envoyé au fils par le père";
+
+	if ((pipe(fdf) == -1) || (pipe(fdp) == -1)) {
+		perror("Pipe erreur");
+		exit(1);
+	}
+	signal(SIGPIPE, &action);
+	
+	if ((pid = fork()) == -1) {
+		perror("Fork erreur");
+		exit(2);
+	}
+	
+	if (pid == 0) {
+		close(fdf[R]);
+		close(fdp[W]);
+		
+		if (write(fdf[W], phrasef, strlen(phrasef)+1) != -1) {
+			sleep(4);
+		
+			if (read(fdp[R], message, 100) >= 0) {
+				printf("J'ai lu : %s\n", message);
+			} else {
+				perror("Read erreur"); exit(4);
+			}
+		} else {
+			perror("Write erreur"); exit(3);
+		}
+		
+		close(fdp[R]);
+		close(fdf[W]);
+		exit(0);
+	}
+	
+	close(fdp[R]);
+	close(fdf[W]);
+	
+	if (write(fdp[W], phrasep, strlen(phrasep)+1) != -1) {
+		sleep(2);
+	
+		if (read(fdf[R], message, 100) >= 0) {
+			printf("J'ai lu : %s\n", message);
+		} else {
+			perror("Read erreur"); exit(4);
+		}
+	} else {
+		perror("Write erreur"); exit(3);
+	}
+
+	
+	close(fdf[R]);
+	close(fdp[W]);
+
+	return 0;
+// A compléter
+
+}

Exemples/06-Tubes/fils.c

@@ -0,0 +1,35 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+
+int main() {
+	int f1, f2; 
+	
+	char message[100]; // pour récupérer un message
+	char *phrasef = "message envoyé au père par le fils";
+
+	f1 = open("f2p", O_WRONLY);
+	f2 = open("p2f", O_RDONLY);
+		
+	if (write(f1, phrasef, strlen(phrasef)+1) != -1) {
+			sleep(4);
+		
+			if (read(f2, message, 100) >= 0) {
+				printf("J'ai lu : %s\n", message);
+			} else {
+				perror("Read erreur"); exit(4);
+			}
+		} else {
+			perror("Write erreur"); exit(3);
+		}
+
+		
+		close(f1);
+		close(f2);
+
+return 0;
+}

Exemples/06-Tubes/lecteur.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+int main (void) {
+	int fd, n;
+	char input;
+	
+	fd = open("my_tube", O_RDONLY);
+	printf("Ici reader [%d]\n", getpid());
+	if (fd != -1) {
+		printf("Recu par le reader : \n");
+		while ((n = read(fd, &input, 1)) > 0) {
+			printf("%c", input);
+		}
+		printf("Le reader a fini sa mission\n");
+	}
+	else 
+		printf("Désolé, je trouve pas le tube\n");
+	
+	close(fd);
+	return 0;
+}

Exemples/06-Tubes/pere.c

@@ -0,0 +1,35 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+
+int main() {
+	int f1, f2; 
+	
+	char message[100]; // pour récupérer un message
+	char *phrasep = "message envoyé au fils par le père";
+
+	f1 = open("f2p", O_RDONLY);
+	f2 = open("p2f", O_WRONLY);
+		
+	if (write(f2, phrasep, strlen(phrasep)+1) != -1) {
+			sleep(2);
+		
+			if (read(f1, message, 100) >= 0) {
+				printf("J'ai lu : %s\n", message);
+			} else {
+				perror("Read erreur"); exit(4);
+			}
+		} else {
+			perror("Write erreur"); exit(3);
+		}
+
+		
+		close(f1);
+		close(f2);
+
+return 0;
+}

Exemples/06-Tubes/upipe.c

@@ -0,0 +1,28 @@
+#include <sys/types.h> 
+#include <unistd.h>  
+#include <stdio.h> 
+#include <string.h>
+
+#define R 0 
+#define W 1
+
+int main ( ) {
+	int fd[2] ;
+	char message[100] ;
+	int nboctets ;
+	char *phrase = " message envoye au pere par le fils " ;
+	
+	pipe ( fd ) ;
+	if (fork() == 0) {
+		close ( fd[R] ) ;
+		write ( fd[W] , phrase , strlen (phrase) + 1 ) ;
+		close ( fd[W] ) ;
+	}
+	else {
+		close ( fd[W] ) ;
+		nboctets = read ( fd[R] , message , 100 ) ;
+		printf ( " Lecture %d octets : %s\n" , nboctets , message ) ;
+		close ( fd [R] ) ;
+	}
+	return 0;
+}

Exemples/06-Tubes2/ecrivain.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+
+int main (void) {
+	int fd;
+	char message[26];
+	
+	sprintf(message, "bonjour du writer [%d]\n", getpid());
+	
+	fd = open("my_tube", O_WRONLY);
+	printf("Ici writer [%d]\n", getpid());
+	if (fd != -1) {
+		write(fd, message, strlen(message));
+	}
+	else 
+		printf("Désolé, je trouve pas le tube\n");
+	
+	close(fd);
+	return 0;
+}

Exemples/06-Tubes2/exTube.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+int tube[2], fcntlLecture, fcntlEcriture;
+char buf[10];
+
+struct stat statLecture, statEcriture;
+
+void noeud (struct stat *statDesc) {
+	printf("Quelques caractérisitques du noeud\n");
+	if (S_ISFIFO(statDesc->st_mode)) printf("\t Type : tube\n");
+	else printf("\t Type : autre que tube\n");
+	printf("\t Numéro : %llu\n", statDesc-> st_ino);
+	printf("\t Numéro de disque : %d\n", statDesc-> st_dev);
+	printf("\t Numéro de liens physiques : %d\n", statDesc-> st_nlink);
+	printf("\t Taille : %lld\n", statDesc-> st_size);
+}
+
+main() {
+	if (pipe(tube) == -1) { perror("Création ratée"), exit(2); }
+	if ((fcntlLecture = fcntl(tube[0], F_GETFL)) == -1) {
+		perror("Fcntl lecture "); exit(2); }
+	if ((fcntlEcriture = fcntl(tube[1], F_GETFL)) == -1) {
+		perror("Fcntl ecriture "); exit(2); }
+	printf("Attributs de %d (tube[0]) : %d\n", tube[0], fcntlLecture);	
+	printf("Attributs de %d (tube[1]) : %d\n", tube[1], fcntlEcriture);	
+	write(tube[1], "0123456789", 10);
+	read(tube[0], buf, 5);
+	printf("Chaine lue : %s\n", buf);
+
+	fstat(tube[0], &statLecture);
+	fstat(tube[1], &statEcriture);
+	if (memcmp(&statLecture, &statEcriture, sizeof(struct stat)) != 0) {
+		fprintf(stderr, "Noeuds en lecture et écriture différents\n");
+		printf("Descripteur en lecture\n"); noeud(&statLecture);
+		printf("Descripteur en ecriture\n"); noeud(&statEcriture);
+	} else {
+		printf("Noeud en lecture et ecriture identique\n");
+		noeud(&statEcriture); }
+}

Exemples/06-Tubes2/exo1.c

@@ -0,0 +1,71 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <signal.h>
+
+#define R 0
+#define W 1
+
+void action (int sig) {
+	printf("Je capture le signal\n");
+}
+
+int main() {
+	int fdp[2], // père vers le fils
+		fdf[2]; // fils vers père
+	pid_t pid;
+	
+	char message[100]; // pour récupérer un message
+	char *phrasef = "message envoyé au père par le fils";
+	char *phrasep = "message envoyé au fils par le père";
+
+	if ((pipe(fdp) != 0) || (pipe(fdf) != 0)) {
+		perror("Pipe pas possible");
+		exit(1);
+	}
+	signal( SIGPIPE, &action);
+	
+	if ((pid = fork()) == -1) {
+		perror("Fork pas possible");
+		exit(2);
+	}
+	
+	
+	if (pid == 0) {
+		
+		close(fdf[R]); //
+		close(fdp[W]); //
+		
+		if (write( fdf[W], phrasef, strlen(phrasef)+1) > 0) {
+			sleep(4);
+			int n = read(fdp[R], message, 100); 
+			// Dans ce cas le signal SIGPIPE est recu => processus tué
+			printf("Valeur de n : %d\n", n);
+			if (n > 0) {
+				printf("J'ai lu : %s\n", message);
+			} else {
+				perror("Lecture pas bon"); 
+				exit(2);
+			}
+			close(fdf[W]);
+			exit(0);
+		} else {
+			perror("Write pas bon"); exit(2);
+		}
+	}
+	
+	close(fdp[R]);
+	close(fdf[W]);
+	
+	write (fdp[W], phrasep, strlen(phrasep)+1);
+	sleep(2);
+	read(fdf[R], message, 100);
+	printf("J'ai lu : %s\n", message);
+	// wait(NULL);
+	close(fdp[W]);
+	
+
+return 0;
+}

Exemples/06-Tubes2/exo1a.c

@@ -0,0 +1,78 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define R 0
+#define W 1
+
+void action (int sig) {
+	printf("Je capture SIGPIPE\n");
+	// quand les read se font sur des tubes sans écrivain 
+}
+
+int main() {
+	int fdp[2], // père vers le fils
+		fdf[2]; // fils vers père
+	pid_t pid;
+		
+	char message[100]; // pour récupérer un message
+	char *phrasef = "message envoyé au père par le fils";
+	char *phrasep = "message envoyé au fils par le père";
+
+	if ((pipe(fdf) == -1) || (pipe(fdp) == -1)) {
+		perror("Pipe erreur");
+		exit(1);
+	}
+	signal(SIGPIPE, &action);
+	
+	if ((pid = fork()) == -1) {
+		perror("Fork erreur");
+		exit(2);
+	}
+	
+	if (pid == 0) {
+		close(fdf[R]);
+		close(fdp[W]);
+		
+		if (write(fdf[W], phrasef, strlen(phrasef)+1) != -1) {
+			sleep(4);
+		
+			if (read(fdp[R], message, 100) >= 0) {
+				printf("J'ai lu : %s\n", message);
+			} else {
+				perror("Read erreur"); exit(4);
+			}
+		} else {
+			perror("Write erreur"); exit(3);
+		}
+		
+		close(fdp[R]);
+		close(fdf[W]);
+		exit(0);
+	}
+	
+	close(fdp[R]);
+	close(fdf[W]);
+	
+	if (write(fdp[W], phrasep, strlen(phrasep)+1) != -1) {
+		sleep(2);
+	
+		if (read(fdf[R], message, 100) >= 0) {
+			printf("J'ai lu : %s\n", message);
+		} else {
+			perror("Read erreur"); exit(4);
+		}
+	} else {
+		perror("Write erreur"); exit(3);
+	}
+
+	
+	close(fdf[R]);
+	close(fdp[W]);
+
+	return 0;
+// A compléter
+
+}

Exemples/06-Tubes2/fils.c

@@ -0,0 +1,35 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+
+int main() {
+	int f1, f2; 
+	
+	char message[100]; // pour récupérer un message
+	char *phrasef = "message envoyé au père par le fils";
+
+	f1 = open("f2p", O_WRONLY);
+	f2 = open("p2f", O_RDONLY);
+		
+	if (write(f1, phrasef, strlen(phrasef)+1) != -1) {
+			sleep(4);
+		
+			if (read(f2, message, 100) >= 0) {
+				printf("J'ai lu : %s\n", message);
+			} else {
+				perror("Read erreur"); exit(4);
+			}
+		} else {
+			perror("Write erreur"); exit(3);
+		}
+
+		
+		close(f1);
+		close(f2);
+
+return 0;
+}

Exemples/06-Tubes2/lecteur.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+int main (void) {
+	int fd, n;
+	char input;
+	
+	fd = open("my_tube", O_RDONLY);
+	printf("Ici reader [%d]\n", getpid());
+	if (fd != -1) {
+		printf("Recu par le reader : \n");
+		while ((n = read(fd, &input, 1)) > 0) {
+			printf("%c", input);
+		}
+		printf("Le reader a fini sa mission\n");
+	}
+	else 
+		printf("Désolé, je trouve pas le tube\n");
+	
+	close(fd);
+	return 0;
+}

Exemples/06-Tubes2/pere.c

@@ -0,0 +1,35 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+
+int main() {
+	int f1, f2; 
+	
+	char message[100]; // pour récupérer un message
+	char *phrasep = "message envoyé au fils par le père";
+
+	f1 = open("f2p", O_RDONLY);
+	f2 = open("p2f", O_WRONLY);
+		
+	if (write(f2, phrasep, strlen(phrasep)+1) != -1) {
+			sleep(2);
+		
+			if (read(f1, message, 100) >= 0) {
+				printf("J'ai lu : %s\n", message);
+			} else {
+				perror("Read erreur"); exit(4);
+			}
+		} else {
+			perror("Write erreur"); exit(3);
+		}
+
+		
+		close(f1);
+		close(f2);
+
+return 0;
+}

Exemples/06-Tubes2/upipe.c

@@ -0,0 +1,28 @@
+#include <sys/types.h> 
+#include <unistd.h>  
+#include <stdio.h> 
+#include <string.h>
+
+#define R 0 
+#define W 1
+
+int main ( ) {
+	int fd[2] ;
+	char message[100] ;
+	int nboctets ;
+	char *phrase = " message envoye au pere par le fils " ;
+	
+	pipe ( fd ) ;
+	if (fork() == 0) {
+		close ( fd[R] ) ;
+		write ( fd[W] , phrase , strlen (phrase) + 1 ) ;
+		close ( fd[W] ) ;
+	}
+	else {
+		close ( fd[W] ) ;
+		nboctets = read ( fd[R] , message , 100 ) ;
+		printf ( " Lecture %d octets : %s\n" , nboctets , message ) ;
+		close ( fd [R] ) ;
+	}
+	return 0;
+}