Changeset 131


Ignore:
Timestamp:
Oct 22, 2007, 11:19:15 PM (12 years ago)
Author:
rainer
Message:

Use thread-safe libc functions.

Location:
trunk
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • trunk/configure.ac

    r129 r131  
    273273        initgroups getpagesize \ 
    274274        ttyname fchmod \ 
    275         getsid getpriority getpgid statvfs 
     275        getsid getpriority getpgid statvfs \ 
     276        fpathconf dirfd \ 
     277        getgrgid_r getpwnam_r getpwuid_r gmtime_r localtime_r rand_r readdir_r strtok_r 
    276278) 
    277279AC_CHECK_FUNC(statfs, AC_DEFINE(HAVE_STATFS) statfs="yes",  statfs="no") 
  • trunk/docs/Changelog

    r128 r131  
     12.4.0: 
     2        * eliminate alarm() for I/O timeout (replaced by select) 
     3        * use getgrgid_r, getpwnam_r, getpwuid_r, gmtime_r, localtime_r,  
     4          rand_r, strtok_r if available 
     5        * protect readdir() with mutex (readdir_r considered harmful) 
     6 
    172.3.8: 
    28        * new option PortCheckIgnore = interface:portlist 
  • trunk/docs/TODO

    r18 r131  
    11 
     2sh_unix_time: not thread_safe (static buffer) 
     3sh_error_message: not thread_safe (static buffer) 
     4 
     5check thread_safe sh_entropy 
     6 
     7lock NEED_LOCK 
     8 
     9globber 
     10 
     11sh_alloc/sh_free 
     12 
  • trunk/include/samhain.h

    r115 r131  
    4242#define SH_MAXBUF      4096 
    4343#define SH_PATHBUF      256 
     44 
     45#define SH_GRBUF_SIZE  4096 
     46#define SH_PWBUF_SIZE  4096 
    4447 
    4548/* Sizes for arrays (user, group, timestamp). 
  • trunk/include/sh_files.h

    r27 r131  
    2121#define SH_FILES_H 
    2222 
     23struct sh_dirent { 
     24  char             * sh_d_name; 
     25  struct sh_dirent * next; 
     26}; 
     27 
     28/* free a directory listing 
     29 */ 
     30void kill_sh_dirlist (struct sh_dirent * dirlist); 
     31 
     32/* add an entry to a directory listing 
     33 */ 
     34struct sh_dirent * addto_sh_dirlist (struct dirent * thisEntry,  
     35                                     struct sh_dirent * dirlist); 
    2336/* register exceptions to hardlink check 
    2437 */ 
  • trunk/include/sh_static.h

    r111 r131  
    1515void  sh_setpwent(void); 
    1616struct group * sh_getgrnam(const char *name); 
     17 
    1718struct passwd * sh_getpwnam(const char *name); 
     19int getpwnam_r(const char *name, struct passwd *pwbuf, 
     20               char *buf, size_t buflen, struct passwd **pwbufp); 
     21 
    1822struct group * sh_getgrgid(gid_t gid); 
     23int getgrgid_r(gid_t gid, struct group *gbuf, 
     24               char *buf, size_t buflen, struct group **gbufp); 
     25 
    1926struct passwd * sh_getpwuid(uid_t uid); 
     27int getpwuid_r(uid_t uid, struct passwd *pwbuf, 
     28               char *buf, size_t buflen, struct passwd **pwbufp); 
     29 
    2030#endif 
    2131 
     
    2939#define sh_initgroups initgroups 
    3040#define sh_getgrgid   getgrgid 
     41#define sh_getgrgid_r getgrgid_r 
     42#define sh_getpwnam   getpwnam 
     43#define sh_getpwnam_r getpwnam_r 
     44#define sh_getpwuid   getpwuid 
     45#define sh_getpwuid_r getpwuid_r 
    3146#define sh_getpwent   getpwent 
    32 #define sh_getpwnam   getpwnam 
    33 #define sh_getpwuid   getpwuid 
    3447#define sh_endpwent   endpwent 
    3548#define sh_setpwent   setpwent 
  • trunk/include/slib.h

    r76 r131  
    353353  int sl_read_timeout_prep (SL_TICKET ticket); 
    354354 
     355  int sl_read_timeout_fd (int fd, void * buf,  
     356                          size_t count, int timeout, int is_nonblocking); 
     357 
    355358  int sl_read_timeout (SL_TICKET ticket, void * buf,  
    356                        size_t count, int timeout); 
     359                       size_t count, int timeout, int is_nonblocking); 
    357360 
    358361  int sl_read_fast (SL_TICKET ticket, void * buf_in, size_t count); 
  • trunk/src/samhain.c

    r96 r131  
    6363 
    6464#include "samhain.h" 
     65#include "sh_pthread.h" 
    6566#include "sh_files.h" 
    6667#include "sh_utils.h" 
     
    450451  if (0 == strcmp (DEFAULT_MAILADDRESS, _("NULL"))) 
    451452    { 
     453#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     454      char * saveptr; 
     455      (void) sl_strncpy(q, DEFAULT_MAILADDRESS, SH_PATHBUF); 
     456      p = strtok_r (q, ", \t", &saveptr); 
     457      if (p) 
     458        { 
     459          (void) sh_mail_setaddress_int (p); 
     460          while (NULL != (p = strtok_r (NULL, ", \t", &saveptr))) 
     461            (void) sh_mail_setaddress_int (p); 
     462        } 
     463#else 
    452464      (void) sl_strncpy(q, DEFAULT_MAILADDRESS, SH_PATHBUF); 
    453465      p = strtok (q, ", \t"); 
     
    458470            (void) sh_mail_setaddress_int (p); 
    459471        } 
     472#endif 
    460473    } 
    461474#endif 
     
    747760      return NULL; 
    748761    } 
     762 
     763  SH_MUTEX_LOCK(readdir_lock); 
     764 
    749765  while (NULL != (d = readdir(dp)) && i < 65535) 
    750766    { 
     
    767783        } 
    768784    } 
     785 
     786  SH_MUTEX_UNLOCK(readdir_lock); 
     787 
    769788  closedir(dp); 
    770789  return pidlist; 
     
    12941313      if ( 0 == strcmp(argv[1], NOCL_CODE) ) 
    12951314        { 
     1315#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     1316          char * saveptr; 
     1317#endif 
    12961318          my_argv[0] = argv[0]; ++my_argc;   
    12971319          command_line[0] = '\0'; 
     
    12991321          command_line[sizeof(command_line)-1] = '\0'; 
    13001322          do { 
     1323#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
    13011324            my_argv[my_argc] =  
    1302               strtok( (my_argc == 1) ? command_line : NULL, " \n");  
     1325              strtok_r( (my_argc == 1) ? command_line : NULL, " \n", &saveptr); 
     1326#else 
     1327            my_argv[my_argc] =  
     1328              strtok( (my_argc == 1) ? command_line : NULL, " \n"); 
     1329#endif  
    13031330            if (my_argv[my_argc] != NULL) { 
    13041331              ++my_argc; 
  • trunk/src/sh_entropy.c

    r102 r131  
    276276#if defined (HAVE_URANDOM) 
    277277 
    278 #include <setjmp.h> 
    279  
    280 static jmp_buf          entropy_timeout; 
    281  
    282 static void sh_entropy_alarmhandle (int mysignal) 
    283 { 
    284   (void) mysignal; /* avoid compiler warning */ 
    285   longjmp (entropy_timeout, 1); 
    286 } 
    287  
    288  
    289278int read_mbytes(int timeout_val, char * path, char * nbuf, int nbytes) 
    290279{ 
    291   int count, m_count; 
     280  int m_count; 
    292281  int fd2; 
    293  
    294   struct  sigaction  new_act; 
    295   sigset_t           unblock; 
    296  
    297   struct sigaction      old_act; 
    298   volatile unsigned int old_alarm = 0; 
    299  
    300   new_act.sa_handler = sh_entropy_alarmhandle; 
    301   sigemptyset( &new_act.sa_mask );       /* set an empty mask       */ 
    302   new_act.sa_flags = 0;                  /* init sa_flags           */ 
    303  
    304   sigemptyset(&unblock); 
    305   sigaddset  (&unblock, SIGALRM); 
    306282 
    307283  SL_ENTER(_("read_mbytes")); 
     
    314290      if (0 == sh_unix_device_readable(fd2))  
    315291        { 
    316  
    317           /* alarm was triggered 
    318            */ 
    319           if (setjmp(entropy_timeout) != 0) 
    320             { 
    321               alarm(0); 
    322               sigaction (SIGALRM, &old_act, NULL); 
    323               alarm(old_alarm); 
    324               sigprocmask(SIG_UNBLOCK, &unblock, NULL); 
    325               TPT((0,FIL__,__LINE__, _("msg=<read_mbytes: timeout>\n")));  
    326               close (fd2); 
    327               SL_RETURN(0, _("read_mbytes")); 
    328             } 
    329  
    330           /* timeout after 30 seconds 
    331            */ 
    332           old_alarm = alarm(0); 
    333           sigaction (SIGALRM, &new_act, &old_act); 
    334           alarm(timeout_val); 
    335  
    336           m_count = 0; 
    337  
    338           while (m_count < nbytes)  
    339             { 
    340               errno = 0; /* paranoia */ 
    341               count = read (fd2, &nbuf[m_count], nbytes-m_count); 
    342  
    343               switch (count) 
    344                 { 
    345                 case -1: 
    346 #ifdef EWOULDBLOCK 
    347                   if (errno == EINTR || errno == EAGAIN || 
    348                       errno == EWOULDBLOCK) 
    349 #else 
    350                   if (errno == EINTR || errno == EAGAIN) 
    351 #endif 
    352                     continue; 
    353  
    354                   /* if errno == -1 && no continue: fallthrough to this */ 
    355                 case 0: 
    356                   break; 
    357                 default: 
    358                   m_count += count; 
    359                 } 
    360             } 
    361           close (fd2); 
    362  
    363           alarm(0); 
    364           sigaction (SIGALRM, &old_act, NULL); 
    365           alarm(old_alarm); 
    366           sigprocmask(SIG_UNBLOCK, &unblock, NULL); 
     292          m_count = sl_read_timeout_fd(fd2, &nbuf, nbytes,  
     293                                       timeout_val, SL_FALSE); 
     294          if (m_count < 0) 
     295            m_count = 0; 
    367296        } 
    368297      else 
     
    371300  else 
    372301    m_count = 0; 
     302 
     303  close(fd2); 
    373304 
    374305  TPT((0, FIL__, __LINE__, _("msg=<read_mbytes: OK>\n")));  
     
    568499  int pipedes[2]; 
    569500  FILE *outf = NULL; 
    570   struct passwd * tempres; 
    571501  char * arg[4]; 
    572502  char * envp[2]; 
     
    645575       */ 
    646576      i = 0;  
    647       if (0 == geteuid()) {   
    648         tempres = sh_getpwnam(DEFAULT_IDENT); 
    649         if (NULL != tempres) { 
    650           i = aud_setgid(FIL__, __LINE__, tempres->pw_gid);  
    651           if (i == 0) 
    652             i = sh_unix_initgroups(DEFAULT_IDENT ,tempres->pw_gid); 
    653           if (i == 0)  
    654             i = aud_setuid(FIL__, __LINE__, tempres->pw_uid); 
    655           /* make sure we cannot get root again 
    656            */ 
    657           if ((tempres->pw_uid != 0) && (aud_setuid(FIL__, __LINE__, 0) >= 0)) 
     577      if (0 == geteuid())  
     578        { 
     579#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     580          struct passwd    pwd; 
     581          char             buffer[SH_PWBUF_SIZE]; 
     582          struct passwd *  tempres; 
     583          sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres); 
     584#else 
     585          struct passwd * tempres = sh_getpwnam(DEFAULT_IDENT); 
     586#endif 
     587   
     588          if (NULL != tempres) { 
     589            i = aud_setgid(FIL__, __LINE__, tempres->pw_gid);  
     590            if (i == 0) 
     591              i = sh_unix_initgroups(DEFAULT_IDENT ,tempres->pw_gid); 
     592            if (i == 0)  
     593              i = aud_setuid(FIL__, __LINE__, tempres->pw_uid); 
     594            /* make sure we cannot get root again 
     595             */ 
     596            if ((tempres->pw_uid != 0) && (aud_setuid(FIL__, __LINE__, 0) >= 0)) 
     597              i = -1; 
     598          } else { 
    658599            i = -1; 
    659         } else { 
    660           i = -1; 
     600          } 
    661601        } 
    662       } 
    663602       
    664603      /* some problem ... 
  • trunk/src/sh_error.c

    r86 r131  
    257257 
    258258  do { 
    259     if (num == 0) 
    260       { 
    261         p = strtok (c, " ,\t"); 
    262         ++num; 
    263       } 
    264     else 
     259#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     260    char * saveptr; 
     261    if (num == 0) { 
     262      p = strtok_r (c, " ,\t", &saveptr); 
     263      ++num; 
     264    } else { 
     265      p = strtok_r (NULL, " ,\t", &saveptr); 
     266    } 
     267#else 
     268    if (num == 0) { 
     269      p = strtok (c, " ,\t"); 
     270      ++num; 
     271    } else { 
    265272      p = strtok (NULL, " ,\t"); 
     273    } 
     274#endif 
    266275 
    267276    if (p == NULL) 
  • trunk/src/sh_extern.c

    r102 r131  
    914914int sh_ext_uid (const char * user, /*@out@*/uid_t * uid, /*@out@*/gid_t * gid) 
    915915{ 
    916   struct passwd * tempres; 
     916  struct passwd *  tempres; 
     917#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     918  struct passwd    pwd; 
     919  char             buffer[SH_PWBUF_SIZE]; 
     920#endif 
    917921 
    918922  SL_ENTER(_("sh_ext_uid")); 
     
    924928      SL_RETURN (-1, _("sh_ext_uid")); 
    925929    } 
     930 
     931#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     932  sh_getpwnam_r(user, &pwd, buffer, sizeof(buffer), &tempres); 
     933#else 
    926934  tempres = sh_getpwnam(user); 
     935#endif 
    927936 
    928937  if (NULL != tempres)  
     
    959968  do 
    960969    { 
     970#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     971      char * saveptr; 
     972      if (i == 0) 
     973        p = strtok_r (new, ", \t", &saveptr); 
     974      else 
     975        p = strtok_r (NULL, ", \t", &saveptr); 
     976#else 
    961977      if (i == 0) 
    962978        p = strtok (new, ", \t"); 
    963979      else 
    964980        p = strtok (NULL, ", \t"); 
     981#endif 
     982 
    965983      if (p == NULL) 
    966984        break; 
  • trunk/src/sh_files.c

    r114 r131  
    6060#if (defined (SH_WITH_CLIENT) || defined (SH_STANDALONE))  
    6161 
     62#include "sh_pthread.h" 
    6263#include "sh_error.h" 
    6364#include "sh_utils.h" 
     
    191192  SL_RETURN((0), _("sh_files_setrecursion")); 
    192193} 
    193  
    194194 
    195195unsigned long sh_files_chk () 
     
    13401340} 
    13411341 
     1342/** 
    13421343struct sh_dirent { 
    1343   /* char               sh_d_name[NAME_MAX + 2]; */ 
    13441344  char             * sh_d_name; 
    13451345  struct sh_dirent * next; 
    13461346}; 
    1347  
    1348 static void kill_sh_dirlist (struct sh_dirent * dirlist) 
     1347**/ 
     1348 
     1349void kill_sh_dirlist (struct sh_dirent * dirlist) 
    13491350{ 
    13501351  struct sh_dirent * this; 
     
    13621363/* -- add an entry to a directory listing 
    13631364 */ 
    1364 static struct sh_dirent * addto_sh_dirlist (struct dirent * thisEntry,  
    1365                                             struct sh_dirent * dirlist) 
     1365struct sh_dirent * addto_sh_dirlist (struct dirent * thisEntry,  
     1366                                     struct sh_dirent * dirlist) 
    13661367{ 
    13671368  struct sh_dirent * this; 
     
    14851486  dir_type        theDir; 
    14861487  ShFileType      checkit; 
    1487  
     1488  static unsigned int state = 1; 
    14881489 
    14891490  file_type       theFile; 
     
    16331634  /* ---- read ---- 
    16341635   */ 
     1636  SH_MUTEX_LOCK(readdir_lock); 
     1637 
    16351638  do { 
    16361639      thisEntry = readdir (thisDir); 
     
    16521655  } while (thisEntry != NULL); 
    16531656 
     1657  SH_MUTEX_UNLOCK(readdir_lock); 
     1658 
    16541659  closedir (thisDir); 
    16551660 
     
    16721677 
    16731678    BREAKEXIT(sh_derr); 
    1674     if (0 == (rand() % 5)) 
    1675       (void) sh_derr(); 
     1679 
     1680#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_RAND_R) 
     1681    if (0 == (rand_r(&state) % 5)) (void) sh_derr(); 
     1682#else 
     1683    if (0 == state * (rand() % 5)) (void) sh_derr(); 
     1684#endif 
    16761685     
    16771686    /* ---- Check the file. ----  
     
    19291938  char          * fileName; 
    19301939  struct utimbuf  utime_buf; 
     1940  static unsigned int state = 1; 
    19311941 
    19321942  SL_ENTER(_("sh_files_filecheck")); 
    19331943 
    19341944  BREAKEXIT(sh_derr); 
    1935   if (0 == (rand() % 2)) 
    1936     (void) sh_derr(); 
     1945 
     1946#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_RAND_R) 
     1947  if (0 == (rand_r(&state) % 2)) (void) sh_derr(); 
     1948#else 
     1949  if (0 == state * (rand() % 2)) (void) sh_derr(); 
     1950#endif 
    19371951 
    19381952  if (dirName && infileName && (dirName[0] == '/') && (dirName[1] == '\0') 
  • trunk/src/sh_gpg.c

    r111 r131  
    292292      struct stat lbuf; 
    293293      int         status_stat = 0; 
     294#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     295      struct passwd    pwd; 
     296      char             buffer[SH_PWBUF_SIZE]; 
     297      struct passwd *  tempres; 
     298      sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres); 
     299#else 
    294300      struct passwd * tempres = sh_getpwnam(DEFAULT_IDENT); 
     301#endif 
    295302 
    296303      if (!tempres) 
     
    844851  while (NULL != fgets(line, sizeof(line), source.pipe)) 
    845852    { 
     853#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     854      char * saveptr = NULL; 
     855#endif 
    846856      if (line[strlen(line)-1] == '\n') 
    847857        line[strlen(line)-1] = ' '; 
     
    852862      if (sl_strlen(line) < 18)  
    853863        continue; 
     864#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     865      ptr = strtok_r (line, " ", &saveptr); 
     866#else 
    854867      ptr = strtok (line, " "); 
     868#endif 
    855869      while (ptr) 
    856870        { 
     871#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     872          ptr = strtok_r (NULL, " ", &saveptr); 
     873#else 
    857874          ptr = strtok (NULL, " "); 
     875#endif 
    858876          if (ptr && 0 == sl_strncmp (ptr, _("fingerprint"), 11)) 
    859877            { 
     878#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     879              ptr = strtok_r (NULL, " ", &saveptr); /* to '=' */ 
     880#else 
    860881              ptr = strtok (NULL, " "); /* to '=' */ 
     882#endif 
    861883              sign_fp[0] = '\0'; 
    862884              while (ptr) 
    863885                { 
     886#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     887                  ptr = strtok_r (NULL, " ", &saveptr); /* part of fingerprint */ 
     888#else 
    864889                  ptr = strtok (NULL, " "); /* part of fingerprint */ 
     890#endif 
    865891                  sl_strlcat (sign_fp, ptr, SH_MINIBUF+1); 
    866892                } 
     
    923949#if defined(SH_WITH_SERVER) 
    924950  struct passwd * tempres; 
    925 #endif 
     951#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     952  struct passwd    pwd; 
     953  char             buffer[SH_PWBUF_SIZE]; 
     954#endif 
     955#endif 
     956 
    926957#ifdef USE_FINGERPRINT 
    927958#include "sh_gpg_fp.h" 
     
    952983      TPT(((0), FIL__, __LINE__, _("msg=<GPG_CHECK: FD1 = %d>\n"), fd1)); 
    953984#if defined(SH_WITH_SERVER) 
     985#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     986      sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres); 
     987#else 
    954988      tempres = sh_getpwnam(DEFAULT_IDENT); 
     989#endif 
    955990 
    956991      if ((tempres != NULL) && (0 == sl_ret_euid())) 
     
    9691004      TPT(((0), FIL__, __LINE__, _("msg=<GPG_CHECK: FD2 = %d>\n"), fd2)); 
    9701005#if defined(SH_WITH_SERVER) 
     1006#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     1007      sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres); 
     1008#else 
    9711009      tempres = sh_getpwnam(DEFAULT_IDENT); 
     1010#endif 
    9721011 
    9731012      if ((tempres != NULL) && (0 == sl_ret_euid())) 
     
    10771116 
    10781117#if defined(SH_WITH_SERVER) 
     1118#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     1119      struct passwd    e_pwd; 
     1120      char             e_buffer[SH_PWBUF_SIZE]; 
     1121      struct passwd *  e_tempres; 
     1122      sh_getpwnam_r(DEFAULT_IDENT, &e_pwd, e_buffer, sizeof(e_buffer), &e_tempres); 
     1123#else 
    10791124      struct passwd * e_tempres = sh_getpwnam(DEFAULT_IDENT); 
     1125#endif 
    10801126 
    10811127      if ((e_tempres != NULL) && (0 == sl_ret_euid()))    
  • trunk/src/sh_hash.c

    r115 r131  
    36653665  time_t then = (time_t) p->theFile.mtime; 
    36663666 
     3667#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R) 
     3668  struct tm   * time_ptr; 
     3669  struct tm     time_tm; 
     3670 
     3671  time_ptr = gmtime_r(&then, &time_tm); 
     3672  strftime(thetime, 127, _("%b %d  %Y"), time_ptr); 
     3673  time_ptr = gmtime_r(&now,  &time_tm); 
     3674  strftime(nowtime, 127, _("%b %d  %Y"), time_ptr); 
     3675  if (0 == strncmp(&nowtime[7], &thetime[7], 4)) 
     3676    { 
     3677      time_ptr = gmtime_r(&then, &time_tm); 
     3678      strftime(thetime, 127, _("%b %d %H:%M"), time_ptr); 
     3679    } 
     3680#else 
    36673681  strftime(thetime, 127, _("%b %d  %Y"), gmtime(&then)); 
    36683682  strftime(nowtime, 127, _("%b %d  %Y"), gmtime(&now)); 
    36693683  if (0 == strncmp(&nowtime[7], &thetime[7], 4)) 
    36703684    strftime(thetime, 127, _("%b %d %H:%M"), gmtime(&then)); 
     3685#endif 
    36713686 
    36723687  tmp = sh_util_safe_name(p->fullpath); 
  • trunk/src/sh_html.c

    r34 r131  
    3434#endif 
    3535#endif 
     36#include <unistd.h> 
    3637 
    3738 
     
    9091  time_t    now; 
    9192  struct tm   * time_ptr; 
     93#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     94  struct tm    time_tm; 
     95#endif 
    9296 
    9397  char    * formatted; 
     
    148152      if (!SL_ISERROR(status)) 
    149153        { 
     154#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     155          time_ptr   = localtime_r (&(server_status.start), &time_tm); 
     156#else 
    150157          time_ptr   = localtime (&(server_status.start)); 
     158#endif 
    151159          if (time_ptr != NULL)  
    152160            status = strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr); 
    153161          now = time(NULL); 
     162#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     163          time_ptr   = localtime_r (&now, &time_tm); 
     164#else 
    154165          time_ptr   = localtime (&now); 
     166#endif 
    155167          if (time_ptr != NULL)  
    156168            status = strftime (ts2, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr); 
     
    174186          if (server_status.last > (time_t) 0) 
    175187            { 
     188#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     189              time_ptr   = localtime_r (&(server_status.last), &time_tm); 
     190#else 
    176191              time_ptr   = localtime (&(server_status.last)); 
     192#endif 
    177193              if (time_ptr != NULL)  
    178194                status = strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr); 
  • trunk/src/sh_kern.c

    r114 r131  
    5858 
    5959#include "samhain.h" 
     60#include "sh_pthread.h" 
    6061#include "sh_utils.h" 
    6162#include "sh_error.h" 
     
    966967  if (df) 
    967968    { 
     969      SH_MUTEX_LOCK(readdir_lock); 
     970 
    968971      while (NULL != (entry = readdir(df))) 
    969972        { 
     
    977980          SH_FREE(pcipath); 
    978981        } 
     982 
     983      SH_MUTEX_UNLOCK(readdir_lock); 
     984 
    979985      closedir(df); 
    980986    } 
  • trunk/src/sh_mail.c

    r34 r131  
    654654/* The mailer. 
    655655 */ 
    656 static int sh_mail_end_conn (FILE * connfile); 
    657 static FILE * sh_mail_start_conn (int aFlag); 
     656static int sh_mail_end_conn (FILE * connfile, int fd); 
     657static FILE * sh_mail_start_conn (int aFlag, int * fd); 
    658658 
    659659static 
     
    797797 
    798798    static  int ma_block = 0; 
     799 
     800    int       ma_socket = -1; 
    799801 
    800802    SH_FIFO * fifo_temp = NULL; 
     
    10651067        while (address_list[i] != NULL && i < address_num) 
    10661068          { 
    1067             connfile = sh_mail_start_conn (i); 
     1069            connfile = sh_mail_start_conn (i, &ma_socket); 
    10681070             
    10691071            if (NULL != connfile) 
     
    10731075                wrlen -= sl_strlen(mailMsg); 
    10741076                if (wrlen == 0)  
    1075                   status = sh_mail_end_conn (connfile); 
     1077                  status = sh_mail_end_conn (connfile, ma_socket); 
    10761078                else 
    10771079                  status = -1; 
     
    11011103    else 
    11021104      { 
    1103         connfile = sh_mail_start_conn ( -9 ); 
     1105        connfile = sh_mail_start_conn ( -9 , &ma_socket); 
    11041106         
    11051107        if (NULL != connfile) 
     
    11081110            wrlen -= sl_strlen(mailMsg); 
    11091111            if (wrlen == 0) 
    1110               status = sh_mail_end_conn (connfile); 
     1112              status = sh_mail_end_conn (connfile, ma_socket); 
    11111113            else 
    11121114              status = -1; 
     
    12871289static time_t time_wait = 300; 
    12881290 
    1289 static FILE * sh_mail_start_conn (int aFlag) 
     1291static FILE * sh_mail_start_conn (int aFlag, int * ma_socket) 
    12901292{ 
    12911293  char       * address; 
     
    13021304  FILE       * connFile = NULL; 
    13031305  struct tm  * my_tm; 
     1306#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     1307  struct tm    time_tm; 
     1308#endif 
    13041309  time_t       my_time; 
    13051310  char         my_tbuf[128]; 
     
    13121317  SL_ENTER(_("sh_mail_start_conn")); 
    13131318 
    1314   time_wait = 300; 
     1319  *ma_socket = -1; 
     1320  time_wait  = 300; 
    13151321 
    13161322  if (aFlag >= 0) 
     
    14161422  /* say HELO to the other socket 
    14171423   */ 
    1418   if (0 == sh_mail_wait (220, connFile))  
     1424  if (0 == sh_mail_wait (220, fd))  
    14191425    { 
    14201426      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,  
     
    14461452  (void) fflush(connFile); 
    14471453 
    1448   if (0 == sh_mail_wait(250, connFile))  
     1454  if (0 == sh_mail_wait(250, fd))  
    14491455    { 
    14501456      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,  
     
    14791485  (void) fflush(connFile); 
    14801486 
    1481   if (0 == sh_mail_wait(250, connFile))  
     1487  if (0 == sh_mail_wait(250, fd))  
    14821488    { 
    14831489      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,  
     
    15001506      (void) fflush(connFile); 
    15011507 
    1502       if (0 == sh_mail_wait(250, connFile))  
     1508      if (0 == sh_mail_wait(250, fd))  
    15031509        { 
    15041510          sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,  
     
    15241530          (void) fflush(connFile); 
    15251531           
    1526           if (0 == sh_mail_wait(250, connFile))  
     1532          if (0 == sh_mail_wait(250, fd))  
    15271533            { 
    15281534              sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,  
     
    15491555  (void) fflush(connFile); 
    15501556 
    1551   if (0 == sh_mail_wait(354, connFile))  
     1557  if (0 == sh_mail_wait(354, fd))  
    15521558    { 
    15531559      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_NET,  
     
    15611567 
    15621568  my_time = time(NULL); 
     1569#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     1570  my_tm   = localtime_r(&my_time, &time_tm); 
     1571#else 
    15631572  my_tm   = localtime(&my_time); 
     1573#endif 
    15641574  (void)    strftime(my_tbuf, 127, _("%a, %d %b %Y %H:%M:%S %Z"), my_tm); 
    15651575 
     
    15761586          my_tbuf, 13, 10); 
    15771587 
     1588  *ma_socket = fd; 
    15781589  SL_RETURN( connFile, _("sh_mail_start_conn")); 
    15791590} 
     
    15851596 */ 
    15861597 
    1587 static int sh_mail_end_conn (FILE * connFile) 
     1598static int sh_mail_end_conn (FILE * connFile, int fd) 
    15881599{ 
    15891600  SL_ENTER(_("sh_mail_end_conn")); 
     
    15971608  TPT(( 0, FIL__, __LINE__, _("msg=<message end written>\n"))); 
    15981609 
    1599   if (0 != sh_mail_wait(250, connFile)) 
     1610  if (0 != sh_mail_wait(250, fd)) 
    16001611    {   
    16011612      (void) fflush(connFile); 
     
    16251636 */ 
    16261637 
    1627 static jmp_buf wait_timeout; 
    1628  
    1629 static void sh_mail_alarmhandle (int mysignal) 
    1630 { 
    1631   /*@-noeffect@*/ 
    1632   (void) mysignal; /* avoid compiler warning */ 
    1633   /*@+noeffect@*/ 
    1634  
    1635   longjmp(wait_timeout, 1); 
    1636 } 
    1637  
    1638 static int sh_mail_wait(int code, FILE * ma_socket) 
     1638static int sh_mail_wait(int code, int ma_socket) 
    16391639{ 
    16401640  int rcode, g; 
     1641 
     1642  char c; 
    16411643 
    16421644  char errmsg[128]; 
     
    16511653  time_t waited_time; 
    16521654 
    1653   struct   sigaction          old_act; 
    1654   volatile unsigned int       old_alarm = 0; 
    1655  
    1656   struct  sigaction  new_act; 
    1657   sigset_t           unblock; 
    1658  
    1659   (void) sigemptyset(&unblock); 
    1660   (void) sigaddset  (&unblock, SIGALRM); 
    1661  
    1662   new_act.sa_handler = sh_mail_alarmhandle; 
    1663   (void) sigemptyset( &new_act.sa_mask );       /* set an empty mask       */ 
    1664   new_act.sa_flags = 0;                         /* init sa_flags           */ 
    1665  
    16661655  SL_ENTER(_("mail_wait")); 
    16671656   
    1668   /* alarm was triggered 
    1669    */ 
    1670   if (setjmp(wait_timeout) != 0) 
    1671     { 
    1672       (void) alarm(0); 
    1673       (void) sigaction (SIGALRM, &old_act, NULL); 
    1674       (void) alarm(old_alarm); 
    1675       (void) sigprocmask(SIG_UNBLOCK, &unblock, NULL); 
    1676       TPT((0, FIL__, __LINE__, _("msg=<mail_wait: timeout>\n")));  
    1677       SL_RETURN( 0, _("mail_wait")); 
    1678     } 
    1679  
    16801657  waited_time = time(NULL); 
    16811658 
    16821659  /* timeout after 5 minutes 
    16831660   */ 
    1684   old_alarm = alarm(0); 
    1685   (void) sigaction (SIGALRM, &new_act, &old_act); 
    1686   (void) alarm((unsigned int) time_wait); 
    16871661 
    16881662  rcode = 0; 
    16891663  state = WAIT_CODE_START; 
    16901664 
    1691   while (0 == feof(ma_socket) && 0 == ferror(ma_socket)) { 
     1665  while (sl_read_timeout_fd (ma_socket, &c, 1, time_wait, SL_FALSE) > 0) { 
     1666 
     1667    g = (int) c; 
    16921668 
    16931669    if ( (g=fgetc(ma_socket)) == EOF) 
    16941670      { 
    1695         (void) alarm(0); 
    1696         (void) sigaction (SIGALRM, &old_act, NULL);  
    1697         (void) alarm(old_alarm); 
    1698         (void) sigprocmask(SIG_UNBLOCK, &unblock, NULL); 
    16991671        TPT((0, FIL__, __LINE__, _("msg=<mail_wait: EOF>\n")));  
    17001672        SL_RETURN( 0, _("mail_wait"));  
     
    17331705        break; 
    17341706      /*@-charintliteral@*/ 
    1735       (void) alarm(0); 
    1736       (void) sigaction (SIGALRM, &old_act, NULL);  
    1737       (void) alarm(old_alarm); 
    1738       (void) sigprocmask(SIG_UNBLOCK, &unblock, NULL); 
    17391707 
    17401708      TPT((0, FIL__, __LINE__,  
     
    17691737       
    17701738    default: 
    1771       (void) alarm(0); 
    1772       (void) sigaction (SIGALRM, &old_act, NULL);  
    1773       (void) alarm(old_alarm); 
    1774       (void) sigprocmask(SIG_UNBLOCK, &unblock, NULL); 
    17751739 
    17761740      TPT((0, FIL__, __LINE__, _("msg=<mail_wait: bad>\n")));  
     
    17791743    } 
    17801744  } 
    1781  
    1782   (void) alarm(0);                            /* Disable alarm       */ 
    1783   (void) sigaction (SIGALRM, &old_act, NULL);  
    1784   (void) alarm(old_alarm); 
    1785   (void) sigprocmask(SIG_UNBLOCK, &unblock, NULL); 
    17861745 
    17871746  TPT((0, FIL__, __LINE__, _("msg=<mail_wait: failed>\n")));  
  • trunk/src/sh_portcheck.c

    r128 r131  
    11451145  char * list; 
    11461146  char * p; 
     1147#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     1148  char * saveptr; 
     1149#endif 
    11471150 
    11481151  if (!str) 
     
    11871190 
    11881191  list = sh_util_strdup(&str[ll]); 
     1192#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     1193  p    = strtok_r (list, " ,\t", &saveptr); 
     1194#else 
    11891195  p    = strtok (list, " ,\t"); 
     1196#endif 
    11901197  if (!p) 
    11911198    { 
     
    12021209          return -1; 
    12031210        } 
     1211#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     1212      p    = strtok_r (NULL, " ,\t", &saveptr); 
     1213#else 
    12041214      p    = strtok (NULL, " ,\t"); 
     1215#endif 
    12051216    } 
    12061217  SH_FREE(interface); 
  • trunk/src/sh_prelink.c

    r107 r131  
    8484    return S_FALSE; 
    8585 
    86   status = sl_read_timeout (fd, magic, 4, alert_timeout); 
     86  status = sl_read_timeout (fd, magic, 4, alert_timeout, SL_FALSE); 
    8787  (void) sl_rewind(fd); 
    8888  if (status == 4) 
  • trunk/src/sh_prelude.c

    r108 r131  
    8383#include "sh_error_min.h" 
    8484#include "sh_prelude.h" 
     85#define SH_NEED_PWD_GRP 1 
     86#include "sh_static.h" 
    8587 
    8688/* 
     
    138140        char * p; 
    139141        char * dup = strdup (str); 
     142#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     143        char * saveptr; 
     144#endif 
    140145 
    141146        if (!dup)  
    142147                return -1; 
    143148 
     149#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     150        p = strtok_r (dup, ", \t", &saveptr); 
     151#else 
    144152        p = strtok (dup, ", \t"); 
     153#endif 
    145154        if (p) { 
    146155                do { 
     
    165174                                return -1; 
    166175                        } 
     176#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     177                        p = strtok_r (NULL, ", \t", &saveptr); 
     178#else 
    167179                        p = strtok (NULL, ", \t"); 
     180#endif 
    168181                } while (p); 
    169182        } 
     
    679692        idmef_node_t *node; 
    680693        struct passwd *pw; 
     694#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     695        struct passwd pwd; 
     696        char buffer[SH_PWBUF_SIZE]; 
     697#endif 
    681698        prelude_string_t *str; 
    682699        idmef_user_id_t *user_id; 
     
    763780                idmef_user_id_set_type(user_id, IDMEF_USER_ID_TYPE_TARGET_USER); 
    764781                 
    765                 pw = getpwnam(ptr); 
     782#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     783                sh_getpwnam_r(ptr, &pwd, buffer, sizeof(buffer), &pw); 
     784#else 
     785                pw = sh_getpwnam(ptr); 
     786#endif 
    766787                if ( pw ) 
    767788                        idmef_user_id_set_number(user_id, pw->pw_uid); 
  • trunk/src/sh_schedule.c

    r34 r131  
    130130  struct tm * tval; 
    131131  int count, i, nval; 
     132#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     133  struct tm     time_tm; 
     134#endif 
    132135 
    133136  if (!isched) 
     
    135138 
    136139  now  = time(NULL); 
     140#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     141  tval = localtime_r(&now, &time_tm); 
     142#else 
    137143  tval = localtime(&now); 
    138  
     144#endif 
    139145  count = 0; 
    140146  for (i = 0; i < 5; ++i) 
     
    320326  int    i = 0; 
    321327  size_t len; 
     328#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     329  char * saveptr; 
     330#endif 
    322331 
    323332  if (!ssched || !isched) 
     
    332341  sl_strlcpy(copy, ssched, len); 
    333342 
     343#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     344  p = strtok_r(copy, " \t", &saveptr); /* parse crontab-style schedule */ 
     345#else 
    334346  p = strtok(copy, " \t"); /* parse crontab-style schedule */ 
     347#endif 
     348 
    335349  if (!p) 
    336350    goto err;  
     
    340354  for (i = 1; i < 5; ++i) 
    341355    { 
     356#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     357      p = strtok_r(NULL, " \t", &saveptr); /* parse crontab-style schedule */ 
     358#else 
    342359      p = strtok(NULL, " \t"); /* parse crontab-style schedule */ 
     360#endif 
    343361      if (!p) 
    344362        goto err;  
     
    420438    { 
    421439      if (test_sched(&isched)) 
    422         printf("EXECUTE  at: %s", ctime(&(isched.last_exec))); 
     440        printf("EXECUTE  at: %s", ctime(&(isched.last_exec))); /* TESTONLY */ 
    423441      sleep (1); /* TESTONLY */ 
    424442    } 
  • trunk/src/sh_suidchk.c

    r119 r131  
    7171 
    7272#include "samhain.h" 
     73#include "sh_pthread.h" 
    7374#include "sh_utils.h" 
    7475#include "sh_error.h" 
     
    842843  char            fileHash[2*(KEY_LEN + 1)]; 
    843844 
     845  struct sh_dirent * dirlist = NULL; 
     846  struct sh_dirent * dirlist_orig = NULL; 
    844847 
    845848  SL_ENTER(_("sh_suidchk_check_internal")); 
     
    870873  /* Loop over directory entries 
    871874   */ 
     875  SH_MUTEX_LOCK(readdir_lock); 
     876 
    872877  do { 
    873878 
     
    886891        continue; 
    887892 
    888       tmpcat = SH_ALLOC(PATH_MAX); 
    889       (void) sl_strlcpy(tmpcat, iname, PATH_MAX); 
    890  
    891       if ((sl_strlen(tmpcat) != sl_strlen(iname)) || (tmpcat[0] == '\0')) 
    892         { 
    893           sl_status = SL_ETRUNC; 
    894         } 
    895       else 
    896         { 
    897           if (tmpcat[1] != '\0')  
    898             sl_status = sl_strlcat(tmpcat, "/",                 PATH_MAX); 
    899         } 
    900  
    901       if (! SL_ISERROR(sl_status)) 
    902         sl_status = sl_strlcat(tmpcat, thisEntry->d_name,   PATH_MAX); 
    903  
    904       if (SL_ISERROR(sl_status)) 
    905         { 
    906           tmp = sh_util_safe_name(tmpcat); 
    907           sh_error_handle ((-1), FIL__, __LINE__, (int) sl_status,  
    908                            MSG_E_SUBGPATH, 
    909                            _("path too long"), 
    910                            _("sh_suidchk_check_internal"), tmp ); 
    911           SH_FREE(tmp); 
    912           continue; 
    913         } 
    914  
    915       ++FileLimNum; 
    916       ++FileLimTotal; 
    917  
    918       /* Rate limit (Fps == Files per second) 
    919        */ 
    920       if ((ShSuidchkFps > 0 && FileLimNum > ShSuidchkFps && FileLimTotal > 0)&& 
    921           (ShSuidchkYield == S_FALSE)) 
    922         { 
    923           FileLimNum  = 0; 
    924           FileLimNow  = time(NULL); 
    925   
    926           if ( (FileLimNow  - FileLimStart) > 0 &&  
    927                FileLimTotal/(FileLimNow  - FileLimStart) > ShSuidchkFps ) 
    928             (void) retry_msleep((int)((FileLimTotal/(FileLimNow-FileLimStart))/ 
    929                    ShSuidchkFps) , 0); 
    930         } 
     893      dirlist = addto_sh_dirlist (thisEntry, dirlist); 
     894    } 
     895 
     896  } while (thisEntry != NULL); 
     897 
     898  SH_MUTEX_UNLOCK(readdir_lock); 
     899 
     900  closedir(thisDir); 
     901 
     902  dirlist_orig = dirlist; 
     903 
     904  do { 
     905 
     906    /* If the directory is empty, dirlist = NULL 
     907     */ 
     908    if (!dirlist) 
     909      break; 
     910 
     911    tmpcat = SH_ALLOC(PATH_MAX); 
     912    (void) sl_strlcpy(tmpcat, iname, PATH_MAX); 
     913     
     914    if ((sl_strlen(tmpcat) != sl_strlen(iname)) || (tmpcat[0] == '\0')) 
     915      { 
     916        sl_status = SL_ETRUNC; 
     917      } 
     918    else 
     919      { 
     920        if (tmpcat[1] != '\0')  
     921          sl_status = sl_strlcat(tmpcat, "/",                 PATH_MAX); 
     922      } 
     923 
     924    if (! SL_ISERROR(sl_status)) 
     925      sl_status = sl_strlcat(tmpcat, dirlist->sh_d_name,   PATH_MAX); 
     926 
     927    if (SL_ISERROR(sl_status)) 
     928      { 
     929        tmp = sh_util_safe_name(tmpcat); 
     930        sh_error_handle ((-1), FIL__, __LINE__, (int) sl_status,  
     931                         MSG_E_SUBGPATH, 
     932                         _("path too long"), 
     933                         _("sh_suidchk_check_internal"), tmp ); 
     934        SH_FREE(tmp); 
     935        dirlist = dirlist->next; 
     936        continue; 
     937      } 
     938 
     939    ++FileLimNum; 
     940    ++FileLimTotal; 
     941 
     942    /* Rate limit (Fps == Files per second) 
     943     */ 
     944    if ((ShSuidchkFps > 0 && FileLimNum > ShSuidchkFps && FileLimTotal > 0)&& 
     945        (ShSuidchkYield == S_FALSE)) 
     946      { 
     947        FileLimNum  = 0; 
     948        FileLimNow  = time(NULL); 
     949         
     950        if ( (FileLimNow  - FileLimStart) > 0 &&  
     951             FileLimTotal/(FileLimNow  - FileLimStart) > ShSuidchkFps ) 
     952          (void) retry_msleep((int)((FileLimTotal/(FileLimNow-FileLimStart))/ 
     953                                    ShSuidchkFps) , 0); 
     954      } 
    931955               
    932       status = (int) retry_lstat(FIL__, __LINE__, tmpcat, &buf); 
    933  
    934       if (status != 0) 
    935         { 
    936           status = errno; 
    937           tmp = sh_util_safe_name(tmpcat); 
    938           sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, status, MSG_ERR_LSTAT, 
    939                            sh_error_message(status), 
    940                            tmpcat ); 
    941           SH_FREE(tmp); 
    942         } 
    943       else 
    944         { 
    945           if (/*@-usedef@*/S_ISDIR(buf.st_mode)/*@+usedef@*/ && 
    946               (ShSuidchkExclude == NULL ||  
    947                0 != strcmp(tmpcat, ShSuidchkExclude))) 
    948             { 
    949               /* fs is a STATIC string or NULL 
    950                */ 
    951               fs = filesystem_type (tmpcat, tmpcat, &buf); 
    952               if (fs != NULL  
     956    status = (int) retry_lstat(FIL__, __LINE__, tmpcat, &buf); 
     957 
     958    if (status != 0) 
     959      { 
     960        status = errno; 
     961        tmp = sh_util_safe_name(tmpcat); 
     962        sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, status, MSG_ERR_LSTAT, 
     963                         sh_error_message(status), 
     964                         tmpcat ); 
     965        SH_FREE(tmp); 
     966      } 
     967    else 
     968      { 
     969        if (/*@-usedef@*/S_ISDIR(buf.st_mode)/*@+usedef@*/ && 
     970            (ShSuidchkExclude == NULL ||  
     971             0 != strcmp(tmpcat, ShSuidchkExclude))) 
     972          { 
     973            /* fs is a STATIC string or NULL 
     974             */ 
     975            fs = filesystem_type (tmpcat, tmpcat, &buf); 
     976            if (fs != NULL  
    953977#ifndef SH_SUIDTESTDIR 
    954                   &&  
    955                   0 != strncmp (_("afs"),     fs, 3) &&  
    956                   0 != strncmp (_("devfs"),   fs, 5) && 
    957                   0 != strncmp (_("iso9660"), fs, 7) && 
    958                   0 != strncmp (_("lustre"),  fs, 6) && 
    959                   0 != strncmp (_("mmfs"),    fs, 4) &&  
    960                   0 != strncmp (_("msdos"),   fs, 5) && 
    961                   0 != strncmp (_("nfs"),     fs, 3) && 
    962                   0 != strncmp (_("proc"),    fs, 4) && 
    963                   0 != strncmp (_("vfat"),    fs, 4) 
     978                &&  
     979                0 != strncmp (_("afs"),     fs, 3) &&  
     980                0 != strncmp (_("devfs"),   fs, 5) && 
     981                0 != strncmp (_("iso9660"), fs, 7) && 
     982                0 != strncmp (_("lustre"),  fs, 6) && 
     983                0 != strncmp (_("mmfs"),    fs, 4) &&  
     984                0 != strncmp (_("msdos"),   fs, 5) && 
     985                0 != strncmp (_("nfs"),     fs, 3) && 
     986                0 != strncmp (_("proc"),    fs, 4) && 
     987                0 != strncmp (_("vfat"),    fs, 4) 
    964988#endif  
     989                ) 
     990              { 
     991                if ((ShSuidchkNosuid == S_TRUE) ||  
     992                    (0 != strncmp (_("nosuid"),  fs, 6))) 
     993                  /* fprintf(stderr, "%s: %s\n", fs, tmpcat); */ 
     994                  (void) sh_suidchk_check_internal(tmpcat); 
     995              } 
     996          } 
     997        else if (S_ISREG(buf.st_mode) && 
     998                 (0 !=(S_ISUID & buf.st_mode) || 
     999#if defined(HOST_IS_LINUX) 
     1000                  (0 !=(S_ISGID & buf.st_mode) &&  
     1001                   0 !=(S_IXGRP & buf.st_mode))  
     1002#else   
     1003                  0 !=(S_ISGID & buf.st_mode) 
     1004#endif 
    9651005                  ) 
    966                 { 
    967                   if ((ShSuidchkNosuid == S_TRUE) ||  
    968                       (0 != strncmp (_("nosuid"),  fs, 6))) 
    969                     /* fprintf(stderr, "%s: %s\n", fs, tmpcat); */ 
    970                     (void) sh_suidchk_check_internal(tmpcat); 
    971                 } 
    972             } 
    973           else if (S_ISREG(buf.st_mode) && 
    974                    (0 !=(S_ISUID & buf.st_mode) || 
    975 #if defined(HOST_IS_LINUX) 
    976                     (0 !=(S_ISGID & buf.st_mode) &&  
    977                      0 !=(S_IXGRP & buf.st_mode))  
    978 #else   
    979                     0 !=(S_ISGID & buf.st_mode) 
    980 #endif 
    981                     ) 
    982                    ) 
    983             { 
    984                
    985               (void) sl_strlcpy (theFile.fullpath, tmpcat, PATH_MAX); 
    986               theFile.check_mask  = sh_files_maskof(SH_LEVEL_READONLY); 
    987               CLEAR_SH_FFLAG_REPORTED(theFile.file_reported); 
    988               theFile.attr_string = NULL; 
    989  
    990               status = sh_unix_getinfo (ShDFLevel[SH_ERR_T_RO],  
    991                                         thisEntry->d_name, 
    992                                         &theFile, fileHash, 0); 
    993  
    994               tmp = sh_util_safe_name(tmpcat); 
    995  
    996               if (status != 0) 
    997                 { 
    998                   sh_error_handle (ShSuidchkSeverity, FIL__, __LINE__,  
    999                                    0, MSG_E_SUBGPATH, 
    1000                                    _("Could not check suid/sgid file"), 
    1001                                    _("sh_suidchk_check_internal"), 
    1002                                    tmp); 
    1003                 } 
    1004               else 
    1005                 { 
    1006  
    1007                   if ( sh.flag.update   == S_TRUE &&  
    1008                       (sh.flag.checkSum == SH_CHECK_INIT  ||  
    1009                        sh.flag.checkSum == SH_CHECK_CHECK)) 
    1010                     { 
    1011                       /* Updating database. Report new files that 
    1012                        * are not in database already. Then compare 
    1013                        * to database and report changes. 
    1014                        */ 
    1015                       if (-1 == sh_hash_have_it (tmpcat)) 
    1016                         { 
    1017                           sh_error_handle ((-1), FIL__, __LINE__,  
    1018                                            0, MSG_SUID_FOUND, tmp ); 
    1019                         } 
    1020                       else 
    1021                         { 
    1022                           sh_error_handle (SH_ERR_ALL, FIL__, __LINE__,  
    1023                                            0, MSG_SUID_FOUND, tmp ); 
    1024                         } 
    1025  
    1026                       if (0 == sh_hash_compdata (SH_LEVEL_READONLY,  
     1006                 ) 
     1007          { 
     1008             
     1009            (void) sl_strlcpy (theFile.fullpath, tmpcat, PATH_MAX); 
     1010            theFile.check_mask  = sh_files_maskof(SH_LEVEL_READONLY); 
     1011            CLEAR_SH_FFLAG_REPORTED(theFile.file_reported); 
     1012            theFile.attr_string = NULL; 
     1013             
     1014            status = sh_unix_getinfo (ShDFLevel[SH_ERR_T_RO],  
     1015                                      thisEntry->d_name, 
     1016                                      &theFile, fileHash, 0); 
     1017             
     1018            tmp = sh_util_safe_name(tmpcat); 
     1019             
     1020            if (status != 0) 
     1021              { 
     1022                sh_error_handle (ShSuidchkSeverity, FIL__, __LINE__,  
     1023                                 0, MSG_E_SUBGPATH, 
     1024                                 _("Could not check suid/sgid file"), 
     1025                                 _("sh_suidchk_check_internal"), 
     1026                                 tmp); 
     1027              } 
     1028            else 
     1029              { 
     1030                 
     1031                if ( sh.flag.update   == S_TRUE &&  
     1032                     (sh.flag.checkSum == SH_CHECK_INIT  ||  
     1033                      sh.flag.checkSum == SH_CHECK_CHECK)) 
     1034                  { 
     1035                    /* Updating database. Report new files that 
     1036                     * are not in database already. Then compare 
     1037                     * to database and report changes. 
     1038                     */ 
     1039                    if (-1 == sh_hash_have_it (tmpcat)) 
     1040                      { 
     1041                        sh_error_handle ((-1), FIL__, __LINE__,  
     1042                                         0, MSG_SUID_FOUND, tmp ); 
     1043                      } 
     1044                    else 
     1045                      { 
     1046                        sh_error_handle (SH_ERR_ALL, FIL__, __LINE__,  
     1047                                         0, MSG_SUID_FOUND, tmp ); 
     1048                      } 
     1049                     
     1050                    if (0 == sh_hash_compdata (SH_LEVEL_READONLY,  
     1051                                               &theFile, fileHash, 
     1052                                               _("[SuidCheck]"),  
     1053                                               ShSuidchkSeverity)) 
     1054                      { 
     1055                        sh_hash_pushdata_memory (&theFile, fileHash); 
     1056                      } 
     1057                     
     1058                    sh_hash_addflag(tmpcat, SH_FFLAG_SUIDCHK); 
     1059                     
     1060                  } 
     1061                 
     1062                else if (sh.flag.checkSum == SH_CHECK_INIT  &&  
     1063                         sh.flag.update == S_FALSE ) 
     1064                  { 
     1065                    /* Running init. Report on files detected. 
     1066                     */ 
     1067                    sh_hash_pushdata (&theFile, fileHash); 
     1068                    sh_error_handle ((-1), FIL__, __LINE__,  
     1069                                     0, MSG_SUID_FOUND, tmp ); 
     1070                  } 
     1071                 
     1072                else if (sh.flag.checkSum == SH_CHECK_CHECK ) 
     1073                  { 
     1074                    /* Running file check. Report on new files 
     1075                     * detected, and quarantine them. 
     1076                     */ 
     1077                    sh_error_handle (SH_ERR_ALL, FIL__, __LINE__,  
     1078                                     0, MSG_SUID_FOUND, tmp ); 
     1079                     
     1080                    fflags = sh_hash_getflags(tmpcat); 
     1081                     
     1082                    if ( (-1 == fflags) || (!SH_FFLAG_SUIDCHK_SET(fflags))) 
     1083                      { 
     1084                        if (-1 == fflags) 
     1085                          report_file(tmpcat, &theFile, timestrc, timestra, timestrm); 
     1086                         
     1087                        /* Quarantine file according to configured method 
     1088                         */ 
     1089                        if (ShSuidchkQEnable == S_TRUE) 
     1090                          { 
     1091                            switch (ShSuidchkQMethod) 
     1092                              { 
     1093                              case SH_Q_DELETE: 
     1094                                sh_q_delete(theFile.fullpath); 
     1095                                break; 
     1096                              case SH_Q_CHANGEPERM: 
     1097                                sh_q_changeperm(theFile.fullpath); 
     1098                                break; 
     1099                              case SH_Q_MOVE: 
     1100                                sh_q_move(theFile.fullpath, &theFile, timestrc, timestra, timestrm); 
     1101                                break; 
     1102                              default: 
     1103                                sh_error_handle (ShSuidchkSeverity, FIL__, 
     1104                                                 __LINE__, 0, MSG_SUID_QREPORT, 
     1105                                                 _("Bad quarantine method"), tmp); 
     1106                                break; 
     1107                              } 
     1108                          } 
     1109                        else 
     1110                          { 
     1111                            /* 1.8.1 push file to in-memory database 
     1112                             */ 
     1113                            (void) sh_hash_compdata (SH_LEVEL_READONLY, 
     1114                                                     &theFile, fileHash, 
     1115                                                     _("[SuidCheck]"), 
     1116                                                     ShSuidchkSeverity); 
     1117                             
     1118                            sh_hash_addflag(tmpcat, SH_FFLAG_SUIDCHK); 
     1119                             
     1120                          } 
     1121                      } 
     1122                    else 
     1123                      { 
     1124                        /* File exists. Check for modifications. 
     1125                         */ 
     1126                        (void) sh_hash_compdata (SH_LEVEL_READONLY,  
    10271127                                                 &theFile, fileHash, 
    1028                                                  _("[SuidCheck]"),  
    1029                                                  ShSuidchkSeverity)) 
    1030                         { 
    1031                           sh_hash_pushdata_memory (&theFile, fileHash); 
    1032                         } 
    1033                        
    1034                       sh_hash_addflag(tmpcat, SH_FFLAG_SUIDCHK); 
    1035                        
    1036                     } 
    1037  
    1038                   else if (sh.flag.checkSum == SH_CHECK_INIT  &&  
    1039                            sh.flag.update == S_FALSE ) 
    1040                     { 
    1041                       /* Running init. Report on files detected. 
    1042                        */ 
    1043                       sh_hash_pushdata (&theFile, fileHash); 
    1044                       sh_error_handle ((-1), FIL__, __LINE__,  
    1045                                        0, MSG_SUID_FOUND, tmp ); 
    1046                     } 
    1047  
    1048                   else if (sh.flag.checkSum == SH_CHECK_CHECK ) 
    1049                     { 
    1050                       /* Running file check. Report on new files 
    1051                        * detected, and quarantine them. 
    1052                        */ 
    1053                       sh_error_handle (SH_ERR_ALL, FIL__, __LINE__,  
    1054                                        0, MSG_SUID_FOUND, tmp ); 
    1055  
    1056                       fflags = sh_hash_getflags(tmpcat); 
    1057  
    1058                       if ( (-1 == fflags) || (!SH_FFLAG_SUIDCHK_SET(fflags))) 
    1059                         { 
    1060                           if (-1 == fflags) 
    1061                             report_file(tmpcat, &theFile, timestrc, timestra, timestrm); 
    1062  
    1063                           /* Quarantine file according to configured method 
    1064                           */ 
    1065                           if (ShSuidchkQEnable == S_TRUE) 
    1066                             { 
    1067                               switch (ShSuidchkQMethod) 
    1068                                 { 
    1069                                   case SH_Q_DELETE: 
    1070                                     sh_q_delete(theFile.fullpath); 
    1071                                     break; 
    1072                                   case SH_Q_CHANGEPERM: 
    1073                                     sh_q_changeperm(theFile.fullpath); 
    1074                                     break; 
    1075                                   case SH_Q_MOVE: 
    1076                                     sh_q_move(theFile.fullpath, &theFile, timestrc, timestra, timestrm); 
    1077                                     break; 
    1078                                   default: 
    1079                                     sh_error_handle (ShSuidchkSeverity, FIL__, 
    1080                                                      __LINE__, 0, MSG_SUID_QREPORT, 
    1081                                                      _("Bad quarantine method"), tmp); 
    1082                                     break; 
    1083                                 } 
    1084                             } 
    1085                           else 
    1086                             { 
    1087                               /* 1.8.1 push file to in-memory database 
    1088                                */ 
    1089                               (void) sh_hash_compdata (SH_LEVEL_READONLY, 
    1090                                                        &theFile, fileHash, 
    1091                                                        _("[SuidCheck]"), 
    1092                                                        ShSuidchkSeverity); 
    1093  
    1094                               sh_hash_addflag(tmpcat, SH_FFLAG_SUIDCHK); 
    1095  
    1096                             } 
    1097                         } 
    1098                       else 
    1099                         { 
    1100                           /* File exists. Check for modifications. 
    1101                            */ 
    1102                           (void) sh_hash_compdata (SH_LEVEL_READONLY,  
    1103                                                    &theFile, fileHash, 
    1104                                                    _("[SuidCheck]"), 
    1105                                                    ShSuidchkSeverity); 
    1106                            
    1107                           sh_hash_addflag(tmpcat, SH_FFLAG_SUIDCHK); 
    1108  
    1109                         } 
    1110                     } 
    1111                 } 
    1112               SH_FREE(tmp); 
    1113               if (theFile.attr_string) 
    1114                 SH_FREE(theFile.attr_string); 
    1115             } 
    1116         } 
    1117       SH_FREE(tmpcat); 
    1118     } 
    1119  
     1128                                                 _("[SuidCheck]"), 
     1129                                                 ShSuidchkSeverity); 
     1130                         
     1131                        sh_hash_addflag(tmpcat, SH_FFLAG_SUIDCHK); 
     1132                         
     1133                      } 
     1134                  } 
     1135              } 
     1136            SH_FREE(tmp); 
     1137            if (theFile.attr_string) 
     1138              SH_FREE(theFile.attr_string); 
     1139          } 
     1140      } 
     1141    SH_FREE(tmpcat); 
     1142 
     1143   
    11201144#ifdef HAVE_SCHED_YIELD 
    11211145    if (ShSuidchkYield == S_TRUE) 
     
    11251149            status = errno; 
    11261150            sh_error_handle ((-1), FIL__, __LINE__, status, MSG_E_SUBGEN, 
    1127                              _("Failed to release time slice"), 
     1151                             _("Failed to release time slice"), 
    11281152                             _("sh_suidchk_check_internal") ); 
    11291153          } 
    11301154      } 
    11311155#endif 
    1132  
    1133   }  while (thisEntry != NULL); 
    1134  
    1135   (void) closedir (thisDir); 
     1156   
     1157    dirlist = dirlist->next; 
     1158 
     1159  }  while (dirlist != NULL); 
     1160 
     1161 
     1162  kill_sh_dirlist (dirlist_orig); 
     1163 
    11361164  SL_RETURN( (0), _("sh_suidchk_check_internal")); 
    11371165} 
  • trunk/src/sh_tiger0.c

    r107 r131  
    206206      { 
    207207        if (timeout > 0) 
    208           count = sl_read_timeout (fd, buffer, PRIV_MAX, timeout); 
     208          count = sl_read_timeout (fd, buffer, PRIV_MAX, timeout, SL_TRUE); 
    209209        else 
    210210          count = sl_read         (fd, buffer, PRIV_MAX); 
  • trunk/src/sh_unix.c

    r114 r131  
    598598  strncpy (sh_sig_msg, sh_unix_siglist(mysignal), 40); 
    599599#endif 
     600  sh_sig_msg[63] = '\0'; 
    600601 
    601602  sl_stack_print(); 
     
    648649  if (mysignal == SIGQUIT) 
    649650    { 
    650       sig_terminate         = 1; 
     651      sig_terminate       = 1; 
    651652      ++sig_urgent; 
    652653    } 
     
    770771#endif 
    771772#ifdef SIGTERM 
    772   retry_sigaction(FIL__, __LINE__, SIGTERM,     &act,  &oldact); 
     773  retry_sigaction(FIL__, __LINE__, SIGTERM,    &act,  &oldact); 
    773774#endif 
    774775 
     
    951952  uid_t                     pwid  = (uid_t)-1; 
    952953 
     954#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     955  struct passwd    pwd; 
     956  char             buffer[SH_PWBUF_SIZE]; 
     957#endif 
     958   
    953959  SL_ENTER(_("tf_add_trusted_user_int")); 
    954960 
    955961  /* First check for a user name. 
    956962   */ 
    957   if ((w = sh_getpwnam(c)) != NULL && ((pwid = w->pw_uid) > 0)) 
     963#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     964  status = sh_getpwnam_r(c, &pwd, buffer, sizeof(buffer), &w); 
     965#else 
     966  w = sh_getpwnam(c); 
     967#endif 
     968 
     969  if ((w != NULL) && ((pwid = w->pw_uid) > 0)) 
    958970    goto succe; 
    959971         
     
    978990  char * q; 
    979991  char * p = sh_util_strdup (c); 
    980    
     992#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     993  char * saveptr; 
     994#endif 
     995 
    981996  SL_ENTER(_("tf_add_trusted_user")); 
    982997 
     998#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     999  q = strtok_r(p, ", \t", &saveptr); 
     1000#else 
    9831001  q = strtok(p, ", \t"); 
     1002#endif 
    9841003  if (!q) 
    9851004    { 
     
    9951014          SL_RETURN((i), _("tf_add_trusted_user")); 
    9961015        } 
     1016#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R) 
     1017      q = strtok_r(NULL, ", \t", &saveptr); 
     1018#else 
    9971019      q = strtok(NULL, ", \t"); 
     1020#endif 
    9981021    } 
    9991022  SH_FREE(p); 
     
    10311054  if (0 == sl_ret_euid())   /* privileges not dropped yet */ 
    10321055    { 
     1056#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     1057      struct passwd    pwd; 
     1058      char             buffer[SH_PWBUF_SIZE]; 
     1059      struct passwd *  tempres; 
     1060      sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres); 
     1061#else 
    10331062      struct passwd * tempres = sh_getpwnam(DEFAULT_IDENT); 
     1063#endif 
    10341064 
    10351065      if (!tempres) 
     
    19641994  SL_ENTER(_("t_zone")); 
    19651995 
    1966  
     1996#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R) 
     1997  cc = gmtime_r (xx, &aa); 
     1998#else 
    19671999  cc = gmtime (xx); 
    19682000  memcpy (&aa, cc, sizeof(struct tm)); 
     2001#endif 
     2002 
     2003#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     2004  cc = localtime_r (xx, &bb); 
     2005#else 
    19692006  cc = localtime (xx); 
    19702007  memcpy (&bb, cc, sizeof(struct tm)); 
     2008#endif 
    19712009 
    19722010  /* Check for datum wrap-around. 
     
    20642102  time_t        time_now; 
    20652103  struct tm   * time_ptr; 
     2104#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     2105  struct tm     time_tm; 
     2106#endif 
    20662107  static char   AsciiTime[81];                       /* local time   */ 
    20672108  static char   RetTime[81];                         /* local time   */ 
     
    21642205    SL_RETURN( _(deftime), _("sh_unix_time")); 
    21652206  else 
    2166     time_ptr   = localtime (&time_now); 
    2167  
     2207    { 
     2208#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     2209      time_ptr   = localtime_r (&time_now, &time_tm); 
     2210#else 
     2211      time_ptr   = localtime (&time_now); 
     2212#endif 
     2213    } 
    21682214  if (time_ptr != NULL)  
    21692215    { 
     
    22082254 
    22092255  struct tm   * time_ptr; 
     2256#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) 
     2257  struct tm     time_tm; 
     2258#endif 
    22102259  static char   AsciiTime[81];                       /* GMT time   */ 
    22112260#ifdef SH_USE_XML 
     
    22182267 
    22192268  if (sh_unix_use_localtime == S_FALSE) 
    2220     time_ptr   = gmtime (&thetime); 
     2269    { 
     2270#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R) 
     2271      time_ptr   = gmtime_r (&thetime, &time_tm); 
     2272#else 
     2273      time_ptr   = gmtime (&thetime); 
     2274#endif 
     2275    } 
    22212276  else 
    2222     time_ptr   = localtime (&thetime); 
    2223  
     2277    { 
     2278#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R) 
     2279      time_ptr   = localtime_r (&thetime, &time_tm); 
     2280#else 
     2281      time_ptr   = localtime (&thetime); 
     2282#endif 
     2283    } 
    22242284  if (time_ptr != NULL)  
    22252285    { 
     
    22492309  struct passwd * tempres; 
    22502310  int    status = 0; 
     2311#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R) 
     2312  struct passwd pwd; 
     2313  char   buffer[SH_PWBUF_SIZE]; 
     2314#endif 
    22512315 
    22522316  SL_ENTER(_("sh_unix_getUIDdir")); 
    22532317 
     2318#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R) 
     2319  sh_getpwuid_r(uid, &pwd, buffer, sizeof(buffer), &tempres); 
     2320#else 
    22542321  errno = 0; 
    22552322  tempres = sh_getpwuid(uid); 
    22562323  status = errno; 
     2324#endif 
    22572325 
    22582326  if (tempres == NULL) { 
     
    22762344{ 
    22772345  struct passwd * tempres; 
     2346#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R) 
     2347  struct passwd pwd; 
     2348  char   buffer[SH_PWBUF_SIZE]; 
     2349#endif 
    22782350  int             status = 0; 
    22792351  static uid_t    old_uid; 
     
    22862358  } 
    22872359 
     2360#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R) 
     2361  sh_getpwuid_r(uid, &pwd, buffer, sizeof(buffer), &tempres); 
     2362#else 
    22882363  errno = 0; 
    22892364  tempres = sh_getpwuid(uid); 
    22902365  status = errno; 
     2366#endif 
    22912367  
    22922368  if (tempres == NULL) { 
     
    22992375 
    23002376  if (tempres->pw_name != NULL) { 
     2377    /* NEED_LOCK */ 
    23012378    sl_strlcpy(name, tempres->pw_name, sizeof(name)); 
    23022379    old_uid = uid; 
     2380    /* END_LOCK  */ 
    23032381    SL_RETURN( name, _("sh_unix_getUIDname")); 
    23042382  } else { 
     
    23162394  static gid_t    old_gid; 
    23172395  static char     name[32] = { '\0' }; 
     2396#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R) 
     2397  struct group    grp; 
     2398  char            buffer[SH_GRBUF_SIZE]; 
     2399#endif 
     2400   
    23182401 
    23192402  SL_ENTER(_("sh_unix_getGIDname")); 
     
    23232406  } 
    23242407   
     2408#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R) 
     2409  status = sh_getgrgid_r(gid, &grp, buffer, sizeof(buffer), &tempres); 
     2410#else 
    23252411  errno = 0; 
    23262412  tempres = sh_getgrgid(gid); 
    23272413  status = errno; 
     2414#endif 
    23282415 
    23292416  if (tempres == NULL) { 
     
    23362423 
    23372424  if (tempres->gr_name != NULL) { 
     2425    /* NEED_LOCK */ 
    23382426    sl_strlcpy(name, tempres->gr_name, sizeof(name)); 
    23392427    old_gid = gid; 
     2428    /* END_LOCK  */ 
    23402429    SL_RETURN( name, _("sh_unix_getGIDname")); 
    23412430  } else { 
  • trunk/src/slib.c

    r76 r131  
    14251425int sl_policy_get_real(char * user) 
    14261426{ 
    1427   struct passwd * tempres; 
    1428  
    14291427  SL_ENTER(_("sl_policy_get_real")); 
    14301428  SL_REQUIRE(uids_are_stored == SL_FALSE, _("uids_are_stored == SL_FALSE")); 
     
    14331431  if (euid == 0 || ruid == 0) 
    14341432    { 
    1435       tempres = sh_getpwnam(user); 
     1433#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     1434      struct passwd    pwd; 
     1435      char             buffer[SH_PWBUF_SIZE]; 
     1436      struct passwd *  tempres; 
     1437      sh_getpwnam_r(user, &pwd, buffer, sizeof(buffer), &tempres); 
     1438#else 
     1439      struct passwd * tempres = sh_getpwnam(user); 
     1440#endif 
    14361441 
    14371442      SL_REQUIRE (NULL != tempres, _("tempres != NULL")); 
     
    14711476  if (euid != ruid || egid != rgid) 
    14721477    { 
    1473       tempres = sh_getpwnam(user); 
     1478#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     1479      struct passwd    pwd; 
     1480      char             buffer[SH_PWBUF_SIZE]; 
     1481      struct passwd *  tempres; 
     1482      sh_getpwnam_r(user, &pwd, buffer, sizeof(buffer), &tempres); 
     1483#else 
     1484      struct passwd * tempres = sh_getpwnam(user); 
     1485#endif 
    14741486 
    14751487      SL_REQUIRE (NULL != tempres, _("tempres != NULL")); 
    14761488 
    1477 #if 0 
    1478       rgid = tempres->pw_gid; 
    1479       ruid = tempres->pw_uid; 
    1480       SL_REQUIRE(sl_unset_suid() == SL_ENONE,  
    1481                  _("sl_unset_suid() == SL_ENONE")); 
    1482 #endif 
    14831489      SL_REQUIRE (sl_drop_privileges() == SL_ENONE, 
    14841490                  _("sl_drop_privileges() == SL_ENONE")); 
     
    21152121  SL_IRETURN(SL_ENONE, _("sl_read_timeout_prep")); 
    21162122} 
    2117    
    2118  
    2119 int sl_read_timeout (SL_TICKET ticket, void * buf_in, size_t count,  
    2120                      int timeout) 
    2121 { 
     2123 
     2124 
     2125int sl_read_timeout_fd (int fd, void * buf_in, size_t count,  
     2126                        int timeout, int is_nonblocking) 
     2127{ 
     2128  int sflags; 
    21222129  fd_set readfds; 
    21232130  struct timeval tv; 
     
    21352142  extern volatile int sig_termfast; 
    21362143  
    2137   if (buf_in == NULL || SL_ISERROR(fd = get_the_fd(ticket))) 
    2138     { 
    2139       if (buf_in == NULL) 
    2140         { 
    2141           TPT(( 0, FIL__, __LINE__, _("msg=<null buffer>"))); 
    2142           return (SL_ENULL); 
    2143         } 
    2144       if (SL_ISERROR(fd = get_the_fd(ticket))) 
    2145         { 
    2146           TPT(( 0, FIL__, __LINE__, _("msg=<ticket error> errno=<%d>"), fd)); 
    2147           return (fd); 
    2148         } 
     2144  if (is_nonblocking == SL_FALSE) 
     2145    { 
     2146      /* set to non-blocking mode  
     2147       */ 
     2148      sflags = retry_fcntl(FIL__, __LINE__, fd, F_GETFL, 0); 
     2149      retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags | O_NONBLOCK); 
    21492150    } 
    21502151 
     
    21902191              else 
    21912192                { 
     2193                  if (is_nonblocking == SL_FALSE) 
     2194                      retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags); 
    21922195                  return (SL_EREAD); 
    21932196                } 
     
    22032206      else if (retval == 0) 
    22042207        { 
     2208          if (is_nonblocking == SL_FALSE) 
     2209              retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags); 
    22052210          return (SL_TIMEOUT); 
    22062211        } 
    22072212      else 
    22082213        { 
     2214          if (is_nonblocking == SL_FALSE) 
     2215              retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags); 
    22092216          return (SL_EREAD); 
    22102217        } 
     
    22122219      if (sig_termfast == 1)  
    22132220        { 
     2221          if (is_nonblocking == SL_FALSE) 
     2222              retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags); 
    22142223          return (SL_EREAD); 
    22152224        } 
     
    22202229      if (tdiff > timeout) 
    22212230        { 
     2231          if (is_nonblocking == SL_FALSE) 
     2232              retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags); 
    22222233          return (SL_TIMEOUT); 
    22232234        } 
    22242235    } 
    22252236 
     2237  if (is_nonblocking == SL_FALSE) 
     2238    retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags); 
    22262239  return ((int) bytes); 
     2240} 
     2241 
     2242int sl_read_timeout (SL_TICKET ticket, void * buf_in, size_t count,  
     2243                     int timeout, int is_nonblocking) 
     2244{ 
     2245  int    fd; 
     2246  
     2247  if (buf_in == NULL || SL_ISERROR(fd = get_the_fd(ticket))) 
     2248    { 
     2249      if (buf_in == NULL) 
     2250        { 
     2251          TPT(( 0, FIL__, __LINE__, _("msg=<null buffer>"))); 
     2252          return (SL_ENULL); 
     2253        } 
     2254      if (SL_ISERROR(fd = get_the_fd(ticket))) 
     2255        { 
     2256          TPT(( 0, FIL__, __LINE__, _("msg=<ticket error> errno=<%d>"), fd)); 
     2257          return (fd); 
     2258        } 
     2259    } 
     2260 
     2261  return sl_read_timeout_fd (fd, buf_in, count, timeout, is_nonblocking); 
    22272262} 
    22282263 
  • trunk/src/trustfile.c

    r111 r131  
    9999 
    100100#ifndef TRUST_MAIN 
     101 
    101102#include "slib.h" 
    102103#define SH_NEED_PWD_GRP 1 
    103104#include "sh_static.h" 
     105#define SH_GRBUF_SIZE 4096 
     106#define SH_PWBUF_SIZE 4096 
    104107 
    105108#else 
    106109 
    107110#define sh_getgrgid   getgrgid 
     111#define sh_getgrgid_r getgrgid_r 
     112#define sh_getpwnam   getpwnam 
     113#define sh_getpwnam_r getpwnam_r 
     114#define sh_getpwuid   getpwuid 
     115#define sh_getpwuid_r getpwuid_r 
    108116#define sh_getpwent   getpwent 
    109 #define sh_getpwnam   getpwnam 
    110 #define sh_getpwuid   getpwuid 
    111117#define sh_endpwent   endpwent 
    112118 
     
    410416  register struct group *g;     /* pointer to group information */ 
    411417   
     418#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R) 
     419  struct group    gr; 
     420  char            buffer[SH_GRBUF_SIZE]; 
     421  struct passwd   pwd; 
     422  char            pbuffer[SH_PWBUF_SIZE]; 
     423#endif 
     424 
    412425  SL_ENTER(_("isingrp")); 
    413426 
    414   if ((g = sh_getgrgid(grp)) == NULL) 
     427#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R) 
     428  sh_getgrgid_r(grp, &gr, buffer, sizeof(buffer), &g); 
     429#else 
     430  g = sh_getgrgid(grp); 
     431#endif 
     432 
     433  if (g == NULL) 
    415434    { 
    416435      SL_IRETURN(SL_FALSE, _("isingrp") ); 
     
    428447        { 
    429448          /* map user name to UID and compare */ 
     449#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     450          sh_getpwnam_r(*p, &pwd, pbuffer, sizeof(pbuffer), &w); 
     451#else 
     452          w = sh_getpwnam(*p); 
     453#endif 
     454 
    430455#ifdef TRUST_MAIN 
    431           if ((w = sh_getpwnam(*p)) != NULL && *u == (uid_t)(w->pw_uid) ) 
     456          if (w != NULL && *u == (uid_t)(w->pw_uid) ) 
    432457            SL_IRETURN(SL_TRUE, _("isingrp")); 
    433458#else 
    434           if ((w = sh_getpwnam(*p)) != NULL && *u == (uid_t)(w->pw_uid) ) 
     459          if (w != NULL && *u == (uid_t)(w->pw_uid) ) 
    435460            { 
    436461              SL_IRETURN(SL_TRUE, _("isingrp")); 
     
    444469  for(u = ulist; *u != tf_uid_neg; u++) 
    445470    { 
     471#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R) 
     472      sh_getpwuid_r(*u, &pwd, pbuffer, sizeof(pbuffer), &w); 
     473#else 
     474      w = sh_getpwuid(*u); 
     475#endif 
    446476#ifdef TRUST_MAIN 
    447       if ((w = sh_getpwuid(*u)) != NULL && grp == (gid_t)(w->pw_gid) ) 
     477      if (w != NULL && grp == (gid_t)(w->pw_gid) ) 
    448478        SL_IRETURN(SL_TRUE, _("isingrp")); 
    449479#else 
    450       if ((w = sh_getpwuid(*u)) != NULL && grp == (gid_t)(w->pw_gid) ) 
     480      if (w != NULL && grp == (gid_t)(w->pw_gid) ) 
    451481        { 
    452482          SL_IRETURN(SL_TRUE, _("isingrp")); 
     
    470500  register int flag = -1;       /* group member found */ 
    471501 
     502#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R) 
     503  struct group    gr; 
     504  char            buffer[SH_GRBUF_SIZE]; 
     505  struct group    pw; 
     506  char            pbuffer[SH_PWBUF_SIZE]; 
     507#endif 
     508 
    472509  SL_ENTER(_("onlytrustedingrp")); 
    473510 
     
    477514#endif 
    478515 
    479   if ((g = sh_getgrgid(grp)) == NULL) 
     516#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R) 
     517  sh_getgrgid_r(grp, &gr, buffer, sizeof(buffer), &g); 
     518#else 
     519  g = sh_getgrgid(grp); 
     520#endif 
     521 
     522  if (g == NULL) 
    480523    { 
    481524#ifdef TRUST_DEBUG 
     
    503546      /* map user name to UID and compare  
    504547       */ 
     548#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R) 
     549      sh_getpwnam_r(*p, &pw, pbuffer, sizeof(pbuffer), &w); 
     550#else 
    505551      w = sh_getpwnam(*p); 
    506 #ifndef TRUST_MAIN 
    507       if (!w) 
    508         w = sh_getpwnam(*p); 
    509 #endif 
     552#endif 
     553 
    510554      if (w == NULL)    /* not a valid user, ignore    */ 
    511555        { 
     
    9611005  tf_path[0] = '\0'; 
    9621006#if defined(SH_WITH_SERVER) 
    963   pass = sh_getpwnam(SH_IDENT); 
     1007  pass = sh_getpwnam(SH_IDENT);  /* TESTONLY */ 
    9641008  if (pass != NULL) 
    9651009    tf_euid = pass->pw_uid; 
Note: See TracChangeset for help on using the changeset viewer.