/* soluzione parte C esame del 28 Marzo 2008 */
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <sys/wait.h> 
#include <string.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 

typedef int pipe_t[2]; 		/* tipo di dato per contenere i file descriptors di una pipe */

/* VARIABILI GLOBALI */
int N;	 			/* Numero di processi figli */
pipe_t *pipe_fp; 		/* array di pipe per la comunicazione figli-padre */
pipe_t *pipe_pf; 		/* array di pipe per la comunicazione padre-figli */
char CZ; 			/* Dato di progetto */
int Y; 				/* Dato di progetto */
long int posizione; 		/* QUESTA VARIABILE TIENE TRACCIA DELLA POSIZIONE NEL FILE, SENZA USARE LSEEK (vedi soluzione con segnali e pipe). Anche in questo caso la posizione iniziale si riferisce allo 0 */

/* funzione processo figlio, prototipo */
int figlio(int arg, const char *filename);

int main(int argc, char **argv) 
{
	int pid_f;	/* per fork */
	int status;	/* per wait */
	int i, j;	/* indici per cicli */
	int finito;	/* per sapere se il padre ha finito di leggere */
        char chControllo;       /* variabile per inviare indicazione ai figli */

if (argc < 4) 
{	/* il testo non specifica quanti devono essere i parametri, ma e' sensato assumere che ci debbano essere almeno 3 parametri (almeno un nome di file, CZ e Y) e quindi argc >= 4 */
	printf("Errore numero argomenti\n");
	exit(1);
}

/* Anche se non richiesti, facciamo il controllo sugli altri due parametri */

/* Controlliamo se il pienultimo parametro e' un singolo carattere */
if (strlen(argv[argc-2]) != 1)
{
        printf("Errore primo parametro non singolo carattere %s\n", argv[1]);
        exit(2);
}

/* ricaviamo il carattere CZ */
CZ = argv[argc-2][0];
/* ricaviamo il numero Y */
Y = atoi(argv[argc-1]);
/* Controlliamo il numero (deve essere strettamente positivo) */
if (Y <= 0) 
{
	printf("Y non valido\n");
	exit(3);
}

N = argc - 3; /* ogni figlio associato a argv[1]..argv[argc-3] */

/* allocazione memoria dinamica per pipe_fp e per pipe_pf */
pipe_fp=malloc(N*sizeof(pipe_t));
if (pipe_fp == NULL) 
{
	printf("Errore nella malloc pipe figli-padre\n");
	exit(4);
}
pipe_pf=malloc(N*sizeof(pipe_t));
if (pipe_pf == NULL) 
{
	printf("Errore nella malloc pipe padre-figli\n");
	exit(5);
}

/* creazione delle pipe */
for (i=0; i < N; i++) 
{
	if (pipe(pipe_fp[i])!=0) 
	{
		printf("Errore creazione delle pipe figli-padre\n");
		exit(6);
	}
	if (pipe(pipe_pf[i])!=0) 
	{
		printf("Errore creazione delle pipe padrei-figli\n");
		exit(7);
	}
}

/* creazione dei processi figli */
for (i=0; i < N; i++) 
{
	switch (fork()) 
	{
		case 0:
			/* chiusura lati pipe non utilizzati */
	 		/* ogni figlio scrive solo su pipe_fp[i] e legge solo da pipe_pf[i] */
                	for (j=0;j<N;j++)
                	{
                        	close(pipe_fp[j][0]);
                        	close(pipe_pf[j][1]);
                        	if (j!=i)
                        	{
                                	close(pipe_fp[j][1]);
                                	close(pipe_pf[j][0]);
                        	}
                	}
			/* invocazione della funzione figlio e terminazione del processo con 
			 * exit value uguale al return value della funzione figlio() */
			exit(figlio(i, argv[i+1]));
		case -1:
			printf("Errorei creazione figlio %d\n", i);
			exit(8);
		default:/* solo dal padre */
			;
	}
}

/*codice del padre*/

/* chiusura lati pipe non usati */
for (i=0;i<N;i++)
{
   close(pipe_fp[i][1]);
   close(pipe_pf[i][0]);
}

/* ALTRO MODO PER CONTROLLARE FINITO RISPETTO ALL'ARRAY DI FLAG (vedi soluzione con segnali e pipe)*/
finito = 0; /* all'inizio supponiamo che non sia finito nessun figlio */
while (!finito)
{
	finito = 1;
        for (i=0; i<N; i++)
        {
		if (read(pipe_fp[i][0], &posizione, sizeof(posizione)) == sizeof(posizione)) 
		{
			/*
			printf("PADRE FIGLIO CON INDICE %d MI HA INVIATO POSIZIONE=%ld\n", i, posizione);
			*/
			if (posizione < Y) 
				/* il figlio deve continuare a cercare */
 				chControllo = 'S';

			else 
				/* il figlio deve smettere di cercare */
				 chControllo = 'N';
			write(pipe_pf[i][1], &chControllo, 1);
			finito=0; /* almeno un processo non e' finito */
		}
	}
}

/* ciclo eseguito dal solo processo padre per recuperare le info di terminazione dei processi figli */
for (i=0; i < N; i++) 
{
	pid_f=wait(&status);
	printf("Figlio con pid %d %s %d\n", pid_f,
			(WIFEXITED(status) ? "ritorna" : "terminato da"),
			(WIFEXITED(status) ? WEXITSTATUS(status) : WTERMSIG(status)));
}

/* exit value del processo padre */
exit(0);
}

/* funzione processo figlio, definizione */
int figlio(int arg, const char * filename) 
{
	int fd;
	char ch;
	int occorrenze;

	fd=open(filename, O_RDONLY);
	if (fd < 0) 
	{
		printf("Impossibile aprire il file %s\n", filename);
                return 0; /* in caso di errore torniamo 0 perche' non e' stato possibile cercare alcuna occorrenza */
	}
	printf("Figlio %d: analizzo il file %s\n", getpid(), filename);

	/* inizializziamo sia posizione che occorrenze */
	posizione=0;
	occorrenze=0;
 	while (read(fd, &ch, 1))
        {
		if (ch==CZ) 
		{
			occorrenze++;
                        /* inviamo posizione corrente al padre */
 			write(pipe_fp[arg][1], &posizione, sizeof(posizione));
			printf("Figlio %d: trovata occorrenza alla posizione %ld. Aspetto autorizzazione...\n", getpid(), posizione);
                        /* aspettiamo dal padre se dobbiamo continuare o meno */
			read(pipe_pf[arg][0], &ch, 1);
			if (ch=='S')
		 	{
 				printf("Figlio %d: padre mi ha detto di continuare \n", getpid());
				/* autorizzato, continua */
			}
			else 
			{
				/* non autorizzato termina la lettura */
				printf("Figlio %d: padre mi ha detto di interrompere\n", getpid());
				break;
			}
		}
                posizione++;    /* incrementiamo il valore di posizione per il prossimo carattere */
	}
	return occorrenze-1; /* dobbiamo decrementare il numero di occorrenze perche' il testo dice che ogni processo figlio deve tornare al padre il numero di occorrenze trovate del carattere CZ sulla base delle autorizzazioni ricevute e quindi in pratica e' come dire che si devono contare le autorizzazioni ricevute */
}