[BACK]Return to rpl.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/rpl.c between versions 1.36 and 1.49

version 1.36, 2010/08/06 15:33:04 version 1.49, 2010/09/06 16:50:17
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.18    RPL/2 (R) version 4.0.19
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2010 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 23 Line 23
 #define  MAIN_RPL  #define  MAIN_RPL
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
 #ifdef OS2  #ifdef IPCS_SYSV
   #ifndef OS2
     unsigned char       *chemin_semaphores_SysV;      unsigned char       *chemin_semaphores_SysV;
 #endif  #endif
   #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 102  rplinit(int argc, char *argv[], unsigned Line 105  rplinit(int argc, char *argv[], unsigned
     volatile int                        erreur;      volatile int                        erreur;
     volatile unsigned char              traitement_fichier_temporaire;      volatile unsigned char              traitement_fichier_temporaire;
   
       errno = 0;
   
 #   ifdef DEBUG_MEMOIRE  #   ifdef DEBUG_MEMOIRE
     debug_memoire_initialisation();      debug_memoire_initialisation();
 #   endif  #   endif
Line 184  rplinit(int argc, char *argv[], unsigned Line 189  rplinit(int argc, char *argv[], unsigned
   
     (*s_etat_processus).rpl_home = rpl_home;      (*s_etat_processus).rpl_home = rpl_home;
   
     insertion_thread(s_etat_processus, d_vrai);  
   
     pthread_mutexattr_init(&attributs_mutex);      pthread_mutexattr_init(&attributs_mutex);
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);      pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
     pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex);      pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex);
Line 234  rplinit(int argc, char *argv[], unsigned Line 237  rplinit(int argc, char *argv[], unsigned
             .mutex), &attributs_mutex);              .mutex), &attributs_mutex);
     pthread_mutexattr_destroy(&attributs_mutex);      pthread_mutexattr_destroy(&attributs_mutex);
   
       (*s_etat_processus).chemin_fichiers_temporaires =
               recherche_chemin_fichiers_temporaires(s_etat_processus);
   
   #   ifdef IPCS_SYSV
   #   ifndef OS2
       chemin_semaphores_SysV = (*s_etat_processus).chemin_fichiers_temporaires;
   #   endif
   #   endif
   
   #   ifdef _BROKEN_SIGINFO
       creation_fifos_signaux(s_etat_processus);
   #   ifdef return
   #       undef return
   #   endif
   #   define return destruction_fifos_signaux(s_etat_processus); return
   #   endif
   
       insertion_thread(s_etat_processus, d_vrai);
   
   #   ifndef OS2
     localisation_courante(s_etat_processus);      localisation_courante(s_etat_processus);
   #   else
       if ((*s_etat_processus).erreur_systeme != d_es)
       {
           if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) *
                   sizeof(unsigned char))) == NULL)
           {
               if ((*s_etat_processus).langue == 'F')
               {
                   uprintf("+++Système : Mémoire insuffisante\n");
               }
               else
               {
                   uprintf("+++System : Not enough memory\n");
               }
   
               return(EXIT_FAILURE);
           }
   
           strcpy((*s_etat_processus).localisation, d_locale);
       }
   #   endif
   
     (*s_etat_processus).erreur_systeme = d_es;      (*s_etat_processus).erreur_systeme = d_es;
   
     if ((*s_etat_processus).localisation == NULL)      if ((*s_etat_processus).localisation == NULL)
Line 330  rplinit(int argc, char *argv[], unsigned Line 375  rplinit(int argc, char *argv[], unsigned
     // Initialisation d'une pile de signal pour récupérer les      // Initialisation d'une pile de signal pour récupérer les
     // débordement de pile      // débordement de pile
   
 #   if !defined(Cygwin)  #   if !defined(Cygwin) && !defined(OpenBSD)
     if (((*s_etat_processus).pile_signal.ss_sp =      if (((*s_etat_processus).pile_signal.ss_sp =
             malloc((*s_etat_processus).pile_signal.ss_size =              malloc((*s_etat_processus).pile_signal.ss_size =
             SIGSTKSZ)) == NULL)              SIGSTKSZ)) == NULL)
Line 369  rplinit(int argc, char *argv[], unsigned Line 414  rplinit(int argc, char *argv[], unsigned
     }      }
 #   endif  #   endif
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption1;      action.sa_sigaction = interruption1;
     action.sa_flags = SA_ONSTACK | SA_SIGINFO;  #   else
       action.sa_handler = interruption1;
   #   endif
       action.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_NODEFER;
   
     if (sigaction(SIGINT, &action, NULL) != 0)      if (sigaction(SIGINT, &action, NULL) != 0)
     {      {
Line 389  rplinit(int argc, char *argv[], unsigned Line 438  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption2;      action.sa_sigaction = interruption2;
   #   else
       action.sa_handler = interruption2;
   #   endif
     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;      action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
   
     if (sigaction(SIGTSTP, &action, NULL) != 0)      if (sigaction(SIGTSTP, &action, NULL) != 0)
Line 407  rplinit(int argc, char *argv[], unsigned Line 460  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption4;      action.sa_sigaction = interruption4;
     action.sa_flags = SA_ONSTACK | SA_SIGINFO;  #   else
       action.sa_handler = interruption4;
   #   endif
       action.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_NODEFER;
   
     if (sigaction(SIGSTART, &action, NULL) != 0)      if (sigaction(SIGSTART, &action, NULL) != 0)
     {      {
Line 440  rplinit(int argc, char *argv[], unsigned Line 497  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption5;      action.sa_sigaction = interruption5;
   #   else
       action.sa_handler = interruption5;
   #   endif
     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;      action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
   
     if (sigaction(SIGFSTOP, &action, NULL) != 0)      if (sigaction(SIGFSTOP, &action, NULL) != 0)
Line 460  rplinit(int argc, char *argv[], unsigned Line 521  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption11;      action.sa_sigaction = interruption11;
   #   else
       action.sa_handler = interruption11;
   #   endif
     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;      action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
   
     if (sigaction(SIGFABORT, &action, NULL) != 0)      if (sigaction(SIGFABORT, &action, NULL) != 0)
Line 480  rplinit(int argc, char *argv[], unsigned Line 545  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption8;      action.sa_sigaction = interruption8;
   #   else
       action.sa_handler = interruption8;
   #   endif
     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;      action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
   
     if (sigaction(SIGURG, &action, NULL) != 0)      if (sigaction(SIGURG, &action, NULL) != 0)
Line 500  rplinit(int argc, char *argv[], unsigned Line 569  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption7;      action.sa_sigaction = interruption7;
   #   else
       action.sa_handler = interruption7;
   #   endif
     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;      action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
   
     if (sigaction(SIGPIPE, &action, NULL) != 0)      if (sigaction(SIGPIPE, &action, NULL) != 0)
Line 520  rplinit(int argc, char *argv[], unsigned Line 593  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption6;      action.sa_sigaction = interruption6;
     action.sa_flags = SA_ONSTACK | SA_SIGINFO;  #   else
       action.sa_handler = interruption6;
   #   endif
       action.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_NODEFER;
   
     if (sigaction(SIGINJECT, &action, NULL) != 0)      if (sigaction(SIGINJECT, &action, NULL) != 0)
     {      {
Line 540  rplinit(int argc, char *argv[], unsigned Line 617  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption9;      action.sa_sigaction = interruption9;
     action.sa_flags = SA_ONSTACK | SA_SIGINFO;  #   else
       action.sa_handler = interruption9;
   #   endif
       action.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_NODEFER;
   
     if (sigaction(SIGABORT, &action, NULL) != 0)      if (sigaction(SIGABORT, &action, NULL) != 0)
     {      {
Line 560  rplinit(int argc, char *argv[], unsigned Line 641  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption1;      action.sa_sigaction = interruption1;
   #   else
       action.sa_handler = interruption1;
   #   endif
     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;      action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
   
     if (sigaction(SIGALRM, &action, NULL) != 0)      if (sigaction(SIGALRM, &action, NULL) != 0)
Line 580  rplinit(int argc, char *argv[], unsigned Line 665  rplinit(int argc, char *argv[], unsigned
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
   #   ifndef _BROKEN_SIGINFO
     action.sa_sigaction = interruption3;      action.sa_sigaction = interruption3;
     action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;  #   else
       action.sa_handler = interruption3;
     (*s_etat_processus).chemin_fichiers_temporaires =  
             recherche_chemin_fichiers_temporaires(s_etat_processus);  
   
 #   ifdef OS2  
     chemin_semaphores_SysV = (*s_etat_processus).chemin_fichiers_temporaires;  
 #   endif  #   endif
       action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
   
     erreur = d_absence_erreur;      erreur = d_absence_erreur;
     core = d_faux;      core = d_faux;
Line 1512  rplinit(int argc, char *argv[], unsigned Line 1594  rplinit(int argc, char *argv[], unsigned
   
         if (option_n == d_vrai)          if (option_n == d_vrai)
         {          {
   #           ifndef _BROKEN_SIGINFO
             action.sa_sigaction = interruption10;              action.sa_sigaction = interruption10;
             action.sa_flags = SA_ONSTACK | SA_SIGINFO;  #           else
               action.sa_handler = interruption10;
   #           endif
               action.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_NODEFER;
   
             if (sigaction(SIGHUP, &action, NULL) != 0)              if (sigaction(SIGHUP, &action, NULL) != 0)
             {              {
Line 1888  rplinit(int argc, char *argv[], unsigned Line 1974  rplinit(int argc, char *argv[], unsigned
             (*s_etat_processus).pid_processus_pere = getpid();              (*s_etat_processus).pid_processus_pere = getpid();
             (*s_etat_processus).processus_detache = d_vrai;              (*s_etat_processus).processus_detache = d_vrai;
             (*s_etat_processus).var_volatile_processus_pere = -1;              (*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_traitement_retarde_stop = 0;
             (*s_etat_processus).var_volatile_alarme = 0;              (*s_etat_processus).var_volatile_alarme = 0;
             (*s_etat_processus).var_volatile_requete_arret = 0;              (*s_etat_processus).var_volatile_requete_arret = 0;
Line 1967  rplinit(int argc, char *argv[], unsigned Line 2054  rplinit(int argc, char *argv[], unsigned
   
             free((*s_etat_processus).instruction_courante);              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;                  erreur = d_es_allocation_memoire;
             }              }
Line 3418  rplinit(int argc, char *argv[], unsigned Line 3505  rplinit(int argc, char *argv[], unsigned
                         l_element_courant = l_element_suivant;                          l_element_courant = l_element_suivant;
                     }                      }
   
                     free((*s_etat_processus).chemin_fichiers_temporaires);  
   
                     l_element_courant = (*s_etat_processus).s_marques;                      l_element_courant = (*s_etat_processus).s_marques;
                     while(l_element_courant != NULL)                      while(l_element_courant != NULL)
                     {                      {
Line 3471  rplinit(int argc, char *argv[], unsigned Line 3556  rplinit(int argc, char *argv[], unsigned
         }          }
     }      }
   
 #   ifndef Cygwin  #   if !defined(Cygwin) && !defined(OpenBSD)
     (*s_etat_processus).pile_signal.ss_flags = SS_DISABLE;      (*s_etat_processus).pile_signal.ss_flags = SS_DISABLE;
     sigaltstack(&((*s_etat_processus).pile_signal), NULL);      sigaltstack(&((*s_etat_processus).pile_signal), NULL);
     free((*s_etat_processus).pile_signal.ss_sp);      free((*s_etat_processus).pile_signal.ss_sp);
Line 3514  rplinit(int argc, char *argv[], unsigned Line 3599  rplinit(int argc, char *argv[], unsigned
             sem_gestionnaires_signaux_atomique);              sem_gestionnaires_signaux_atomique);
 #   endif  #   endif
   
   #   ifdef _BROKEN_SIGINFO
       destruction_fifos_signaux(s_etat_processus);
   #   undef return
   #   endif
   
       free((*s_etat_processus).chemin_fichiers_temporaires);
     free(s_etat_processus);      free(s_etat_processus);
   
 #   ifdef DEBUG_MEMOIRE  #   ifdef DEBUG_MEMOIRE
Removed from v.1.36  
changed lines
  Added in v.1.49

CVSweb interface <joel.bertrand@systella.fr>