--- rpl/src/rpl.c 2011/11/26 10:01:33 1.98 +++ rpl/src/rpl.c 2013/02/26 19:56:17 1.134 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.5 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.12 + Copyright (C) 1989-2013 Dr. BERTRAND Joël This file is part of RPL/2. @@ -31,15 +31,21 @@ */ int -rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home) +rplinit(int argc, char *argv[], char *envp[], + unsigned char ***resultats, char *rpl_home) { # include "copyright-conv.h" # include "licence-conv.h" + char **arg_exec; + # ifdef HAVE_STACK_OVERFLOW_RECOVERY char pile_signaux[SIGSTKSZ]; # endif +# define RPL_PATH_MAX 1024 + char repertoire_initial[RPL_PATH_MAX]; + file *f_source; int erreur_historique; @@ -74,7 +80,14 @@ rplinit(int argc, char *argv[], unsigned struct_processus *s_etat_processus; - struct_table_variables_partagees s_variables_partagees; + struct_liste_variables_partagees *l_element_partage_courant; + struct_liste_variables_partagees *l_element_partage_suivant; + + struct_liste_variables_statiques *l_element_statique_courant; + struct_liste_variables_statiques *l_element_statique_suivant; + + struct_arbre_variables_partagees *s_arbre_variables_partagees; + struct_liste_variables_partagees *l_liste_variables_partagees; struct sigaction action; struct sigaction registre; @@ -145,6 +158,14 @@ rplinit(int argc, char *argv[], unsigned if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); +# else + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); +# endif + erreur = d_es_allocation_memoire; if ((langue = getenv("LANG")) != NULL) @@ -176,12 +197,64 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus).langue = 'E'; } + if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL) + { +# ifndef SEMAPHORES_NOMMES + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); +# else + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); +# endif + + if ((*s_etat_processus).langue == 'F') + { + uprintf("+++Système : Mémoire insuffisante\n"); + } + else + { + uprintf("+++System : Not enough memory\n"); + } + + return(EXIT_FAILURE); + } + + if ((arg_exec = malloc((argc + 1) * sizeof(char *))) == NULL) + { +# ifndef SEMAPHORES_NOMMES + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); +# else + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); +# endif + + if ((*s_etat_processus).langue == 'F') + { + uprintf("+++Système : Mémoire insuffisante\n"); + } + else + { + uprintf("+++System : Not enough memory\n"); + } + + return(EXIT_FAILURE); + } + + for(i = 0; i < (unsigned long) argc; i++) + { + arg_exec[i] = argv[i]; + } + + argv[argc] = NULL; + initialisation_contexte_cas(s_etat_processus); (*s_etat_processus).exception = d_ep; (*s_etat_processus).erreur_systeme = d_es; (*s_etat_processus).erreur_execution = d_ex; + (*s_etat_processus).requete_redemarrage = d_faux; (*s_etat_processus).rpl_home = rpl_home; pthread_mutexattr_init(&attributs_mutex); @@ -195,12 +268,33 @@ rplinit(int argc, char *argv[], unsigned &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); + pthread_mutexattr_init(&attributs_mutex); + pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex); + pthread_mutexattr_destroy(&attributs_mutex); + + pthread_mutexattr_init(&attributs_mutex); + pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex); + pthread_mutexattr_destroy(&attributs_mutex); + # ifndef SEMAPHORES_NOMMES sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); # else if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(), pthread_self(), SEM_FORK)) == SEM_FAILED) { +# ifndef SEMAPHORES_NOMMES + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); +# else + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); +# endif + + liberation(contexte_cas(s_etat_processus); + if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); @@ -220,31 +314,67 @@ rplinit(int argc, char *argv[], unsigned &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); - (*s_etat_processus).s_liste_variables_partagees = &s_variables_partagees; - - s_variables_partagees.nombre_variables = 0; - s_variables_partagees.nombre_variables_allouees = 0; - s_variables_partagees.table = NULL; - - pthread_mutexattr_init(&attributs_mutex); - pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); - pthread_mutex_init(&((*((*s_etat_processus).s_liste_variables_partagees)) - .mutex), &attributs_mutex); - pthread_mutexattr_destroy(&attributs_mutex); - (*s_etat_processus).chemin_fichiers_temporaires = recherche_chemin_fichiers_temporaires(s_etat_processus); insertion_thread(s_etat_processus, d_vrai); creation_queue_signaux(s_etat_processus); -# ifndef OS2 - localisation_courante(s_etat_processus); -# else if ((*s_etat_processus).erreur_systeme != d_es) { - if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) * - sizeof(unsigned char))) == NULL) +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + + if ((*s_etat_processus).langue == 'F') + { + uprintf("+++Système : Mémoire insuffisante\n"); + } + else + { + uprintf("+++System : Not enough memory\n"); + } + + return(EXIT_FAILURE); + } + + if (d_forced_locale == 0) + { + localisation_courante(s_etat_processus); + } + else + { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + + if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + + 1) * sizeof(unsigned char))) == NULL) { if ((*s_etat_processus).langue == 'F') { @@ -260,7 +390,6 @@ rplinit(int argc, char *argv[], unsigned strcpy((*s_etat_processus).localisation, d_locale); } -# endif (*s_etat_processus).erreur_systeme = d_es; @@ -269,6 +398,23 @@ rplinit(int argc, char *argv[], unsigned if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) * sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); @@ -289,11 +435,11 @@ rplinit(int argc, char *argv[], unsigned if ((*s_etat_processus).langue == 'F') { - printf("+++Copyright (C) 1989 à 2010, 2011 BERTRAND Joël\n"); + printf("+++Copyright (C) 1989 à 2012, 2013 BERTRAND Joël\n"); } else { - printf("+++Copyright (C) 1989 to 2010, 2011 BERTRAND Joel\n"); + printf("+++Copyright (C) 1989 to 2012, 2013 BERTRAND Joel\n"); } if (getenv("HOME") != NULL) @@ -322,6 +468,23 @@ rplinit(int argc, char *argv[], unsigned if (stackoverflow_install_handler(interruption_depassement_pile, pile_signaux, sizeof(pile_signaux)) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -350,11 +513,70 @@ rplinit(int argc, char *argv[], unsigned } # endif + if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur) + { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + erreur = d_es_signal; + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Initialisation des signaux POSIX " + "impossible\n"); + } + else + { + printf("+++System : Initialization of POSIX signals failed\n"); + } + + return(EXIT_FAILURE); + } + action.sa_handler = interruption1; action.sa_flags = 0; if (sigaction(SIGINT, &action, NULL) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -371,10 +593,39 @@ rplinit(int argc, char *argv[], unsigned } signal_test = SIGTEST; - kill(getpid(), SIGINT); + raise(SIGINT); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } if (signal_test != SIGINT) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -392,6 +643,27 @@ rplinit(int argc, char *argv[], unsigned if (sigaction(SIGTERM, &action, NULL) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -408,10 +680,126 @@ rplinit(int argc, char *argv[], unsigned } signal_test = SIGTEST; - kill(getpid(), SIGTERM); + raise(SIGTERM); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } if (signal_test != SIGTERM) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + erreur = d_es_signal; + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Initialisation des signaux POSIX " + "impossible\n"); + } + else + { + printf("+++System : Initialization of POSIX signals failed\n"); + } + + return(EXIT_FAILURE); + } + + if (sigaction(SIGALRM, &action, NULL) != 0) + { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + + erreur = d_es_signal; + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Initialisation des signaux POSIX " + "impossible\n"); + } + else + { + printf("+++System : Initialization of POSIX signals failed\n"); + } + + return(EXIT_FAILURE); + } + + signal_test = SIGTEST; + raise(SIGALRM); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } + + if (signal_test != SIGALRM) + { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -432,6 +820,27 @@ rplinit(int argc, char *argv[], unsigned if (sigaction(SIGTSTP, &action, NULL) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation des signaux POSIX " @@ -446,10 +855,39 @@ rplinit(int argc, char *argv[], unsigned } signal_test = SIGTEST; - kill(getpid(), SIGTSTP); + raise(SIGTSTP); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } if (signal_test != SIGTSTP) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -470,6 +908,27 @@ rplinit(int argc, char *argv[], unsigned if (sigaction(SIGPIPE, &action, NULL) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -486,10 +945,39 @@ rplinit(int argc, char *argv[], unsigned } signal_test = SIGTEST; - kill(getpid(), SIGPIPE); + raise(SIGPIPE); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } if (signal_test != SIGPIPE) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -510,6 +998,27 @@ rplinit(int argc, char *argv[], unsigned if (sigaction(SIGUSR1, &action, NULL) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -526,10 +1035,39 @@ rplinit(int argc, char *argv[], unsigned } signal_test = SIGTEST; - kill(getpid(), SIGUSR1); + raise(SIGUSR1); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } if (signal_test != SIGUSR1) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), + SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -614,6 +1152,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_a == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -a présente " @@ -636,6 +1196,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_A == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -A présente " @@ -660,6 +1242,33 @@ rplinit(int argc, char *argv[], unsigned if ((arguments = malloc((strlen(argv[0]) + 7) * sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " @@ -696,6 +1305,33 @@ rplinit(int argc, char *argv[], unsigned if ((arguments = malloc((strlen(argv[0]) + 7) * sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " @@ -727,6 +1363,28 @@ rplinit(int argc, char *argv[], unsigned } else { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : Aucune donnée " @@ -748,6 +1406,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_c == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -c présente " @@ -771,6 +1451,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_d == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -d présente " @@ -794,6 +1496,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_D == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -D présente " @@ -816,6 +1540,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_h == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -h présente " @@ -839,6 +1585,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_i == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -i présente " @@ -854,6 +1622,28 @@ rplinit(int argc, char *argv[], unsigned } else if (option_S == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : options -i et -S " @@ -869,6 +1659,28 @@ rplinit(int argc, char *argv[], unsigned } else if (option_p == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : options -i et -p " @@ -893,6 +1705,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_l == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -l présente " @@ -925,6 +1759,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_n == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -n présente " @@ -948,6 +1804,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_p == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -p présente " @@ -963,6 +1841,28 @@ rplinit(int argc, char *argv[], unsigned } else if (option_i == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : options -i et -p " @@ -986,6 +1886,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_P > 2) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -P présente " @@ -1009,6 +1931,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_s == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -s présente " @@ -1032,6 +1976,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_S == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -S présente " @@ -1047,6 +2013,28 @@ rplinit(int argc, char *argv[], unsigned } else if (option_i == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : options -i et -S " @@ -1072,6 +2060,33 @@ rplinit(int argc, char *argv[], unsigned malloc((strlen(argv[0]) + 1) * sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " @@ -1106,6 +2121,33 @@ rplinit(int argc, char *argv[], unsigned malloc((strlen(argv[0]) + 1) * sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " @@ -1134,6 +2176,28 @@ rplinit(int argc, char *argv[], unsigned } else { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : Aucun script " @@ -1152,6 +2216,28 @@ rplinit(int argc, char *argv[], unsigned compactage((*s_etat_processus) .definitions_chainees)) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " @@ -1177,6 +2263,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_t == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -t présente " @@ -1202,6 +2310,33 @@ rplinit(int argc, char *argv[], unsigned if ((type_debug = malloc((strlen(argv[0]) + 1) * sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " @@ -1236,6 +2371,33 @@ rplinit(int argc, char *argv[], unsigned malloc((strlen(argv[0]) + 1) * sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire " @@ -1263,6 +2425,28 @@ rplinit(int argc, char *argv[], unsigned } else { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : Aucun niveau " @@ -1306,6 +2490,40 @@ rplinit(int argc, char *argv[], unsigned default: { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post( + &semaphore_gestionnaires_signaux + ); + sem_destroy( + &semaphore_gestionnaires_signaux + ); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post( + semaphore_gestionnaires_signaux + ); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas( + s_etat_processus); + liberation_queue_signaux( + s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : Niveau " @@ -1329,6 +2547,28 @@ rplinit(int argc, char *argv[], unsigned if (sscanf(type_debug, "%llX", &((*s_etat_processus).type_debug)) != 1) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : Niveau " @@ -1351,6 +2591,28 @@ rplinit(int argc, char *argv[], unsigned { if (option_v == d_vrai) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : option -v présente " @@ -1455,10 +2717,31 @@ rplinit(int argc, char *argv[], unsigned if (debug == d_faux) { - # ifdef HAVE_SIGSEGV_RECOVERY if (sigsegv_install_handler(interruption_violation_access) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -1480,6 +2763,28 @@ rplinit(int argc, char *argv[], unsigned if (sigaction(SIGSEGV, &action, NULL) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation des signaux POSIX " @@ -1495,10 +2800,40 @@ rplinit(int argc, char *argv[], unsigned } signal_test = SIGTEST; - kill(getpid(), SIGSEGV); + raise(SIGSEGV); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } if (signal_test != SIGSEGV) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -1516,8 +2851,40 @@ rplinit(int argc, char *argv[], unsigned } # endif + action.sa_handler = interruption3; + action.sa_flags = 0; + if (sigaction(SIGBUS, &action, NULL) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation des signaux POSIX " @@ -1533,10 +2900,47 @@ rplinit(int argc, char *argv[], unsigned } signal_test = SIGTEST; - kill(getpid(), SIGBUS); + raise(SIGBUS); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } if (signal_test != SIGBUS) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_signal; if ((*s_etat_processus).langue == 'F') @@ -1562,6 +2966,35 @@ rplinit(int argc, char *argv[], unsigned if (sigaction(SIGHUP, &action, NULL) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Initialisation des signaux POSIX " @@ -1604,6 +3037,35 @@ rplinit(int argc, char *argv[], unsigned creation_nom_fichier(s_etat_processus, (*s_etat_processus) .chemin_fichiers_temporaires)) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Fichier indisponible\n"); @@ -1619,6 +3081,35 @@ rplinit(int argc, char *argv[], unsigned if ((f_source = fopen(nom_fichier_temporaire, "w")) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Fichier introuvable\n"); @@ -1633,6 +3124,35 @@ rplinit(int argc, char *argv[], unsigned if (fprintf(f_source, "MODE_INTERACTIF\n") < 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Erreur d'écriture dans un fichier\n"); @@ -1648,6 +3168,35 @@ rplinit(int argc, char *argv[], unsigned if (fprintf(f_source, "<< DO HALT UNTIL FALSE END >>\n") < 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Erreur d'écriture dans un fichier\n"); @@ -1662,6 +3211,35 @@ rplinit(int argc, char *argv[], unsigned if (fclose(f_source) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Fichier indisponible\n"); @@ -1699,6 +3277,34 @@ rplinit(int argc, char *argv[], unsigned if (((existence == d_faux) || (erreur_fichier != d_absence_erreur)) && (option_S == d_faux)) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if (presence_definition == 'O') { if ((*s_etat_processus).langue == 'F') @@ -1731,6 +3337,34 @@ rplinit(int argc, char *argv[], unsigned if ((*s_etat_processus).chemin_fichiers_temporaires == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Chemin des fichiers temporaires nul\n"); @@ -1768,6 +3402,7 @@ rplinit(int argc, char *argv[], unsigned gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL); (*s_etat_processus).liste_mutexes = NULL; + (*s_etat_processus).sections_critiques = 0; (*s_etat_processus).test_instruction = 'N'; (*s_etat_processus).nombre_arguments = 0; @@ -1801,16 +3436,21 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus).s_arbre_variables = NULL; (*s_etat_processus).l_liste_variables_par_niveau = NULL; + (*s_etat_processus).l_liste_variables_statiques = NULL; (*s_etat_processus).gel_liste_variables = d_faux; + s_arbre_variables_partagees = NULL; + l_liste_variables_partagees = NULL; + (*s_etat_processus).s_arbre_variables_partagees = + &s_arbre_variables_partagees; + (*s_etat_processus).l_liste_variables_partagees = + &l_liste_variables_partagees; (*s_etat_processus).pointeur_variable_courante = NULL; - (*s_etat_processus).s_liste_variables_statiques = NULL; - (*s_etat_processus).nombre_variables_statiques = 0; - (*s_etat_processus).nombre_variables_statiques_allouees = 0; + (*s_etat_processus).pointeur_variable_statique_courante = NULL; + (*s_etat_processus).pointeur_variable_partagee_courante = NULL; (*s_etat_processus).niveau_courant = 0; (*s_etat_processus).niveau_initial = 0; (*s_etat_processus).creation_variables_statiques = d_faux; (*s_etat_processus).creation_variables_partagees = d_faux; - (*s_etat_processus).position_variable_statique_courante = 0; (*s_etat_processus).s_bibliotheques = NULL; (*s_etat_processus).s_instructions_externes = NULL; @@ -1939,6 +3579,7 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus).arbre_instructions = NULL; (*s_etat_processus).tid_processus_pere = pthread_self(); + (*s_etat_processus).tid = pthread_self(); (*s_etat_processus).pid_processus_pere = getpid(); (*s_etat_processus).processus_detache = d_vrai; (*s_etat_processus).var_volatile_processus_pere = -1; @@ -1962,6 +3603,34 @@ rplinit(int argc, char *argv[], unsigned if ((*s_etat_processus).erreur_systeme != d_es) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Système : Mémoire insuffisante\n"); @@ -1977,6 +3646,34 @@ rplinit(int argc, char *argv[], unsigned if (((*s_etat_processus).instruction_derniere_erreur = malloc(sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2006,6 +3703,34 @@ rplinit(int argc, char *argv[], unsigned if (((*s_etat_processus).instruction_courante = (unsigned char *) malloc(sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2035,12 +3760,10 @@ rplinit(int argc, char *argv[], unsigned (*((*s_etat_processus).l_base_pile_systeme)) .retour_definition = 'Y'; - (*s_etat_processus).indep = (struct_objet *) malloc( - sizeof(struct_objet)); - (*s_etat_processus).depend = (struct_objet *) malloc( - sizeof(struct_objet)); + (*s_etat_processus).indep = allocation(s_etat_processus, NON); + (*s_etat_processus).depend = allocation(s_etat_processus, NON); (*s_etat_processus).parametres_courbes_de_niveau = - (struct_objet *) malloc(sizeof(struct_objet)); + allocation(s_etat_processus, NON); if (((*s_etat_processus).indep != NULL) && ((*s_etat_processus).depend != NULL) && @@ -2070,6 +3793,34 @@ rplinit(int argc, char *argv[], unsigned ((*((*s_etat_processus). parametres_courbes_de_niveau)).objet == NULL)) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2094,6 +3845,34 @@ rplinit(int argc, char *argv[], unsigned (*((*s_etat_processus).depend)).objet)).nom == NULL)) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2146,6 +3925,34 @@ rplinit(int argc, char *argv[], unsigned .parametres_courbes_de_niveau)).objet)).donnee == NULL)) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2174,6 +3981,34 @@ rplinit(int argc, char *argv[], unsigned .objet = malloc(10 * sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2234,20 +4069,6 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus).my2_lines = d_faux; (*s_etat_processus).mz2_lines = d_faux; - if ((*s_etat_processus).erreur_systeme != d_es) - { - if ((*s_etat_processus).langue == 'F') - { - printf("+++Système : Mémoire insuffisante\n"); - } - else - { - printf("+++System : Not enough memory\n"); - } - - return(EXIT_FAILURE); - } - (*s_etat_processus).mode_evaluation_expression = 'N'; (*s_etat_processus).mode_execution_programme = 'Y'; @@ -2256,6 +4077,35 @@ rplinit(int argc, char *argv[], unsigned if ((erreur = chainage(s_etat_processus)) != d_absence_erreur) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Fatal :" @@ -2287,6 +4137,34 @@ rplinit(int argc, char *argv[], unsigned if ((erreur = compilation(s_etat_processus)) != d_absence_erreur) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if (traitement_fichier_temporaire == 'Y') { if (destruction_fichier(nom_fichier_temporaire) @@ -2346,6 +4224,34 @@ rplinit(int argc, char *argv[], unsigned if ((*s_etat_processus).s_arbre_variables == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Fatal : Aucun point d'entrée\n"); @@ -2366,6 +4272,34 @@ rplinit(int argc, char *argv[], unsigned if (recherche_instruction_suivante(s_etat_processus) == d_erreur) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Fatal : Aucun point d'entrée\n"); @@ -2387,6 +4321,34 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus) .instruction_courante) == d_faux) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Fatal : Aucun point d'entrée\n"); @@ -2407,6 +4369,34 @@ rplinit(int argc, char *argv[], unsigned if ((*(*s_etat_processus).pointeur_variable_courante) .niveau != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Fatal : Aucun point d'entrée\n"); @@ -2432,6 +4422,34 @@ rplinit(int argc, char *argv[], unsigned strlen(ds_fichier_historique) + 2) * sizeof(unsigned char))) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus).semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2450,6 +4468,11 @@ rplinit(int argc, char *argv[], unsigned home, ds_fichier_historique); using_history(); + + // Pour pouvoir utiliser le keymap avant le premier + // appel à readline(). + rl_initialize(); + erreur_historique = read_history( (*s_etat_processus).nom_fichier_historique); @@ -2466,6 +4489,40 @@ rplinit(int argc, char *argv[], unsigned if ((message = messages(s_etat_processus)) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2502,6 +4559,40 @@ rplinit(int argc, char *argv[], unsigned { if ((*s_etat_processus).erreur_systeme != d_es) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2519,6 +4610,40 @@ rplinit(int argc, char *argv[], unsigned } else { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((*s_etat_processus).langue == 'F') { printf("+++Erreur : Erreur de " @@ -2542,6 +4667,35 @@ rplinit(int argc, char *argv[], unsigned if ((*s_etat_processus).erreur_systeme != d_es) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + if ((message = messages(s_etat_processus)) == NULL) { @@ -2572,6 +4726,40 @@ rplinit(int argc, char *argv[], unsigned if ((message = messages(s_etat_processus)) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2591,6 +4779,35 @@ rplinit(int argc, char *argv[], unsigned printf("%s [%d]\n", message, (int) getpid()); free(message); +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + return(EXIT_FAILURE); } @@ -2601,6 +4818,41 @@ rplinit(int argc, char *argv[], unsigned if ((message = messages(s_etat_processus)) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + + erreur = d_es_allocation_memoire; erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2620,6 +4872,35 @@ rplinit(int argc, char *argv[], unsigned printf("%s [%d]\n", message, (int) getpid()); free(message); +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus).semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy(&semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus).semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2(semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus).semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + return(EXIT_FAILURE); } @@ -2631,6 +4912,45 @@ rplinit(int argc, char *argv[], unsigned if ((message = messages(s_etat_processus)) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post( + &semaphore_gestionnaires_signaux + ); + sem_destroy( + &semaphore_gestionnaires_signaux + ); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post( + semaphore_gestionnaires_signaux + ); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2651,6 +4971,41 @@ rplinit(int argc, char *argv[], unsigned (int) getpid()); free(message); +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + + erreur = d_es_allocation_memoire; return(EXIT_FAILURE); } @@ -2660,6 +5015,45 @@ rplinit(int argc, char *argv[], unsigned if ((message = messages(s_etat_processus)) == NULL) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post( + &semaphore_gestionnaires_signaux + ); + sem_destroy( + &semaphore_gestionnaires_signaux + ); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post( + semaphore_gestionnaires_signaux + ); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + erreur = d_es_allocation_memoire; if ((*s_etat_processus).langue == 'F') @@ -2680,6 +5074,40 @@ rplinit(int argc, char *argv[], unsigned (int) getpid()); free(message); +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post(&semaphore_gestionnaires_signaux); + sem_destroy( + &semaphore_gestionnaires_signaux); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post(semaphore_gestionnaires_signaux); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, + getpid(), pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + return(EXIT_FAILURE); } } @@ -2746,6 +5174,11 @@ rplinit(int argc, char *argv[], unsigned } } + for(i = 0; i < (*s_etat_processus).sections_critiques; i++) + { + pthread_mutex_unlock(&mutex_sections_critiques); + } + liberation(s_etat_processus, (*s_etat_processus).at_exit); liberation(s_etat_processus, (*s_etat_processus).at_poke); @@ -2757,16 +5190,6 @@ rplinit(int argc, char *argv[], unsigned l_element_courant = (*s_etat_processus).liste_mutexes; while(l_element_courant != NULL) { - pthread_mutex_trylock(&((*((struct_mutex *) - (*(*((struct_liste_chainee *) - l_element_courant)).donnee).objet)).mutex)); - pthread_mutex_unlock(&((*((struct_mutex *) - (*(*((struct_liste_chainee *) - l_element_courant)).donnee).objet)).mutex)); - pthread_mutex_destroy(&((*((struct_mutex *) - (*(*((struct_liste_chainee *) - l_element_courant)).donnee).objet)).mutex)); - liberation(s_etat_processus, (*((struct_liste_chainee *) l_element_courant)).donnee); @@ -2983,6 +5406,45 @@ rplinit(int argc, char *argv[], unsigned if (sigaction(SIGPIPE, &action, ®istre) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post( + &semaphore_gestionnaires_signaux + ); + sem_destroy( + &semaphore_gestionnaires_signaux + ); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post( + semaphore_gestionnaires_signaux + ); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + pthread_mutex_unlock( &((*s_etat_processus).mutex)); return(EXIT_FAILURE); @@ -3007,6 +5469,45 @@ rplinit(int argc, char *argv[], unsigned if (sigaction(SIGPIPE, ®istre, NULL) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_etat_processus) + .semaphore_fork)); + sem_post( + &semaphore_gestionnaires_signaux + ); + sem_destroy( + &semaphore_gestionnaires_signaux + ); + sem_destroy(&((*s_etat_processus) + .semaphore_fork)); +# else + sem_post((*s_etat_processus) + .semaphore_fork); + sem_post( + semaphore_gestionnaires_signaux + ); + sem_destroy2( + semaphore_gestionnaires_signaux, + getpid(), SEM_SIGNAUX); + sem_destroy3((*s_etat_processus) + .semphore_fork, getpid(), + pthread_self(), SEM_FORK); +# endif + + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } +# endif + pthread_mutex_unlock( &((*s_etat_processus).mutex)); return(EXIT_FAILURE); @@ -3178,35 +5679,34 @@ rplinit(int argc, char *argv[], unsigned * le libérer... */ + liberation_arbre_variables_partagees(s_etat_processus, + (*(*s_etat_processus).s_arbre_variables_partagees)); liberation_arbre_variables(s_etat_processus, (*s_etat_processus).s_arbre_variables, d_vrai); free((*s_etat_processus).pointeurs_caracteres_variables); - for(i = 0; i < (*s_etat_processus) - .nombre_variables_statiques; i++) + l_element_statique_courant = (*s_etat_processus) + .l_liste_variables_statiques; + + while(l_element_statique_courant != NULL) { - liberation(s_etat_processus, (*s_etat_processus) - .s_liste_variables_statiques[i].objet); - free((*s_etat_processus) - .s_liste_variables_statiques[i].nom); + l_element_statique_suivant = + (*l_element_statique_courant).suivant; + free(l_element_statique_courant); + l_element_statique_courant = l_element_statique_suivant; } - free((*s_etat_processus).s_liste_variables_statiques); + l_element_partage_courant = (*(*s_etat_processus) + .l_liste_variables_partagees); - for(i = 0; i < (*((*s_etat_processus) - .s_liste_variables_partagees)).nombre_variables; - i++) + while(l_element_partage_courant != NULL) { - liberation(s_etat_processus, (*((*s_etat_processus) - .s_liste_variables_partagees)).table[i].objet); - free((*((*s_etat_processus) - .s_liste_variables_partagees)).table[i].nom); + l_element_partage_suivant = + (*l_element_partage_courant).suivant; + free(l_element_partage_courant); + l_element_partage_courant = l_element_partage_suivant; } - free((struct_variable_partagee *) - (*((*s_etat_processus).s_liste_variables_partagees)) - .table); - /* * Si resultats est non nul, rplinit a été appelé * depuis rpl() [librpl] et non main(). @@ -3524,11 +6024,7 @@ rplinit(int argc, char *argv[], unsigned if (traitement_fichier_temporaire == 'Y') { - if (destruction_fichier(nom_fichier_temporaire) == d_erreur) - { - return(EXIT_FAILURE); - } - + destruction_fichier(nom_fichier_temporaire); free(nom_fichier_temporaire); } @@ -3542,13 +6038,13 @@ rplinit(int argc, char *argv[], unsigned closelog(); pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes)); - pthread_mutex_destroy(&((*((*s_etat_processus).s_liste_variables_partagees)) - .mutex)); retrait_thread(s_etat_processus); pthread_mutex_destroy(&((*s_etat_processus).mutex)); pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation)); + pthread_mutex_destroy(&mutex_sections_critiques); + pthread_mutex_destroy(&mutex_liste_variables_partagees); # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); @@ -3561,9 +6057,6 @@ rplinit(int argc, char *argv[], unsigned free((*s_etat_processus).localisation); - pthread_mutex_destroy(&mutex_liste_threads); - pthread_mutex_destroy(&mutex_gestionnaires_signaux_atomique); - # ifndef SEMAPHORES_NOMMES sem_post(&semaphore_gestionnaires_signaux); sem_destroy(&semaphore_gestionnaires_signaux); @@ -3576,6 +6069,16 @@ rplinit(int argc, char *argv[], unsigned liberation_contexte_cas(s_etat_processus); free((*s_etat_processus).chemin_fichiers_temporaires); + + if ((*s_etat_processus).requete_redemarrage == d_vrai) + { + chdir(repertoire_initial); + execvp(arg_exec[0], &(arg_exec[0])); + erreur = d_erreur; + } + + free(arg_exec); + arret_thread_signaux(s_etat_processus); free(s_etat_processus); # ifdef DEBUG_MEMOIRE @@ -3616,7 +6119,7 @@ informations(struct_processus *s_etat_pr printf(" -l : licence d'utilisation\n"); printf(" -n : ignorance du signal HUP\n"); printf(" -p : précompilation du script avant exécution\n"); - printf(" -P : profilage\n"); + printf(" -P : profilage (-P ou -PP)\n"); printf(" -s : empêchement de l'ouverture de l'écran initial\n"); printf(" -S : exécution du script passé en ligne de commande\n"); printf(" -t : trace\n"); @@ -3637,7 +6140,7 @@ informations(struct_processus *s_etat_pr printf(" -l : prints the user licence of the software\n"); printf(" -n : ignores HUP signal\n"); printf(" -p : precompiles script\n"); - printf(" -P : computes profile data\n"); + printf(" -P : computes profile data (-P or -PP)\n"); printf(" -s : disables splash screen\n"); printf(" -S : executes script written in command line\n"); printf(" -t : enables tracing mode\n"); @@ -3650,6 +6153,57 @@ informations(struct_processus *s_etat_pr } +logical1 +controle_integrite(struct_processus *s_etat_processus, + unsigned char *executable_candidat, unsigned char *executable) +{ + unsigned char *md5; + unsigned char *sha1; + + if (strcmp(executable, "rplpp") == 0) + { + md5 = rplpp_md5; + sha1 = rplpp_sha1; + } + else if (strcmp(executable, "rplfile") == 0) + { + md5 = rplfile_md5; + sha1 = rplfile_sha1; + } + else if (strcmp(executable, "rpliconv") == 0) + { + md5 = rpliconv_md5; + sha1 = rpliconv_sha1; + } + else if (strcmp(executable, "rplawk") == 0) + { + md5 = rplawk_md5; + sha1 = rplawk_sha1; + } + else if (strcmp(executable, "rplconvert") == 0) + { + md5 = rplconvert_md5; + sha1 = rplconvert_sha1; + } + else + { + return(d_faux); + } + + if (controle(s_etat_processus, executable_candidat, "md5", md5) != d_vrai) + { + return(d_faux); + } + + if (controle(s_etat_processus, executable_candidat, "sha1", sha1) != d_vrai) + { + return(d_faux); + } + + return(d_vrai); +} + + unsigned char * date_compilation() {