Changeset 371


Ignore:
Timestamp:
Oct 31, 2011, 9:42:22 PM (13 years ago)
Author:
katerina
Message:

Patch for ticket #265 (inotify support).

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/configure.ac

    r367 r371  
    229229        sys/vfs.h mntent.h \
    230230        sys/select.h sys/socket.h netinet/in.h \
    231         regex.h glob.h \
     231        regex.h glob.h fnmatch.h \
    232232        linux/ext2_fs.h linux/fs.h ext2fs/ext2_fs.h asm/segment.h \
    233233        elf.h linux/elf.h auparse.h \

  • trunk/include/sh_files.h

    r367 r371  
    4646int sh_files_hle_reg (const char * str);
    4747
    48 /* Check for new files matching configured glob patterns.
     48/* Check for new files/dirs matching configured glob patterns.
    4949 */
    5050void sh_files_check_globPatterns();
     51
     52/* Check for new files (only) matching configured glob patterns.
     53 */
     54void sh_files_check_globFilePatterns();
    5155
    5256/* check the setup

  • trunk/include/sh_inotify.h

    r367 r371  
    4343                              int * class, unsigned long * check_mask);
    4444ssize_t sh_inotify_read(char * buffer, size_t count);
     45ssize_t sh_inotify_read_timeout(char * buffer, size_t count, int timeout);
    4546int sh_inotify_recheck_watches (sh_watches * watches, sh_watches * save);
    4647

  • trunk/include/sh_pthread.h

    r320 r371  
    3434                pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);  \
    3535                pthread_cleanup_push(sh_pthread_mutex_unlock, (void*)&(M));\
    36                 pthread_mutex_trylock(&(M));                               \
    37                 executeStack = 1
     36                if (0 == pthread_mutex_trylock(&(M))) {                    \
     37                  executeStack = 1
     38
     39#define SH_MUTEX_TRYLOCK_UNLOCK(M)                                         \
     40                }                                                          \
     41                pthread_cleanup_pop(executeStack);                         \
     42                pthread_setcanceltype(oldtype, NULL);                      \
     43        } while (0)
    3844
    3945#define SH_MUTEX_UNLOCK(M)                                                 \

  • trunk/src/sh_fInotify.c

    r368 r371  
    143143        }
    144144    }
     145  else if (arg != NULL && arg->initval < 0 &&
     146      (sh.flag.isdaemon != S_TRUE && sh.flag.loop != S_TRUE))
     147    {
     148      sh.flag.inotify = 0;
     149      return SH_MOD_FAILED;
     150    }
    145151  else if (arg != NULL && arg->initval == SH_MOD_THREAD &&
    146152           (sh.flag.isdaemon == S_TRUE || sh.flag.loop == S_TRUE))
    … …  
    162168  ssize_t len = -1;
    163169  char *  buffer = SH_ALLOC(16384);
     170  static int count = 0;
    164171
    165172  if (ShfInotifyActive == S_FALSE)
    … …  
    175182  /* Blocking read from inotify file descriptor.
    176183   */
    177   len = sh_inotify_read(buffer, 16384);
     184  len = sh_inotify_read_timeout(buffer, 16384, 1);
    178185 
    179186  if (len > 0)
    … …  
    203210   */
    204211  sh_inotify_recheck_watches (&sh_file_watches, &sh_file_missing);
     212
     213  ++count;
     214
     215  if (count >= 10)
     216    {
     217      count = 0; /* Re-expand glob patterns to discover added files */
     218      sh_files_check_globFilePatterns();
     219    }
    205220
    206221  return 0;
    … …  
    274289  SH_MUTEX_LOCK(mutex_thread_nolog);
    275290  sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
    276                   _("Cannot set max_user_watches"), _("sh_fInotify_set_nwatches"));
     291                  _("Cannot set max_user_watches"),
     292                  _("sh_fInotify_set_nwatches"));
    277293  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    278294  return;
    … …  
    353369  unsigned long check_mask;
    354370  char * filename;
     371  extern int flag_err_debug;
     372
     373  if (flag_err_debug == SL_TRUE)
     374    {
     375      char dbgbuf[256];
     376      sl_strlcpy (dbgbuf, "inotify mask: ", sizeof(dbgbuf));
     377      if (event->mask & IN_ACCESS) sl_strlcat(dbgbuf, "IN_ACCESS ", sizeof(dbgbuf));
     378      if (event->mask & IN_ATTRIB) sl_strlcat(dbgbuf, "IN_ATTRIB ", sizeof(dbgbuf));
     379      if (event->mask & IN_CLOSE_WRITE) sl_strlcat(dbgbuf, "IN_CLOSE_WRITE ", sizeof(dbgbuf));
     380      if (event->mask & IN_CLOSE_NOWRITE) sl_strlcat(dbgbuf, "IN_CLOSE_NOWRITE ", sizeof(dbgbuf));
     381      if (event->mask & IN_CREATE) sl_strlcat(dbgbuf, "IN_CREATE ", sizeof(dbgbuf));
     382      if (event->mask & IN_DELETE) sl_strlcat(dbgbuf, "IN_DELETE ", sizeof(dbgbuf));
     383      if (event->mask & IN_DELETE_SELF) sl_strlcat(dbgbuf, "IN_DELETE_SELF ", sizeof(dbgbuf));
     384      if (event->mask & IN_MODIFY) sl_strlcat(dbgbuf, "IN_MODIFY ", sizeof(dbgbuf));
     385      if (event->mask & IN_MOVE_SELF) sl_strlcat(dbgbuf, "IN_MOVE_SELF ", sizeof(dbgbuf));
     386      if (event->mask & IN_MOVED_FROM) sl_strlcat(dbgbuf, "IN_MOVED_FROM ", sizeof(dbgbuf));
     387      if (event->mask & IN_MOVED_TO) sl_strlcat(dbgbuf, "IN_MOVED_TO ", sizeof(dbgbuf));
     388      if (event->mask & IN_OPEN) sl_strlcat(dbgbuf, "IN_OPEN ", sizeof(dbgbuf));
     389      if (event->mask & IN_IGNORED) sl_strlcat(dbgbuf, "IN_IGNORED ", sizeof(dbgbuf));
     390      if (event->mask & IN_ISDIR) sl_strlcat(dbgbuf, "IN_ISDIR ", sizeof(dbgbuf));
     391      if (event->mask & IN_Q_OVERFLOW) sl_strlcat(dbgbuf, "IN_Q_OVERFLOW ", sizeof(dbgbuf));
     392      if (event->mask & IN_UNMOUNT) sl_strlcat(dbgbuf, "IN_UNMOUNT ", sizeof(dbgbuf));
     393      SH_MUTEX_LOCK(mutex_thread_nolog);
     394      sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, 0, MSG_E_SUBGEN,
     395                      dbgbuf, _("sh_fInotify_process"));
     396      SH_MUTEX_UNLOCK(mutex_thread_nolog);
     397    }
     398
    355399
    356400  if (event->wd >= 0)
    … …  
    438482    }
    439483
    440   if ( (event->mask & (IN_ACCESS|IN_MODIFY)) != 0)
     484  if ( (event->mask & (IN_ATTRIB|IN_MODIFY)) != 0)
    441485    {
    442486      sh_files_search_file(path, &class, &check_mask, &reported);
    … …  
    477521      if (S_FALSE == sh_ignore_chk_new(path))
    478522        {
     523          int ret;
     524
    479525          sh_files_clear_file_reported(path);
    480526         
    481           sh_files_search_file(path, &class, &check_mask, &reported);
     527          ret = sh_files_search_file(path, &class, &check_mask, &reported);
    482528         
    483529          sh_files_filecheck (class, check_mask, filename,
    … …  
    486532          if (SH_FFLAG_REPORTED_SET(reported))
    487533            sh_files_set_file_reported(path);
     534
     535          if (ret != 0)
     536            {
     537              sh_inotify_add_watch(path, &sh_file_watches, &ret,
     538                                   class, check_mask);
     539            }
    488540        }
    489541    }

  • trunk/src/sh_files.c

    r367 r371  
    5656#include <glob.h>
    5757#endif
     58#ifdef HAVE_FNMATCH_H
     59#include <fnmatch.h>
     60#endif
     61
    5862
    5963#include "samhain.h"
    … …  
    281285static zAVLTree * zfileList     = NULL;
    282286
     287SH_MUTEX_STATIC(mutex_zfiles,      PTHREAD_MUTEX_INITIALIZER);
     288SH_MUTEX_STATIC(mutex_zglob,       PTHREAD_MUTEX_INITIALIZER);
    283289
    284290static int        sh_files_fullpath  (char * testdir, char * d_name,
    … …  
    503509  SL_ENTER(_("sh_files_delfilestack"));
    504510
     511  SH_MUTEX_LOCK(mutex_zfiles);
    505512  zAVLFreeTree (zfileList, free_dirstack);
    506513  zfileList = NULL;
     514  SH_MUTEX_UNLOCK(mutex_zfiles);
    507515
    508516  SL_RETURN(0, _("sh_files_delfilestack"));
    … …  
    559567  SL_ENTER(_("sh_files_reset"));
    560568
     569  SH_MUTEX_LOCK(mutex_zfiles);
    561570  for (ptr = (dirstack_t *) zAVLFirst(&avlcursor, zfileList); ptr;
    562571       ptr = (dirstack_t *) zAVLNext(&avlcursor))
    563572    ptr->checked = 0;
    564 
     573  SH_MUTEX_UNLOCK(mutex_zfiles);
    565574  SL_RET0(_("sh_files_reset"));
    566575}
    … …  
    903912  new_item_ptr->childs_checked = S_FALSE;
    904913
     914  SH_MUTEX_LOCK(mutex_zfiles);
    905915  if (zfileList == NULL)
    906916    {
    … …  
    914924
    915925  ret = zAVLInsert (zfileList, new_item_ptr);
     926  SH_MUTEX_UNLOCK(mutex_zfiles);
    916927
    917928  if (-1 == ret)
    … …  
    920931      aud__exit(FIL__, __LINE__, EXIT_FAILURE);
    921932    }
    922 
    923   if (3 == ret)
     933  else if (3 == ret)
    924934    {
    925935      if (sh.flag.started != S_TRUE)
    … …  
    930940      new_item_ptr = NULL;
    931941    }
    932 
    933   if (new_item_ptr && MODI_AUDIT_ENABLED(new_item_ptr->check_mask))
    934     {
    935       sh_audit_mark(new_item_ptr->name);
     942  else
     943    {
     944      unsigned long mask = sh_files_maskof(class);
     945      if (MODI_AUDIT_ENABLED(mask))
     946        {
     947          sh_audit_mark(new_item_ptr->name);
     948        }
    936949    }
    937950  SL_RETURN(0, _("sh_files_push_file_int"));
    … …  
    954967
    955968static void sh_files_pushglob (int class, int type, const char * p, int rdepth,
    956                                unsigned long check_mask, int flag)
     969                               unsigned long check_mask_in, int flag)
    957970{
    958971  int     globstatus = -1;
    959972  unsigned int     gloop;
    960973  glob_t  pglob;
     974
     975  volatile unsigned long check_mask = check_mask_in;
    961976 
    962977  SL_ENTER(_("sh_files_pushglob"));
    … …  
    974989          int     ret;
    975990         
     991          SH_MUTEX_TRYLOCK(mutex_zfiles);
    976992          fileName = sh_util_strdup (p);
    977993         
    … …  
    10011017              SH_FREE(new_item_ptr);
    10021018            }
     1019          SH_MUTEX_TRYLOCK_UNLOCK(mutex_zfiles);
    10031020        }
    10041021
    … …  
    10581075}
    10591076
    1060 void sh_files_check_globPatterns()
     1077void sh_files_check_globFilePatterns()
    10611078{
    10621079  sh_globstack_t * testPattern;
    … …  
    10651082  SL_ENTER(_("sh_files_check_globPatterns"));
    10661083
    1067   for (testPattern = (sh_globstack_t *) zAVLFirst (&cursor, zglobList); testPattern;
     1084  SH_MUTEX_LOCK(mutex_zglob);
     1085  for (testPattern = (sh_globstack_t *) zAVLFirst (&cursor, zglobList);
     1086       testPattern;
     1087       testPattern = (sh_globstack_t *) zAVLNext  (&cursor))
     1088    {
     1089      if (testPattern->type == SH_LIST_FILE)
     1090        {
     1091          sh_files_pushglob(testPattern->class, testPattern->type,
     1092                            testPattern->name, testPattern->rdepth,
     1093                            testPattern->check_mask, 1);
     1094        }
     1095    }
     1096  SH_MUTEX_UNLOCK(mutex_zglob);
     1097  SL_RET0(_("sh_files_check_globPatterns"));
     1098}
     1099
     1100void sh_files_check_globPatterns()
     1101{
     1102  sh_globstack_t * testPattern;
     1103  zAVLCursor   cursor;
     1104
     1105  SL_ENTER(_("sh_files_check_globPatterns"));
     1106
     1107  SH_MUTEX_LOCK(mutex_zglob);
     1108  for (testPattern = (sh_globstack_t *) zAVLFirst (&cursor, zglobList);
     1109       testPattern;
    10681110       testPattern = (sh_globstack_t *) zAVLNext  (&cursor))
    10691111    {
    … …  
    10721114                        testPattern->check_mask, 1);
    10731115    }
     1116  SH_MUTEX_UNLOCK(mutex_zglob);
    10741117  SL_RET0(_("sh_files_check_globPatterns"));
    10751118}
    … …  
    10971140  SL_ENTER(_("sh_files_delglobstack"));
    10981141
     1142  SH_MUTEX_LOCK(mutex_zglob);
    10991143  zAVLFreeTree (zglobList, free_globstack);
    11001144  zglobList = NULL;
     1145  SH_MUTEX_UNLOCK(mutex_zglob);
    11011146
    11021147  SL_RETURN(0, _("sh_files_delglobstack"));
    … …  
    12451290}
    12461291
     1292static void * sh_dummy_ptr;
     1293
    12471294unsigned long sh_dirs_chk (int which)
    12481295{
    … …  
    12521299  dirstack_t * dst_ptr;
    12531300  int          status;
    1254   unsigned long dcount = 0;
     1301  volatile unsigned long dcount = 0;
    12551302  char       * tmp;
    12561303 
    12571304  SL_ENTER(_("sh_dirs_chk"));
    12581305
     1306  sh_dummy_ptr = (void *) &ptr;
     1307 
    12591308  if (which == 1)
    12601309    tree = zdirListOne;
    … …  
    12711320      if (ptr->checked == S_FALSE)
    12721321        {
     1322          SH_MUTEX_LOCK(mutex_zfiles);
    12731323          /* 28 Aug 2001 check the top level directory
    12741324           */
    … …  
    12901340                }
    12911341            }
     1342          SH_MUTEX_UNLOCK(mutex_zfiles);
    12921343
    12931344          if (status == S_FALSE)
    … …  
    17551806#endif
    17561807
     1808static void * sh_dummy_dirlist;
     1809
    17571810/* -- check a single directory and its content
    17581811 */
    … …  
    17811834  int             rdepth_next;
    17821835  int             class_next;
    1783   int             file_class_next;
     1836  volatile int    file_class_next;
    17841837  unsigned long   check_mask_next;
    1785   unsigned long   file_check_mask_next;
    1786 
    1787   int             checked_flag  = S_FALSE;
    1788   int             cchecked_flag = S_FALSE;
     1838  volatile unsigned long   file_check_mask_next;
     1839
     1840  volatile int    checked_flag  = S_FALSE;
     1841  volatile int    cchecked_flag = S_FALSE;
    17891842
    17901843  dirstack_t *    dst_ptr;
    … …  
    17971850
    17981851  SL_ENTER(_("sh_files_checkdir"));
     1852
     1853  sh_dummy_dirlist = (void *) &dirlist;
    17991854
    18001855  if (sig_urgent > 0) {
    … …  
    20452100      }
    20462101
     2102    SH_MUTEX_LOCK(mutex_zfiles);
    20472103    dst_ptr         = (dirstack_t *) zAVLSearch(zfileList, tmpcat);
    20482104
    … …  
    20592115        /* cchecked_flag      = dst_ptr->childs_checked; */
    20602116      }
     2117    SH_MUTEX_UNLOCK(mutex_zfiles);
    20612118   
    20622119    /* ---- Has been checked already. ----
    … …  
    25182575 * -----------------------------------
    25192576 */
    2520 int sh_files_search_file(char * name, int * class, unsigned long *check_mask, int *reported)
    2521 {
    2522   dirstack_t * item = zAVLSearch(zfileList, name);
     2577int sh_files_search_file(char * name, int * class,
     2578                         unsigned long *check_mask, int *reported)
     2579{
     2580  int retval = 0;
     2581#if defined(HAVE_GLOB_H) && defined(HAVE_FNMATCH_H)
     2582  sh_globstack_t * testPattern;
     2583  zAVLCursor   cursor;
     2584#endif
     2585  dirstack_t * item;
     2586
     2587  SH_MUTEX_LOCK(mutex_zfiles);
     2588  item = zAVLSearch(zfileList, name);
    25232589
    25242590  if (item)
    … …  
    25272593      *class      = item->class;
    25282594      *reported   = item->is_reported;
    2529       return 1;
    2530     }
    2531   return 0;
     2595      retval = 1;
     2596      goto out;
     2597    }
     2598
     2599#if defined(HAVE_GLOB_H) && defined(HAVE_FNMATCH_H)
     2600  SH_MUTEX_LOCK(mutex_zglob);
     2601  for (testPattern = (sh_globstack_t *) zAVLFirst (&cursor, zglobList);
     2602       testPattern;
     2603       testPattern = (sh_globstack_t *) zAVLNext  (&cursor))
     2604    {
     2605      if (testPattern->type == SH_LIST_FILE)
     2606        {
     2607          if (0 == fnmatch(testPattern->name, name, FNM_PATHNAME|FNM_PERIOD))
     2608            {
     2609              *check_mask = testPattern->check_mask;
     2610              *class      = testPattern->class;
     2611              retval = 1;
     2612              break;
     2613            }
     2614       
     2615        }
     2616    }
     2617  SH_MUTEX_UNLOCK(mutex_zglob);
     2618#endif
     2619 out:
     2620  SH_MUTEX_UNLOCK(mutex_zfiles);
     2621  return retval;
    25322622}
    25332623
    25342624void sh_files_set_file_reported(char * name)
    25352625{
    2536   dirstack_t * item = zAVLSearch(zfileList, name);
     2626  dirstack_t * item;
     2627
     2628  SH_MUTEX_LOCK_UNSAFE(mutex_zfiles);
     2629  item = zAVLSearch(zfileList, name);
    25372630
    25382631  if (item)
    … …  
    25412634        SET_SH_FFLAG_REPORTED(item->is_reported);
    25422635    }
     2636  SH_MUTEX_UNLOCK_UNSAFE(mutex_zfiles);
    25432637  return;
    25442638}
    … …  
    25462640void sh_files_clear_file_reported(char * name)
    25472641{
    2548   dirstack_t * item = zAVLSearch(zfileList, name);
     2642  dirstack_t * item;
     2643
     2644  SH_MUTEX_LOCK_UNSAFE(mutex_zfiles);
     2645  item = zAVLSearch(zfileList, name);
    25492646
    25502647  if (item)
    … …  
    25522649      CLEAR_SH_FFLAG_REPORTED(item->is_reported);
    25532650    }
     2651  SH_MUTEX_UNLOCK_UNSAFE(mutex_zfiles);
    25542652  return;
    25552653}
    … …  
    25672665  dirstack_t * pfilL;
    25682666  zAVLCursor   cursor;
     2667  volatile int retval = -1;
    25692668
    25702669  SL_ENTER(_("check_file"));
    … …  
    25732672    SL_RETURN(0, _("check_file"));
    25742673
     2674  SH_MUTEX_LOCK(mutex_zfiles);
    25752675  for (pfilL = (dirstack_t *) zAVLFirst (&cursor, zfileList); pfilL;
    25762676       pfilL = (dirstack_t *) zAVLNext  (&cursor))
    … …  
    25802680          (pfilL->check_mask & MODI_CTM) == 0 &&
    25812681          (pfilL->check_mask & MODI_MTM) == 0)
    2582         SL_RETURN(0, _("check_file"));
    2583     }
    2584   SL_RETURN((-1), _("check_file"));
    2585 }
    2586  
     2682        {
     2683          retval = 0;
     2684          break;
     2685        }
     2686    }
     2687  SH_MUTEX_UNLOCK(mutex_zfiles);
     2688
     2689  SL_RETURN(retval, _("check_file"));
     2690}
     2691
     2692static void * sh_dummy_pdirL;
     2693
    25872694int sh_files_test_setup_int (zAVLTree * tree)
    25882695{
    … …  
    25962703  SL_ENTER(_("sh_files_test_setup"));
    25972704
     2705  sh_dummy_pdirL = (void *) &pdirL;
     2706
    25982707  for (pdirL = (dirstack_t *) zAVLFirst (&cursor1, tree); pdirL;
    25992708       pdirL = (dirstack_t *) zAVLNext  (&cursor1))
    … …  
    26012710      dlen = strlen(pdirL->name);
    26022711
     2712      SH_MUTEX_LOCK(mutex_zfiles);
    26032713      for (pfilL = (dirstack_t *) zAVLFirst (&cursor2, zfileList); pfilL;
    26042714           pfilL = (dirstack_t *) zAVLNext  (&cursor2))
    … …  
    26312741            }
    26322742        }
     2743      SH_MUTEX_UNLOCK(mutex_zfiles);
    26332744    }
    26342745

  • trunk/src/sh_hash.c

    r367 r371  
    15101510 unlock_and_exit:
    15111511  ; /* 'label at end of compound statement */
    1512   SH_MUTEX_UNLOCK(mutex_hash);
     1512  SH_MUTEX_TRYLOCK_UNLOCK(mutex_hash);
    15131513
    15141514  SL_RET0(_("sh_hash_hashdelete"));

  • trunk/src/sh_inotify.c

    r369 r371  
    213213ssize_t sh_inotify_read(char * buffer, size_t count)
    214214{
     215  ssize_t len = -1;
     216  int     ifd = sh_inotify_getfd();
     217
     218  do {
     219    len = read (ifd, buffer, count);
     220  } while (len < 0 && (errno == EINTR || errno == EAGAIN));
     221
     222  return len;
     223}
     224
     225ssize_t sh_inotify_read_timeout(char * buffer, size_t count, int timeout)
     226{
    215227  ssize_t len;
    216228  int     ifd = sh_inotify_getfd();
    217229
    218   do {
    219     len = read (ifd, buffer, count);
    220   } while (len < 0 || errno == EINTR);
     230  len = sl_read_timeout_fd (ifd, buffer, count, timeout, SL_FALSE);
    221231
    222232  return len;
    223233}
     234
    224235
    225236static void sh_inotify_free_watch(void * item)
    … …  
    287298    {
    288299      listcursor->curnode = listcursor->curnode->next;
    289       return listcursor->curnode->watch;
     300      if (listcursor->curnode)
     301        return listcursor->curnode->watch;
     302      else
     303        return NULL;
    290304    }
    291305
    … …  
    512526  int ifd = sh_get_inotify_fd();
    513527
    514   extern void sh_fInotify_report_add(char * path, int class, unsigned long check_mask);
     528  extern void sh_fInotify_report_add(char * path,
     529                                     int class, unsigned long check_mask);
    515530
    516531  sh_dummy_litem = (void*) &litem;
    … …  
    520535  SH_MUTEX_LOCK(mutex_list_dormant);
    521536 
    522   for (litem = sh_inotify_list_first(&listcursor, save); litem;
    523        litem = sh_inotify_list_next(&listcursor, save))
     537  litem = sh_inotify_list_first(&listcursor, save);
     538
     539  while (litem)
    524540    {
    525541    have_next:
    … …  
    545561            }
    546562        }
     563      litem = sh_inotify_list_next(&listcursor, save);
    547564    }
    548565  SH_MUTEX_UNLOCK(mutex_list_dormant);
    … …  
    725742      /* -- Blocking read on inotify file descriptor
    726743       */
    727       sh_inotify_read(buffer, sizeof(buffer));
     744      len = sh_inotify_read(buffer, sizeof(buffer));
    728745
    729746      if (len > 0)

  • trunk/src/slib.c

    r318 r371  
    26112611          else if (byteread == 0)
    26122612            {
     2613              /* zero indicates end of file */
    26132614              break;
    26142615            }
    … …  
    26462647          TPT(( 0, FIL__, __LINE__, _("msg=<timeout>")));
    26472648          errno = 0;
     2649          if (bytes > 0)
     2650            return ((int) bytes);
    26482651          return (SL_TIMEOUT);
    26492652        }
    … …  
    26762679          TPT(( 0, FIL__, __LINE__, _("msg=<timeout>")));
    26772680          errno = 0;
     2681          if (bytes > 0)
     2682            return ((int) bytes);
    26782683          return (SL_TIMEOUT);
    26792684        }

  • trunk/test/testhash.sh

    r367 r371  
    5858        fi
    5959        #
    60         ${TOP_SRCDIR}/configure --quiet $TRUST --prefix=$PW_DIR --localstatedir=$PW_DIR --with-config-file=$RCFILE --with-log-file=$LOGFILE --with-pid-file=$PW_DIR/.samhain_lock --with-data-file=$PW_DIR/.samhain_file --enable-db-reload '--enable-login-watch' '--enable-mounts-check' ${C_LOGFILE} '--enable-port-check' '--enable-suidcheck' '--with-rnd=unix'
     60        ${TOP_SRCDIR}/configure --enable-debug=gdb --quiet $TRUST --prefix=$PW_DIR --localstatedir=$PW_DIR --with-config-file=$RCFILE --with-log-file=$LOGFILE --with-pid-file=$PW_DIR/.samhain_lock --with-data-file=$PW_DIR/.samhain_file --enable-db-reload '--enable-login-watch' '--enable-mounts-check' ${C_LOGFILE} '--enable-port-check' '--enable-suidcheck' '--with-rnd=unix'
    6161        #
    6262        fail=0

  • trunk/test/testrun_1.sh

    r257 r371  
    10511051run_check ()
    10521052{
    1053     ${VALGRIND} ./samhain -t check -p none -l debug 2>>test_log_valgrind
     1053    if [ "x$1" = "x"  ]; then
     1054        logsev=debug
     1055    else
     1056        logsev=$1
     1057    fi
     1058    ${VALGRIND} ./samhain -t check -p none -l $logsev 2>>test_log_valgrind
    10541059 
    10551060    if test x$? = x0; then

  • trunk/test/testrun_1d.sh

    r169 r371  
    155155              rm -f "$LOGFILE"
    156156              if [ $errval -eq 0 ]; then
    157                   run_check
     157                  run_check info
    158158                  check_err $? ${tcount}; errval=$?
    159159              fi
Note: See TracChangeset for help on using the changeset viewer.