--- rpl/src/rpl.c 2010/04/28 11:05:45 1.22 +++ rpl/src/rpl.c 2012/12/17 21:22:44 1.127 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.15 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.11 + Copyright (C) 1989-2012 Dr. BERTRAND Joël This file is part of RPL/2. @@ -21,7 +21,7 @@ #define MAIN_RPL -#include "rpl.conv.h" +#include "rpl-conv.h" /* @@ -31,16 +31,25 @@ */ 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" +# 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; int option_P; - int status; logical1 core; logical1 debug; @@ -71,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; @@ -99,22 +115,24 @@ rplinit(int argc, char *argv[], unsigned volatile int erreur; volatile unsigned char traitement_fichier_temporaire; + errno = 0; + s_queue_signaux = NULL; + routine_recursive = 0; + pid_processus_pere = getpid(); + +# ifdef DEBUG_MEMOIRE + debug_memoire_initialisation(); +# endif + setvbuf(stdout, NULL, _IOLBF, 0); setvbuf(stderr, NULL, _IOLBF, 0); # ifndef SEMAPHORES_NOMMES - sem_init(&semaphore_liste_threads, 0, 1); sem_init(&semaphore_gestionnaires_signaux, 0, 0); - sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1); # else - semaphore_liste_threads = sem_init2(1, sem_liste_threads); - semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux); - semaphore_gestionnaires_signaux_atomique = sem_init2(1, - sem_gestionnaires_signaux_atomique); - - if ((semaphore_liste_threads == SEM_FAILED) || - (semaphore_gestionnaires_signaux == SEM_FAILED) || - (semaphore_gestionnaires_signaux_atomique == SEM_FAILED)) + semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX); + + if (semaphore_gestionnaires_signaux == SEM_FAILED) { erreur = d_es_allocation_memoire; @@ -140,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) @@ -171,25 +197,142 @@ 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; - insertion_thread(s_etat_processus, d_vrai); - pthread_mutexattr_init(&attributs_mutex); pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex); pthread_mutexattr_destroy(&attributs_mutex); + pthread_mutexattr_init(&attributs_mutex); + pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); + pthread_mutex_init(&((*s_etat_processus).mutex_allocation), + &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); + # ifndef SEMAPHORES_NOMMES - sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); + sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); # else - if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) == - SEM_FAILED) + 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"); + } + else + { + uprintf("+++System : Not enough memory\n"); + } + + return(EXIT_FAILURE); + } +# endif + + pthread_mutexattr_init(&attributs_mutex); + pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); + pthread_mutex_init(&((*s_etat_processus).protection_liste_mutexes), + &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); + + 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); + if ((*s_etat_processus).langue == 'F') { uprintf("+++Système : Mémoire insuffisante\n"); @@ -201,27 +344,48 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } -# endif - pthread_mutexattr_init(&attributs_mutex); - pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); - pthread_mutex_init(&((*s_etat_processus).protection_liste_mutexes), - &attributs_mutex); - pthread_mutexattr_destroy(&attributs_mutex); + 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); - (*s_etat_processus).s_liste_variables_partagees = &s_variables_partagees; + if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + + 1) * sizeof(unsigned char))) == NULL) + { + if ((*s_etat_processus).langue == 'F') + { + uprintf("+++Système : Mémoire insuffisante\n"); + } + else + { + uprintf("+++System : Not enough memory\n"); + } - s_variables_partagees.nombre_variables = 0; - s_variables_partagees.nombre_variables_allouees = 0; - s_variables_partagees.table = NULL; + return(EXIT_FAILURE); + } - 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); + strcpy((*s_etat_processus).localisation, d_locale); + } - localisation_courante(s_etat_processus); (*s_etat_processus).erreur_systeme = d_es; if ((*s_etat_processus).localisation == NULL) @@ -229,6 +393,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"); @@ -249,11 +430,11 @@ rplinit(int argc, char *argv[], unsigned if ((*s_etat_processus).langue == 'F') { - printf("+++Copyright (C) 1989 à 2009, 2010 BERTRAND Joël\n"); + printf("+++Copyright (C) 1989 à 2011, 2012 BERTRAND Joël\n"); } else { - printf("+++Copyright (C) 1989 to 2009, 2010 BERTRAND Joel\n"); + printf("+++Copyright (C) 1989 to 2011, 2012 BERTRAND Joel\n"); } if (getenv("HOME") != NULL) @@ -278,89 +459,168 @@ rplinit(int argc, char *argv[], unsigned home = ""; } - // Initialisation d'une clef +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + 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 - if (pthread_key_create(&semaphore_fork_processus_courant, NULL) != 0) - { - if ((*s_etat_processus).langue == 'F') - { - printf("+++Système : Mémoire insuffisante\n"); - } - else - { - printf("+++System : Not enough memory\n"); - } + liberation_contexte_cas(s_etat_processus); + liberation_queue_signaux(s_etat_processus); - return(EXIT_FAILURE); - } + erreur = d_es_signal; -# ifndef SEMAPHORES_NOMMES - if (pthread_setspecific(semaphore_fork_processus_courant, - &((*s_etat_processus).semaphore_fork)) != 0) + if ((*s_etat_processus).langue == 'F') + { + printf("+++Système : Initialisation de la pile alternative " + "impossible\n"); + } + else + { + printf("+++System : Initialization of alternate " + "stack failed\n"); + } + + return(EXIT_FAILURE); + } # else - if (pthread_setspecific(semaphore_fork_processus_courant, - (*s_etat_processus).semaphore_fork) != 0) -# endif - { if ((*s_etat_processus).langue == 'F') { - printf("+++Système : Mémoire insuffisante\n"); + printf("+++Attention : Le système ne supporte pas de pile " + "alternative\n"); } else { - printf("+++System : Not enough memory\n"); + printf("+++Warning : Operating system does not support alternate " + "stack\n"); } +# endif - return(EXIT_FAILURE); - } - - // Initialisation d'une pile de signal pour récupérer les - // débordement de pile - -# ifndef Cygwin - if (((*s_etat_processus).pile_signal.ss_sp = - malloc((*s_etat_processus).pile_signal.ss_size = - SIGSTKSZ)) == NULL) + if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur) { - erreur = d_es_allocation_memoire; +# 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 : Mémoire insuffisante\n"); + printf("+++Système : Initialisation des signaux POSIX " + "impossible\n"); } else { - printf("+++System : Not enough memory\n"); + printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } - (*s_etat_processus).pile_signal.ss_flags = 0; + action.sa_handler = interruption1; + action.sa_flags = 0; - if (sigaltstack(&((*s_etat_processus).pile_signal), NULL) != 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') { - printf("+++Système : Initialisation de la pile spécifique de signal" - " impossible\n"); + printf("+++Système : Initialisation des signaux POSIX " + "impossible\n"); } else { - printf("+++System : Initialization of signal stack failed\n"); + printf("+++System : Initialization of POSIX signals failed\n"); } return(EXIT_FAILURE); } -# endif - action.sa_sigaction = interruption1; - action.sa_flags = SA_ONSTACK | SA_SIGINFO; + signal_test = SIGTEST; + kill(getpid(), SIGINT); - if (sigaction(SIGINT, &action, NULL) != 0) + 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') @@ -376,11 +636,31 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption2; - action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; - - if (sigaction(SIGTSTP, &action, NULL) != 0) + 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') { printf("+++Système : Initialisation des signaux POSIX " @@ -394,11 +674,42 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption4; - action.sa_flags = SA_ONSTACK | SA_SIGINFO; + signal_test = SIGTEST; + kill(getpid(), SIGTERM); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } - if (sigaction(SIGSTART, &action, NULL) != 0) + 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 " @@ -412,8 +723,31 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - if (sigaction(SIGCONT, &action, NULL) != 0) + 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 " @@ -427,11 +761,40 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption5; - action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; + signal_test = SIGTEST; + kill(getpid(), SIGALRM); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } - if (sigaction(SIGFSTOP, &action, NULL) != 0) + 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') @@ -447,12 +810,31 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption5; - action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; + action.sa_handler = interruption2; + action.sa_flags = 0; - if (sigaction(SIGFABORT, &action, NULL) != 0) + if (sigaction(SIGTSTP, &action, NULL) != 0) { - erreur = d_es_signal; +# 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') { @@ -467,11 +849,40 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption8; - action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; + signal_test = SIGTEST; + kill(getpid(), SIGTSTP); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; + + for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++) + { + nanosleep(&attente, NULL); + } - if (sigaction(SIGURG, &action, NULL) != 0) + 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') @@ -487,11 +898,32 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption7; - action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; + action.sa_handler = interruption5; + action.sa_flags = 0; 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') @@ -507,11 +939,40 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption6; - action.sa_flags = SA_ONSTACK | SA_SIGINFO; + signal_test = SIGTEST; + kill(getpid(), SIGPIPE); + + attente.tv_sec = 0; + attente.tv_nsec = 1000000; - if (sigaction(SIGINJECT, &action, NULL) != 0) + 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') @@ -527,11 +988,32 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption9; - action.sa_flags = SA_ONSTACK | SA_SIGINFO; + action.sa_handler = interruption1; + action.sa_flags = 0; - if (sigaction(SIGABORT, &action, NULL) != 0) + 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') @@ -547,11 +1029,40 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption1; - action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; + signal_test = SIGTEST; + kill(getpid(), SIGUSR1); - if (sigaction(SIGALRM, &action, NULL) != 0) + 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') @@ -567,11 +1078,7 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - action.sa_sigaction = interruption3; - action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO; - - (*s_etat_processus).chemin_fichiers_temporaires = - recherche_chemin_fichiers_temporaires(s_etat_processus); + signal_test = SIGTEST + 1; erreur = d_absence_erreur; core = d_faux; @@ -619,6 +1126,15 @@ rplinit(int argc, char *argv[], unsigned option_t = d_faux; option_v = d_faux; + // Lorsque le programme est appelé depuis un shebang, argv[0] contient + // le chemin du programme et argv[1] tous les arguments. + // argv[2] contient quant à lui le nom du script RPL/2. + // + // Exemple : + // argv[0] : /usr/local/bin/rpl + // argv[1] : -csdp -t 800 + // argv[2] : ./on_exit.rpl + while((--argc) > 0) { if ((*(++argv))[0] == '-') @@ -631,6 +1147,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 " @@ -653,6 +1191,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 " @@ -677,6 +1237,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 " @@ -713,6 +1300,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 " @@ -744,6 +1358,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 " @@ -765,6 +1401,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 " @@ -788,6 +1446,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 " @@ -811,6 +1491,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 " @@ -833,6 +1535,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 " @@ -856,6 +1580,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 " @@ -871,6 +1617,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 " @@ -886,6 +1654,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 " @@ -910,6 +1700,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 " @@ -942,6 +1754,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 " @@ -965,6 +1799,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 " @@ -980,6 +1836,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 " @@ -1003,6 +1881,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 " @@ -1026,6 +1926,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 " @@ -1049,6 +1971,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 " @@ -1064,6 +2008,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 " @@ -1089,6 +2055,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 " @@ -1123,6 +2116,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 " @@ -1151,6 +2171,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 " @@ -1169,6 +2211,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 " @@ -1194,6 +2258,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 " @@ -1219,6 +2305,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 " @@ -1253,6 +2366,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 " @@ -1280,6 +2420,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 " @@ -1323,6 +2485,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 " @@ -1346,6 +2542,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 " @@ -1368,6 +2586,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 " @@ -1414,6 +2654,12 @@ rplinit(int argc, char *argv[], unsigned break; } + case '-': + case ' ': + { + break; + } + default : { if ((*s_etat_processus).langue == 'F') @@ -1458,10 +2704,133 @@ rplinit(int argc, char *argv[], unsigned } } + /* + * Dans le cas où le programme est appelé avec l'option -d, + * on ne récupère par les signaux de violation d'accès. On + * tente simplement la récupération des dépassements de pile. + */ + 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') + { + printf("+++Système : Initialisation de la pile alternative " + "impossible\n"); + } + else + { + printf("+++System : Initialization of alternate " + "stack failed\n"); + } + + return(EXIT_FAILURE); + } +# else + action.sa_handler = interruption3; + action.sa_flags = 0; + 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 " + "impossible\n"); + } + else + { + printf("+++System : Initialization of POSIX signals " + "failed\n"); + } + + return(EXIT_FAILURE); + } + + signal_test = SIGTEST; + kill(getpid(), 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') { printf("+++Système : Initialisation des signaux POSIX " @@ -1475,9 +2844,42 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } +# 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 " @@ -1491,15 +2893,103 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } + + signal_test = SIGTEST; + kill(getpid(), 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') + { + printf("+++Système : Initialisation des signaux POSIX " + "impossible\n"); + } + else + { + printf("+++System : Initialization of POSIX signals " + "failed\n"); + } + + return(EXIT_FAILURE); + } + } if (option_n == d_vrai) { - action.sa_sigaction = interruption10; - action.sa_flags = SA_ONSTACK | SA_SIGINFO; + action.sa_handler = interruption4; + action.sa_flags = 0; 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 " @@ -1542,6 +3032,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"); @@ -1557,6 +3076,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"); @@ -1571,6 +3119,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"); @@ -1586,6 +3163,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"); @@ -1600,6 +3206,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"); @@ -1637,6 +3272,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') @@ -1669,6 +3332,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"); @@ -1706,16 +3397,27 @@ 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; (*s_etat_processus).affichage_arguments = 'N'; (*s_etat_processus).autorisation_conversion_chaine = 'Y'; (*s_etat_processus).autorisation_evaluation_nom = 'Y'; - (*s_etat_processus).autorisation_nom_implicite = 'Y'; + + if (mode_interactif == d_vrai) + { + (*s_etat_processus).autorisation_nom_implicite = 'Y'; + } + else + { + (*s_etat_processus).autorisation_nom_implicite = 'N'; + } + (*s_etat_processus).autorisation_empilement_programme = 'N'; (*s_etat_processus).requete_arret = 'N'; (*s_etat_processus).evaluation_forcee = 'N'; + (*s_etat_processus).recherche_type = 'N'; (*s_etat_processus).constante_symbolique = 'N'; (*s_etat_processus).traitement_symbolique = 'N'; @@ -1727,19 +3429,23 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus).l_base_pile = NULL; (*s_etat_processus).l_base_pile_last = NULL; - (*s_etat_processus).s_liste_variables = NULL; + (*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_etat_processus).nombre_variables = 0; - (*s_etat_processus).nombre_variables_allouees = 0; - (*s_etat_processus).s_liste_variables_statiques = NULL; - (*s_etat_processus).nombre_variables_statiques = 0; - (*s_etat_processus).nombre_variables_statiques_allouees = 0; + 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).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_courante = 0; - (*s_etat_processus).position_variable_statique_courante = 0; (*s_etat_processus).s_bibliotheques = NULL; (*s_etat_processus).s_instructions_externes = NULL; @@ -1861,14 +3567,18 @@ rplinit(int argc, char *argv[], unsigned } (*s_etat_processus).at_exit = NULL; + (*s_etat_processus).at_poke = NULL; + (*s_etat_processus).traitement_at_poke = 'N'; (*s_etat_processus).pointeurs_caracteres = NULL; (*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; + (*s_etat_processus).var_volatile_processus_racine = -1; (*s_etat_processus).var_volatile_traitement_retarde_stop = 0; (*s_etat_processus).var_volatile_alarme = 0; (*s_etat_processus).var_volatile_requete_arret = 0; @@ -1878,12 +3588,44 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus).var_volatile_recursivite = 0; (*s_etat_processus).var_volatile_exception_gsl = 0; (*s_etat_processus).arret_depuis_abort = 0; + (*s_etat_processus).pointeur_signal_lecture = 0; + (*s_etat_processus).pointeur_signal_ecriture = 0; initialisation_allocateur(s_etat_processus); initialisation_drapeaux(s_etat_processus); + initialisation_variables(s_etat_processus); + initialisation_instructions(s_etat_processus); 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"); @@ -1897,8 +3639,36 @@ rplinit(int argc, char *argv[], unsigned } if (((*s_etat_processus).instruction_derniere_erreur = - malloc(2 * sizeof(unsigned char))) == NULL) + 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') @@ -1928,6 +3698,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') @@ -1948,7 +3746,7 @@ rplinit(int argc, char *argv[], unsigned free((*s_etat_processus).instruction_courante); - if ((*s_etat_processus).erreur_systeme == d_es_allocation_memoire) + if ((*s_etat_processus).erreur_systeme != d_es) { erreur = d_es_allocation_memoire; } @@ -1957,12 +3755,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) && @@ -1992,6 +3788,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') @@ -2016,6 +3840,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') @@ -2068,6 +3920,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') @@ -2096,6 +3976,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') @@ -2156,20 +4064,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'; @@ -2178,6 +4072,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 :" @@ -2209,6 +4132,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) @@ -2266,8 +4217,36 @@ rplinit(int argc, char *argv[], unsigned (*s_etat_processus).position_courante = 0; (*s_etat_processus).traitement_cycle_exit = 'N'; - if ((*s_etat_processus).nombre_variables == 0) + 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"); @@ -2288,6 +4267,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"); @@ -2309,6 +4316,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"); @@ -2326,10 +4361,37 @@ rplinit(int argc, char *argv[], unsigned return(EXIT_FAILURE); } - if ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante].niveau != 0) + 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"); @@ -2355,6 +4417,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') @@ -2373,6 +4463,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); @@ -2389,6 +4484,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') @@ -2414,8 +4543,6 @@ rplinit(int argc, char *argv[], unsigned fflush(stdout); - initialisation_instructions(s_etat_processus); - if (arguments != NULL) { tampon = (*s_etat_processus).definitions_chainees; @@ -2427,6 +4554,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') @@ -2444,6 +4605,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 " @@ -2467,6 +4662,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) { @@ -2497,6 +4721,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') @@ -2516,6 +4774,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); } @@ -2526,6 +4813,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') @@ -2545,6 +4867,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); } @@ -2556,6 +4907,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') @@ -2576,6 +4966,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); } @@ -2585,6 +5010,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') @@ -2605,6 +5069,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); } } @@ -2632,6 +5130,20 @@ rplinit(int argc, char *argv[], unsigned if (setjmp(contexte_initial) == 0) { erreur = sequenceur(s_etat_processus); + + if (erreur == d_absence_erreur) + { + if (((*s_etat_processus).var_volatile_alarme + == 0) && ((*s_etat_processus) + .arret_depuis_abort == 0) && + ((*s_etat_processus).at_exit + != NULL)) + { + erreur = evaluation(s_etat_processus, + (*s_etat_processus).at_exit, + 'E'); + } + } } } else @@ -2639,25 +5151,32 @@ rplinit(int argc, char *argv[], unsigned if (setjmp(contexte_initial) == 0) { erreur = sequenceur_optimise(s_etat_processus); - } - } - if (erreur == d_absence_erreur) - { - if (((*s_etat_processus).var_volatile_alarme == 0) - && ((*s_etat_processus).arret_depuis_abort - == 0) && ((*s_etat_processus).at_exit - != NULL)) - { - erreur = evaluation(s_etat_processus, - (*s_etat_processus).at_exit, 'E'); + if (erreur == d_absence_erreur) + { + if (((*s_etat_processus).var_volatile_alarme + == 0) && ((*s_etat_processus) + .arret_depuis_abort == 0) && + ((*s_etat_processus).at_exit + != NULL)) + { + erreur = evaluation(s_etat_processus, + (*s_etat_processus).at_exit, + 'E'); + } + } } } + } - liberation(s_etat_processus, - (*s_etat_processus).at_exit); + 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); + if ((*s_etat_processus).generateur_aleatoire != NULL) { liberation_generateur_aleatoire(s_etat_processus); @@ -2666,16 +5185,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); @@ -2767,27 +5276,30 @@ rplinit(int argc, char *argv[], unsigned { if ((*s_etat_processus).var_volatile_alarme != 0) { - kill((*(*((struct_processus_fils *) + envoi_signal_processus( + (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) - .thread).pid, SIGURG); + .thread).pid, rpl_sigurg); } else { if ((*s_etat_processus).arret_depuis_abort == -1) { - kill((*(*((struct_processus_fils *) + envoi_signal_processus( + (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) - .thread).pid, SIGFABORT); + .thread).pid, rpl_sigabort); } else { - kill((*(*((struct_processus_fils *) + envoi_signal_processus( + (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) - .thread).pid, SIGFSTOP); + .thread).pid, rpl_sigstop); } } } @@ -2806,31 +5318,32 @@ rplinit(int argc, char *argv[], unsigned if ((*s_etat_processus).var_volatile_alarme != 0) { - pthread_kill((*(*((struct_processus_fils *) + envoi_signal_thread( + (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee).objet)) - .thread).tid, SIGURG); + .thread).tid, rpl_sigurg); } else { if ((*s_etat_processus).arret_depuis_abort == -1) { - pthread_kill( + envoi_signal_thread( (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee) .objet)).thread).tid, - SIGFABORT); + rpl_sigabort); } else { - pthread_kill( + envoi_signal_thread( (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) l_element_courant)).donnee) .objet)).thread).tid, - SIGFSTOP); + rpl_sigstop); } } } @@ -2859,18 +5372,9 @@ rplinit(int argc, char *argv[], unsigned while((*s_etat_processus).l_base_pile_processus != NULL) { - status = 0; - l_element_courant = (void *) (*s_etat_processus).l_base_pile_processus; - if ((*s_etat_processus) - .nombre_interruptions_non_affectees != 0) - { - affectation_interruptions_logicielles( - s_etat_processus); - } - for(i = 0; i < (unsigned long) (*(*((struct_processus_fils *) (*(*((struct_liste_chainee *) @@ -2892,11 +5396,50 @@ rplinit(int argc, char *argv[], unsigned .thread).nombre_objets_dans_pipe--; action.sa_handler = SIG_IGN; - action.sa_flags = SA_ONSTACK; + action.sa_flags = 0; 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); @@ -2921,6 +5464,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); @@ -2929,7 +5511,16 @@ rplinit(int argc, char *argv[], unsigned } pthread_mutex_unlock(&((*s_etat_processus).mutex)); + + if ((*s_etat_processus) + .nombre_interruptions_non_affectees != 0) + { + affectation_interruptions_logicielles( + s_etat_processus); + } + nanosleep(&attente, NULL); + scrutation_interruptions(s_etat_processus); pthread_mutex_lock(&((*s_etat_processus).mutex)); } @@ -3083,40 +5674,34 @@ rplinit(int argc, char *argv[], unsigned * le libérer... */ - for(i = 0; i < (*s_etat_processus).nombre_variables; i++) - { - liberation(s_etat_processus, - (*s_etat_processus).s_liste_variables[i].objet); - free((*s_etat_processus).s_liste_variables[i].nom); - } + 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); - free((*s_etat_processus).s_liste_variables); + l_element_statique_courant = (*s_etat_processus) + .l_liste_variables_statiques; - for(i = 0; i < (*s_etat_processus) - .nombre_variables_statiques; i++) + 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(). @@ -3398,8 +5983,6 @@ rplinit(int argc, char *argv[], unsigned l_element_courant = l_element_suivant; } - free((*s_etat_processus).chemin_fichiers_temporaires); - l_element_courant = (*s_etat_processus).s_marques; while(l_element_courant != NULL) { @@ -3436,11 +6019,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); } @@ -3451,48 +6030,65 @@ rplinit(int argc, char *argv[], unsigned } } -# ifndef Cygwin - free((*s_etat_processus).pile_signal.ss_sp); -# endif - 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); + # ifndef SEMAPHORES_NOMMES sem_post(&((*s_etat_processus).semaphore_fork)); sem_destroy(&((*s_etat_processus).semaphore_fork)); # else sem_post((*s_etat_processus).semaphore_fork); - sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork); + sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(), + SEM_FORK); # endif free((*s_etat_processus).localisation); - free(s_etat_processus); # ifndef SEMAPHORES_NOMMES - sem_destroy(&semaphore_liste_threads); -# else - sem_destroy2(semaphore_liste_threads, sem_liste_threads); -# endif -# ifndef SEMAPHORES_NOMMES sem_post(&semaphore_gestionnaires_signaux); sem_destroy(&semaphore_gestionnaires_signaux); - sem_destroy(&semaphore_gestionnaires_signaux_atomique); # else sem_post(semaphore_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux); - sem_destroy2(semaphore_gestionnaires_signaux_atomique, - sem_gestionnaires_signaux_atomique); + sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX); # endif + destruction_queue_signaux(s_etat_processus); + 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 - debug_memoire_verification(s_etat_processus); + debug_memoire_verification(); + analyse_post_mortem(); +# endif + +# ifdef HAVE_STACK_OVERFLOW_RECOVERY + stackoverflow_deinstall_handler(); +# endif + +# ifdef HAVE_SIGSEGV_RECOVERY + if (debug == d_faux) + { + sigsegv_deinstall_handler(); + } # endif return((erreur == d_absence_erreur) ? EXIT_SUCCESS : EXIT_FAILURE); @@ -3517,7 +6113,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"); @@ -3538,7 +6134,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"); @@ -3550,4 +6146,72 @@ informations(struct_processus *s_etat_pr return; } + +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() +{ + unsigned char *date; + + if ((date = malloc((strlen(d_date_en_rpl) + 1) * sizeof(unsigned char))) + == NULL) + { + return(NULL); + } + + strcpy(date, d_date_en_rpl); + + return(date); +} + // vim: ts=4