Changeset 134


Ignore:
Timestamp:
Oct 26, 2007, 12:20:10 AM (12 years ago)
Author:
rainer
Message:

More thread-safety changes.

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/docs/Changelog

    r131 r134  
    33        * use getgrgid_r, getpwnam_r, getpwuid_r, gmtime_r, localtime_r,
    44          rand_r, strtok_r if available
    5         * protect readdir() with mutex (readdir_r considered harmful)
     5        * protect readdir(), getpwent(), gethostname() with mutexes
     6          (readdir_r considered harmful)
     7        * make checksum/hash function reentrant
     8        * use thread-specific conversion buffer for globber()
    69
    7102.3.8:
  • trunk/docs/TODO

    r132 r134  
    11
    2 not thread-safe: checksum function (returns static memory),
    3                  sh_util_siggen
    4                  sh_util_hash_tiger
    5                  sh_util_hmac_tiger
    62
    73check thread_safe sh_entropy
    84check thread_safe rng
    95
    10 lock globber
    116
    12 lock sh_alloc/sh_free
    13 
  • trunk/include/sh_pthread.h

    r133 r134  
    3030 */
    3131SH_MUTEX_EXTERN(mutex_skey);
     32SH_MUTEX_EXTERN(mutex_resolv);
     33SH_MUTEX_EXTERN(mutex_pwent);
     34
     35/*
     36 * ----   Initialize thread-specific conversion area   ----
     37 */
     38extern int sh_g_thread();
    3239
    3340#else
  • trunk/src/samhain.c

    r133 r134  
    138138#endif
    139139
     140#ifdef HAVE_PTHREAD
     141typedef struct gt {
     142  size_t g_count;
     143  char * g_glob;
     144};
     145
     146pthread_key_t g_key;
     147
     148int sh_g_thread()
     149{
     150  struct gt * ptr = malloc(sizeof(struct gt));
     151  if (!gt)
     152    return -1;
     153  ptr->g_count    = 0;
     154  ptr->g_glob     = calloc(1, SH_MAX_GLOBS * (GLOB_LEN+1));
     155  if (!(ptr->g_glob))
     156    return -1;
     157  return pthread_setspecific(g_key, ptr);
     158}
     159
     160void sh_g_destroy(void * data)
     161{
     162  struct gt * ptr = (struct gt *) data;
     163  free(ptr->g_glob);
     164  free(ptr);
     165  return;
     166}
     167
     168static void sh_g_init()
     169{
     170  if (0 != pthread_key_create(&g_key, sh_g_destroy))
     171    {
     172      perror("1");
     173      exit(EXIT_FAILURE);
     174    }
     175
     176  if (0 != sh_g_thread())
     177    {
     178      perror("1");
     179      exit(EXIT_FAILURE);
     180    }
     181  return;
     182}
     183#define SH_G_INIT sh_g_init()
     184#else
     185#define SH_G_INIT ((void)0)
     186#endif
     187
    140188char * globber(const char * str)
    141189{
     
    143191  size_t j;
    144192
    145   static   size_t  items = 0;
     193#ifdef HAVE_PTHREAD
     194  struct gt * ptr = pthread_getspecific(g_key);
     195  size_t count = ptr->g_count;
     196  char *  glob = ptr->g_glob;
     197#else
    146198  static   size_t  count = 0;
    147199  static   char glob[SH_MAX_GLOBS * (GLOB_LEN+1)];
     200#
    148201
    149202  if (str == NULL)
     
    152205    j = strlen(str);
    153206
    154   ++items;
    155 
    156207  ASSERT((j <= GLOB_LEN), _("j <= GLOB_LEN"))
    157208
     
    164215    {
    165216      count = 0;
    166       items = 0;
    167217    }
    168218
     
    177227
    178228  i     = count;
     229#ifdef HAVE_PTHREAD
     230  ptr->count = count + j + 1;
     231#else
    179232  count = count + j + 1;
     233#endif
    180234  return &glob[i];
    181235}
     
    11441198  char  * my_argv[32];
    11451199#endif
     1200
     1201  SH_G_INIT; /* Must precede any use of _() */
    11461202
    11471203  SL_ENTER(_("main"));
  • trunk/src/sh_calls.c

    r132 r134  
    250250  error = errno;
    251251  if (val_retry < 0) {
    252       (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
     252      (void) sh_error_message(error, aud_err_message, 64);
    253253      sh_error_handle ((-1), file, line, error, MSG_ERR_LSTAT,
    254254                       sh_error_message(error, errbuf, sizeof(errbuf)),
     
    273273  error = errno;
    274274  if (val_retry < 0) {
    275       (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
     275      (void) sh_error_message(error, aud_err_message, 64);
    276276      sh_error_handle ((-1), file, line, error, MSG_ERR_STAT,
    277277                       sh_error_message(error, errbuf, sizeof(errbuf)),
     
    363363  if (sec > 0)
    364364    {
    365       sleep (sec);
     365      sleep (sec); /* nanosleep not available */
    366366    }
    367367  else
     
    584584  if (val_return < 0)
    585585    {
    586       (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
     586      (void) sh_error_message(error, aud_err_message, 64);
    587587    }
    588588
     
    618618  if (val_return < 0)
    619619    {
    620       (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
     620      (void) sh_error_message(error, aud_err_message, 64);
    621621    }
    622622
  • trunk/src/sh_mail.c

    r133 r134  
    21392139#endif
    21402140        }
     2141
     2142      SH_MUTEX_LOCK(mutex_resolv);
    21412143      if (domain != NULL)
    21422144        host = /*@-unrecog@*/sh_gethostbyname (domain)/*@+unrecog@*/;
     2145
     2146      if (host)
     2147        {
     2148          result       = SH_ALLOC (sizeof (mx));
     2149          retval       = SH_ALLOC (sizeof (dnsrep));
     2150          retval->reply = result;
     2151          retval->count = 1;
     2152          result->pref  = 0;
     2153          /*@-type@*/
     2154          len = strlen (host->h_name) + 1;
     2155          result->address = SH_ALLOC (len);
     2156          sl_strlcpy (result->address, host->h_name, len);
     2157          /*@+type@*/
     2158        }
     2159      SH_MUTEX_UNLOCK(mutex_resolv);
     2160
    21432161      if (!host)
    21442162        {
     
    21522170          SL_RETURN (NULL, _("return_mx"));
    21532171        }
    2154       result       = SH_ALLOC (sizeof (mx));
    2155       retval       = SH_ALLOC (sizeof (dnsrep));
    2156       retval->reply = result;
    2157       retval->count = 1;
    2158       result->pref  = 0;
    2159       /*@-type@*/
    2160       len = strlen (host->h_name) + 1;
    2161       result->address = SH_ALLOC (len);
    2162       sl_strlcpy (result->address, host->h_name, len);
    2163       /*@+type@*/
     2172
    21642173      SL_RETURN (retval, _("return_mx"));
    21652174    }
  • trunk/src/sh_mem.c

    r22 r134  
    3838#include "sh_utils.h"
    3939#include "sh_mem.h"
     40#include "sh_pthread.h"
    4041
    4142extern int safe_logger (int signal, int method, char * details);
     
    103104#endif
    104105
     106#ifdef HAVE_PTHREAD
     107static pthread_once_t mem_is_initialized = PTHREAD_ONCE_INIT;
     108static pthread_mutex_t mutex_mem;
     109
     110static int initialize_mem(void)
     111{
     112  pthread_mutexattr_t   mta;
     113  pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_RECURSIVE);
     114  pthread_mutex_init(&mutex_mem, &mta);
     115  pthread_mutexattr_destroy(&mta);
     116  return 0;
     117}
     118#define MEM_MUTEX_INIT  (void) pthread_once(&mem_is_initialized, initialize_mem)
     119#else
     120#define MEM_MUTEX_INIT ((void)0)
     121#endif
     122
    105123#ifdef MEM_LOG
    106124void sh_mem_dump ()
     
    109127
    110128
    111   FILE * fd = fopen(MEM_LOG, "w");
     129  FILE * fd;
     130
     131  MEM_MUTEX_INIT;
     132  SH_MUTEX_LOCK(mutex_mem);
     133
     134  fd = fopen(MEM_LOG, "w");
    112135
    113136  while (this != NULL)
     
    117140    }
    118141  fclose(fd);
     142  SH_MUTEX_UNLOCK(mutex_mem);
    119143  return;
    120144}
     
    133157  SL_ENTER(_("sh_mem_stat"));
    134158
     159  MEM_MUTEX_INIT;
     160  SH_MUTEX_LOCK(mutex_mem);
     161
    135162  if (Alloc_Count == Free_Count)
    136163    {
    137164      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_MSTAMP,
    138165                       Mem_Max, Mem_Current);
    139       SL_RET0(_("sh_mem_stat"));
     166      goto out;
    140167    }
    141168   
     
    167194      this = this->next;
    168195    }
    169 
     196 out:
     197  SH_MUTEX_UNLOCK(mutex_mem);
    170198  SL_RET0(_("sh_mem_stat"));
    171199}
     
    178206  SL_ENTER(_("sh_mem_check"));
    179207
     208  MEM_MUTEX_INIT;
     209  SH_MUTEX_LOCK(mutex_mem);
    180210  sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_MSTAMP,
    181211                   Mem_Max, Mem_Current);
     
    210240  /* if (nerr > 0) abort(); */
    211241
     242  SH_MUTEX_UNLOCK(mutex_mem);
    212243  SL_RET0(_("sh_mem_check"));
    213244}
     
    221252  SL_ENTER(_("sh_mem_malloc"));
    222253
     254  MEM_MUTEX_INIT;
     255  SH_MUTEX_LOCK(mutex_mem);
    223256  the_realAddress = malloc(size + 2 * SH_MEMMULT);
    224257 
     
    327360          eblock = 0;
    328361        }
    329       SL_RETURN( the_realAddress, _("sh_mem_malloc"));
     362      _exit(42);
    330363    }
    331364
     
    341374  memlist = this;
    342375
     376  SH_MUTEX_UNLOCK(mutex_mem);
    343377  SL_RETURN( theAddress, _("sh_mem_malloc"));
    344378}
     
    353387  SL_ENTER(_("sh_mem_free"));
    354388
     389  MEM_MUTEX_INIT;
     390  SH_MUTEX_LOCK(mutex_mem);
    355391  if ( a == NULL )
    356392    {
    357393      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_E_MNULL,
    358394                       file, line);
    359       SL_RET0(_("sh_mem_free"));
     395      goto out;
    360396    }
    361397   
     
    374410      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_E_MREC,
    375411                       file, line);
    376       SL_RET0(_("sh_mem_free"));
     412      goto out;
    377413    }
    378414  else
     
    423459
    424460  Mem_Current -= size;
     461 out:
     462  SH_MUTEX_UNLOCK(mutex_mem);
    425463  SL_RET0(_("sh_mem_free"));
    426464}
  • trunk/src/sh_portcheck.c

    r132 r134  
    835835    }
    836836           
     837  SH_MUTEX_LOCK(mutex_resolv);
    837838  hent = gethostbyname(portchk_hostname);
    838839
     
    840841    {
    841842      memcpy (&(iface_list.iface[iface_list.used].s_addr), hent->h_addr_list[i], sizeof(in_addr_t));
     843      ++iface_list.used;
     844      ++i;
     845    }
     846  SH_MUTEX_UNLOCK(mutex_resolv);
     847
     848  for (i = 0; i < iface_list.used; ++i)
     849    {
    842850      sl_snprintf(errbuf, sizeof(errbuf), _("interface: %s"),
    843                   inet_ntoa(iface_list.iface[iface_list.used]));
     851                  inet_ntoa(iface_list.iface[i]));
    844852      sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    845853                      errbuf, _("sh_portchk_init"));
    846 
    847       ++iface_list.used;
    848       ++i;
    849854    }
    850855
     
    14421447  sh_portchk_check();
    14431448
    1444   /*
    1445   sleep(10);
    1446 
    1447   sh_portchk_check();
    1448   */
    1449 
    14501449  return 0;
    14511450}
  • trunk/src/sh_prelude_old.c

    r1 r134  
    127127#define SH_NEED_GETHOSTBYXXX
    128128#include "sh_static.h"
     129#include "sh_pthread.h"
    129130
    130131static char               programname[64];
     
    627628  /* Get information about ip address */
    628629 
     630  SH_MUTEX_LOCK(mutex_resolv);
    629631  myhost = sh_gethostbyname(hostname);
    630632  src_ip = xstrdup(inet_ntoa(*((struct in_addr *)myhost->h_addr_list[0])));
     633  SH_MUTEX_UNLOCK(mutex_resolv);
    631634             
    632635
  • trunk/src/sh_static.c

    r22 r134  
    5151#include <pwd.h>
    5252#include <grp.h>
     53
     54#include "sh_pthread.h"
    5355
    5456#ifndef _PATH_PASSWD
     
    312314}
    313315
    314 #define LOCK            ((void) 0)
    315 #define UNLOCK          ((void) 0)
     316SH_MUTEX_STATIC(pwf_lock, PTHREAD_MUTEX_INITIALIZER);
     317
    316318
    317319static FILE *pwf = NULL;
     
    319321void  sh_setpwent(void)
    320322{
    321         LOCK;
     323        SH_MUTEX_LOCK(pwf_lock);
    322324        if (pwf) {
    323325                rewind(pwf);
    324326        }
    325         UNLOCK;
     327        SH_MUTEX_UNLOCK(pwf_lock);
    326328}
    327329
    328330void  sh_endpwent(void)
    329331{
    330         LOCK;
     332        SH_MUTEX_LOCK(pwf_lock);
    331333        if (pwf) {
    332334                fclose(pwf);
    333335                pwf = NULL;
    334336        }
    335         UNLOCK;
     337        SH_MUTEX_UNLOCK(pwf_lock);
    336338}
    337339
     
    343345        int rv;
    344346
    345         LOCK;
     347        SH_MUTEX_LOCK(pwf_lock);
    346348
    347349        *result = NULL;                         /* In case of error... */
     
    361363
    362364 ERR:
    363         UNLOCK;
     365        SH_MUTEX_UNLOCK(pwf_lock);
    364366
    365367        return rv;
    366368}
    367369
    368 #define LOCK            ((void) 0)
    369 #define UNLOCK          ((void) 0)
     370SH_MUTEX_STATIC(grf_lock, PTHREAD_MUTEX_INITIALIZER);
    370371
    371372static FILE *grf = NULL;
     
    373374void  sh_setgrent(void)
    374375{
    375         LOCK;
     376        SH_MUTEX_LOCK(grf_lock);
    376377        if (grf) {
    377378                rewind(grf);
    378379        }
    379         UNLOCK;
     380        SH_MUTEX_UNLOCK(grf_lock);
    380381}
    381382
    382383void  sh_endgrent(void)
    383384{
    384         LOCK;
     385        SH_MUTEX_LOCK(grf_lock);
    385386        if (grf) {
    386387                fclose(grf);
    387388                grf = NULL;
    388389        }
    389         UNLOCK;
     390        SH_MUTEX_UNLOCK(grf_lock);
    390391}
    391392
     
    396397        int rv;
    397398
    398         LOCK;
     399        SH_MUTEX_LOCK(grf_lock);
    399400
    400401        *result = NULL;                         /* In case of error... */
     
    414415
    415416 ERR:
    416         UNLOCK;
     417        SH_MUTEX_UNLOCK(grf_lock);
    417418
    418419        return rv;
     
    437438        struct group *result;
    438439
    439          sh_getgrent_r(&gr, line_buff, sizeof(line_buff), &result);
     440        sh_getgrent_r(&gr, line_buff, sizeof(line_buff), &result);
    440441        return result;
    441442}
     
    669670                skip = 0;
    670671                do {
    671                         if (!fgets_unlocked(line_buff, buflen, f)) {
    672                                 if (feof_unlocked(f)) {
     672                        if (!fgets(line_buff, buflen, f)) {
     673                                if (feof(f)) {
    673674                                        rv = ENOENT;
    674675                                }
     
    863864#include <arpa/nameser.h>
    864865
    865 #define BIGLOCK
    866 #define BIGUNLOCK
     866SH_MUTEX_STATIC(resolv_lock, PTHREAD_MUTEX_INITIALIZER);
    867867
    868868#define __UCLIBC_HAS_IPV6__
     
    11981198
    11991199                sl_strlcpy(lookup,name,MAXDNAME);
    1200                 BIGLOCK;
     1200                SH_MUTEX_LOCK_UNSAFE(resolv_lock);
    12011201                if (variant < __searchdomains && strchr(lookup, '.') == NULL)
    12021202                {
     
    12041204                    sl_strlcat(lookup,__searchdomain[variant], MAXDNAME);
    12051205                }
    1206                 BIGUNLOCK;
     1206                SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
    12071207                DPRINTF("lookup name: %s\n", lookup);
    12081208                q.dotted = (char *)lookup;
     
    13481348                    int sdomains;
    13491349
    1350                     BIGLOCK;
     1350                    SH_MUTEX_LOCK_UNSAFE(resolv_lock);
    13511351                    sdomains=__searchdomains;
    1352                     BIGUNLOCK;
     1352                    SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
    13531353                    variant = 0;
    13541354                    if (retries >= nscount*(sdomains+1))
     
    13601360                {
    13611361                    int sdomains;
    1362                     BIGLOCK;
     1362                    SH_MUTEX_LOCK_UNSAFE(resolv_lock);
    13631363                    sdomains=__searchdomains;
    1364                     BIGUNLOCK;
     1364                    SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
    13651365
    13661366                    if (variant < sdomains) {
     
    15661566        int argc;
    15671567
    1568         BIGLOCK;
    1569         if (__nameservers > 0) {
    1570             BIGUNLOCK;
    1571             return 0;
     1568        SH_MUTEX_LOCK(resolv_lock);
     1569        if (__nameservers > 0) {
     1570          goto the_end;
    15721571        }
    15731572
     
    16141613        }
    16151614        DPRINTF("nameservers = %d\n", __nameservers);
    1616         BIGUNLOCK;
     1615 the_end:
     1616        SH_MUTEX_UNLOCK(resolv_lock);
    16171617        return 0;
    16181618}
     
    16911691        for (;;) {
    16921692
    1693         BIGLOCK;
     1693        SH_MUTEX_LOCK_UNSAFE(resolv_lock);
    16941694        __nameserversXX=__nameservers;
    16951695        __nameserverXX=__nameserver;
    1696         BIGUNLOCK;
     1696        SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
    16971697                i = __dns_lookup(buf, T_A, __nameserversXX, __nameserverXX, &packet, &a);
    16981698
     
    19111911        for (;;) {
    19121912
    1913         BIGLOCK;
     1913        SH_MUTEX_LOCK_UNSAFE(resolv_lock);
    19141914        __nameserversXX=__nameservers;
    19151915        __nameserverXX=__nameserver;
    1916         BIGUNLOCK;
     1916        SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
    19171917                i = __dns_lookup(buf, T_PTR, __nameserversXX, __nameserverXX, &packet, &a);
    19181918
  • trunk/src/sh_tiger0.c

    r133 r134  
    100100 */
    101101
    102 static sh_byte buffer[PRIV_MAX + 72];
     102/* static sh_byte buffer[PRIV_MAX + 72]; */
    103103
    104104#if defined(TIGER_64_BIT)
     
    121121  UINT64    bcount = 0;
    122122
    123   static int lockflag = SL_FALSE;
     123  char * buffer = SH_ALLOC(PRIV_MAX + 72);
    124124
    125125  unsigned long pages_read;
     
    176176                           MSG_E_ACCESS, (long) euid, tmp);
    177177          SH_FREE(tmp);
     178          SH_FREE(buffer);
    178179          SL_RETURN( NULL, _("sh_tiger_hash_val"));
    179180        }
    180181
    181       SH_MUTEX_LOCK(mutex_skey); 
    182182#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
    183     if ((lockflag == SL_FALSE) && (skey->mlock_failed == SL_FALSE))
     183    if (skey->mlock_failed == SL_FALSE)
    184184      {
    185         lockflag = SL_TRUE;
    186185        if ( (-1) == sh_unix_mlock(FIL__, __LINE__,
    187186                                   (char *)buffer,
    188187                                   (PRIV_MAX)*sizeof(sh_byte)))
    189           skey->mlock_failed = SL_TRUE;
     188          {
     189            SH_MUTEX_LOCK_UNSAFE(mutex_skey); 
     190            skey->mlock_failed = SL_TRUE;
     191            SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
     192          }
    190193      }
    191194#else
    192     if (lockflag == SL_FALSE && skey->mlock_failed == SL_FALSE)
     195    if (skey->mlock_failed == SL_FALSE)
    193196      {
    194         lockflag = SL_TRUE;
     197        SH_MUTEX_LOCK_UNSAFE(mutex_skey); 
    195198        skey->mlock_failed = SL_TRUE;
     199        SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    196200      }
    197201#endif
    198     SH_MUTEX_UNLOCK(mutex_skey);
    199202
    200203#ifdef TIGER_DBG
     
    216219          {
    217220            if (sig_termfast == 1) {
     221              sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
     222              SH_FREE(buffer);
    218223              SL_RETURN( NULL, _("sh_tiger_hash_val"));
    219224            }
     
    234239            memset (buffer, 0, PRIV_MAX);
    235240
     241            sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
     242            SH_FREE(buffer);
    236243            SL_RETURN( NULL, _("sh_tiger_hash_val"));
    237244          }
     
    278285            memset (bbuf,   0, 64);
    279286            memset (buffer, 0, PRIV_MAX);
    280 
     287            sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
     288            SH_FREE(buffer);
    281289            SL_RETURN( NULL, _("sh_tiger_hash_val"));
    282290          }
     
    364372    if (what == TIGER_FILE)
    365373      (void) sl_close (fd);
    366 
     374    sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
     375    SH_FREE(buffer);
    367376    SL_RETURN( res, _("sh_tiger_hash_val"));
    368377  }
     
    370379  if (what == TIGER_DATA && filename != NULL)
    371380    {
    372       tiger(TIGER_CAST filename, (sh_word32) Length, res);
     381      tiger(TIGER_CAST filename, (sh_word32) Length, res);
     382      sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
     383      SH_FREE(buffer);
    373384      SL_RETURN(res, _("sh_tiger_hash_val"));
    374385    }
     386  sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
     387  SH_FREE(buffer);
    375388  SL_RETURN( NULL, _("sh_tiger_hash_val"));
    376389}
  • trunk/src/sh_tools.c

    r133 r134  
    521521#endif
    522522        {
    523      
     523          SH_MUTEX_LOCK(mutex_resolv);
     524
    524525          host_entry = sh_gethostbyname(address);
    525526
     
    598599                }
    599600            }
     601          SH_MUTEX_UNLOCK(mutex_resolv);
    600602        }
    601603 
  • trunk/src/sh_unix.c

    r133 r134  
    15831583    }
    15841584
     1585  SH_MUTEX_LOCK(mutex_resolv);
    15851586  he1 = sh_gethostbyname(hostname);
     1587
     1588  if (he1 != NULL)
     1589    {
     1590      sl_strlcpy (sh.host.name, sh_unix_h_name(he1), SH_PATHBUF);
     1591    }
     1592  SH_MUTEX_UNLOCK(mutex_resolv);
    15861593
    15871594  if (he1 == NULL)
     
    15911598           hostname);
    15921599      sl_strlcpy (sh.host.name, hostname,    SH_PATHBUF);
    1593     }
    1594   else
    1595     {
    1596       sl_strlcpy (sh.host.name, sh_unix_h_name(he1), SH_PATHBUF);
    15971600    }
    15981601 
     
    16381641  (void) gethostname (hostname, 1024);
    16391642  hostname[1023] = '\0';
     1643
     1644  SH_MUTEX_LOCK(mutex_resolv);
    16401645  he1 = sh_gethostbyname(hostname);
    16411646
     
    16441649      sl_strlcpy (sh.host.name, sh_unix_h_name(he1), SH_PATHBUF);
    16451650    }
    1646   else
     1651  SH_MUTEX_UNLOCK(mutex_resolv);
     1652
     1653  if (he1 == NULL)
    16471654    {
    16481655      dlog(1, FIL__, __LINE__,
     
    16931700                                  (char *) skey, sizeof (sh_key_t)) )
    16941701        {
     1702          SH_MUTEX_LOCK_UNSAFE(mutex_skey);
    16951703          skey->mlock_failed = SL_TRUE;
     1704          SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    16961705        }
    16971706    }
     
    16991708  if (skey->mlock_failed == SL_FALSE)
    17001709    {
     1710      SH_MUTEX_LOCK_UNSAFE(mutex_skey);
    17011711      skey->mlock_failed = SL_TRUE;
     1712      SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    17021713    }
    17031714#endif
     
    41884199
    41894200#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
     4201
     4202SH_MUTEX_STATIC(mutex_mlock,PTHREAD_MUTEX_INITIALIZER);
     4203
    41904204int sh_unix_mlock (char * file, int line, void * in_addr, size_t len)
    41914205{
     
    42014215  SL_ENTER(_("sh_unix_mlock"));
    42024216
     4217  /* There's no cancellation point here, except if tracing is on
     4218   */
     4219  SH_MUTEX_LOCK_UNSAFE(mutex_mlock);
     4220
    42034221  if (0 != page_locking)
    42044222    {
    42054223      SL_RETURN((-1), _("sh_unix_mlock"));
    42064224    }
     4225
    42074226  page_locking = 1;
    42084227
     
    42184237   * addr is first page; num_pages is #(consecutive pages) to lock
    42194238   */
     4239
    42204240  while ((page_list != NULL) && (num_pages > 0))
    42214241    {
     
    42714291      addr += pagesize;
    42724292    }
    4273 
    42744293  page_locking = 0;
     4294  SH_MUTEX_UNLOCK_UNSAFE(mutex_mlock);
     4295
    42754296  SL_RETURN((status), _("sh_unix_mlock"));
    42764297}
     
    43044325
    43054326  SL_ENTER(_("sh_unix_munlock"));
     4327
     4328  /* There's no cancellation point here, except if tracing is on
     4329   */
     4330  SH_MUTEX_LOCK_UNSAFE(mutex_mlock);
    43064331
    43074332  if (0 != page_locking)
     
    44124437
    44134438  page_locking = 0;
     4439  SH_MUTEX_UNLOCK_UNSAFE(mutex_mlock);
     4440
    44144441  SL_RETURN((status), _("sh_unix_munlock"));
    44154442}
  • trunk/src/sh_userfiles.c

    r111 r134  
    267267    /* We build a list in here because the samhain internals want to use
    268268     * getpwent() too */
     269    SH_MUTEX_LOCK(mutex_pwent);
    269270    /*@-unrecog@*/
    270271    sh_setpwent();
     
    292293        }
    293294    }
     295    sh_endpwent();
     296    SH_MUTEX_UNLOCK(mutex_pwent);
    294297
    295298    for (homes = userHomes; homes != NULL; homes = homes->next ) {
  • trunk/src/trustfile.c

    r131 r134  
    507507#endif
    508508
     509  int retval = SL_FALSE;
     510
    509511  SL_ENTER(_("onlytrustedingrp"));
    510512
     
    603605  /* now check ALL users for their GID !!!
    604606   */
     607  SH_MUTEX_LOCK(mutex_pwent);
     608
    605609  while (NULL != (w = sh_getpwent()))
    606610    {
     
    643647#endif
    644648              tf_baduid = w->pw_uid;
    645               SL_IRETURN(SL_FALSE, _("onlytrustedingrp"));
     649              retval = SL_FALSE;
     650              goto out;
     651              /* SL_IRETURN(SL_FALSE, _("onlytrustedingrp")); */
    646652            }
    647653        }
    648654    }
     655  retval = SL_TRUE;
     656
     657 out:
    649658
    650659#ifdef HAVE_ENDPWENT
    651660  sh_endpwent();
    652661#endif
     662
     663  SH_MUTEX_UNLOCK(mutex_pwent);
     664
    653665  /* TEST_ONLY */
    654666#endif
    655 
    656667  /* #ifdef HAVE_GETPWENT */
    657668#endif
    658669
    659670#ifdef TRUST_DEBUG
    660   fprintf(stderr,
    661           "trustfile: group %ld:  all members are trusted users --> OK\n",
    662           (UID_CAST)grp);
     671  if (retval == SL_TRUE)
     672    fprintf(stderr,
     673            "trustfile: group %ld:  all members are trusted users --> OK\n",
     674            (UID_CAST)grp);
    663675#endif
    664676  /* all found
    665677   */
    666   SL_IRETURN(SL_TRUE, _("onlytrustedingrp"));
     678  SL_IRETURN(retval, _("onlytrustedingrp"));
    667679}
    668680
Note: See TracChangeset for help on using the changeset viewer.