Changeset 134


Ignore:
Timestamp:
Oct 26, 2007, 12:20:10 AM (11 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.