void tim_stop( const char *name )
{
tim_Entry entry;
struct timeval real;
struct rusage rusage;
#define DIFFTIME(now,then)\
(((now).tv_sec - (then).tv_sec)*1000 \
+ ((now).tv_usec - (then).tv_usec)/1000)
_tim_check();
#if HAVE_GETTIMEOFDAY
gettimeofday( &real, NULL );
#else
time( &real.tv_sec );
real.tv_usec = 0;
#endif
if (!(entry = (tim_Entry)hsh_retrieve( _tim_Hash, name ) ))
err_internal ( __FUNCTION__, "No timer: %s\n", name );
entry->real = DIFFTIME( real, entry->real_mark );
getrusage( RUSAGE_SELF, &rusage );
entry->self_user = DIFFTIME( rusage.ru_utime, entry->self_mark.ru_utime );
entry->self_system = DIFFTIME( rusage.ru_stime, entry->self_mark.ru_stime );
getrusage( RUSAGE_CHILDREN, &rusage );
entry->children_user
= DIFFTIME( rusage.ru_utime, entry->children_mark.ru_utime );
entry->children_system
= DIFFTIME( rusage.ru_stime, entry->children_mark.ru_stime );
}
int main (int argc, char *argv [], char *env []) {
char fraseOriginal[MAX_LINE];
char claveCifrado[MAX_LINE];
char readbuffer[MAX_LINE];
char *noEncriptados=NULL;
char *Cifrado=NULL;
pid_t PIDcronometro;
pid_t PIDcifrador;
pid_t PIDcontPalabras;
pid_t PIDcontCaracteres;
pid_t PIDnoCifrados;
sigset_t maskImprime;
int estadoaux;
int numPalabras, numCaracteres;;
int estadoPIDcontPalabras;
int estadoPIDcontCaracteres;
signal(SIGALRM, expira);
signal(SIGINT, termina);
/*
* Captura de la clave de cifrado.
* Se repetira hasta que se introduzca una clave correcta
*/
do{
alarm(60);
flagTiempo=0;
printf("Clave de cifrado: ");
fgets(claveCifrado, MAX_LINE,stdin);
alarm(0);
flagTiempo=1;
claveCifrado[strlen(claveCifrado)-1]='\0';
}while(charvalidos(claveCifrado)==-1);
/*
* Inicialización de la mascara del sigsuspend() del cronometro
* y del pipe que utilizaran los procesos que lo necesiten.
*/
sigfillset(&maskImprime);
sigdelset(&maskImprime,SIGBUS);
pipe(miPipe);
do{
/*
* Captura de la frase a codificar.
* Se añade '\0' al final para su manipulación posterior.
*/
alarm(60);
flagTiempo=0;
printf("Frase a codificar: ");
fgets(fraseOriginal, MAX_LINE,stdin);
printf("\n\n");
flagTiempo=1;
fraseOriginal[strlen(fraseOriginal)-1]='\0';
alarm(0);
PIDcronometro = fork();
if(PIDcronometro==-1){
printf("Error al crear el proceso Cronometro\n");
exit(-1);
}
if(PIDcronometro==0){
/**********************************************************************
**************************PROCESO CRONOMETRO***************************
**********************************************************************/
gettimeofday(&comienzo,NULL);
/* El inicio de todos los procesos es practicamente
* en el mismo instante de tiempo */
signal(SIGUSR1,finalTiempoCodificador);
signal(SIGUSR2,finalTiempoCoutPalb);
signal(SIGFPE,finalTiempoCountChar);
signal(SIGXFSZ,finalTiempoCoutCharnoCod);
signal(SIGBUS, imprimeTiempos);
/* Espera a que el proceso padre le de la señal de imprimir (SIGBUS) */
sigsuspend(&maskImprime);
printf("-Y por último los tiempos de cada proceso en el mismo\n");
printf("orden que las impresiones anteriores: %lf, %lf, %lf, %lf \n\n\n",
(double)DIFFTIME(TiempoCodificador,comienzo)*0.000001,
(double)DIFFTIME(TiempoCoutPalb,comienzo)*0.000001,
(double)DIFFTIME(TiempoCountChar,comienzo)*0.000001,
(double)DIFFTIME(TiempoCoutCharnoCod,comienzo)*0.000001);
exit(0);
}
if(PIDcronometro>0){
PIDcifrador = fork();
if(PIDcifrador==-1){
printf("Error al crear el proceso Codificador\n");
exit(-1);
}
if(PIDcifrador==0){
/**********************************************************************
**************************PROCESO CODIFICADOR**************************
**********************************************************************/
Cifrado=vignere(claveCifrado,fraseOriginal);
printf("Codificado: %s\n",Cifrado);
free(Cifrado);
kill(PIDcronometro, SIGUSR1);
exit(0);
}
if(PIDcifrador>0){
PIDcontPalabras = fork();
if(PIDcontPalabras==-1){
printf("Error al crear el proceso Contador de Palabras\n");
exit(-1);
}
if(PIDcontPalabras==0){
/**********************************************************************
**************************PROCESO CONT PALABRAS************************
**********************************************************************/
/* Comienza el proceso */
numPalabras=cuentapalab(fraseOriginal);
kill(PIDcronometro, SIGUSR2); /* Proceso finalizado */
exit(numPalabras);
}
if(PIDcontPalabras>0){
PIDcontCaracteres= fork();
if(PIDcontCaracteres==-1){
printf("Error al crear el proceso Contador de Caracteres\n");
exit(-1);
}
if(PIDcontCaracteres==0){
/**********************************************************************
**************************PROCESO CONT CARACTER************************
**********************************************************************/
/* Comienza el proceso */
numCaracteres=cuentachar(fraseOriginal);
kill(PIDcronometro,SIGFPE);
exit(numCaracteres);
}
if(PIDcontCaracteres>0){
PIDnoCifrados= fork();
if(PIDnoCifrados==-1){
printf("Error al crear el proceso Caracteres no Cifrados\n");
exit(-1);
}
if(PIDnoCifrados==0){
/**********************************************************************
**********************PROCESO CARACTER NOCIFRADOS**********************
**********************************************************************/
noEncriptados=noencripchar(fraseOriginal);
/* Escribe en el pipe el resultado de la operacion */
write(miPipe[1],noEncriptados,strlen(noEncriptados)+1);
free(noEncriptados);
kill(PIDcronometro, SIGXFSZ);
exit(0);
}
}
}
}
/*
* El padre espera a la finalización de todos sus hijos
* de forma ordenada.
*/
waitpid(PIDcifrador,&estadoaux,0);
waitpid(PIDcontPalabras,&estadoPIDcontPalabras,0);
if (WIFEXITED(estadoPIDcontPalabras)!=0)/*Ha terminado con exit()*/
numPalabras=WEXITSTATUS(estadoPIDcontPalabras);
waitpid(PIDcontCaracteres,&estadoPIDcontCaracteres,0);
if (WIFEXITED(estadoPIDcontCaracteres)!=0)/*Ha terminado con exit()*/
numCaracteres=WEXITSTATUS(estadoPIDcontCaracteres);
waitpid(PIDnoCifrados,&estadoaux,0);
/* Lee el resultado del proceso NoCifrados del pipe */
read(miPipe[0], readbuffer, sizeof(readbuffer));
/* Impresión por pantalla de los resultados */
printf("-Después el conteo de palabras: El numero de palabras es %d\n", numPalabras);
printf("-Luego el número de letras: El numero de caracteres es %d\n", numCaracteres);
printf("-A continuación cuantos caracteres no se han encriptado: %s \n",readbuffer);
/* Por ultimo, envia la señal de impresion al cronometro */
kill(PIDcronometro,SIGBUS);
waitpid(PIDcronometro,&estadoaux,0);
}
}while(1);
exit(0);
}