Changeset 143 for trunk/src


Ignore:
Timestamp:
Oct 31, 2007, 1:09:26 AM (17 years ago)
Author:
rainer
Message:

Bugfixes and threaded process check.

Location:
trunk/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/samhain.c

    r142 r143  
    114114volatile  int      sh_global_suspend_flag;
    115115volatile  int      sig_fresh_trail;        /* SIGIOT  */
     116volatile  int      sh_thread_pause_flag = S_FALSE;
    116117volatile  int      sig_config_read_again;  /* SIGHUP  */
    117118volatile  int      sig_terminate;          /* SIGQUIT */
    … …  
    17241725              sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_RECONF);
    17251726
     1727              sh_thread_pause_flag = S_TRUE;
     1728
    17261729#if defined(WITH_EXTERNAL)
    17271730              /* delete list of external tasks
    … …  
    17931796                  sh.flag.loop     = S_FALSE;
    17941797                }
     1798
     1799              sh_thread_pause_flag = S_FALSE;
    17951800
    17961801              /* --- Initialize modules. ---
    … …  
    18291834          if (sig_fresh_trail == 1) /* SIGIOT */
    18301835            {
    1831               /* Logfile access
    1832                */
     1836              if (sh_global_suspend_flag == 0)
     1837                {
     1838                  SH_MUTEX_LOCK(mutex_thread_nolog);
     1839
     1840                  /* Logfile access
     1841                   */
    18331842#ifdef SH_USE_XML
    1834               (void) sh_log_file (NULL, NULL);
    1835 #endif
    1836               TPT((0, FIL__, __LINE__, _("msg=<Logfile stop/restart.>\n")));
    1837               sh_error_only_stderr (S_TRUE);
    1838               (void) sh_unix_rm_lock_file(sh.srvlog.name);
    1839               (void) retry_msleep(3, 0);
    1840               sh.flag.log_start = S_TRUE;
    1841               sh_error_only_stderr (S_FALSE);
    1842               sig_fresh_trail       = 0;
    1843               --sig_raised;
     1843                  (void) sh_log_file (NULL, NULL);
     1844#endif
     1845                  TPT((0, FIL__, __LINE__, _("msg=<Logfile stop/restart.>\n")));
     1846                  sh_error_only_stderr (S_TRUE);
     1847                  (void) sh_unix_rm_lock_file(sh.srvlog.name);
     1848                  (void) retry_msleep(3, 0);
     1849                  sh.flag.log_start = S_TRUE;
     1850                  sh_error_only_stderr (S_FALSE);
     1851                  sh_thread_pause_flag = S_FALSE;
     1852                  sig_fresh_trail       = 0;
     1853                  --sig_raised;
     1854                  SH_MUTEX_UNLOCK(mutex_thread_nolog);
     1855                }
    18441856            }
    18451857         
    … …  
    18631875            {
    18641876              TPT((0, FIL__, __LINE__, _("msg=<Suspend switch.>\n")));
    1865               if (sh_global_suspend_flag == 1) {
    1866                 sh_global_suspend_flag = 0;
    1867               } else {
     1877              if (sh_global_suspend_flag != 1) {
     1878                SH_MUTEX_LOCK_UNSAFE(mutex_thread_nolog);
     1879                sh_global_suspend_flag = 1;
    18681880                sh_error_handle((-1), FIL__, __LINE__, 0, MSG_SUSPEND,
    18691881                                sh.prg_name);
    1870                 sh_global_suspend_flag = 1;
     1882              } else {
     1883                sh_global_suspend_flag = 0;
     1884                SH_MUTEX_UNLOCK_UNSAFE(mutex_thread_nolog);
    18711885              }
    18721886              --sig_suspend_switch;

  • trunk/src/sh_kern.c

    r140 r143  
    968968  if (df)
    969969    {
    970       SH_MUTEX_LOCK(mutex_readdir);
    971 
    972       while (NULL != (entry = readdir(df)))
     970      while (1)
    973971        {
     972          SH_MUTEX_LOCK(mutex_readdir);
     973          entry = readdir(df);
     974          SH_MUTEX_UNLOCK(mutex_readdir);
     975
     976          if (entry == NULL)
     977            break;
     978
    974979          if (0 == strcmp(entry->d_name, ".") &&
    975980              0 == strcmp(entry->d_name, ".."))
    … …  
    981986          SH_FREE(pcipath);
    982987        }
    983 
    984       SH_MUTEX_UNLOCK(mutex_readdir);
    985988
    986989      closedir(df);

  • trunk/src/sh_mem.c

    r140 r143  
    108108
    109109#ifdef HAVE_PTHREAD
    110 
    111110SH_MUTEX_RECURSIVE(mutex_mem);
    112 
    113 #else
    114 #define MEM_MUTEX_INIT ((void)0)
    115111#endif
    116112

  • trunk/src/sh_processcheck.c

    r140 r143  
    6464#include "sh_extern.h"
    6565#include "sh_calls.h"
     66#include "sh_pthread.h"
    6667
    6768#ifdef SH_USE_PROCESSCHECK
    … …  
    7071
    7172#ifdef __linux__
    72 #define HAVE_THREADS
     73#define PS_THREADS
    7374#endif
    7475
    … …  
    7677 */
    7778#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
     79
     80SH_MUTEX_STATIC(mutex_proc_check, PTHREAD_MUTEX_INITIALIZER);
    7881
    7982/* sh_prochk_maxpid is one more than the largest pid
    … …  
    405408          if (S_FALSE == is_in_list(&list_missing, list->str, 0))
    406409            {
     410              SH_MUTEX_LOCK(mutex_thread_nolog);
    407411              sh_error_handle(sh_prochk_severity, FIL__, __LINE__, 0,
    408412                              MSG_PCK_MISS,
    409413                              list->str);
     414              SH_MUTEX_UNLOCK(mutex_thread_nolog);
    410415            }
    411416        }
    … …  
    424429                {
    425430                  tmp = sh_util_safe_name (list->str);
     431                  SH_MUTEX_LOCK(mutex_thread_nolog);
    426432                  sh_error_handle(sh_prochk_severity, FIL__, __LINE__, 0,
    427433                                  MSG_PCK_MISS,
    428434                                  tmp);
     435                  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    429436                  SH_FREE(tmp);
    430437                }
    … …  
    458465    {
    459466      regerror(status, &(new->preg), errbuf, sizeof(errbuf));
     467      SH_MUTEX_LOCK(mutex_thread_nolog);
    460468      sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
    461                       errbuf, _("sh_processes_runps"));
     469                      errbuf, _("sh_processes_add_process"));
     470      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    462471      SH_FREE(new->str);
    463472      SH_FREE(new);
    … …  
    578587  if (val <= 0)
    579588    {
     589      SH_MUTEX_LOCK(mutex_thread_nolog);
    580590      sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
    581591                       _("process check interval"), c);
     592      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    582593      retval = -1;
    583594    }
    … …  
    826837              char errbuf[SH_ERRBUF_SIZE];
    827838
     839              /* SH_MUTEX_LOCK(mutex_thread_nolog) is in caller */
    828840              sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, errno, MSG_E_SUBGEN,
    829841                              sh_error_message(errno, errbuf, sizeof(errbuf)),
    … …  
    848860              if (flag_err_debug == SL_TRUE)
    849861                {
    850                   sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, num, MSG_E_SUBGEN,
     862                  /* SH_MUTEX_LOCK(mutex_thread_nolog) is in caller */
     863                  sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, num,
     864                                  MSG_E_SUBGEN,
    851865                                  tstr,
    852866                                  _("sh_processes_readps"));
    … …  
    880894          else if (isspace(cc))
    881895            {
    882 #ifdef HAVE_THREADS
     896#ifdef PS_THREADS
    883897              num  = 0;
    884898              line = SKIP_WS2;
    … …  
    979993  if (!sh_prochk_psarg)
    980994    {
    981 #ifdef HAVE_THREADS
     995#ifdef PS_THREADS
    982996      (void) sh_ext_tas_add_argv(&task,  _("-eT"));
    983997#else
    … …  
    9961010  if (status != 0)
    9971011    {
     1012      /* SH_MUTEX_LOCK(mutex_thread_nolog) is in caller */
    9981013      sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, status, MSG_E_SUBGEN,
    9991014                      _("Could not open pipe"), _("sh_processes_runps"));
    … …  
    10371052  if (!res)
    10381053    {
     1054      SH_MUTEX_LOCK(mutex_thread_nolog);
    10391055      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
    10401056                      _("Internal error: NULL argument"),
    10411057                      _("sh_process_check_int"));
     1058      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    10421059      SL_RETURN ((-1), _("sh_process_check_int"));
    10431060    }
    10441061
     1062  SH_MUTEX_LOCK(mutex_thread_nolog);
    10451063  sh_processes_runps (res, NULL, 0, SH_PR_PS, 0);
     1064  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    10461065  for (i = sh_prochk_minpid; i != sh_prochk_maxpid; ++i)
    10471066    {
    … …  
    10491068      res[j] = sh_processes_check ((pid_t) i, res[j]);
    10501069    }
     1070  SH_MUTEX_LOCK(mutex_thread_nolog);
    10511071  sh_processes_runps (res, NULL, 0, SH_PR_PS2, 0);
     1072  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    10521073
    10531074  /* Evaluate results
    … …  
    10841105          if ((res[j] & SH_PR_PS_ANY) && (res[j] & SH_PR_ANY))
    10851106            {
     1107              SH_MUTEX_LOCK(mutex_thread_nolog);
    10861108              sh_error_handle((-1), FIL__, __LINE__, 0, MSG_PCK_OK,
    10871109                              (unsigned long) i, tests);
     1110              SH_MUTEX_UNLOCK(mutex_thread_nolog);
    10881111            }
    10891112
    … …  
    11051128                      char * safe;
    11061129
     1130                      SH_MUTEX_LOCK(mutex_thread_nolog);
    11071131                      aout = get_user_and_path ((pid_t) i, user, sizeof(user));
     1132                      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    11081133
    11091134                      if (aout)
    11101135                        {
    11111136                          safe = sh_util_safe_name (aout);
     1137                          SH_MUTEX_LOCK(mutex_thread_nolog);
    11121138                          sh_error_handle(sh_prochk_severity, FIL__, __LINE__, 0,
    11131139                                          MSG_PCK_P_HIDDEN,
    11141140                                          (unsigned long) i, tests, safe, user);
     1141                          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    11151142                          SH_FREE(safe);
    11161143                          SH_FREE(aout);
    11171144                        }
    11181145                      else
    1119                         sh_error_handle(sh_prochk_severity, FIL__, __LINE__, 0,
    1120                                         MSG_PCK_HIDDEN,
    1121                                         (unsigned long) i, tests);
    1122                        
     1146                        {
     1147                          SH_MUTEX_LOCK(mutex_thread_nolog);
     1148                          sh_error_handle(sh_prochk_severity, FIL__, __LINE__, 0,
     1149                                          MSG_PCK_HIDDEN,
     1150                                          (unsigned long) i, tests);
     1151                          SH_MUTEX_UNLOCK(mutex_thread_nolog);
     1152                        }
    11231153                    }
    11241154                }
    … …  
    11341164                  if (S_FALSE == is_in_list(&list_fake, NULL, i))
    11351165                    {
     1166                      SH_MUTEX_LOCK(mutex_thread_nolog);
    11361167                      sh_error_handle(sh_prochk_severity, FIL__, __LINE__, 0,
    11371168                                      MSG_PCK_FAKE,
    11381169                                      (unsigned long) i, tests);
     1170                      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    11391171                    }
    11401172                }
    … …  
    11501182/* Initialise.
    11511183 */
    1152 int sh_prochk_init(struct mod_type * arg)
    1153 {
    1154   (void) arg;
     1184static int sh_prochk_init_internal()
     1185{
    11551186  SL_ENTER(_("sh_prochk_init"));
    11561187
    … …  
    11791210}
    11801211
     1212int sh_prochk_init (struct mod_type * arg)
     1213{
     1214  if (ShProchkActive == S_FALSE)
     1215    return SH_MOD_FAILED;
     1216#ifdef HAVE_PTHREAD
     1217  if (arg != NULL && arg->initval < 0 && sh.flag.isdaemon == S_TRUE)
     1218    {
     1219      if (0 == sh_pthread_create(sh_threaded_module_run, (void *)arg))
     1220        return SH_MOD_THREAD;
     1221      else
     1222        return SH_MOD_FAILED;
     1223    }
     1224#endif
     1225  return sh_prochk_init_internal();
     1226}
    11811227
    11821228int sh_prochk_timer(time_t tcurrent)
    … …  
    11991245  SL_ENTER(_("sh_prochk_check"));
    12001246
     1247  SH_MUTEX_LOCK(mutex_proc_check);
    12011248  if( ShProchkActive != S_FALSE )
    12021249    {
     1250      SH_MUTEX_LOCK(mutex_thread_nolog);
    12031251      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_PCK_CHECK,
    12041252                      (unsigned long) sh_prochk_minpid,
    12051253                      (unsigned long) (sh_prochk_maxpid-1));
     1254      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    12061255
    12071256      if (sh_prochk_res) {
    … …  
    12201269      clean_list (&list_fake);
    12211270    }
     1271  SH_MUTEX_UNLOCK(mutex_proc_check);
    12221272
    12231273  SL_RETURN(status, _("sh_prochk_check"));
    … …  
    12541304  SL_ENTER(_("sh_prochk_reconf"));
    12551305
     1306  SH_MUTEX_LOCK(mutex_proc_check);
    12561307  userdef_maxpid     = 0;
    12571308  sh_prochk_maxpid   = 0x8000;
    … …  
    12711322    SH_FREE(sh_prochk_pspath);
    12721323  sh_prochk_pspath = NULL;
     1324  SH_MUTEX_UNLOCK(mutex_proc_check);
    12731325
    12741326  SL_RETURN(0, _("sh_prochk_reconf"));

  • trunk/src/sh_pthread.c

    r142 r143  
    88#include "sh_calls.h"
    99#include "sh_modules.h"
    10 
    11 SH_MUTEX_INIT(mutex_skey,   PTHREAD_MUTEX_INITIALIZER);
    12 SH_MUTEX_INIT(mutex_resolv, PTHREAD_MUTEX_INITIALIZER);
    13 SH_MUTEX_INIT(mutex_pwent,  PTHREAD_MUTEX_INITIALIZER);
    14 SH_MUTEX_INIT(mutex_readdir,PTHREAD_MUTEX_INITIALIZER);
     10extern volatile  int      sh_thread_pause_flag;
     11
     12SH_MUTEX_INIT(mutex_skey,         PTHREAD_MUTEX_INITIALIZER);
     13SH_MUTEX_INIT(mutex_resolv,       PTHREAD_MUTEX_INITIALIZER);
     14SH_MUTEX_INIT(mutex_pwent,        PTHREAD_MUTEX_INITIALIZER);
     15SH_MUTEX_INIT(mutex_readdir,      PTHREAD_MUTEX_INITIALIZER);
     16SH_MUTEX_INIT(mutex_thread_nolog, PTHREAD_MUTEX_INITIALIZER);
    1517
    1618void sh_pthread_mutex_unlock (void *arg)
    … …  
    136138/* ---- Utility functions for modules ----
    137139 */
     140
     141#undef  S_TRUE
     142#define S_TRUE    1
     143#undef  S_FALSE
     144#define S_FALSE   0
     145
    138146void sh_threaded_module_cleanup(void *arg)
    139147{
    … …  
    162170          while (1)
    163171            {
    164               if (0 != this_module->mod_timer(time(NULL)))
     172              if (sh_thread_pause_flag != S_TRUE &&
     173                  0 != this_module->mod_timer(time(NULL)))
    165174                {
    166175                  /* If module has been de-activated on reconfigure,
    … …  
    172181                    break;
    173182                  pthread_testcancel();
    174                   retry_msleep(1,0);
    175183                }
     184              retry_msleep(1,0);
    176185            }
    177186

  • trunk/src/sh_suidchk.c

    r140 r143  
    874874  do {
    875875
    876     if (sig_urgent > 0) {
    877       SL_RETURN( (0), _("sh_suidchk_check_internal"));
    878     }
    879 
    880876    thisEntry = readdir (thisDir);
    881877
    … …  
    905901    if (!dirlist)
    906902      break;
     903
     904    if (sig_urgent > 0) {
     905      SL_RETURN( (0), _("sh_suidchk_check_internal"));
     906    }
    907907
    908908    tmpcat = SH_ALLOC(PATH_MAX);

  • trunk/src/sh_tools.c

    r137 r143  
    522522#endif
    523523        {
     524          host_name = NULL;
     525
    524526          SH_MUTEX_LOCK(mutex_resolv);
    525527
    … …  
    596598                        }
    597599                    }
    598 
    599                   SH_FREE(host_name);
    600600                }
    601601            }
    602602          SH_MUTEX_UNLOCK(mutex_resolv);
     603          if (host_name) SH_FREE(host_name);
    603604        }
    604605 

  • trunk/src/sh_unix.c

    r138 r143  
    42214221  if (0 != page_locking)
    42224222    {
    4223       SL_RETURN((-1), _("sh_unix_mlock"));
     4223      status = -1;
     4224      goto exit_mlock;
    42244225    }
    42254226
    … …  
    42844285          SH_FREE(page_list);
    42854286          page_locking = 0;
    4286           SL_RETURN((status), _("sh_unix_mlock"));
     4287          goto exit_mlock;
    42874288        }
    42884289      page_list->next = sh_page_locked;
    … …  
    42924293    }
    42934294  page_locking = 0;
     4295
     4296 exit_mlock:
    42944297  SH_MUTEX_UNLOCK_UNSAFE(mutex_mlock);
    42954298
    … …  
    43324335  if (0 != page_locking)
    43334336    {
    4334       SL_RETURN((-1), _("sh_unix_munlock"));
     4337      status = -1;
     4338      goto exit_munlock;
    43354339    }
    43364340  page_locking = 1;
    … …  
    44374441
    44384442  page_locking = 0;
     4443
     4444 exit_munlock:
    44394445  SH_MUTEX_UNLOCK_UNSAFE(mutex_mlock);
    4440 
    44414446  SL_RETURN((status), _("sh_unix_munlock"));
    44424447}

  • trunk/src/sh_utmp.c

    r142 r143  
    7979#include "sh_modules.h"
    8080#include "sh_utmp.h"
    81 
     81#include "sh_pthread.h"
     82
     83SH_MUTEX_EXTERN(mutex_thread_nolog);
    8284
    8385#ifdef TM_IN_SYS_TIME
    … …  
    300302  if (sh_utmpfile == NULL)
    301303    {
     304      SH_MUTEX_LOCK(mutex_thread_nolog);
    302305      fd = (int) aud_open (FIL__, __LINE__, SL_NOPRIV,
    303306                           sh_utmppath, O_RDONLY, 0);
     307      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    304308      if (fd >= 0)
    305309        {
    … …  
    313317        {
    314318          error = errno;
     319          SH_MUTEX_LOCK(mutex_thread_nolog);
    315320          sh_error_handle ((-1), FIL__, __LINE__, error, MSG_E_ACCESS,
    316321                           (long) sh.real.uid, sh_utmppath);
     322          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    317323          SL_RET0(_("sh_utmp_setutent"));
    318324        }
    … …  
    489495    return SH_MOD_FAILED;
    490496#ifdef HAVE_PTHREAD
    491   if (arg != NULL && arg->initval < 0)
     497  if (arg != NULL && arg->initval < 0 && sh.flag.isdaemon == S_TRUE)
    492498    {
    493499      if (0 == sh_pthread_create(sh_threaded_module_run, (void *)arg))
    … …  
    559565  if (ShUtmpActive == BAD)
    560566    SL_RETURN( (-1), _("sh_utmp_check"));
     567  SH_MUTEX_LOCK(mutex_thread_nolog);
    561568  sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_UT_CHECK);
     569  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    562570  sh_utmp_check_internal (1);
    563571
    … …  
    579587  tmp[0] = '='; tmp[1] = '\0';
    580588  (void) sl_strlcat (tmp, c, 32);
     589  SH_MUTEX_LOCK(mutex_thread_nolog);
    581590  retval = sh_error_set_level (tmp, &ShUtmpLoginSolo);
     591  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    582592  SL_RETURN(retval, _("sh_utmp_set_login_solo"));
    583593}
    … …  
    591601  tmp[0] = '='; tmp[1] = '\0';
    592602  (void) sl_strlcat (tmp, c, 32);
     603  SH_MUTEX_LOCK(mutex_thread_nolog);
    593604  retval = sh_error_set_level (tmp, &ShUtmpLoginMulti);
     605  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    594606  SL_RETURN(retval, _("sh_utmp_set_login_multi"));
    595607}
    … …  
    603615  tmp[0] = '='; tmp[1] = '\0';
    604616  (void) sl_strlcat (tmp, c, 32);
     617  SH_MUTEX_LOCK(mutex_thread_nolog);
    605618  retval = sh_error_set_level (tmp, &ShUtmpLogout);
     619  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    606620  SL_RETURN(retval, _("sh_utmp_set_logout_good"));
    607621}
    … …  
    616630  if (val <= 0)
    617631    {
     632      SH_MUTEX_LOCK(mutex_thread_nolog);
    618633      sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
    619634                       _("utmp timer"), c);
     635      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    620636      retval = -1;
    621637    }
    … …  
    823839          ) {
    824840        status = sh_utmp_login_a(user->name);
     841        SH_MUTEX_LOCK(mutex_thread_nolog);
    825842        (void) sh_unix_time (user->time, ttt, TIM_MAX);
    826843        sh_error_handle( ShUtmpLoginSolo, FIL__, __LINE__, 0,
    … …  
    843860                         status
    844861                         );
     862        SH_MUTEX_UNLOCK(mutex_thread_nolog);
    845863      } else
    846864        if (0 != sh_utmp_is_virtual(ut->ut_line, user->ut_host))
    847865          {       
    848866            status = sh_utmp_login_a(user->name);
     867            SH_MUTEX_LOCK(mutex_thread_nolog);
    849868            (void) sh_unix_time (user->time, ttt, TIM_MAX);
    850869            sh_error_handle( ShUtmpLoginMulti, FIL__, __LINE__, 0,
    … …  
    867886                             status
    868887                             );
     888            SH_MUTEX_UNLOCK(mutex_thread_nolog);
    869889          }
    870890     
    … …  
    882902        {
    883903          status = sh_utmp_login_r(user->name);
     904          SH_MUTEX_LOCK(mutex_thread_nolog);
    884905          (void) sh_unix_time (ut->ut_time, ttt, TIM_MAX);
    885906          sh_error_handle( ShUtmpLogout, FIL__, __LINE__, 0,
    … …  
    902923                           status
    903924                           );
     925          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    904926          userold->next = user->next;
    905927          if (user == userlist)
    … …  
    912934        {
    913935          (void) sl_strlcpy(terminated_line, ut->ut_line, UT_HOSTSIZE);
     936          SH_MUTEX_LOCK(mutex_thread_nolog);
    914937          (void) sh_unix_time (ut->ut_time, ttt, TIM_MAX);
    915938          sh_error_handle( ShUtmpLogout, FIL__, __LINE__, 0,
    … …  
    918941                           ttt, 0
    919942                           );
     943          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    920944        }
    921945      SL_RET0(_("sh_utmp_addlogin"));
    … …  
    943967      userlist         = user;
    944968
     969      SH_MUTEX_LOCK(mutex_thread_nolog);
    945970      (void) sh_unix_time (user->time, ttt, TIM_MAX);
    946 
    947 
    948971      sh_error_handle( ShUtmpLoginSolo, FIL__, __LINE__, 0,
    949972#if defined(HAVE_UTHOST) && defined(HAVE_UTADDR)
    … …  
    965988                       1
    966989                       );
     990      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    967991      sh_utmp_login_morechecks(ut);
    968992    }
    969993  else  /* probably a logout */
    970994    {
     995      SH_MUTEX_LOCK(mutex_thread_nolog);
    971996      (void) sh_unix_time (ut->ut_time, ttt, TIM_MAX);
    972 
    973997      sh_error_handle( ShUtmpLogout, FIL__, __LINE__, 0,
    974998#if defined(HAVE_UTHOST) && defined(HAVE_UTADDR)
    … …  
    9901014                       1
    9911015                       );
     1016      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    9921017      sh_utmp_logout_morechecks(user);
    9931018      userold->next = user->next;
    … …  
    10141039  struct SH_UTMP_S * ut;
    10151040  unsigned long this_read = 0;
     1041  int           val_retry;
    10161042
    10171043  SL_ENTER(_("sh_utmp_check_internal"));
    … …  
    10191045  /* error if no access
    10201046   */
    1021   if (0 != retry_lstat(FIL__, __LINE__, mode_path[mode], &buf))
     1047  do {
     1048    val_retry = /*@-unrecog@*/lstat ( mode_path[mode], &buf)/*@+unrecog@*/;
     1049  } while (val_retry < 0 && errno == EINTR);
     1050
     1051  if (0 != val_retry)
    10221052    {
    10231053      error = errno;
     1054      SH_MUTEX_LOCK(mutex_thread_nolog);
    10241055      sh_error_handle((-1), FIL__, __LINE__, error, MSG_E_ACCESS,
    10251056                      (long) sh.real.uid, mode_path[mode]);
     1057      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    10261058      SL_RET0(_("sh_utmp_check_internal"));
    10271059    }
    … …  
    10431075  if (/*@-usedef@*/buf.st_size < lastsize/*@+usedef@*/ && mode < 2)
    10441076    {
     1077      SH_MUTEX_LOCK(mutex_thread_nolog);
    10451078      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_UT_ROT,
    10461079                      mode_path[mode]);
     1080      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    10471081      lastread = 0;
    10481082#ifndef USE_SETUTENT
Note: See TracChangeset for help on using the changeset viewer.