524 lines
17 KiB
C
524 lines
17 KiB
C
|
#include<stdio.h>
|
||
|
|
#include<stdlib.h>
|
||
|
|
#include<string.h>
|
||
|
|
#include<unistd.h>
|
||
|
|
#include<sys/types.h>
|
||
|
|
#include<sys/wait.h>
|
||
|
|
#include<sys/select.h>
|
||
|
|
#include<sys/time.h>
|
||
|
|
#include<sys/resource.h>
|
||
|
|
#include<signal.h>
|
||
|
|
#include<errno.h>
|
||
|
|
|
||
|
|
int joueHM(int taille, char * p2, char *log);
|
||
|
|
int joueMH(int taille, char * p1, char *log);
|
||
|
|
int joueMM(int taille, char * p1, char * p2, char *log);
|
||
|
|
int dansGrille(char col ,int lig, int taille);
|
||
|
|
void finMachineSimple(int from1, char *nom1, int status, int from2, int to2, int pid2, char *nom2, FILE *logFile);
|
||
|
|
int safeWrite(int fd, char *s);
|
||
|
|
|
||
|
|
int main(int argc, char *argv[]){
|
||
|
|
|
||
|
|
int taille;
|
||
|
|
char joueur1, joueur2, trace, rep;
|
||
|
|
char *path1 = NULL, *path2 = NULL;
|
||
|
|
char *logFile = NULL;
|
||
|
|
signal(SIGPIPE,SIG_IGN); /* on ignore les signaux de tube ferme */
|
||
|
|
printf("Bonjour\n");
|
||
|
|
printf("procedure simplifiee ? (O/N): ");
|
||
|
|
scanf(" %c",&rep);
|
||
|
|
if (rep == 'N') {
|
||
|
|
/* filtre de saisie: taille impaire, entre 5 et 25 */
|
||
|
|
do {
|
||
|
|
printf("Quelle est la taille (impaire) pour la grille ? ");
|
||
|
|
scanf("%d",&taille);
|
||
|
|
} while ((taille%2 ==0)||(taille>26)||(taille<4));
|
||
|
|
/* filtre de saisie: premier joueur humain ou programme */
|
||
|
|
do {
|
||
|
|
printf("Qui joue les blancs ? Humain ? Machine ? (H/M): ");
|
||
|
|
scanf(" %c",&joueur1);
|
||
|
|
} while ((joueur1 != 'H') && (joueur1 != 'M'));
|
||
|
|
/* filtre de saisie: second joueur humain ou programme */
|
||
|
|
do {
|
||
|
|
printf("Qui joue les noirs ? Humain ? Machine ? (H/M): ");
|
||
|
|
scanf(" %c",&joueur2);
|
||
|
|
} while ((joueur2 != 'H') && (joueur2 != 'M'));
|
||
|
|
|
||
|
|
if (joueur1 == 'M'){
|
||
|
|
/* le chemin d'acces au programme joueur 1 */
|
||
|
|
path1 = malloc(513 * sizeof(char));
|
||
|
|
printf("Veuillez entrer le chemin du programme joueur 1: ");
|
||
|
|
scanf("%s",path1);
|
||
|
|
while(access(path1,R_OK|X_OK|F_OK) != 0) {
|
||
|
|
printf("Ce fichier n'existe pas ou bien n'est pas executable\n");
|
||
|
|
printf("Veuillez entrer le chemin du programme joueur 1: ");
|
||
|
|
scanf("%s",path1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (joueur2 == 'M'){
|
||
|
|
/* le chemin d'acces au programme joueur 2 */
|
||
|
|
|
||
|
|
path2 = malloc(513 * sizeof(char));
|
||
|
|
printf("Veuillez entrer le chemin du programme joueur 2: ");
|
||
|
|
scanf("%s",path2);
|
||
|
|
while(access(path2,R_OK|X_OK|F_OK) != 0) {
|
||
|
|
printf("Ce fichier n'existe pas ou bien n'est pas executable\n");
|
||
|
|
printf("Veuillez entrer le chemin du programme joueur 2: ");
|
||
|
|
scanf("%s",path2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* si jamais on veut une trace: non implementee pour l'instant */
|
||
|
|
do {
|
||
|
|
printf("voulez-vous enregistrer la trace d'execution ? (O/N): ");
|
||
|
|
scanf(" %c",&trace);
|
||
|
|
} while (trace != 'O' && trace != 'N');
|
||
|
|
|
||
|
|
if (trace == 'O'){
|
||
|
|
logFile = malloc(513 * sizeof(char));
|
||
|
|
printf("Veuillez entrer le chemin du fichier de log: ");
|
||
|
|
scanf("%s",logFile);
|
||
|
|
}
|
||
|
|
} else { /* remplissage par defaut */
|
||
|
|
joueur1 = 'M';
|
||
|
|
joueur2 = 'M';
|
||
|
|
taille = 25;
|
||
|
|
path1 = malloc(30*sizeof(char));
|
||
|
|
strcpy(path1,"./olono");
|
||
|
|
path2 = malloc(30*sizeof(char));
|
||
|
|
strcpy(path2,"./olono-rand");
|
||
|
|
logFile = malloc(30*sizeof(char));
|
||
|
|
strcpy(logFile,"test");
|
||
|
|
}
|
||
|
|
/* maintenant on a toutes les informations qu'il faut */
|
||
|
|
/* pour l'instant, on n'implemente pas le fichier de log */
|
||
|
|
int retval;
|
||
|
|
if ((joueur1 == 'H') && (joueur2 == 'H')){
|
||
|
|
printf("Deux joueurs humains, ce n'est pas mon boulot\n");
|
||
|
|
} else if((joueur1 == 'H') && (joueur2 == 'M')) {
|
||
|
|
printf("Humain contre machine (%s), taille %d\n",path2,taille);
|
||
|
|
retval = joueHM(taille,path2,logFile);
|
||
|
|
} else if((joueur1 == 'M') && (joueur2 == 'H')) {
|
||
|
|
printf("Machine (%s) contre humain, taille %d\n",path1,taille);
|
||
|
|
retval = joueMH(taille,path1,logFile);
|
||
|
|
} else {
|
||
|
|
printf("Machine (%s) contre machine (%s)\n",path1,path2);
|
||
|
|
retval = joueMM(taille,path1,path2,logFile);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
printf("\n\nLe jeu est termine ! \n\n");
|
||
|
|
free(path1);
|
||
|
|
free(path2);
|
||
|
|
free(logFile);
|
||
|
|
return retval;
|
||
|
|
}
|
||
|
|
|
||
|
|
int dansGrille(char col, int lig, int taille){
|
||
|
|
return (((col -'A') >= 0) && ((col - 'A') < taille) &&
|
||
|
|
(lig >= 0) && (lig < taille));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* jeu d'un homme contre une machine */
|
||
|
|
int joueHM(int taille, char *p2, char *log){
|
||
|
|
int versProgramme[2]; /* tube pour envoyer des infos VERS le programme */
|
||
|
|
int deProgramme[2]; /* tube pour recuperer des infos DEPUIS le programme */
|
||
|
|
FILE *logFile = NULL;
|
||
|
|
if (log != NULL){
|
||
|
|
printf("fichier d'enregistrement: %s\n",log);
|
||
|
|
logFile = fopen(log,"w");
|
||
|
|
}
|
||
|
|
pipe(versProgramme);
|
||
|
|
pipe(deProgramme);
|
||
|
|
int pid = fork();
|
||
|
|
if (pid == -1){
|
||
|
|
perror("Fork n'a pas reussi\n");
|
||
|
|
return(-1);
|
||
|
|
} else if (pid == 0){
|
||
|
|
/* on est l'enfant: lancer le programme apres avoir
|
||
|
|
* redirige entree et sortie standard vers les tubes */
|
||
|
|
dup2(versProgramme[0],STDIN_FILENO);
|
||
|
|
dup2(deProgramme[1],STDOUT_FILENO);
|
||
|
|
close(versProgramme[1]); // pas besoin de lire ce qu'on ecrit
|
||
|
|
close(deProgramme[0]); // et inversement
|
||
|
|
char t[40];
|
||
|
|
sprintf(t,"%d",taille);
|
||
|
|
execlp(p2,p2,t,"grilleOn","ia","N",(char *) NULL);
|
||
|
|
perror("Pas reussi a executer le programme. Desole");
|
||
|
|
free(p2);
|
||
|
|
exit(-4);
|
||
|
|
} else {
|
||
|
|
/* on est le pere et pid est le pid du fils */
|
||
|
|
/* on recupere les infos du tube. On veut bien sur aussi
|
||
|
|
* garder entree et sortie standard */
|
||
|
|
close(versProgramme[0]);
|
||
|
|
close(deProgramme[1]);
|
||
|
|
printf("Vous etes les blancs, vous commencez\n");
|
||
|
|
char *coupBlanc = malloc(513 * sizeof(char));
|
||
|
|
char *coupNoir = malloc(513 * sizeof(char));
|
||
|
|
coupNoir[512] = '\0';
|
||
|
|
char colonneB, colonneN;
|
||
|
|
int ligneB, ligneN;
|
||
|
|
int nbRead;
|
||
|
|
int status;
|
||
|
|
int changed;
|
||
|
|
do {
|
||
|
|
changed = waitpid(pid,&status,WNOHANG); // on regarde si le fils n'a pas termine
|
||
|
|
if (changed == 0) {
|
||
|
|
do {
|
||
|
|
printf("Votre coup (blancs) : ");
|
||
|
|
scanf("%s",coupBlanc);
|
||
|
|
colonneB = coupBlanc[0];
|
||
|
|
sscanf(coupBlanc+1,"%d",&ligneB);
|
||
|
|
} while (dansGrille(colonneB,ligneB,taille) == 0);
|
||
|
|
printf("Vous jouez le coup: %s\n",coupBlanc);
|
||
|
|
write(versProgramme[1],coupBlanc,strlen(coupBlanc));
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coupBlanc);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
/* attente bloquante */
|
||
|
|
nbRead = read(deProgramme[0],coupNoir,512);
|
||
|
|
printf("Lu %d caracteres\n",nbRead);
|
||
|
|
if (nbRead >= 5){
|
||
|
|
printf("Les noirs declarent %s\n",coupNoir);
|
||
|
|
} else { /* un coup legal */
|
||
|
|
printf("Les noirs jouent %s\n",coupNoir);
|
||
|
|
}
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coupNoir);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
printf("Les noirs ont termine de jouer: %d\n",WEXITSTATUS(status));
|
||
|
|
}
|
||
|
|
} while (changed == 0);
|
||
|
|
/* on continue tant que le fils n'a pas termine */
|
||
|
|
/* puis on libere tout */
|
||
|
|
free(coupNoir);
|
||
|
|
free(coupBlanc);
|
||
|
|
close(versProgramme[1]);
|
||
|
|
close(deProgramme[0]);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* jeu d'une machine contre un homme */
|
||
|
|
int joueMH(int taille, char *p1, char *log){
|
||
|
|
int versProgramme[2]; /* tube pour envoyer des infos VERS le programme */
|
||
|
|
int deProgramme[2]; /* tube pour recuperer des infos DEPUIS le programme */
|
||
|
|
FILE *logFile = NULL;
|
||
|
|
if (log != NULL){
|
||
|
|
printf("fichier d'enregistrement: %s\n",log);
|
||
|
|
logFile = fopen(log,"w");
|
||
|
|
}
|
||
|
|
pipe(versProgramme);
|
||
|
|
pipe(deProgramme);
|
||
|
|
int pid = fork();
|
||
|
|
if (pid == -1){
|
||
|
|
perror("Fork n'a pas reussi\n");
|
||
|
|
return(-1);
|
||
|
|
} else if (pid == 0){
|
||
|
|
/* on est l'enfant: lancer le programme apres avoir
|
||
|
|
* redirige entree et sortie standard vers les tubes */
|
||
|
|
dup2(versProgramme[0],STDIN_FILENO);
|
||
|
|
dup2(deProgramme[1],STDOUT_FILENO);
|
||
|
|
close(versProgramme[1]); // pas besoin d ecrire ce qu'on lit
|
||
|
|
close(deProgramme[0]); // et inversement
|
||
|
|
char t[40];
|
||
|
|
sprintf(t,"%d",taille);
|
||
|
|
execlp(p1,p1,t,"grilleOn","ia","B",(char *) NULL);
|
||
|
|
perror("Pas reussi a executer le programme. Desole");
|
||
|
|
free(p1);
|
||
|
|
exit(-4);
|
||
|
|
} else {
|
||
|
|
/* on est le pere et pid est le pid du fils */
|
||
|
|
/* on recupere les infos du tube. On veut bien sur aussi
|
||
|
|
* garder entree et sortie standard */
|
||
|
|
close(versProgramme[0]);
|
||
|
|
close(deProgramme[1]);
|
||
|
|
printf("Vous etes les noirs, vous jouez en second\n");
|
||
|
|
char *coupBlanc = malloc(513 * sizeof(char));
|
||
|
|
char *coupNoir = malloc(513 * sizeof(char));
|
||
|
|
coupBlanc[512] = '\0';
|
||
|
|
char colonneB, colonneN;
|
||
|
|
int ligneB, ligneN;
|
||
|
|
int nbRead;
|
||
|
|
int status;
|
||
|
|
int changed;
|
||
|
|
do {
|
||
|
|
changed = waitpid(pid,&status,WNOHANG); // on regarde si le fils n'a pas termine
|
||
|
|
if (changed == 0) {
|
||
|
|
/* attente bloquante ??? */
|
||
|
|
nbRead = read(deProgramme[0],coupBlanc,512*sizeof(char));
|
||
|
|
if (nbRead >= 5){
|
||
|
|
printf("Les blancs declarent: %s",coupBlanc);
|
||
|
|
} else { /* un coup legal */
|
||
|
|
printf("Les blancs jouent: %s",coupBlanc);
|
||
|
|
}
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coupBlanc);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
changed = waitpid(pid,&status,WNOHANG); // on teste encore une fois le fils
|
||
|
|
if (changed == 0) {
|
||
|
|
do {
|
||
|
|
printf("Votre coup (noirs) : ");
|
||
|
|
scanf("%s",coupNoir);
|
||
|
|
colonneN = coupNoir[0];
|
||
|
|
sscanf(coupNoir+1,"%d",&ligneN);
|
||
|
|
} while (dansGrille(colonneN,ligneN,taille) == 0);
|
||
|
|
printf("Vous jouez le coup: %s\n",coupNoir);
|
||
|
|
write(versProgramme[1],coupNoir,strlen(coupNoir));
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coupNoir);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
printf("Les blancs ont termine de jouer: %d\n",WEXITSTATUS(status));
|
||
|
|
}
|
||
|
|
} while (changed == 0);
|
||
|
|
/* on continue tant que les blancs n'ont pas termine */
|
||
|
|
/* puis on libere tout */
|
||
|
|
free(coupNoir);
|
||
|
|
free(coupBlanc);
|
||
|
|
close(versProgramme[1]);
|
||
|
|
close(deProgramme[0]);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int joueMM(int taille, char *p1, char *p2, char *log){
|
||
|
|
FILE *logFile = NULL;
|
||
|
|
if (log != NULL){
|
||
|
|
printf("fichier d'enregistrement: %s\n",log);
|
||
|
|
logFile = fopen(log,"w");
|
||
|
|
}
|
||
|
|
int versProgrammeA[2], versProgrammeB[2];
|
||
|
|
int deProgrammeA[2], deProgrammeB[2];
|
||
|
|
pipe(versProgrammeA);
|
||
|
|
pipe(deProgrammeA);
|
||
|
|
int pidA = fork();
|
||
|
|
if (pidA == -1){
|
||
|
|
perror("Fork n'a pas reussi");
|
||
|
|
return(-1);
|
||
|
|
} else if (pidA == 0){
|
||
|
|
/* fils A: les blancs */
|
||
|
|
dup2(versProgrammeA[0],STDIN_FILENO);
|
||
|
|
dup2(deProgrammeA[1],STDOUT_FILENO);
|
||
|
|
close(versProgrammeA[1]);
|
||
|
|
close(deProgrammeA[0]);
|
||
|
|
fclose(logFile);
|
||
|
|
char t[40];
|
||
|
|
sprintf(t,"%d",taille);
|
||
|
|
execlp(p1,p1,t,"grilleOn","ia","B",(char *) NULL);
|
||
|
|
perror("Pas reussi a executer le programme A. Desole");
|
||
|
|
return -4;
|
||
|
|
|
||
|
|
} else {
|
||
|
|
/* pere */
|
||
|
|
pipe(versProgrammeB);
|
||
|
|
pipe(deProgrammeB);
|
||
|
|
close(versProgrammeA[0]);
|
||
|
|
close(deProgrammeA[1]);
|
||
|
|
int pidB = fork();
|
||
|
|
if (pidB == -1){
|
||
|
|
perror("Fork 2 n'a pas reussi");
|
||
|
|
return -1; /* le fils A est tue quand le pere meurt */
|
||
|
|
} else if (pidB == 0) {
|
||
|
|
|
||
|
|
/* fils B: les noirs */
|
||
|
|
close(versProgrammeA[1]);
|
||
|
|
close(deProgrammeA[0]);
|
||
|
|
close(versProgrammeB[1]);
|
||
|
|
close(deProgrammeB[0]);
|
||
|
|
fclose(logFile);
|
||
|
|
dup2(versProgrammeB[0],STDIN_FILENO);
|
||
|
|
dup2(deProgrammeB[1],STDOUT_FILENO);
|
||
|
|
char t[40];
|
||
|
|
sprintf(t,"%d",taille);
|
||
|
|
execlp(p2,p2,t,"grilleOff","ia","N",(char *) NULL);
|
||
|
|
perror("Pas reussi a executer le programme B. Desole");
|
||
|
|
return -5;
|
||
|
|
|
||
|
|
} else {
|
||
|
|
/* le pere */
|
||
|
|
close(versProgrammeB[0]);
|
||
|
|
close(deProgrammeB[1]);
|
||
|
|
char *coupBlanc = malloc(513 * sizeof(char));
|
||
|
|
char *coupNoir = malloc(513 * sizeof(char));
|
||
|
|
int nbRead;
|
||
|
|
int status;
|
||
|
|
int changed;
|
||
|
|
int i=0;
|
||
|
|
do {
|
||
|
|
changed = waitpid(pidA,&status,WNOHANG);
|
||
|
|
if (changed == 0) {
|
||
|
|
nbRead = read(deProgrammeA[0],coupBlanc,512);
|
||
|
|
coupBlanc[nbRead] = '\0';
|
||
|
|
if (nbRead >= 5){
|
||
|
|
printf("Les blancs declarent: %s",coupBlanc);
|
||
|
|
} else { /* un coup legal: colonne, ligne, \n et \0 */
|
||
|
|
printf("Les blancs jouent: %s",coupBlanc);
|
||
|
|
}
|
||
|
|
safeWrite(versProgrammeB[1],coupBlanc);
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coupBlanc);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
changed = waitpid(pidB,&status,WNOHANG);
|
||
|
|
if (changed == 0){
|
||
|
|
nbRead = read(deProgrammeB[0],coupNoir,512);
|
||
|
|
coupNoir[nbRead] = '\0';
|
||
|
|
if (nbRead >= 5){
|
||
|
|
printf("Les noirs declarent: %s",coupNoir);
|
||
|
|
} else { /* un coup legal: colonne, ligne, \n et \0 */
|
||
|
|
printf("Les noirs jouent: %s",coupNoir);
|
||
|
|
}
|
||
|
|
/* tester si on peut ecrire avant de le faire ! Sinon ca plante */
|
||
|
|
safeWrite(versProgrammeA[1],coupNoir);
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coupNoir);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
finMachineSimple(deProgrammeB[0],"noirs",status,deProgrammeA[0],versProgrammeA[1],pidA,"blancs",logFile);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
finMachineSimple(deProgrammeA[0],"blancs",status,deProgrammeB[0],versProgrammeB[1],pidB,"noirs",logFile);
|
||
|
|
}
|
||
|
|
} while (changed == 0);
|
||
|
|
free(coupNoir);
|
||
|
|
free(coupBlanc);
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,"\n---- partie terminee ----\n ");
|
||
|
|
fflush(logFile);
|
||
|
|
fclose(logFile);
|
||
|
|
}
|
||
|
|
close(versProgrammeA[1]);
|
||
|
|
close(deProgrammeA[0]);
|
||
|
|
close(versProgrammeB[1]);
|
||
|
|
close(deProgrammeB[0]);
|
||
|
|
return 0;
|
||
|
|
} // fin second fork
|
||
|
|
} // fin premier fork
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void finMachineSimple(int from1, char *nom1, int status, int from2, int to2, int pid2, char *nom2, FILE *logFile){
|
||
|
|
int nbRead;
|
||
|
|
char *coup1 = malloc(513 * sizeof(char));
|
||
|
|
char *coup2 = malloc(513 * sizeof(char));
|
||
|
|
struct rusage infoFils;
|
||
|
|
double uFils1, sFils1, uFils2, sFils2;
|
||
|
|
printf("Les %s ont termine de jouer: %d!\n",nom1,WEXITSTATUS(status));
|
||
|
|
getrusage(RUSAGE_CHILDREN,&infoFils);
|
||
|
|
/* on recupere des secondes et des micro secondes pour le temps CPU passe
|
||
|
|
* en calculs utilisateurs et en appel de fonctions systeme du fils 1 */
|
||
|
|
sFils1 = ((double) infoFils.ru_stime.tv_sec) + ((double) infoFils.ru_stime.tv_usec)/1000000;
|
||
|
|
uFils1 = ((double) infoFils.ru_utime.tv_sec) + ((double) infoFils.ru_utime.tv_usec)/1000000;
|
||
|
|
printf("Les %s ont utilise %lf sec de systeme et %lf de temps utilisateur\n",
|
||
|
|
nom1,sFils1,uFils1);
|
||
|
|
nbRead = read(from1,coup1,512);
|
||
|
|
if (nbRead > 0){
|
||
|
|
coup1[nbRead] = '\0';
|
||
|
|
printf("Les %s ont un dernier message: %s",nom1,coup1);
|
||
|
|
safeWrite(to2,coup1);
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coup1);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
sleep(1); /* on attend une seconde que l'autre ait aussi termine ! */
|
||
|
|
if (waitpid(pid2,&status,WNOHANG) == 0){
|
||
|
|
printf("Cependant, les %s n'ont pas termine de jouer ... tant pis.\n",nom2);
|
||
|
|
/* on les tue */
|
||
|
|
kill(pid2,SIGKILL);
|
||
|
|
waitpid(pid2,&status,WNOHANG);
|
||
|
|
} else {
|
||
|
|
printf("Les %s on aussi termine: %d!\n",nom2,WEXITSTATUS(status));
|
||
|
|
}
|
||
|
|
getrusage(RUSAGE_CHILDREN,&infoFils);
|
||
|
|
/* idem, sauf qu'on recupere la somme du fils 1 et du fils 2 ... */
|
||
|
|
sFils2 = ((double) infoFils.ru_stime.tv_sec) + ((double) infoFils.ru_stime.tv_usec)/1000000;
|
||
|
|
uFils2 = ((double) infoFils.ru_utime.tv_sec) + ((double) infoFils.ru_utime.tv_usec)/1000000;
|
||
|
|
/* idem, sauf qu'on recupere la somme du fils 1 et du fils 2 */
|
||
|
|
sFils2 = sFils2 - sFils1;
|
||
|
|
uFils2 = uFils2 - uFils1;
|
||
|
|
printf("Les %s ont utilise %lf sec de systeme et %lf de temps utilisateur\n",
|
||
|
|
nom2,sFils2,uFils2);
|
||
|
|
nbRead = read(from2,coup2,512);
|
||
|
|
if(nbRead > 0){
|
||
|
|
coup2[nbRead] = '\0';
|
||
|
|
printf("Les %s ont un dernier message: %s",nom2,coup2);
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coup2);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* ecrit de facon "sure" dans un tube: si on essaie d'ecrire dans un tube *
|
||
|
|
* ferme, on recoit un signal qui fait terminer le programme */
|
||
|
|
/* retourne le nombre de caracteres ecrit et -1 si ca s'est mal passe */
|
||
|
|
int safeWrite(int fd, char *s){
|
||
|
|
if (write(fd,s,strlen(s)) == -1)
|
||
|
|
printf("Impossible d'ecrire dans le tube: il est ferme en lecture\n");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* vieux machin complique et qui marche pas
|
||
|
|
|
||
|
|
void finMachine(int from1, char *nom1, int status, int from2, int to2, int pid2, char *nom2, FILE *logFile){
|
||
|
|
int nbRead;
|
||
|
|
fd_set set;
|
||
|
|
struct timeval timeout = {1,0};// timeout a 1 seconde
|
||
|
|
char *coup1 = malloc(513 * sizeof(char));
|
||
|
|
char *coup2 = malloc(513 * sizeof(char));
|
||
|
|
printf("Les %s ont termine de jouer: %d!\n",nom1,WEXITSTATUS(status));
|
||
|
|
FD_ZERO(&set);
|
||
|
|
FD_SET(from1,&set);
|
||
|
|
// s'il y a encore des choses a lire
|
||
|
|
if (select(from1+1,&set,NULL,NULL,&timeout) == 0){
|
||
|
|
printf("Les %s n'ont rien d'autre a ajouter\n",nom1);
|
||
|
|
} else {
|
||
|
|
nbRead = read(from1,coup1,512);
|
||
|
|
coup1[nbRead] = '\0';
|
||
|
|
printf("Les %s ont un dernier message: %s",nom1,coup1);
|
||
|
|
safeWrite(to2,coup1);
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coup1);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (waitpid(pid2,&status,WNOHANG) == 0){
|
||
|
|
printf("Cependant, les %s n'ont pas termine de jouer ... tant pis.\n",nom2);
|
||
|
|
} else {
|
||
|
|
printf("Les %s on aussi termine: %d!\n",nom2,WEXITSTATUS(status));
|
||
|
|
}
|
||
|
|
FD_ZERO(&set);
|
||
|
|
FD_SET(from2,&set);
|
||
|
|
if (select(from2+1,&set,NULL,NULL,&timeout) == 0){
|
||
|
|
printf("Les %s n'ont rien a dire\n",nom2);
|
||
|
|
} else {
|
||
|
|
nbRead = read(from2,coup2,512);
|
||
|
|
coup2[nbRead] = '\0';
|
||
|
|
printf("Les %s ont un dernier message: %s",nom2,coup2);
|
||
|
|
if (logFile != NULL){
|
||
|
|
fprintf(logFile,coup2);
|
||
|
|
fflush(logFile);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
|