Changeset 149 for trunk/src/sh_hash.c


Ignore:
Timestamp:
Jan 7, 2008, 8:52:13 PM (17 years ago)
Author:
katerina
Message:

Make sh_hash.c thread-safe, remove plenty of tiny allocations, improve sh_mem_dump, modify port check to run as thread, and fix unsetting of sh_thread_pause_flag (was too early).

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/sh_hash.c

    r137 r149  
    5757#include "sh_files.h"
    5858#include "sh_ignore.h"
     59#include "sh_pthread.h"
    5960
    6061#if defined(SH_WITH_CLIENT)
    … …  
    6970#define FIL__  _("sh_hash.c")
    7071
     72SH_MUTEX_STATIC(mutex_hash,PTHREAD_MUTEX_INITIALIZER);
     73
     74const char notalink[2] = { '-', '\0' };
     75
    7176static char * all_items (file_type * theFile, char * fileHash, int is_new);
    7277
    7378#define QUOTE_CHAR '='
    7479
    75 char * unquote_string (const char * str)
     80char * unquote_string (const char * str, size_t len)
    7681{
    7782  int    i = 0, t1, t2;
    7883  char * tmp = NULL;
    79   size_t len, l2, j, k = 0;
     84  size_t l2, j, k = 0;
    8085
    8186  SL_ENTER(_("unquote_string"));
    … …  
    8388  if (str != NULL)
    8489    {
    85       len = sl_strlen(str);
    8690      l2  = len - 2;
    8791      tmp = SH_ALLOC(len + 1);
    … …  
    116120}
    117121
    118 static char i2h[2];
    119 
    120 char * int2hex (unsigned char i)
     122
     123static char * int2hex (unsigned char i, char * i2h)
    121124{
    122125  static char hexchars[] = "0123456789ABCDEF";
    … …  
    129132
    130133
    131 char * quote_string (const char * str)
     134char * quote_string (const char * str, size_t len)
    132135{
    133136  char * tmp;
    134137  char * tmp2;
    135   size_t len, l2, j, i = 0, k = 0;
     138  size_t l2, j, i = 0, k = 0;
     139  char   i2h[2];
    136140
    137141  SL_ENTER(_("quote_string"));
    … …  
    141145      SL_RETURN(NULL, _("quote_string"));
    142146    }
    143 
    144   len = sl_strlen(str);
    145147
    146148  for (j = 0; j < len; ++j)
    … …  
    164166      if (str[j] == '\n')
    165167        {
    166           tmp2 = int2hex((unsigned char) '\n'); /* was 'n', fixed in 1.5.4 */
     168          tmp2 = int2hex((unsigned char) '\n', i2h); /* was 'n', fixed in 1.5.4 */
    167169          tmp[k] = QUOTE_CHAR; ++k;
    168170          tmp[k] = tmp2[0];    ++k;
    … …  
    171173      else if (str[j] == QUOTE_CHAR)
    172174        {
    173           tmp2 = int2hex((unsigned char) QUOTE_CHAR);
     175          tmp2 = int2hex((unsigned char) QUOTE_CHAR, i2h);
    174176          tmp[k] = QUOTE_CHAR; ++k;
    175177          tmp[k] = tmp2[0];    ++k;
    … …  
    249251
    250252typedef struct store_info {
    251   /*
    252   char             fullpath[MAX_PATH_STORE+2];
    253   char             linkpath[MAX_PATH_STORE+2];
    254   */
     253
    255254  UINT32           mode;
    256255  UINT32           linkmode;
    … …  
    270269#if defined(__linux__)
    271270  UINT32           attributes;
    272   char             c_attributes[16];
     271  char             c_attributes[ATTRBUF_SIZE];
    273272#endif
    274273#else
    275274  /* #if defined(__linux__) */
    276275  UINT32           attributes;
    277   char             c_attributes[16];
     276  char             c_attributes[ATTRBUF_SIZE];
    278277  /* endif                  */
    279278#endif
    … …  
    281280  char             c_owner[USER_MAX+2];
    282281  char             c_group[GROUP_MAX+2];
    283   char             c_mode[11];
     282  char             c_mode[CMODE_SIZE];
    284283  char             checksum[KEY_LEN+1];
    285284} sh_filestore_t;
    … …  
    351350{
    352351  file_type * theFile;
    353 #if defined(__linux__) || defined(HAVE_STAT_FLAGS)
    354   int i = 16;
    355 #endif
    356352
    357353  SL_ENTER(_("sh_hash_create_ft"));
    … …  
    362358  theFile->mode  =  p->theFile.mode;
    363359#if defined(__linux__) || defined(HAVE_STAT_FLAGS)
    364   sl_strlcpy(theFile->c_attributes, p->theFile.c_attributes, i /* 16 */);
     360  sl_strlcpy(theFile->c_attributes, p->theFile.c_attributes, ATTRBUF_SIZE);
    365361  theFile->attributes =  p->theFile.attributes;
    366362#endif
    … …  
    431427  char * str;
    432428  char hashbuf[KEYBUF_SIZE];
     429  int  retval = 0;
    433430
    434431  /* --------  find the entry for the file ----------------       */
     432
     433  SH_MUTEX_LOCK(mutex_hash);
    435434
    436435  if (sl_strlen(fullpath) <= MAX_PATH_STORE)
    … …  
    443442                    );
    444443  if (p == NULL)
    445     return -1;
     444    {
     445      retval = -1;
     446      goto unlock_and_return;
     447    }
    446448
    447449  theFile = sh_hash_create_ft (p, fileHash);
    … …  
    455457    SH_FREE(theFile->attr_string);
    456458  SH_FREE(theFile);
    457   return 0;
     459
     460 unlock_and_return:
     461  SH_MUTEX_UNLOCK(mutex_hash);
     462  return retval;
    458463}
    459464
    … …  
    564569              if (p->linkpath)
    565570                {
    566                   SH_FREE(p->linkpath);
     571                  if (p->linkpath != notalink)
     572                    SH_FREE(p->linkpath);
    567573                  p->linkpath = NULL;
    568574                }
    … …  
    624630
    625631  SL_ENTER(_("sh_hash_unvisited"));
     632
     633  SH_MUTEX_LOCK(mutex_hash);
    626634  for (i = 0; i < TABSIZE; ++i)
    627635    {
    … …  
    629637        hash_unvisited (i, tab[i], tab[i], level);
    630638    }
     639  SH_MUTEX_UNLOCK(mutex_hash);
     640
    631641  SL_RET0(_("hash_unvisited"));
    632642}
    … …  
    655665  if (p->linkpath)
    656666    {
    657       SH_FREE(p->linkpath);
     667      if (p->linkpath != notalink)
     668        SH_FREE(p->linkpath);
    658669      p->linkpath = NULL;
    659670    }
    … …  
    721732              q = p->next;
    722733              SH_FREE(p->fullpath);
    723               if(p->linkpath)
     734              if(p->linkpath && p->linkpath != notalink)
    724735                SH_FREE(p->linkpath);
    725736              if(p->attr_string)
    … …  
    768779    }
    769780  n = strlen(line);
    770   if (n > 1) {
     781  if (n > 0) {
    771782    --n;
    772783    line[n] = '\0'; /* remove terminating '\n' */
    … …  
    947958   */
    948959  i =  sh_hash_getline (sh_fin_fd, line, size);
    949   if (i < 0 )
     960  if (i <= 0 )
    950961    {
    951962      SH_FREE(line);
    … …  
    961972    }
    962973
    963   tmp = unquote_string (line);
     974  tmp = unquote_string (line, i);
    964975  len = sl_strlen(tmp)+1;
    965976  fullpath = SH_ALLOC(len);
    … …  
    973984   */
    974985  i =  sh_hash_getline (sh_fin_fd, line, size);
    975   if (i < 0 )
     986  if (i <= 0 )
    976987    {
    977988      SH_FREE(line);
    … …  
    988999    }
    9891000
    990   tmp = unquote_string (line);
    991   len = sl_strlen(tmp)+1;
    992   linkpath = SH_ALLOC(len);
    993   (void) sl_strlcpy (linkpath, tmp, len);
     1001  tmp = unquote_string (line, i);
     1002
     1003  if ( tmp && tmp[0] == '-' &&
     1004       (tmp[1] == '\0' || (tmp[1] == '\n' && tmp[2] == '\0')))
     1005    {
     1006      linkpath = (char *)notalink;
     1007    }
     1008  else
     1009    {
     1010      len = sl_strlen(tmp)+1;
     1011      linkpath = SH_ALLOC(len);
     1012      (void) sl_strlcpy (linkpath, tmp, len);
     1013      if (len > 1 && linkpath[len-2] == '\n')
     1014        linkpath[len-2] = '\0';
     1015    }
     1016
    9941017  if (tmp)
    9951018    SH_FREE(tmp);
    996   if (linkpath[len-2] == '\n')
    997     linkpath[len-2] = '\0';
    9981019
    9991020  /* Read next record -- Part Four -- attr_string
    … …  
    10021023    {
    10031024      i =  sh_hash_getline (sh_fin_fd, line, size);
    1004       if (i < 0 )
     1025      if (i <= 0 )
    10051026        {
    10061027          SH_FREE(line);
    10071028          SH_FREE(fullpath);
    1008           SH_FREE(linkpath);
     1029          if (linkpath != notalink)
     1030            SH_FREE(linkpath);
    10091031          SH_FREE(p);
    10101032          dlog(1, FIL__, __LINE__,
    … …  
    10181040        }
    10191041
    1020       tmp = unquote_string (line);
     1042      tmp = unquote_string (line, i);
    10211043
    10221044      len = sl_strlen(tmp)+1;
    … …  
    10441066 
    10451067 
    1046   if (ft.c_mode[0] == 'l')
     1068  if (ft.c_mode[0] == 'l' && linkpath != notalink)
    10471069    { 
    10481070      sh_do_decode(linkpath, sl_strlen(linkpath));
    … …  
    11221144  SL_ENTER(_("sh_hash_init"));
    11231145
    1124   if (IsInit == 1)
    1125     SL_RET0(_("sh_hash_init"));
    1126 
    1127   for (i = 0; i < TABSIZE; ++i)
    1128     tab[i] = NULL;
     1146  SH_MUTEX_LOCK(mutex_hash);
     1147
     1148  if (IsInit == 1)
     1149    {
     1150      goto unlock_and_return;
     1151    }
    11291152
    11301153#if defined(SH_WITH_CLIENT)
    … …  
    12901313  sh_hash_setdataent(fd, line, MAX_PATH_STORE, file_path('D', 'R'));
    12911314
     1315  for (i = 0; i < TABSIZE; ++i)
     1316    tab[i] = NULL;
     1317
    12921318  while (1)
    12931319    {
    … …  
    13081334        break;
    13091335    }
     1336
     1337  /* Initialization completed.
     1338   */
     1339  IsInit = 1;
    13101340
    13111341  if (line != NULL)
    … …  
    13181348  fd = -1;
    13191349
    1320   /* --- Initialization done successfully. ---
    1321    */
    1322   IsInit = 1;
     1350 unlock_and_return:
     1351  SH_MUTEX_UNLOCK(mutex_hash);
    13231352  SL_RET0(_("sh_hash_init"));
    13241353}
    … …  
    13341363
    13351364  SL_ENTER(_("sh_hash_hashdelete"));
     1365  SH_MUTEX_LOCK(mutex_hash);
    13361366
    13371367  if (IsInit == 0)
    1338     SL_RET0(_("sh_hash_hashdelete"));
     1368    goto unlock_and_exit;
     1369
    13391370  for (i = 0; i < TABSIZE; ++i)
    13401371    if (tab[i] != NULL)
    … …  
    13441375      }
    13451376  IsInit = 0;
     1377
     1378 unlock_and_exit:
     1379  SH_MUTEX_UNLOCK(mutex_hash);
    13461380  SL_RET0(_("sh_hash_hashdelete"));
    13471381}
    … …  
    13851419
    13861420
    1387 void sh_hash_pushdata (file_type * buf, char * fileHash)
     1421static void sh_hash_pushdata_int (file_type * buf, char * fileHash)
    13881422{
    13891423  static long p_count = 0;
    … …  
    13941428  size_t      tmp_len = 0;
    13951429  size_t      old_len = 0;
     1430  size_t      path_len = 0;
    13961431
    13971432  sh_filestore_t p;
    … …  
    14111446#endif
    14121447
    1413   SL_ENTER(_("sh_hash_pushdata"));
     1448  SL_ENTER(_("sh_hash_pushdata_int"));
    14141449
    14151450  fullpath = SH_ALLOC(MAX_PATH_STORE+1);
    … …  
    14321467                      _("Writing database to stdout with update"),
    14331468                      sh.prg_name,
    1434                       _("sh_hash_pushdata"));
     1469                      _("sh_hash_pushdata_int"));
    14351470      aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    14361471    }
    … …  
    14431478                      _("Writing database to stdout when suid"),
    14441479                      sh.prg_name,
    1445                       _("sh_hash_pushdata"));
     1480                      _("sh_hash_pushdata_int"));
    14461481      aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    14471482    }
    14481483
    14491484
    1450   if ((pushdata_stdout == S_FALSE) &&
     1485  if ((pushdata_isfirst == 1) && (pushdata_stdout == S_FALSE) &&
    14511486      ( (NULL == file_path('D', 'W')) ||
    14521487        (0 == sl_strcmp(file_path('D', 'W'), _("REQ_FROM_SERVER"))) ))
    … …  
    14571492                      _("No local path for database specified"),
    14581493                      sh.prg_name,
    1459                       _("sh_hash_pushdata"));
     1494                      _("sh_hash_pushdata_int"));
    14601495      aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    14611496    }
    14621497
    14631498
    1464   if ((pushdata_stdout == S_FALSE) && (pushdata_isfirst == 1)) 
     1499  if ((pushdata_isfirst == 1) && (pushdata_stdout == S_FALSE)) 
    14651500    {
    14661501      /* Warn that file already exists; file_path != NULL here because
    … …  
    14881523              sh_error_handle((-1), FIL__, __LINE__, pushdata_fd, MSG_E_ACCESS,
    14891524                              geteuid(), file_path('D', 'W'));
    1490               SL_RET0(_("sh_hash_pushdata"));
     1525              SL_RET0(_("sh_hash_pushdata_int"));
    14911526            }
    14921527          if ( SL_ISERROR(status = sl_forward(pushdata_fd)))
    … …  
    14951530              SH_FREE(linkpath);
    14961531              sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGPATH,
    1497                               _("Fast forward failed"), _("sh_hash_pushdata"),
     1532                              _("Fast forward failed"), _("sh_hash_pushdata_int"),
    14981533                              file_path('D', 'W'));
    1499               SL_RET0(_("sh_hash_pushdata"));
     1534              SL_RET0(_("sh_hash_pushdata_int"));
    15001535            }
    15011536        }
    … …  
    15111546            sh_error_handle((-1), FIL__, __LINE__, pushdata_fd, MSG_E_ACCESS,
    15121547                            geteuid(), file_path('D', 'W'));
    1513             SL_RET0(_("sh_hash_pushdata"));
     1548            SL_RET0(_("sh_hash_pushdata_int"));
    15141549          }
    15151550          line = SH_ALLOC(MAX_PATH_STORE+1);
    … …  
    15211556              SH_FREE(linkpath);
    15221557              SH_FREE(line);
    1523               SL_RET0(_("sh_hash_pushdata"));
     1558              SL_RET0(_("sh_hash_pushdata_int"));
    15241559            }
    15251560          SH_FREE(line);
    … …  
    15331568    sh_do_encode(buf->fullpath, old_len);
    15341569#endif
    1535     tmp = quote_string(buf->fullpath);
     1570    tmp = quote_string(buf->fullpath, old_len);
    15361571    tmp_len = sl_strlen(tmp);
    15371572#if defined(SH_STEALTH)
    … …  
    15631598  }
    15641599
     1600  path_len = sl_strlen(fullpath);
    15651601#if defined(SH_STEALTH)
    1566   sh_do_encode(fullpath, sl_strlen(fullpath));
    1567 #endif
    1568 
    1569   tmp = quote_string(fullpath);
     1602  sh_do_encode(fullpath, path_len);
     1603#endif
     1604
     1605  tmp = quote_string(fullpath, path_len);
    15701606  if (tmp) {
    15711607    sl_strlcpy(fullpath, tmp, MAX_PATH_STORE+1);
    … …  
    15801616      sh_do_encode(buf->linkpath, old_len);
    15811617#endif
    1582       tmp = quote_string(buf->linkpath);
     1618      tmp = quote_string(buf->linkpath, old_len);
    15831619      tmp_len = sl_strlen(tmp);
    15841620#if defined(SH_STEALTH)
    … …  
    16011637      if (tmp) SH_FREE(tmp);
    16021638
     1639      path_len = sl_strlen(linkpath);
    16031640#if defined(SH_STEALTH)
    1604       sh_do_encode(linkpath, sl_strlen(linkpath));
    1605 #endif
    1606       tmp = quote_string(linkpath);
     1641      sh_do_encode(linkpath, path_len);
     1642#endif
     1643      tmp = quote_string(linkpath, path_len);
    16071644      if (tmp)
    16081645        {
    … …  
    16181655      sh_do_encode(buf->attr_string, old_len);
    16191656#endif
    1620       tmp = quote_string(buf->attr_string);
     1657      tmp = quote_string(buf->attr_string, old_len);
    16211658      if (tmp)
    16221659        {
    … …  
    16341671    if (attr_string)
    16351672      p.mark |= REC_FLAGS_ATTR;
    1636     sl_strlcpy(p.c_mode,   buf->c_mode,   11);
     1673    sl_strlcpy(p.c_mode,   buf->c_mode,   CMODE_SIZE);
    16371674    sl_strlcpy(p.c_group,  buf->c_group,  GROUP_MAX+1);
    16381675    sl_strlcpy(p.c_owner,  buf->c_owner,  USER_MAX+1);
    … …  
    16411678    }
    16421679#if defined(__linux__) || defined(HAVE_STAT_FLAGS)
    1643     sl_strlcpy(p.c_attributes, buf->c_attributes, 13);
    1644 #else
    1645     for (i = 0; i < 12; ++i) p.c_attributes[i] = '-';
    1646     p.c_attributes[12] = '\0';
     1680    sl_strlcpy(p.c_attributes, buf->c_attributes, ATTRBUF_SIZE);
     1681#else
     1682    for (i = 0; i < ATTRBUF_USED; ++i) p.c_attributes[i] = '-';
     1683    p.c_attributes[ATTRBUF_USED] = '\0';
    16471684#endif
    16481685   
    … …  
    17781815    SH_FREE(attr_string);
    17791816
    1780   SL_RET0(_("sh_hash_pushdata"));
    1781 }
     1817  SL_RET0(_("sh_hash_pushdata_int"));
     1818}
     1819
     1820SH_MUTEX_STATIC(mutex_writeout,PTHREAD_MUTEX_INITIALIZER);
     1821
     1822void sh_hash_pushdata (file_type * buf, char * fileHash)
     1823{
     1824  SH_MUTEX_LOCK(mutex_writeout);
     1825  sh_hash_pushdata_int (buf, fileHash);
     1826  SH_MUTEX_UNLOCK(mutex_writeout);
     1827  return;
     1828}
     1829
    17821830
    17831831int sh_hash_writeout()
    … …  
    17971845    }
    17981846
     1847  SH_MUTEX_LOCK(mutex_writeout);
    17991848  if (!SL_ISERROR(pushdata_fd))
    18001849    {
    … …  
    18041853  pushdata_isfirst =  1;
    18051854
     1855
     1856  SH_MUTEX_LOCK(mutex_hash);
    18061857  for (i = 0; i < TABSIZE; ++i)
    18071858    {
    … …  
    18091860        {
    18101861          f = sh_hash_create_ft (p, fileHash);
    1811           sh_hash_pushdata (f, fileHash);
     1862          sh_hash_pushdata_int (f, fileHash);
    18121863          if (f->attr_string)
    18131864            SH_FREE(f->attr_string);
    … …  
    18151866        }
    18161867    }
     1868  SH_MUTEX_UNLOCK(mutex_hash);
    18171869
    18181870  if (!SL_ISERROR(pushdata_fd))
    … …  
    18221874    }
    18231875  pushdata_isfirst =  1;
     1876  SH_MUTEX_UNLOCK(mutex_writeout);
    18241877
    18251878  SL_RETURN (0, _("sh_hash_writeout"));
    … …  
    18421895    SL_RETURN( (NULL), _("sh_hash_have_it_int"));
    18431896
    1844   if (IsInit != 1)
    1845     sh_hash_init();
    18461897  if (sl_strlen(newname) <= MAX_PATH_STORE)
    18471898    p = hashsearch(newname);
    … …  
    18511902  if (p == NULL)
    18521903     SL_RETURN( (NULL), _("sh_hash_have_it_int"));
    1853   /*
    1854   if (p->allignore == S_FALSE &&
    1855       (p->modi_mask & MODI_CHK) != 0 &&
    1856       (p->modi_mask & MODI_MOD) != 0)
    1857     SL_RETURN( (1), _("sh_hash_have_it"));
    1858   */
     1904
    18591905  SL_RETURN( (p), _("sh_hash_have_it_int"));
    18601906}
    … …  
    18621908int sh_hash_have_it (char * newname)
    18631909{
    1864   sh_file_t * p = sh_hash_have_it_int (newname);
    1865 
    1866   if (!p) return (-1);
    1867   if ((!SH_FFLAG_ALLIGNORE_SET(p->fflags)) &&
    1868       (p->modi_mask & MODI_CHK) != 0 &&
    1869       (p->modi_mask & MODI_MOD) != 0)
    1870     return 1;
    1871   return 0;
     1910  sh_file_t * p;
     1911  int retval = 0;
     1912
     1913  if (IsInit != 1)
     1914    sh_hash_init();
     1915
     1916  SH_MUTEX_LOCK(mutex_hash);
     1917  p = sh_hash_have_it_int (newname);
     1918
     1919  if (!p)
     1920    retval = (-1);
     1921  else if ((!SH_FFLAG_ALLIGNORE_SET(p->fflags)) &&
     1922           (p->modi_mask & MODI_CHK) != 0 &&
     1923           (p->modi_mask & MODI_MOD) != 0)
     1924    retval = 1;
     1925  SH_MUTEX_UNLOCK(mutex_hash);
     1926
     1927  return retval;
    18721928}
    18731929
    18741930int sh_hash_get_it (char * newname, file_type * tmpFile)
    18751931{
    1876   sh_file_t * p = sh_hash_have_it_int (newname);
    1877   if (!p)
    1878     return (-1);
    1879   sl_strlcpy(tmpFile->fullpath, p->fullpath, PATH_MAX);
    1880   sl_strlcpy(tmpFile->linkpath, p->linkpath, PATH_MAX);
    1881   tmpFile->size  = p->theFile.size;
    1882   tmpFile->mtime = p->theFile.mtime;
    1883   tmpFile->ctime = p->theFile.ctime;
    1884 
    1885   tmpFile->attr_string = NULL;
    1886   return 0;
     1932  sh_file_t * p;
     1933  int retval = -1;
     1934
     1935  if (IsInit != 1)
     1936    sh_hash_init();
     1937
     1938  SH_MUTEX_LOCK(mutex_hash);
     1939  p = sh_hash_have_it_int (newname);
     1940  if (p)
     1941    {
     1942      sl_strlcpy(tmpFile->fullpath, p->fullpath, PATH_MAX);
     1943      sl_strlcpy(tmpFile->linkpath, p->linkpath, PATH_MAX);
     1944      tmpFile->size  = p->theFile.size;
     1945      tmpFile->mtime = p->theFile.mtime;
     1946      tmpFile->ctime = p->theFile.ctime;
     1947      tmpFile->attr_string = NULL;
     1948      retval = 0;
     1949    }
     1950  SH_MUTEX_UNLOCK(mutex_hash);
     1951
     1952  return retval;
    18871953}
    18881954
    18891955int sh_hash_getflags (char * filename)
    18901956{
    1891   sh_file_t * p = sh_hash_have_it_int (filename);
    1892   if (!p)
    1893     return (-1);
    1894   return (p->fflags);
     1957  sh_file_t * p;
     1958  int retval = -1;
     1959
     1960  if (IsInit != 1)
     1961    sh_hash_init();
     1962
     1963  SH_MUTEX_LOCK(mutex_hash);
     1964  p = sh_hash_have_it_int (filename);
     1965  if (p)
     1966    retval = p->fflags;
     1967  SH_MUTEX_UNLOCK(mutex_hash);
     1968  return retval;
    18951969}
    18961970
    18971971int sh_hash_setflags (char * filename, int flags)
    18981972{
    1899   sh_file_t * p = sh_hash_have_it_int (filename);
    1900   if (!p)
    1901     return (-1);
    1902   p->fflags = flags;
    1903   return 0;
     1973  sh_file_t * p;
     1974  int retval = -1;
     1975
     1976  if (IsInit != 1)
     1977    sh_hash_init();
     1978
     1979  SH_MUTEX_LOCK(mutex_hash);
     1980  p = sh_hash_have_it_int (filename);
     1981  if (p)
     1982    {
     1983      p->fflags = flags;
     1984      retval = 0;
     1985    }
     1986  SH_MUTEX_UNLOCK(mutex_hash);
     1987  return retval;
    19041988}
    19051989
    … …  
    19081992void sh_hash_addflag (char * filename, int flag_to_set)
    19091993{
    1910   int fflags = sh_hash_getflags(filename);
    1911 
    1912   if (fflags >= 0)
    1913     {
    1914       fflags |= flag_to_set;
    1915       sh_hash_setflags(filename, fflags);
    1916     }
     1994  sh_file_t * p;
     1995
     1996  if (IsInit != 1)
     1997    sh_hash_init();
     1998
     1999  SH_MUTEX_LOCK(mutex_hash);
     2000  p = sh_hash_have_it_int (filename);
     2001  if (p)
     2002    {
     2003      p->fflags |= flag_to_set;
     2004    }
     2005  SH_MUTEX_UNLOCK(mutex_hash);
    19172006  return;
    19182007}
    … …  
    19292018  sh_file_t * p;
    19302019  char hashbuf[KEYBUF_SIZE];
     2020  int  retval = -1;
    19312021
    19322022  SL_ENTER(_("sh_hash_set_visited_int"));
    … …  
    19342024  if (newname == NULL)
    19352025    SL_RETURN((-1), _("sh_hash_set_visited_int"));
     2026
    19362027  if (IsInit != 1)
    19372028    sh_hash_init();
     2029
     2030  SH_MUTEX_LOCK(mutex_hash);
    19382031
    19392032  if (sl_strlen(newname) <= MAX_PATH_STORE)
    … …  
    19432036                                  hashbuf, sizeof(hashbuf)));
    19442037 
    1945   if (p == NULL)
    1946     SL_RETURN((-1), _("sh_hash_set_visited_int"));
    1947 
    1948   if (flag == SH_FFLAG_CHECKED)
    1949     {
    1950       CLEAR_SH_FFLAG_REPORTED(p->fflags);
    1951       CLEAR_SH_FFLAG_VISITED(p->fflags);
    1952       SET_SH_FFLAG_CHECKED(p->fflags);
    1953     }
    1954   else
    1955     {
    1956       SET_SH_FFLAG_VISITED(p->fflags);
    1957       CLEAR_SH_FFLAG_CHECKED(p->fflags);
    1958       if (flag == SH_FFLAG_REPORTED)
    1959         SET_SH_FFLAG_REPORTED(p->fflags);
     2038  if (p)
     2039    {
     2040      if (flag == SH_FFLAG_CHECKED)
     2041        {
     2042          CLEAR_SH_FFLAG_REPORTED(p->fflags);
     2043          CLEAR_SH_FFLAG_VISITED(p->fflags);
     2044          SET_SH_FFLAG_CHECKED(p->fflags);
     2045        }
    19602046      else
    1961         CLEAR_SH_FFLAG_REPORTED(p->fflags);
    1962     }
    1963   SL_RETURN((0), _("sh_hash_set_visited_int"));
     2047        {
     2048          SET_SH_FFLAG_VISITED(p->fflags);
     2049          CLEAR_SH_FFLAG_CHECKED(p->fflags);
     2050          if (flag == SH_FFLAG_REPORTED)
     2051            SET_SH_FFLAG_REPORTED(p->fflags);
     2052          else
     2053            CLEAR_SH_FFLAG_REPORTED(p->fflags);
     2054        }
     2055      retval = 0;
     2056    }
     2057
     2058  SH_MUTEX_UNLOCK(mutex_hash);
     2059  SL_RETURN((retval), _("sh_hash_set_visited_int"));
    19642060}
    19652061
    … …  
    25902686  if (p)
    25912687    {
     2688      SH_MUTEX_LOCK(mutex_hash);
    25922689      hashinsert (p);
    25932690      p->modi_mask = theFile->check_mask;
     2691      SH_MUTEX_UNLOCK(mutex_hash);
    25942692    }
    25952693
    … …  
    26332731  char hashbuf[KEYBUF_SIZE];
    26342732
     2733  int  retval = 0;
     2734
    26352735  SL_ENTER(_("sh_hash_compdata"));
    26362736
    … …  
    26462746
    26472747  /* --------  find the entry for the file ----------------       */
     2748
     2749  SH_MUTEX_LOCK(mutex_hash);
    26482750
    26492751  if (sl_strlen(theFile->fullpath) <= MAX_PATH_STORE)
    … …  
    26752777        }
    26762778
    2677       if (p)
    2678         {
    2679           SET_SH_FFLAG_VISITED(p->fflags);
    2680           CLEAR_SH_FFLAG_CHECKED(p->fflags);
    2681         }
    2682 
    26832779      if (sh.flag.reportonce == S_TRUE)
    26842780        SET_SH_FFLAG_REPORTED(theFile->file_reported);
    … …  
    26872783        {
    26882784          p = sh_hash_push_int(theFile, fileHash);
    2689           hashinsert (p);
    26902785          if (p)
    2691             p->modi_mask = theFile->check_mask;
     2786            {
     2787              hashinsert (p);
     2788              p->modi_mask = theFile->check_mask;
     2789            }
    26922790        }
    26932791
    … …  
    26972795            {
    26982796              p = sh_hash_push_int(theFile, fileHash);
    2699               hashinsert (p);
    27002797              if (p)
    2701                 p->modi_mask = theFile->check_mask;
     2798                {
     2799                  hashinsert (p);
     2800                  p->modi_mask = theFile->check_mask;
     2801                }
    27022802            }
    27032803          else
    27042804            {
    2705               SL_RETURN(1, _("sh_hash_compdata"));
     2805              retval = 1;
     2806              goto unlock_and_return;
    27062807            }
    27072808        }
    2708        
    2709       SL_RETURN(0, _("sh_hash_compdata"));
    2710     }
    2711   else
    2712     {
    2713       p->modi_mask = theFile->check_mask;
    2714     }
     2809
     2810      goto unlock_and_return;
     2811    }
     2812
     2813  p->modi_mask = theFile->check_mask;
    27152814
    27162815  /* initialize change_code */
    … …  
    32513350          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    32523351            {
    3253               if (p->linkpath != NULL)
     3352              if (p->linkpath != NULL && p->linkpath != notalink)
    32543353                SH_FREE(p->linkpath);
    3255               p->linkpath = sh_util_strdup(theFile->linkpath);
     3354              if (theFile->linkpath[0] == '-' && theFile->linkpath[1] == '\0')
     3355                p->linkpath = (char *)notalink;
     3356              else
     3357                p->linkpath = sh_util_strdup(theFile->linkpath);
    32563358            }
    32573359#endif
    … …  
    33313433              SET_SH_FFLAG_VISITED(p->fflags);
    33323434              CLEAR_SH_FFLAG_CHECKED(p->fflags);
    3333               SL_RETURN(1, _("sh_hash_compdata"));
     3435              retval = 1;
     3436              goto unlock_and_return;
    33343437            }
    33353438          else /* if (sh.flag.reportonce == S_TRUE) */
    … …  
    33623465              if (theFile->c_mode[0] == 'l')
    33633466                {
    3364                   if (p->linkpath != NULL)
     3467                  if (p->linkpath != NULL && p->linkpath != notalink)
    33653468                    SH_FREE(p->linkpath);
    33663469                  p->linkpath = sh_util_strdup(theFile->linkpath);
    … …  
    33683471              else
    33693472                {
    3370                   if (p->linkpath != NULL) {
     3473                  if (p->linkpath != NULL && p->linkpath != notalink) {
    33713474                    p->linkpath[0] = '-';
    33723475                    p->linkpath[1] = '\0';
    33733476                  } else {
    3374                     p->linkpath = SH_ALLOC(2);
    3375                     p->linkpath[0] = '-';
    3376                     p->linkpath[1] = '\0';
     3477                    p->linkpath = (char *)notalink;
    33773478                  }
    33783479                }
    … …  
    34023503  CLEAR_SH_FFLAG_CHECKED(p->fflags);
    34033504
    3404   SL_RETURN(0, _("sh_hash_compdata"));
     3505 unlock_and_return:
     3506
     3507  SH_MUTEX_UNLOCK(mutex_hash);
     3508  SL_RETURN(retval, _("sh_hash_compdata"));
    34053509}
    34063510
    … …  
    34153519    SL_RETURN(0, _("sh_hash_compdata"));
    34163520
     3521  SH_MUTEX_LOCK_UNSAFE(mutex_hash);
    34173522  for (i = 0; i < TABSIZE; ++i)
    34183523    {
    … …  
    34203525        CLEAR_SH_FFLAG_ALLIGNORE(p->fflags);
    34213526    }
     3527  SH_MUTEX_UNLOCK_UNSAFE(mutex_hash);
    34223528  SL_RETURN (0, _("sh_hash_compdata"));
    34233529}
    … …  
    34403546    sh_hash_init();
    34413547
     3548  SH_MUTEX_LOCK_UNSAFE(mutex_hash);
    34423549  for (i = 0; i < TABSIZE; ++i)
    34433550    {
    … …  
    34503557        }
    34513558    }
     3559  SH_MUTEX_UNLOCK_UNSAFE(mutex_hash);
    34523560  SL_RETURN ((0), _("hash_remove_tree"));
    34533561}
    … …  
    34693577int set_full_detail (const char * c)
    34703578{
     3579  (void) c;
    34713580  ListFullDetail = S_TRUE;
    3472   /* warning: unused parameter `c' */
    3473   if (c)
    3474     return 0;
    3475   else
    3476     return 0;
     3581  return 0;
    34773582}
    34783583 
    34793584int set_list_delimited (const char * c)
    34803585{
     3586  (void) c;
    34813587  ListFullDetail = S_TRUE;
    34823588  ListWithDelimiter = S_TRUE;
    3483   /* warning: unused parameter `c' */
    3484   if (c)
    3485     return 0;
    3486   else
    3487     return 0;
    3488 }
    3489 
    3490 /* Always quote the string, except if it is empty. Qoute quotes by
     3589  return 0;
     3590}
     3591
     3592/* Always quote the string, except if it is empty. Quote quotes by
    34913593 * doubling them.
    34923594 */
Note: See TracChangeset for help on using the changeset viewer.