Changeset 19 for trunk/src


Ignore:
Timestamp:
Feb 12, 2006, 10:49:56 PM (19 years ago)
Author:
rainer
Message:

Rewrite of test suite, checksum for growing logs, fix for minor bug with dead client detection.

Location:
trunk/src
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/cutest_sh_tiger0.c

    r17 r19  
    233233  CuAssertTrue(tc, result == 0);
    234234
    235 
    236235} 
     236
     237/* test checksum of file upto some given length
     238 */
     239void Test_tiger_file_with_length(CuTest *tc) {
     240
     241  SL_TICKET     rval_open;
     242  FILE * fp;
     243  int result;
     244  char * actual;
     245  char * expected;
     246
     247  char * teststring = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge, 1996.\n";
     248  int    testlen = strlen(teststring);
     249
     250  init();
     251
     252  fp = fopen("cutest_foo", "w");
     253  CuAssertPtrNotNull(tc, fp);
     254
     255  result = fprintf(fp, "%s", teststring);
     256  CuAssertTrue(tc, result >= 0);
     257  result = fprintf(fp, "%s", teststring);
     258  CuAssertTrue(tc, result >= 0);
     259
     260  result = fclose(fp);
     261  CuAssertTrue(tc, result == 0);
     262 
     263  result = sh_tiger_hashtype("TIGER192");
     264  CuAssertTrue(tc, result == 0);
     265
     266  /* same as GnuPG 1.0.6 (gpg --load-extension tiger --print-md TIGER192)
     267   */
     268  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, testlen, 0);
     269  expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
     270  CuAssertStrEquals(tc, expected, actual);
     271
     272  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 2*testlen, 0);
     273  expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
     274  CuAssertStrEquals(tc, expected, actual);
     275
     276  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 0, 0);
     277  expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
     278  CuAssertStrEquals(tc, expected, actual);
     279
     280  fp = fopen("cutest_foo", "a");
     281  CuAssertPtrNotNull(tc, fp);
     282  result = fprintf(fp, "%s", teststring);
     283  CuAssertTrue(tc, result >= 0);
     284  result = fclose(fp);
     285  CuAssertTrue(tc, result == 0);
     286
     287  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, testlen, 0);
     288  expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
     289  CuAssertStrEquals(tc, expected, actual);
     290
     291  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 2*testlen, 0);
     292  expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
     293  CuAssertStrEquals(tc, expected, actual);
     294
     295  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 3*testlen, 0);
     296  expected = "D0EE1A9956CAB22D84B51A5E0C093B724828C6A1F9CBDB7F";
     297  CuAssertStrEquals(tc, expected, actual);
     298
     299  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 0, 0);
     300  expected = "D0EE1A9956CAB22D84B51A5E0C093B724828C6A1F9CBDB7F";
     301  CuAssertStrEquals(tc, expected, actual);
     302
     303  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 5, 0);
     304  expected = "9F00F599072300DD276ABB38C8EB6DEC37790C116F9D2BDF";
     305  CuAssertStrEquals(tc, expected, actual);
     306
     307  /* same results as GNU md5sum */
     308
     309  result = sh_tiger_hashtype("MD5");
     310  CuAssertTrue(tc, result == 0);
     311
     312  rval_open = sl_open_fastread ("cutest_foo", SL_YESPRIV);
     313  CuAssertTrue(tc, rval_open >= 0);
     314  tiger_fd  = rval_open;
     315
     316  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, testlen, 0);
     317  expected = "11E7E7EA486136273606BEE57C71F34B0000000000000000";
     318  CuAssertStrEquals(tc, expected, actual);
     319
     320  result = sl_rewind(rval_open);
     321  CuAssertTrue(tc, rval_open >= 0);
     322
     323  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 2*testlen, 0);
     324  expected = "D49DAD474095D467E2E5EFCB2DC23A770000000000000000";
     325  CuAssertStrEquals(tc, expected, actual);
     326
     327  result = sl_rewind(rval_open);
     328  CuAssertTrue(tc, rval_open >= 0);
     329
     330  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 3*testlen, 0);
     331  expected = "00A1F1C5EDDCCFC430D3862FDA94593E0000000000000000";
     332  CuAssertStrEquals(tc, expected, actual);
     333
     334  result = sl_rewind(rval_open);
     335  CuAssertTrue(tc, rval_open >= 0);
     336
     337  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 0, 0);
     338  expected = "00A1F1C5EDDCCFC430D3862FDA94593E0000000000000000";
     339  CuAssertStrEquals(tc, expected, actual);
     340
     341  /* same result as gpg --print-md SHA1
     342   */
     343
     344  result = sh_tiger_hashtype("SHA1");
     345  CuAssertTrue(tc, result == 0);
     346
     347  result = sl_rewind(rval_open);
     348  CuAssertTrue(tc, rval_open >= 0);
     349
     350  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, testlen, 0);
     351  expected = "F37DB4344CCD140EE315179E9A27512FB4704F0F00000000";
     352  CuAssertStrEquals(tc, expected, actual);
     353
     354  result = sl_rewind(rval_open);
     355  CuAssertTrue(tc, rval_open >= 0);
     356
     357  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 2*testlen, 0);
     358  expected = "D2AD5FC366452D81400BAC31F96269DEEF314BC200000000";
     359  CuAssertStrEquals(tc, expected, actual);
     360
     361  result = sl_rewind(rval_open);
     362  CuAssertTrue(tc, rval_open >= 0);
     363
     364  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 3*testlen, 0);
     365  expected = "FAA937EF3389C7E786EB0F1006D049D7AEA7B7B600000000";
     366  CuAssertStrEquals(tc, expected, actual);
     367
     368  result = sl_rewind(rval_open);
     369  CuAssertTrue(tc, rval_open >= 0);
     370
     371  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 0, 0);
     372  expected = "FAA937EF3389C7E786EB0F1006D049D7AEA7B7B600000000";
     373  CuAssertStrEquals(tc, expected, actual);
     374
     375  result = sl_close(rval_open);
     376  CuAssertTrue(tc, result == 0);
     377
     378  result = remove("cutest_foo");
     379  CuAssertTrue(tc, result == 0);
     380}

  • trunk/src/cutest_sh_tools.c

    r17 r19  
    44#include <string.h>
    55#include "CuTest.h"
     6#include "samhain.h"
    67#include "sh_tools.h"
    78

  • trunk/src/make-tests.sh

    r17 r19  
    66# Author: Asim Jalis
    77# Date: 01/08/2003
     8
     9# Modified to return non-zero if any test has failed
     10# Rainer Wichmann, 29. Jan 2006
     11# ...and to print to stderr if any test has failed
     12# Rainer Wichmann, 31. Jan 2006
    813
    914if test $# -eq 0 ; then FILES=*.c ; else FILES=$* ; fi
    … …  
    2631'
    2732
    28 void RunAllTests(void)
     33int RunAllTests(void)
    2934{
    3035    CuString *output = CuStringNew();
    … …  
    4348    CuSuiteSummary(suite, output);
    4449    CuSuiteDetails(suite, output);
    45     printf("%s\n", output->buffer);
     50    if (suite->failCount > 0)
     51      fprintf(stderr, "%s\n", output->buffer);
     52    else
     53      fprintf(stdout, "%s\n", output->buffer);
     54    return suite->failCount;
    4655}
    4756
    4857int main(void)
    4958{
    50     RunAllTests();
    51     return 0;
     59    int retval;
     60    retval = RunAllTests();
     61    return (retval == 0) ? 0 : 1;
    5262}
    5363'

  • trunk/src/samhain.c

    r18 r19  
    17521752            }
    17531753         
    1754           if (sig_suspend_switch == 1)  /* SIGUSR2 */
     1754          if (sig_suspend_switch > 0)  /* SIGUSR2 */
    17551755            {
    17561756              TPT((0, FIL__, __LINE__, _("msg=<Suspend switch.>\n")));
    … …  
    17621762                sh_global_suspend_flag = 1;
    17631763              }
    1764               sig_suspend_switch = 0;
     1764              --sig_suspend_switch;
    17651765              --sig_raised; --sig_urgent;
    17661766            }

  • trunk/src/sh_err_log.c

    r1 r19  
    755755  if (skey->mlock_failed == SL_FALSE)
    756756    {
    757       if ( (-1) == sh_unix_mlock( log_msg.msg,
     757      if ( (-1) == sh_unix_mlock( FIL__, __LINE__, log_msg.msg,
    758758                                  (size_t)(2*KEY_LEN + status + 32) ) )
    759759        {

  • trunk/src/sh_files.c

    r8 r19  
    590590        if (0 == strncmp(myword, _("HLN"), 3))
    591591          sh_files_set_mask (mask, MODI_HLN, act);
     592/* size may grow */
     593        if (0 == strncmp(myword, _("GROW"), 3))
     594          sh_files_set_mask (mask, MODI_SGROW, act);
     595/* use prelink */
     596        if (0 == strncmp(myword, _("PRE"), 3))
     597          sh_files_set_mask (mask, MODI_PREL, act);
    592598       
    593599      }
    … …  
    10101016              ++dcount;
    10111017            }
    1012           ptr->checked = S_TRUE;
     1018          ptr->checked        = S_TRUE;
     1019          ptr->childs_checked = S_TRUE;
    10131020        }
    10141021
    … …  
    14251432
    14261433  dirstack_t *    dst_ptr;
     1434  dirstack_t *    tmp_ptr;
    14271435
    14281436  int             hardlink_num = 0;
    … …  
    16451653        file_class_next    = dst_ptr->class;
    16461654        checked_flag       = dst_ptr->checked;
    1647         cchecked_flag      = dst_ptr->childs_checked;
     1655        /* not set, hence always FALSE                   */
     1656        /* cchecked_flag      = dst_ptr->childs_checked; */
    16481657      }
    16491658   
    … …  
    17081717            cchecked_flag = -1;
    17091718           
    1710             dst_ptr     = (dirstack_t *) zAVLSearch(zdirListOne, tmpcat);
    1711 
    1712             if (dst_ptr)
     1719            tmp_ptr     = (dirstack_t *) zAVLSearch(zdirListOne, tmpcat);
     1720
     1721            if (tmp_ptr)
    17131722              {
    17141723                TPT((0, FIL__, __LINE__,
    17151724                     _("msg=<%s -> recursion depth %d\n>"),
    1716                      dst_ptr->name, dst_ptr->rdepth));
    1717                 rdepth_next   = dst_ptr->rdepth;
    1718                 class_next    = dst_ptr->class;
     1725                     tmp_ptr->name, tmp_ptr->rdepth));
     1726                rdepth_next   = tmp_ptr->rdepth;
     1727                class_next    = tmp_ptr->class;
    17191728                /* 28. Aug 2001 reversed
    17201729                 */
    1721                 cchecked_flag = dst_ptr->childs_checked;
    1722                 checked_flag  = dst_ptr->checked;
     1730                cchecked_flag = tmp_ptr->childs_checked;
     1731                checked_flag  = tmp_ptr->checked;
    17231732              }
    17241733           
    17251734            if (checked_flag == -1)
    17261735              {
    1727                 dst_ptr     = (dirstack_t *) zAVLSearch(zdirListTwo, tmpcat);
    1728 
    1729                 if (dst_ptr)
     1736                tmp_ptr     = (dirstack_t *) zAVLSearch(zdirListTwo, tmpcat);
     1737
     1738                if (tmp_ptr)
    17301739                  {
    17311740                    TPT((0, FIL__, __LINE__,
    17321741                         _("msg=<%s -> recursion depth %d\n>"),
    1733                          dst_ptr->name, dst_ptr->rdepth));
    1734                     rdepth_next   = dst_ptr->rdepth;
    1735                     class_next    = dst_ptr->class;
     1742                         tmp_ptr->name, tmp_ptr->rdepth));
     1743                    rdepth_next   = tmp_ptr->rdepth;
     1744                    class_next    = tmp_ptr->class;
    17361745                    /* 28. Aug 2001 reversed
    17371746                     */
    1738                     cchecked_flag = dst_ptr->childs_checked;
    1739                     checked_flag  = dst_ptr->checked;
     1747                    cchecked_flag = tmp_ptr->childs_checked;
     1748                    checked_flag  = tmp_ptr->checked;
    17401749                  }
    17411750              }
    … …  
    17451754                sh_files_checkdir (class_next, rdepth_next, tmpcat,
    17461755                                   dirlist->sh_d_name);
    1747                 dst_ptr->childs_checked = S_TRUE;
     1756                tmp_ptr->childs_checked = S_TRUE;
     1757                /*
     1758                 * 04. Feb 2006 avoid double checking
     1759                 */
     1760                tmp_ptr->checked        = S_TRUE;
    17481761              }
    17491762            else if (checked_flag == -1)
    … …  
    17681781   
    17691782    dirlist = dirlist->next;
     1783
     1784    if (dst_ptr)
     1785      dst_ptr->childs_checked = S_TRUE;
    17701786   
    17711787  } while (dirlist != NULL);
    … …  
    18201836   */
    18211837  char            fullpath[PATH_MAX];
    1822   char            fileHash[KEY_LEN + 1];
     1838  char            fileHash[2*(KEY_LEN + 1)];
    18231839  int             status;
    18241840  file_type       theFile;

  • trunk/src/sh_forward.c

    r12 r19  
    49954995          }
    49964996       
    4997         if (sig_suspend_switch == 1)  /* SIGUSR2 */
     4997        if (sig_suspend_switch > 0)  /* SIGUSR2 */
    49984998          {
    49994999            TPT((0, FIL__, __LINE__, _("msg=<Suspend switch.>\n")));
    … …  
    50055005              sh_global_suspend_flag = 1;
    50065006            }
    5007             sig_suspend_switch = 0;
     5007            --sig_suspend_switch;
    50085008            --sig_raised; --sig_urgent;
    50095009          }
    … …  
    51715171      tcurrent = (unsigned long) time (NULL);
    51725172
     5173      /* check for time limit exceeded
     5174       */
     5175      if ((tcurrent - tchkold) > (unsigned int) 3 )
     5176        {
     5177          tchkold = tcurrent;
     5178          client_time_check(/* all_clients */);
     5179        }
     5180     
     5181      /* seed / re-seed the PRNG if required
     5182       */
     5183      (void) taus_seed();
     5184
    51735185      /* select() timeout handling.
    51745186       */
    … …  
    52465258            }
    52475259        }
    5248 
    5249       /* check for time limit exceeded
    5250        */
    5251       if ((tcurrent - tchkold) > (unsigned int) 3 )
    5252         {
    5253           tchkold = tcurrent;
    5254           client_time_check(/* all_clients */);
    5255         }
    5256       tcurrent = tcurrent;
    5257      
    5258       /* seed / re-seed the PRNG if required
    5259        */
    5260       (void) taus_seed();
    5261      
     5260      /* continue */
    52625261    }
    52635262  /* notreached */

  • trunk/src/sh_hash.c

    r18 r19  
    24852485
    24862486  if ( (fileHash != NULL) && (p->theFile.checksum != NULL)   &&
    2487        (strncmp (fileHash, p->theFile.checksum, 50) != 0) &&
     2487       (strncmp (fileHash, p->theFile.checksum, KEY_LEN) != 0) &&
    24882488       (theFile->check_mask & MODI_CHK) != 0)
    24892489    {
    2490       modi_mask |= MODI_CHK;
    2491       change_code[0] = 'C';
    2492       TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
     2490      if ((theFile->check_mask & MODI_SGROW) == 0)
     2491        {
     2492          modi_mask |= MODI_CHK;
     2493          change_code[0] = 'C';
     2494          TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
     2495        }
     2496      else
     2497        {
     2498          if (0 != strncmp (&fileHash[KEY_LEN + 1],
     2499                            p->theFile.checksum, KEY_LEN))
     2500            {
     2501              modi_mask |= MODI_CHK;
     2502              change_code[0] = 'C';
     2503              TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
     2504            }
     2505          else
     2506            {
     2507              p->theFile.size  = theFile->size;
     2508              sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
     2509            }
     2510        }
    24932511    }
    24942512
    … …  
    26212639       (theFile->check_mask & MODI_SIZ) != 0)
    26222640    {
    2623       if (class == SH_LEVEL_LOGGROW && theFile->size < (off_t) p->theFile.size)
     2641      if ((theFile->check_mask & MODI_SGROW) == 0 ||
     2642          theFile->size < (off_t) p->theFile.size)
    26242643        {
    26252644          modi_mask |= MODI_SIZ;
    26262645          change_code[9] = 'S';
    26272646          TPT ((0, FIL__, __LINE__, _("mod=<size>")));
    2628         }
    2629       else if (class != SH_LEVEL_LOGGROW)
    2630         {
    2631           modi_mask |= MODI_SIZ;
    2632           change_code[9] = 'S';
    2633           TPT ((0, FIL__, __LINE__, _("mod=<size>")));
    2634         }
     2647        }
    26352648    }
    26362649  change_code[10] = '\0';

  • trunk/src/sh_suidchk.c

    r1 r19  
    417417
    418418  file_type       theFile;
    419   char            fileHash[KEY_LEN + 1];
     419  char            fileHash[2*(KEY_LEN + 1)];
    420420
    421421  SL_ENTER(_("sh_suidchk_check_internal"));

  • trunk/src/sh_tiger0.c

    r18 r19  
    104104static
    105105word64 * sh_tiger_hash_val (char * filename, TigerType what,
    106                             unsigned long Length, int timeout)
     106                            UINT64 Length, int timeout)
    107107#else
    108108static
    109109sh_word32 * sh_tiger_hash_val (char * filename, TigerType what,
    110                                unsigned long Length, int timeout)
     110                               UINT64 Length, int timeout)
    111111#endif
    112112{
    … …  
    117117  char    * tmp;
    118118  sh_byte * bptr;
    119   sh_byte bbuf[64];
     119  sh_byte   bbuf[64];
     120  UINT64    bcount = 0;
    120121
    121122  static int lockflag = SL_FALSE;
    … …  
    178179     
    179180#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
    180     if (lockflag == SL_FALSE && skey->mlock_failed == SL_FALSE)
     181    if ((lockflag == SL_FALSE) && (skey->mlock_failed == SL_FALSE))
    181182      {
    182         if ( (-1) == sh_unix_mlock((char *)buffer,(PRIV_MAX)*sizeof(sh_byte)))
     183        lockflag = SL_TRUE;
     184        if ( (-1) == sh_unix_mlock(FIL__, __LINE__,
     185                                   (char *)buffer,
     186                                   (PRIV_MAX)*sizeof(sh_byte)))
    183187          skey->mlock_failed = SL_TRUE;
    184         lockflag = SL_TRUE;
    185188      }
    186189#else
    187190    if (lockflag == SL_FALSE && skey->mlock_failed == SL_FALSE)
    188191      {
     192        lockflag = SL_TRUE;
    189193        skey->mlock_failed = SL_TRUE;
    190         lockflag = SL_TRUE;
    191194      }
    192195#endif
    … …  
    229232
    230233            SL_RETURN( NULL, _("sh_tiger_hash_val"));
     234          }
     235
     236        if (Length > 0)
     237          {
     238            bcount += count;
     239            if (bcount > Length)
     240              count = count - (bcount - Length);
     241            count = (count < 0) ? 0 : count;
    231242          }
    232243
    … …  
    382393  if (what == TIGER_DATA && filename != NULL)
    383394    {
    384       tiger(TIGER_CAST filename,  (sh_word32) Length, res);
     395      tiger(TIGER_CAST filename, (sh_word32) Length, res);
    385396      SL_RETURN(res, _("sh_tiger_hash_val"));
    386397    }
    … …  
    692703   resulting message digest number will be written into the 16 bytes
    693704   beginning at RESBLOCK.  */
    694 static int md5_stream(char * filename, void *resblock, int timeout)
     705static int md5_stream(char * filename, void *resblock,
     706                      UINT64 Length, int timeout)
    695707{
    696708  /* Important: BLOCKSIZE must be a multiple of 64.  */
    … …  
    702714  char * tmp;
    703715  uid_t   euid;
     716  UINT64  bcount = 0;
    704717
    705718  unsigned long pages_read;
    … …  
    762775        }
    763776
     777      if (Length > 0)
     778        {
     779          bcount += n;
     780          if (bcount > Length)
     781            n = n - (bcount - Length);
     782          n = (n < 0) ? 0 : n;
     783        }
     784
    764785      sum += n;
    765786    }
    … …  
    807828static
    808829char * sh_tiger_md5_hash  (char * filename, TigerType what,
    809                            unsigned long Length, int timeout)
    810 {
    811   int cnt = (int) Length;
     830                           UINT64 Length, int timeout)
     831{
     832  int cnt;
    812833  static char out[KEY_LEN+1];
    813834  unsigned char md5buffer[16];
    … …  
    822843    }
    823844
    824   (void) md5_stream (filename, md5buffer, timeout);
     845  (void) md5_stream (filename, md5buffer, Length, timeout);
    825846
    826847  /*@-bufferoverflowhigh -usedef@*/
    … …  
    12021223   resulting message digest number will be written into the 16 bytes
    12031224   beginning at RESBLOCK.  */
    1204 static int sha1_stream(char * filename, void *resblock, int timeout)
     1225static int sha1_stream(char * filename, void *resblock,
     1226                       UINT64 Length, int timeout)
    12051227{
    12061228  /* Important: BLOCKSIZE must be a multiple of 64.  */
    … …  
    12121234  char * tmp;
    12131235  uid_t  euid;
     1236  UINT64 bcount = 0;
    12141237
    12151238  unsigned long pages_read;
    … …  
    12751298        }
    12761299
     1300      if (Length > 0)
     1301        {
     1302          bcount += n;
     1303          if (bcount > Length)
     1304            n = n - (bcount - Length);
     1305          n = (n < 0) ? 0 : n;
     1306        }
     1307
    12771308      sum += n;
    12781309    }
    … …  
    13221353
    13231354static char * sh_tiger_sha1_hash  (char * filename, TigerType what,
    1324                                    unsigned long Length, int timeout)
     1355                                   UINT64 Length, int timeout)
    13251356{
    13261357  int cnt = (int) Length;  /* fix compiler warning */
    … …  
    13371368    }
    13381369
    1339   (void) sha1_stream (filename, sha1buffer, timeout);
     1370  (void) sha1_stream (filename, sha1buffer, Length, timeout);
    13401371
    13411372  /*@-bufferoverflowhigh -usedef@*/
    … …  
    13881419
    13891420static char * sh_tiger_hash_internal (char * filename, TigerType what,
    1390                                       unsigned long Length, int timeout);
     1421                                      UINT64 Length, int timeout);
    13911422
    13921423char * sh_tiger_hash (char * filename, TigerType what,
    1393                       unsigned long Length)
     1424                      UINT64 Length)
    13941425{
    13951426  return sh_tiger_hash_internal (filename, what, Length, 0);
    … …  
    13971428
    13981429char * sh_tiger_generic_hash (char * filename, TigerType what,
    1399                               unsigned long Length, int timeout)
     1430                              UINT64 Length, int timeout)
    14001431{
    14011432#ifdef USE_SHA1
    … …  
    14141445 
    14151446static char * sh_tiger_hash_internal (char * filename, TigerType what,
    1416                                       unsigned long Length, int timeout)
     1447                                      UINT64 Length, int timeout)
    14171448{
    14181449#if defined(TIGER_64_BIT)
    … …  
    14231454  static char out[KEY_LEN+1];
    14241455
    1425   SL_ENTER( _("sh_tiger_hash"));
     1456  SL_ENTER( _("sh_tiger_hash_internal"));
    14261457
    14271458  res = sh_tiger_hash_val (filename, what, Length, timeout);
    … …  
    14511482      /*@+bufferoverflowhigh@*/
    14521483      out[KEY_LEN] = '\0';
    1453       SL_RETURN( out, _("sh_tiger_hash"));
     1484      SL_RETURN( out, _("sh_tiger_hash_internal"));
    14541485
    14551486    }
    14561487
    14571488   SL_RETURN( _("000000000000000000000000000000000000000000000000"),
    1458               _("sh_tiger_hash"));
     1489              _("sh_tiger_hash_internal"));
    14591490}
    14601491
    14611492char * sh_tiger_hash_gpg (char * filename, TigerType what,
    1462                           unsigned long Length)
     1493                          UINT64 Length)
    14631494{
    14641495  size_t  len;
    … …  
    15301561UINT32 * sh_tiger_hash_uint32 (char * filename,
    15311562                               TigerType what,
    1532                                unsigned long Length)
     1563                               UINT64 Length)
    15331564{
    15341565#if defined(TIGER_64_BIT)

  • trunk/src/sh_unix.c

    r18 r19  
    573573  if (mysignal == SIGUSR2)
    574574    {
    575       sig_suspend_switch    = 1;
     575      ++sig_suspend_switch;
    576576      ++sig_urgent;
    577577    }
    … …  
    15821582  if (skey->mlock_failed == SL_FALSE)
    15831583    {
    1584       if ( (-1) == sh_unix_mlock( (char *) skey, sizeof (sh_key_t)) )
     1584      if ( (-1) == sh_unix_mlock( FIL__, __LINE__,
     1585                                  (char *) skey, sizeof (sh_key_t)) )
    15851586        {
    15861587          skey->mlock_failed = SL_TRUE;
    … …  
    27542755#include "sh_ignore.h"
    27552756
     2757int sh_unix_checksum_size (char * filename, struct stat * fbuf,
     2758                           char * fileHash, int alert_timeout)
     2759{
     2760  file_type tmpFile;
     2761  int status;
     2762
     2763  SL_ENTER(_("sh_unix_checksum_size"));
     2764
     2765  /* lookup file in database */
     2766  status = sh_hash_get_it (filename, &tmpFile);
     2767  if (status != 0) {
     2768    goto out;
     2769  }
     2770
     2771  /* if last < current get checksum */
     2772  if (tmpFile.size < fbuf->st_size)
     2773    {
     2774      strcpy(fileHash,                         /* known to fit */
     2775             sh_tiger_generic_hash (filename, TIGER_FD, tmpFile.size,
     2776                                    alert_timeout));
     2777
     2778      /* return */
     2779      SL_RETURN( 0, _("sh_unix_checksum_size"));
     2780    }
     2781
     2782 out:
     2783  strcpy(fileHash,                              /* known to fit */
     2784         _("000000000000000000000000000000000000000000000000"));
     2785  SL_RETURN( -1, _("sh_unix_checksum_size"));
     2786}
     2787
    27562788int sh_unix_getinfo (int level, char * filename, file_type * theFile,
    27572789                     char * fileHash, int policy)
    … …  
    28912923                     _("000000000000000000000000000000000000000000000000"));
    28922924            }
    2893           else if (policy == SH_LEVEL_PRELINK &&
     2925          else if ((theFile->check_mask & MODI_PREL) != 0 &&
    28942926                   S_TRUE == sh_prelink_iself(rval_open, fbuf.st_size,
    28952927                                              alert_timeout))
    … …  
    29062938                     sh_tiger_generic_hash (theFile->fullpath, TIGER_FD, 0,
    29072939                                            alert_timeout));
     2940              if ((theFile->check_mask & MODI_SGROW) != 0)
     2941                {
     2942                  sl_rewind(rval_open);
     2943                  tiger_fd = rval_open;
     2944                  sh_unix_checksum_size (theFile->fullpath, &fbuf,
     2945                                         &fileHash[KEY_LEN + 1],
     2946                                         alert_timeout);
     2947                }
    29082948            }
    29092949        }
    … …  
    29392979                                                alert_timeout),
    29402980                         KEY_LEN + 1);
     2981              if ((theFile->check_mask & MODI_SGROW) != 0)
     2982                {
     2983                  sl_rewind(rval_open);
     2984                  tiger_fd = rval_open;
     2985                  sh_unix_checksum_size (theFile->fullpath, &fbuf,
     2986                                         &fileHash[KEY_LEN + 1],
     2987                                         alert_timeout);
     2988                }
    29412989            }
    29422990        }
    … …  
    36483696  unsigned long  page_start;
    36493697  int            page_refcount;
     3698  char           file[64];
     3699  int            line;
    36503700  struct sh_page_lt * next;
    36513701} sh_page_l;
    … …  
    36913741
    36923742#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
    3693 int sh_unix_mlock (void * in_addr, size_t len)
     3743int sh_unix_mlock (char * file, int line, void * in_addr, size_t len)
    36943744{
    36953745  int         num_pages;
    … …  
    37553805      page_list->page_start = addr;
    37563806      page_list->page_refcount = 1;
     3807      sl_strlcpy(page_list->file, file, 64);
     3808      page_list->line = line;
    37573809      status = mlock( (void *) addr, pagesize);
    37583810      if (status != 0)
    … …  
    39293981  while (page_list != NULL)
    39303982    {
     3983#ifdef WITH_TPT
     3984      sl_snprintf(str, 128, _("file: %s line: %d page: %d"),
     3985                  page_list->file, page_list->line, i+1);
     3986      sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, i, MSG_E_SUBGEN,
     3987                  str, _("sh_unix_count_mlock"));
     3988#endif
    39313989      page_list = page_list->next;
    39323990      ++i;
    39333991    }
    3934   sprintf(str, _("%d pages locked"), i);               /* known to fit  */
     3992  sl_snprintf(str, 128, _("%d pages locked"), i);
    39353993  sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, i, MSG_E_SUBGEN,
    39363994                  str, _("sh_unix_count_mlock"));
Note: See TracChangeset for help on using the changeset viewer.