Changeset 149 for trunk/src


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).

Location:
trunk/src
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/cutest_sh_hash.c

    r76 r149  
    55#include "CuTest.h"
    66
    7 extern char * quote_string   (const char * str);
    8 extern char * unquote_string (const char * str);
     7extern char * quote_string   (const char * str, size_t len);
     8extern char * unquote_string (const char * str, size_t len);
    99
    1010void Test_quote_string_ok (CuTest *tc) {
    … …  
    1919  char   out2[] = "=0A=3Dfoo=0Aba=3Dr=0Atest=3D=0A";
    2020
    21   ret = quote_string(inp1);
     21  ret = quote_string(inp1, strlen(inp1));
    2222  CuAssertPtrNotNull(tc, ret);
    2323  CuAssertStrEquals(tc, out1, ret);
    2424
    25   ret = quote_string(inp2);
     25  ret = quote_string(inp2,strlen(inp2));
    2626  CuAssertPtrNotNull(tc, ret);
    2727  CuAssertStrEquals(tc, out2, ret);
    … …  
    4545  char   inp3[] = "=00=3Dfoo=0Aba=3Dr=0Atest=3D=0A";
    4646
    47   ret = unquote_string(inp1);
     47  ret = unquote_string(inp1, strlen(inp1));
    4848  CuAssertPtrNotNull(tc, ret);
    4949  CuAssertStrEquals(tc, out1, ret);
    5050
    51   ret = unquote_string(inp2);
     51  ret = unquote_string(inp2, strlen(inp2));
    5252  CuAssertPtrNotNull(tc, ret);
    5353  CuAssertStrEquals(tc, out2, ret);
    5454
    55   ret = unquote_string(inp3);
     55  ret = unquote_string(inp3, strlen(inp3));
    5656  CuAssertPtrNotNull(tc, ret);
    5757  CuAssertStrEquals(tc, out3, ret);

  • trunk/src/samhain.c

    r145 r149  
    818818  if (0 != stat(SH_INSTALL_PATH, &buf))
    819819    {
    820       dummy = pidlist;
     820      dummy = (pid_t *)pidlist;
    821821      free(dummy);
    822822      return NULL;
    … …  
    827827  if (NULL == (dp = opendir("/proc")))
    828828    {
    829       dummy = pidlist;
     829      dummy = (pid_t *)pidlist;
    830830      free(dummy);
    831831      return NULL;
    … …  
    858858
    859859  closedir(dp);
    860   return pidlist;
     860  return (pid_t *)pidlist;
    861861}
    862862#else
    … …  
    17551755              for (modnum = 0; modList[modnum].name != NULL; ++modnum)
    17561756                {
    1757                   if (modList[modnum].initval >= SH_MOD_ACTIVE)
    1758                     (void) modList[modnum].mod_reconf();
     1757                  /* sh_thread_pause_flag is true, and we block in lock
     1758                   * until check has returned, so we are sure check will
     1759                   * not run until sh_thread_pause_flag is set to false
     1760                   */
     1761                  /* if (modList[modnum].initval >= SH_MOD_ACTIVE) */
     1762                  (void) modList[modnum].mod_reconf();
    17591763                }
    17601764#endif
    … …  
    18011805                }
    18021806
    1803               sh_thread_pause_flag = S_FALSE;
    18041807
    18051808              /* --- Initialize modules. ---
    … …  
    18321835                    }
    18331836                }
     1837
     1838              /* module is properly set up now
     1839               */
     1840              sh_thread_pause_flag = S_FALSE;
    18341841             
    18351842              --sig_raised;
    … …  
    20692076        sh_hash_writeout ();
    20702077
     2078      /* no-op unless MEM_LOG is defined in sh_mem.c
     2079       */
     2080#ifdef MEM_DEBUG
     2081      sh_mem_dump ();
     2082#endif
     2083
    20712084      /* no loop if not daemon
    20722085       */

  • 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 */

  • trunk/src/sh_mem.c

    r144 r149  
    4747#undef  FIL__
    4848#define FIL__  _("sh_mem.c")
    49 static int eblock = 0;
    5049
    5150#ifdef MEM_DEBUG
    … …  
    7473unsigned long Mem_Current = 0, Mem_Max = 0;
    7574
    76 #if 0
    77 #define MEM_DETAILS
    78 #endif
    79 
    80 #ifdef MEM_DETAILS
    81 int           max_upto_032 = 0;
    82 int           max_upto_064 = 0;
    83 int           max_upto_128 = 0;
    84 int           max_upto_256 = 0;
    85 int           max_upto_512 = 0;
    86 int           max_upto_1024 = 0;
    87 int           max_upto_4096 = 0;
    88 int           max_upto_inf = 0;
    89 
    90 int           now_upto_032 = 0;
    91 int           now_upto_064 = 0;
    92 int           now_upto_128 = 0;
    93 int           now_upto_256 = 0;
    94 int           now_upto_512 = 0;
    95 int           now_upto_1024 = 0;
    96 int           now_upto_4096 = 0;
    97 int           now_upto_inf = 0;
    98 
    99 int           tot_upto_032 = 0;
    100 int           tot_upto_064 = 0;
    101 int           tot_upto_128 = 0;
    102 int           tot_upto_256 = 0;
    103 int           tot_upto_512 = 0;
    104 int           tot_upto_1024 = 0;
    105 int           tot_upto_4096 = 0;
    106 int           tot_upto_inf = 0;
    107 #endif
    108 
    10975#ifdef HAVE_PTHREAD
    11076SH_MUTEX_RECURSIVE(mutex_mem);
    11177#endif
    11278
     79/* define MEM_LOG to an absolute filename to enable this */
    11380#ifdef MEM_LOG
    11481void sh_mem_dump ()
    11582{
    11683  memlist_t   * this = memlist;
    117 
    118 
    11984  FILE * fd;
    12085
    … …  
    12388
    12489  fd = fopen(MEM_LOG, "w");
     90  if (!fd)
     91    {
     92      perror(MEM_LOG);
     93      _exit(EXIT_FAILURE);
     94    }
    12595
    12696  while (this != NULL)
    12797    {
    128       fprintf (fd, "%20s %5d %ld\n",  this->file, this->line, this->size);
     98      fprintf (fd, "## %20s %5d %ld\n",  this->file, this->line, this->size);
     99      fprintf (fd, "%10p %8ld\n", (void *)this->address, this->size);
    129100      this = this->next;
    130101    }
    131102  fclose(fd);
    132   SH_MUTEX_RECURSIVE_UNLOCK(mutex_mem);
    133   return;
     103
     104  SH_MUTEX_RECURSIVE_UNLOCK(mutex_mem);
     105  _exit(EXIT_SUCCESS);
    134106}
    135107#else
    … …  
    162134                   Mem_Max, Mem_Current);
    163135
    164 #ifdef MEM_DETAILS
    165   fprintf(stderr, "\n");
    166   fprintf(stderr, "__SIZE_____TOTAL___MAXIMUM___\n");
    167   fprintf(stderr, "    32    %6d    %6d\n", tot_upto_032, max_upto_032);
    168   fprintf(stderr, "    64    %6d    %6d\n", tot_upto_064, max_upto_064);
    169   fprintf(stderr, "   128    %6d    %6d\n", tot_upto_128, max_upto_128);
    170   fprintf(stderr, "   256    %6d    %6d\n", tot_upto_256, max_upto_256);
    171   fprintf(stderr, "   512    %6d    %6d\n", tot_upto_512, max_upto_512);
    172   fprintf(stderr, "  1024    %6d    %6d\n", tot_upto_1024, max_upto_1024);
    173   fprintf(stderr, "  4096    %6d    %6d\n", tot_upto_4096, max_upto_4096);
    174   fprintf(stderr, "   inf    %6d    %6d\n", tot_upto_inf, max_upto_inf);
    175   fprintf(stderr, "\n");
    176 #endif
    177 
    178136  this = memlist;
    179137
    … …  
    199157  SH_MUTEX_RECURSIVE_INIT(mutex_mem);
    200158  SH_MUTEX_RECURSIVE_LOCK(mutex_mem);
     159
    201160  sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_MSTAMP,
    202161                   Mem_Max, Mem_Current);
    … …  
    229188    }
    230189
    231   /* if (nerr > 0) abort(); */
    232190
    233191  SH_MUTEX_RECURSIVE_UNLOCK(mutex_mem);
    … …  
    249207  if ( the_realAddress  == NULL )
    250208    {
    251       if (eblock == 0)
    252         {
    253           eblock = 1;
    254           (void) safe_logger (0, 0, NULL);
    255           eblock = 0;
    256         }
     209      (void) safe_logger (0, 0, NULL);
     210
    257211      /* use _exit() rather than exit() - we malloc() in atexit() functions
    258212       */
    259       _exit (42);
     213      _exit (EXIT_FAILURE);
    260214    }
    261215 
    … …  
    274228    Max_Alloc_Count = Now_Alloc_Count;
    275229
    276 #ifdef MEM_DETAILS
    277   if (size <= 32)
    278     {
    279       ++now_upto_032;
    280       ++tot_upto_032;
    281       if (now_upto_032 > max_upto_032) max_upto_032 = now_upto_032;
    282     }
    283   else if  (size <= 64)
    284     {
    285       ++now_upto_064;
    286       ++tot_upto_064;
    287       if (now_upto_064 > max_upto_064) max_upto_064 = now_upto_064;
    288     }
    289   else if  (size <= 128)
    290     {
    291       ++now_upto_128;
    292       ++tot_upto_128;
    293       if (now_upto_128 > max_upto_128) max_upto_128 = now_upto_128;
    294     }
    295   else if  (size <= 256)
    296     {
    297       ++now_upto_256;
    298       ++tot_upto_256;
    299       if (now_upto_256 > max_upto_256) max_upto_256 = now_upto_256;
    300     }
    301   else if  (size <= 512)
    302     {
    303       ++now_upto_512;
    304       ++tot_upto_512;
    305       if (now_upto_512 > max_upto_512) max_upto_512 = now_upto_512;
    306     }
    307   else if  (size <= 1024)
    308     {
    309       ++now_upto_1024;
    310       ++tot_upto_1024;
    311       if (now_upto_1024 > max_upto_1024) max_upto_1024 = now_upto_1024;
    312     }
    313   else if  (size <= 4096)
    314     {
    315       ++now_upto_4096;
    316       ++tot_upto_4096;
    317       if (now_upto_4096 > max_upto_4096) max_upto_4096 = now_upto_4096;
    318     }
    319   else
    320     {
    321       ++now_upto_inf;
    322       ++tot_upto_inf;
    323       if (now_upto_inf > max_upto_inf) max_upto_inf = now_upto_inf;
    324 
    325       fprintf(stderr, "\n___BIGSIZE___");
    326       fprintf(stderr, "   %6d  -> %16s  %10d \n", size, file, line);
    327       fprintf(stderr, "\n");
    328 
    329     }
    330 #endif
    331 
    332230  Mem_Current += size;
    333231  Mem_Max = ( (Mem_Current > Mem_Max) ? Mem_Current : Mem_Max);
    … …  
    337235  if ( this == NULL)
    338236    {
    339       if (eblock == 0)
    340         {
    341           eblock = 1;
    342           (void) safe_logger(0, 0, NULL);
    343           eblock = 0;
    344         }
    345       _exit(42);
     237      (void) safe_logger(0, 0, NULL);
     238
     239      _exit(EXIT_FAILURE);
    346240    }
    347241  else
    … …  
    374268  SH_MUTEX_RECURSIVE_INIT(mutex_mem);
    375269  SH_MUTEX_RECURSIVE_LOCK(mutex_mem);
     270
    376271  if ( a == NULL )
    377272    {
    … …  
    424319  --Now_Alloc_Count;
    425320
    426 #ifdef MEM_DETAILS
    427   if (size <= 32)
    428     --now_upto_032;
    429   else if  (size <= 64)
    430     --now_upto_064;
    431   else if  (size <= 128)
    432     --now_upto_128;
    433   else if  (size <= 256)
    434     --now_upto_256;
    435   else if  (size <= 512)
    436     --now_upto_512;
    437   else if  (size <= 1024)
    438     --now_upto_1024;
    439   else if  (size <= 4096)
    440     --now_upto_4096;
    441   else
    442     --now_upto_inf;
    443 #endif
    444 
    445321  Mem_Current -= size;
    446322 out:
    … …  
    475351  theAddress = malloc(size);
    476352
    477   if ( theAddress == NULL )
    478     {
    479       if (eblock == 0)
    480         {
    481           eblock = 1;
    482           (void) safe_logger(0, 0, NULL);
    483           eblock = 0;
    484         }
     353  if ( theAddress != NULL )
     354    {
     355      SL_RETURN( theAddress, _("sh_mem_malloc"));
     356    }
     357  else
     358    {
     359      (void) safe_logger(0, 0, NULL);
     360
    485361      /* use _exit() rather than exit() - we malloc() in atexit() 
    486362       */
    487       _exit (42);
    488     }
    489   /* memset (theAddress, 0, 1); *//* needs testing */
    490 
    491   SL_RETURN( theAddress, _("sh_mem_malloc"));
    492 }
    493 #endif
     363      _exit (EXIT_FAILURE);
     364    }
     365}
     366#endif

  • trunk/src/sh_modules.c

    r142 r149  
    2626    sh_utmp_check,
    2727    sh_utmp_end,
    28     sh_utmp_null,
     28    sh_utmp_reconf,
    2929
    3030    N_("[Utmp]"),
    … …  
    9090    sh_suidchk_check,
    9191    sh_suidchk_end,
    92     sh_suidchk_free_schedule,
     92    sh_suidchk_reconf,
    9393
    9494    N_("[SuidCheck]"),

  • trunk/src/sh_mounts.c

    r140 r149  
    263263
    264264/* Module reconfiguration
    265  * Run on receipt of a HUP. Right now this is identical to _end(), but it may
    266  * not always be. */
     265 * Run on receipt of a HUP.
     266 */
    267267int sh_mounts_reconf()
    268268{
    … …  
    270270  sh_mounts_mnt_free(mountlist);
    271271  mountlist = NULL;
     272
     273  /* re-set defaults
     274   */
     275  ShMountsActive    = S_FALSE;
     276  ShMountsInterval  = 86400;
     277  ShMountsSevMnt    = 7;
     278  ShMountsSevOpt    = 7;
     279
    272280  SL_RETURN( (0), _("sh_mounts_null"));
    273281}

  • trunk/src/sh_portcheck.c

    r140 r149  
    8080#define SH_PORT_OPT 2
    8181#define SH_PORT_IGN 3
     82#define SH_PORT_BLACKLIST 4
    8283
    8384#define SH_PORT_MISS 0
    … …  
    8788#define SH_PORT_NOREPT 0
    8889#define SH_PORT_REPORT 1
     90
     91#define SH_PROTO_TCP 0
     92#define SH_PROTO_UDP 1
     93#define SH_PROTO_STR(a) (((a) == IPPROTO_TCP) ? _("tcp") : _("udp"))
    8994
    9095struct sh_portentry {
    … …  
    101106static struct sh_portentry * portlist_udp = NULL;
    102107
     108struct sh_port {
     109  int              port;
     110  struct in_addr   haddr;
     111  struct sh_port * next;
     112};
     113
     114static struct sh_port * blacklist_tcp = NULL;
     115static struct sh_port * blacklist_udp = NULL;
     116
    103117#define SH_PORTCHK_INTERVAL 300
    104118
    … …  
    117131#include "sh_pthread.h"
    118132
     133SH_MUTEX_STATIC(mutex_port_check, PTHREAD_MUTEX_INITIALIZER);
     134
    119135static int sh_portchk_severity  = SH_ERR_SEVERE;
    120136#endif
    … …  
    132148static int sh_portchk_add_optional (const char * str);
    133149
     150/* Exported interface to add blacklisted ports as 'iface:portlist'
     151 */
     152static int sh_portchk_add_blacklist (const char * str);
     153
    134154/* Exported interface to add an ethernet interface
    135155 */
    136156static int sh_portchk_add_interface (const char * str);
    137157
     158/* verify whether port/interface is blacklisted (do not check)
     159 */
     160static int sh_portchk_is_blacklisted(int port, struct in_addr haddr, int proto);
    138161
    139162#ifndef TEST_ONLY
    … …  
    148171  if (val <= 0)
    149172    {
     173      SH_MUTEX_LOCK(mutex_thread_nolog);
    150174      sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
    151175                       _("port check interval"), c);
     176      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    152177      retval = -1;
    153178    }
    … …  
    196221    },
    197222    {
     223        N_("portcheckskip"),
     224        sh_portchk_add_blacklist,
     225    },
     226    {
    198227        N_("portcheckactive"),
    199228        sh_portchk_set_active,
    … …  
    232261
    233262
    234 static char * check_services (int port, char * proto);
     263static char * check_services (int port, int proto);
    235264
    236265#ifdef TEST_ONLY
    … …  
    249278#endif
    250279
    251 static void sh_portchk_add_to_list (char * proto,
     280static void sh_portchk_add_to_list (int proto,
    252281                                    int port, struct in_addr haddr, char * service,
    253282                                    int flag, int status)
    … …  
    257286  if (portchk_debug)
    258287    fprintf(stderr, _("add to list: port %d/%s %d %d (%s)\n"),
    259             port, proto, flag, status, service ? service : _("undef"));
     288            port, SH_PROTO_STR(proto), flag, status, service ? service : _("undef"));
    260289
    261290  new->port = port;
    … …  
    270299  else
    271300    new->service = NULL;
    272   if (0 == strcmp(proto, "tcp"))
     301  if (proto == IPPROTO_TCP)
    273302    {
    274303      new->next = portlist_tcp;
    … …  
    322351}
    323352 
     353static struct sh_port * sh_portchk_kill_blacklist (struct sh_port * head)
     354{
     355  if (head)
     356    {
     357      if (head->next)
     358        sh_portchk_kill_blacklist (head->next);
     359
     360      SH_FREE(head);
     361    }
     362  return NULL;
     363}
     364 
    324365/* check the list of open ports for any that are marked as UNKN
    325366 */
    326 static void sh_portchk_check_list (struct sh_portentry ** head, char * proto, int report)
     367static void sh_portchk_check_list (struct sh_portentry ** head, int proto, int report)
    327368{
    328369  struct sh_portentry * ptr = *head;
    … …  
    334375      if (portchk_debug && report)
    335376        fprintf(stderr, _("check list: port %d/%s %d %d\n"),
    336                 ptr->port, proto, ptr->flag, ptr->status);
     377                ptr->port, SH_PROTO_STR(proto), ptr->flag, ptr->status);
    337378
    338379      if (ptr->status == SH_PORT_UNKN)
    … …  
    343384            {
    344385              snprintf (errbuf, sizeof(errbuf), _("POLICY [ServiceMissing] port %s:%d/%s (%s)"),
    345                         ptr->interface, ptr->port, proto,
     386                        ptr->interface, ptr->port, SH_PROTO_STR(proto),
    346387                        ptr->service ? ptr->service : check_services(ptr->port, proto));
    347388#ifdef TEST_ONLY
    … …  
    350391#else
    351392              if (report == SH_PORT_REPORT)
    352                 sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0,
    353                                 MSG_PORT_REPORT, errbuf);
     393                {
     394                  SH_MUTEX_LOCK(mutex_thread_nolog);
     395                  sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0,
     396                                  MSG_PORT_REPORT, errbuf);
     397                  SH_MUTEX_UNLOCK(mutex_thread_nolog);
     398                }
    354399#endif
    355400            }
    … …  
    361406              if (portchk_debug && report)
    362407                fprintf(stderr, _("removing: port %d/%s %d %d\n"),
    363                         ptr->port, proto, ptr->flag, ptr->status);
     408                        ptr->port, SH_PROTO_STR(proto), ptr->flag, ptr->status);
    364409             
    365410              if (ptr == *head)
    … …  
    399444
    400445
    401 static struct sh_portentry * sh_portchk_get_from_list (char * proto, int port,
     446static struct sh_portentry * sh_portchk_get_from_list (int proto, int port,
    402447                                                       struct in_addr haddr, char * service)
    403448{
    … …  
    407452  sl_strlcpy (iface_all, _("0.0.0.0"), sizeof(iface_all));
    408453 
    409   if (0 == strcmp(proto, "tcp"))
     454  if (proto == IPPROTO_TCP)
    410455    portlist = portlist_tcp;
    411456  else
    … …  
    439484     
    440485
    441 static void sh_portchk_cmp_to_list (char * proto, int port, struct in_addr haddr, char * service)
     486static void sh_portchk_cmp_to_list (int proto, int port, struct in_addr haddr, char * service)
    442487{
    443488  struct sh_portentry * portent;
    … …  
    452497        {
    453498          snprintf (errbuf, sizeof(errbuf), _("POLICY [ServiceNew] port %s:%d/%s (%s)"),
    454                     inet_ntoa(haddr), port, proto, service);
     499                    inet_ntoa(haddr), port, SH_PROTO_STR(proto), service);
    455500#ifdef TEST_ONLY
    456501          fprintf(stderr, _("open port: %s:%d/%s (%s)\n"),
    457                   inet_ntoa(haddr), port, proto, service);
    458 #else
     502                  inet_ntoa(haddr), port, SH_PROTO_STR(proto), service);
     503#else
     504          SH_MUTEX_LOCK(mutex_thread_nolog);
    459505          sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0,
    460506                          MSG_PORT_REPORT, errbuf);
     507          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    461508#endif
    462509          /*
    … …  
    468515        {
    469516          snprintf (errbuf, sizeof(errbuf), _("POLICY [ServiceRestarted] port %s:%d/%s to %d/%s (%s)"),
    470                     inet_ntoa(haddr), portent->port, proto, port, proto, service);
     517                    inet_ntoa(haddr), portent->port, SH_PROTO_STR(proto), port, SH_PROTO_STR(proto), service);
    471518#ifdef TEST_ONLY
    472519          fprintf(stderr, _("service: %s\n"), errbuf);
    473520#else
     521          SH_MUTEX_LOCK(mutex_thread_nolog);
    474522          sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0,
    475523                          MSG_PORT_REPORT, errbuf);
     524          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    476525#endif
    477526
    … …  
    481530        {
    482531          snprintf (errbuf, sizeof(errbuf), _("POLICY [ServicePortSwitch] port %s:%d/%s to %d/%s (%s)"),
    483                     inet_ntoa(haddr), portent->port, proto, port, proto, service);
     532                    inet_ntoa(haddr), portent->port, SH_PROTO_STR(proto), port, SH_PROTO_STR(proto), service);
    484533#ifdef TEST_ONLY
    485534          fprintf(stderr, _("service: %s\n"), errbuf);
    486535#else
     536          SH_MUTEX_LOCK(mutex_thread_nolog);
    487537          sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0,
    488538                          MSG_PORT_REPORT, errbuf);
     539          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    489540#endif
    490541          portent->port   = port;
    … …  
    501552        {
    502553          snprintf (errbuf, sizeof(errbuf), _("POLICY [ServiceNew] port %s:%d/%s (%s)"),
    503                     inet_ntoa(haddr), port, proto, check_services(port, proto));
     554                    inet_ntoa(haddr), port, SH_PROTO_STR(proto), check_services(port, proto));
    504555#ifdef TEST_ONLY
    505556          fprintf(stderr, _("open port: %s:%d/%s (%s)\n"),
    506                   inet_ntoa(haddr), port, proto, check_services(port, proto));
    507 #else
     557                  inet_ntoa(haddr), port, SH_PROTO_STR(proto), check_services(port, proto));
     558#else
     559          SH_MUTEX_LOCK(mutex_thread_nolog);
    508560          sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0,
    509561                          MSG_PORT_REPORT, errbuf);
     562          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    510563#endif
    511564
    … …  
    517570        {
    518571          snprintf (errbuf, sizeof(errbuf), _("POLICY [ServiceRestarted] port %s:%d/%s (%s)"),
    519                     inet_ntoa(haddr), port, proto, check_services(port, proto));
     572                    inet_ntoa(haddr), port, SH_PROTO_STR(proto), check_services(port, proto));
    520573#ifdef TEST_ONLY
    521574          fprintf(stderr, _("port   : %s\n"), errbuf);
    522575#else
     576          SH_MUTEX_LOCK(mutex_thread_nolog);
    523577          sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0,
    524578                          MSG_PORT_REPORT, errbuf);
     579          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    525580#endif
    526581
    … …  
    541596 * Returns NULL on failure
    542597 */
    543 static char * check_services (int port, char * proto)
     598static char * check_services (int port, int proto)
    544599{
    545600  static char buf[256];
    546   struct servent * service = getservbyport(htons(port), proto);
     601  struct servent * service = getservbyport(htons(port), SH_PROTO_STR(proto));
    547602
    548603  if (service && service->s_name && service->s_name[0] != '\0')
    … …  
    630685      sl_snprintf(errmsg, sizeof(errmsg), _("check port: %5d/udp on %15s: %s"),
    631686                  port, inet_ntoa(haddr), sh_error_message(errno, errbuf, sizeof(errbuf)));
     687      SH_MUTEX_LOCK(mutex_thread_nolog);
    632688      sh_error_handle((-1), FIL__, __LINE__, nerr, MSG_E_SUBGEN,
    633689                      errmsg, _("connect"));
     690      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    634691#endif
    635692    }
    … …  
    666723              p = check_rpc_list (port, &sinr, IPPROTO_UDP);
    667724             
    668               sh_portchk_cmp_to_list ("udp", port, haddr, p ? p : NULL);
     725              sh_portchk_cmp_to_list (IPPROTO_UDP, port, haddr, p ? p : NULL);
    669726             
    670727              /* If not an RPC service, try to get name from /etc/services
    671728               */
    672729              if (!p)
    673                 p = check_services(port, "udp");
     730                p = check_services(port, IPPROTO_UDP);
    674731             
    675732              if (portchk_debug)
    … …  
    722779      sl_snprintf(errmsg, sizeof(errmsg), _("check port: %5d/tcp on %15s: %s"),
    723780                  port, inet_ntoa(haddr), sh_error_message(errno, errbuf, sizeof(errbuf)));
     781      SH_MUTEX_LOCK(mutex_thread_nolog);
    724782      sh_error_handle((-1), FIL__, __LINE__, nerr, MSG_E_SUBGEN,
    725783                      errmsg, _("connect"));
     784      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    726785#endif
    727786    }
    … …  
    732791      p = check_rpc_list (port, &sinr, IPPROTO_TCP);
    733792
    734       sh_portchk_cmp_to_list ("tcp", port, haddr, p ? p : NULL);
     793      sh_portchk_cmp_to_list (IPPROTO_TCP, port, haddr, p ? p : NULL);
    735794
    736795      /* If not an RPC service, try to get name from /etc/services
    737796       */
    738797      if (!p)
    739         p = check_services(port, "tcp");
     798        p = check_services(port, IPPROTO_TCP);
    740799
    741800      if (portchk_debug)
    … …  
    815874#endif
    816875
    817 int sh_portchk_init (struct mod_type * arg)
     876static int sh_portchk_init_internal (void)
    818877{
    819878  struct hostent * hent;
    820879  int              i = 0;
    821880  char errbuf[256];
    822   (void) arg;
    823881
    824882  if (portchk_debug)
    … …  
    831889    return -1;
    832890
     891  SH_MUTEX_LOCK(mutex_port_check);
    833892  if (iface_initialized == 0)
    834893    {
    … …  
    852911      sl_snprintf(errbuf, sizeof(errbuf), _("interface: %s"),
    853912                  inet_ntoa(iface_list.iface[i]));
     913      SH_MUTEX_LOCK(mutex_thread_nolog);
    854914      sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    855915                      errbuf, _("sh_portchk_init"));
    856     }
     916      SH_MUTEX_UNLOCK(mutex_thread_nolog);
     917    }
     918  SH_MUTEX_UNLOCK(mutex_port_check);
    857919
    858920  return 0;
    859921}
     922
     923int sh_portchk_init (struct mod_type * arg)
     924{
     925  if (sh_portchk_active == S_FALSE)
     926    return SH_MOD_FAILED;
     927  if (!portchk_hostname)
     928    return SH_MOD_FAILED;
     929
     930#ifdef HAVE_PTHREAD
     931  if (arg != NULL && arg->initval < 0 &&
     932      (sh.flag.isdaemon == S_TRUE || sh.flag.loop == S_TRUE))
     933    {
     934      if (0 == sh_pthread_create(sh_threaded_module_run, (void *)arg))
     935        return SH_MOD_THREAD;
     936      else
     937        return SH_MOD_FAILED;
     938    }
     939#endif
     940  return sh_portchk_init_internal();
     941}
     942
     943
    860944
    861945#if !defined(TEST_ONLY)
    862946int sh_portchk_reconf ()
    863947{
     948  SH_MUTEX_LOCK(mutex_port_check);
    864949  iface_initialized    = 0;
    865 
    866950  sh_portchk_active    = 1;
    867951  sh_portchk_check_udp = 1;
     952  sh_portchk_interval  = SH_PORTCHK_INTERVAL;
    868953
    869954  portlist_udp = sh_portchk_kill_list (portlist_udp);
    870955  portlist_tcp = sh_portchk_kill_list (portlist_tcp);
     956
     957  blacklist_udp = sh_portchk_kill_blacklist (blacklist_udp);
     958  blacklist_tcp = sh_portchk_kill_blacklist (blacklist_tcp);
     959  SH_MUTEX_UNLOCK(mutex_port_check);
    871960  return 0;
    872961}
    … …  
    903992  while (i < iface_list.used)
    904993    {
     994      haddr.s_addr = iface_list.iface[i].s_addr;
     995
     996      if (0 != sh_portchk_is_blacklisted(port, haddr, protocol))
     997        {
     998          ++i; continue;
     999        }
     1000
    9051001      if ((sock = socket(AF_INET, type, protocol)) < 0 )
    9061002        {
    … …  
    9091005            perror(_("socket"));
    9101006#else
     1007          SH_MUTEX_LOCK(mutex_thread_nolog);
    9111008          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    9121009                          sh_error_message(errno, errbuf, sizeof(errbuf)), _("socket"));
     1010          SH_MUTEX_UNLOCK(mutex_thread_nolog);
     1011          ++i;
     1012          continue;
    9131013#endif
    9141014        }
    … …  
    9201020            perror(_("setsockopt"));
    9211021#else
     1022          SH_MUTEX_LOCK(mutex_thread_nolog);
    9221023          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    9231024                          sh_error_message(errno, errbuf, sizeof(errbuf)),_("setsockopt"));
    924 #endif
    925         }
    926 
    927       memcpy (&(haddr.s_addr), &(iface_list.iface[i].s_addr), sizeof(in_addr_t));
     1025          SH_MUTEX_UNLOCK(mutex_thread_nolog);
     1026#endif
     1027          ++i;
     1028          continue;
     1029        }
     1030
    9281031
    9291032      if (protocol == IPPROTO_TCP)
    … …  
    9821085            perror(_("socket"));
    9831086#else
     1087          SH_MUTEX_LOCK(mutex_thread_nolog);
    9841088          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    9851089                          sh_error_message(errno, errbuf, sizeof(errbuf)), _("socket"));
    986 #endif
     1090          SH_MUTEX_UNLOCK(mutex_thread_nolog);
     1091#endif
     1092          continue;
    9871093        }
    9881094      if ( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
    … …  
    9931099            perror(_("setsockopt"));
    9941100#else
     1101          SH_MUTEX_LOCK(mutex_thread_nolog);
    9951102          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    9961103                          sh_error_message(errno, errbuf, sizeof(errbuf)),_("setsockopt"));
    997 #endif
     1104          SH_MUTEX_UNLOCK(mutex_thread_nolog);
     1105#endif
     1106          continue;
    9981107        }
    9991108
    … …  
    10271136                perror(_("bind"));
    10281137#else
     1138              SH_MUTEX_LOCK(mutex_thread_nolog);
    10291139              sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    10301140                              sh_error_message(errno, errbuf, sizeof(errbuf)), _("bind"));
     1141              SH_MUTEX_UNLOCK(mutex_thread_nolog);
    10311142#endif
    10321143            }
    … …  
    10671178
    10681179  sl_snprintf(errbuf, sizeof(errbuf), _("interface: %s"), inet_ntoa(haddr));
     1180  SH_MUTEX_LOCK(mutex_thread_nolog);
    10691181  sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    10701182                  errbuf, _("sh_portchk_add_interface"));
     1183  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    10711184
    10721185  memcpy (&(iface_list.iface[iface_list.used].s_addr), &(haddr.s_addr), sizeof(in_addr_t));
    … …  
    10761189}
    10771190
     1191/* verify whether port/interface is blacklisted (do not check)
     1192 */
     1193static int sh_portchk_is_blacklisted(int port, struct in_addr haddr, int proto)
     1194{
     1195  struct sh_port * head;
     1196
     1197  if (proto == IPPROTO_TCP)
     1198    head = blacklist_tcp;
     1199  else
     1200    head = blacklist_udp;
     1201
     1202  while (head)
     1203    {
     1204      if (head->port == port)
     1205        {
     1206          if ((head->haddr.s_addr == 0) || (head->haddr.s_addr == haddr.s_addr))
     1207            return 1;
     1208          else
     1209            return 0;
     1210        }
     1211      head = head->next;
     1212    }
     1213  return 0;
     1214}
     1215
     1216
     1217static int sh_portchk_blacklist(int port, struct in_addr haddr, int proto)
     1218{
     1219  struct sh_port * black;
     1220  struct sh_port * head;
     1221
     1222  if (proto == IPPROTO_TCP)
     1223    head = blacklist_tcp;
     1224  else
     1225    head = blacklist_udp;
     1226
     1227  black = head;
     1228
     1229  while (black)
     1230    {
     1231      if (black->port == port && head->haddr.s_addr == haddr.s_addr)
     1232        return -1;
     1233      black = black->next;
     1234    }
     1235  black = SH_ALLOC (sizeof(struct sh_port));
     1236  black->port  = port;
     1237  black->haddr.s_addr = haddr.s_addr;
     1238  black->next  = head;
     1239
     1240  if (proto == IPPROTO_TCP)
     1241    blacklist_tcp = black;
     1242  else
     1243    blacklist_udp = black;
     1244  return 0;
     1245}
     1246 
    10781247 
    10791248/* Subroutine to add a required or optional port/service
    … …  
    10821251{
    10831252  char buf[256];
    1084   char proto[4];
     1253  int proto;
    10851254  char * p;
    10861255  char * endptr;
    … …  
    10981267    return -1;
    10991268  if (0 == strcmp(p, _("/tcp")))
    1100     sl_strlcpy(proto, _("tcp"), sizeof(proto));
    1101   else if  (0 == strcmp(p, _("/udp")))   
    1102     sl_strlcpy(proto, _("udp"), sizeof(proto));
     1269    proto = IPPROTO_TCP;
     1270  else if  (0 == strcmp(p, _("/udp")))
     1271    proto = IPPROTO_UDP;
    11031272  else
    11041273    return -1;
    … …  
    11061275  *p = '\0';
    11071276  port = strtoul(buf, &endptr, 0);
     1277
     1278  /* Blacklisted ports
     1279   */
     1280  if (*endptr == '\0' && port <= 65535 && type == SH_PORT_BLACKLIST)
     1281    return (sh_portchk_blacklist(port, haddr, proto));
    11081282
    11091283  if (*endptr != '\0')
    … …  
    11151289        {
    11161290#ifdef TEST_ONLY
    1117           fprintf(stderr, "** WARNING: duplicate port definition %s/%s\n", buf, proto);
    1118 #else
     1291          fprintf(stderr, "** WARNING: duplicate port definition %s/%s\n", buf, SH_PROTO_STR(proto));
     1292#else
     1293          SH_MUTEX_LOCK(mutex_thread_nolog);
    11191294          sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    11201295                          _("duplicate port definition"), _("sh_portchk_add_required_port_generic"));
     1296          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    11211297#endif
    11221298          return -1;
    … …  
    11311307        {
    11321308#ifdef TEST_ONLY
    1133           fprintf(stderr, "** WARNING: duplicate port definition %lu/%s\n", port, proto);
    1134 #else
     1309          fprintf(stderr, "** WARNING: duplicate port definition %lu/%s\n", port, SH_PROTO_STR(proto));
     1310#else
     1311          SH_MUTEX_LOCK(mutex_thread_nolog);
    11351312          sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    11361313                          _("duplicate port definition"), _("sh_portchk_add_required_port_generic"));
     1314          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    11371315#endif
    11381316          return -1;
    … …  
    11511329  size_t len;
    11521330  size_t ll = 0;
     1331  int    status;
    11531332
    11541333  char * interface = NULL;
    … …  
    12131392  while (p)
    12141393    {
    1215       if (-1 == sh_portchk_add_required_port_generic (p, interface, type))
     1394      status = sh_portchk_add_required_port_generic (p, interface, type);
     1395
     1396      if (-1 == status)
    12161397        {
    12171398          SH_FREE(interface);
    … …  
    12511432}
    12521433
     1434/* User interface to add ports that should not be checked as 'iface:portlist'
     1435 */
     1436static int sh_portchk_add_blacklist (const char * str)
     1437{
     1438  return sh_portchk_add_required_generic (str, SH_PORT_BLACKLIST);
     1439}
     1440
    12531441/* Interface to run port check
    12541442 */
    … …  
    12571445  int min_port = 0;
    12581446
     1447  SH_MUTEX_LOCK(mutex_port_check);
    12591448  if (sh_portchk_active != S_FALSE)
    12601449    {
    … …  
    12661455          fprintf(stderr, "** WARNING not scanning ports < 1024\n");
    12671456#else
     1457          SH_MUTEX_LOCK(mutex_thread_nolog);
    12681458          sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    12691459                          _("not scanning ports below 1024"), _("sh_portchk_check"));
     1460          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    12701461#endif
    12711462        }
    … …  
    12731464        sh_portchk_scan_ports_udp(min_port, -1);
    12741465      sh_portchk_scan_ports_tcp(min_port, -1);
    1275       sh_portchk_check_list (&portlist_tcp, "tcp", SH_PORT_REPORT);
     1466      sh_portchk_check_list (&portlist_tcp, IPPROTO_TCP, SH_PORT_REPORT);
    12761467      if (sh_portchk_check_udp == 1)
    1277         sh_portchk_check_list (&portlist_udp, "udp", SH_PORT_REPORT);
    1278     }
     1468        sh_portchk_check_list (&portlist_udp, IPPROTO_UDP, SH_PORT_REPORT);
     1469    }
     1470  SH_MUTEX_UNLOCK(mutex_port_check);
    12791471  return 0;
    12801472}
    … …  
    12921484  CuAssertTrue(tc, 0 != inet_aton("127.0.0.1", &haddr_local));
    12931485
    1294   sh_portchk_add_to_list ("tcp",  8000, haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
    1295 
    1296   portent = sh_portchk_get_from_list("tcp",  8000, haddr_local, NULL);
     1486  sh_portchk_add_to_list (IPPROTO_TCP,  8000, haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
     1487
     1488  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, NULL);
    12971489  CuAssertPtrNotNull(tc, portent);
    12981490
    … …  
    13021494  CuAssertTrue(tc, portent->flag == SH_PORT_NOT);
    13031495
    1304   sh_portchk_check_list (&portlist_tcp, "tcp", SH_PORT_NOREPT);
     1496  sh_portchk_check_list (&portlist_tcp, IPPROTO_TCP, SH_PORT_NOREPT);
    13051497
    13061498  CuAssertTrue(tc, NULL == portlist_tcp);
    13071499
    1308   sh_portchk_add_to_list ("tcp",  8000, haddr_local, NULL, SH_PORT_REQ, SH_PORT_UNKN);
    1309   sh_portchk_add_to_list ("tcp",  8001, haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
    1310   sh_portchk_add_to_list ("tcp",  8002, haddr_local, NULL, SH_PORT_REQ, SH_PORT_UNKN);
    1311   sh_portchk_add_to_list ("tcp",  8003, haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
    1312   sh_portchk_add_to_list ("tcp",  8004, haddr_local, NULL, SH_PORT_IGN, SH_PORT_UNKN);
    1313   sh_portchk_add_to_list ("tcp",    -1, haddr_local, "foo1", SH_PORT_NOT, SH_PORT_UNKN);
    1314   sh_portchk_add_to_list ("tcp",    -1, haddr_local, "foo2", SH_PORT_REQ, SH_PORT_UNKN);
    1315   sh_portchk_add_to_list ("tcp",    -1, haddr_local, "foo3", SH_PORT_NOT, SH_PORT_UNKN);
    1316   sh_portchk_add_to_list ("tcp",    -1, haddr_local, "foo4", SH_PORT_REQ, SH_PORT_UNKN);
    1317   sh_portchk_add_to_list ("tcp",    -1, haddr_local, "foo5", SH_PORT_IGN, SH_PORT_UNKN);
    1318 
    1319   sh_portchk_check_list (&portlist_tcp, "tcp", SH_PORT_NOREPT);
     1500  sh_portchk_add_to_list (IPPROTO_TCP,  8000, haddr_local, NULL, SH_PORT_REQ, SH_PORT_UNKN);
     1501  sh_portchk_add_to_list (IPPROTO_TCP,  8001, haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
     1502  sh_portchk_add_to_list (IPPROTO_TCP,  8002, haddr_local, NULL, SH_PORT_REQ, SH_PORT_UNKN);
     1503  sh_portchk_add_to_list (IPPROTO_TCP,  8003, haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
     1504  sh_portchk_add_to_list (IPPROTO_TCP,  8004, haddr_local, NULL, SH_PORT_IGN, SH_PORT_UNKN);
     1505  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo1", SH_PORT_NOT, SH_PORT_UNKN);
     1506  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo2", SH_PORT_REQ, SH_PORT_UNKN);
     1507  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo3", SH_PORT_NOT, SH_PORT_UNKN);
     1508  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo4", SH_PORT_REQ, SH_PORT_UNKN);
     1509  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo5", SH_PORT_IGN, SH_PORT_UNKN);
     1510
     1511  sh_portchk_check_list (&portlist_tcp, IPPROTO_TCP, SH_PORT_NOREPT);
    13201512
    13211513  CuAssertPtrNotNull(tc, portlist_tcp);
    13221514
    1323   portent = sh_portchk_get_from_list("tcp",  8000, haddr_local, NULL);
     1515  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, NULL);
    13241516  CuAssertPtrNotNull(tc, portent);
    13251517
    1326   portent = sh_portchk_get_from_list("tcp",  8001, haddr_local, NULL);
     1518  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8001, haddr_local, NULL);
    13271519  CuAssertTrue(tc, NULL == portent);
    13281520
    1329   portent = sh_portchk_get_from_list("tcp",  8002, haddr_local, NULL);
     1521  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8002, haddr_local, NULL);
    13301522  CuAssertPtrNotNull(tc, portent);
    13311523
    1332   portent = sh_portchk_get_from_list("tcp",  8003, haddr_local, NULL);
     1524  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8003, haddr_local, NULL);
    13331525  CuAssertTrue(tc, NULL == portent);
    13341526
    1335   portent = sh_portchk_get_from_list("tcp",  8004, haddr_local, NULL);
     1527  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8004, haddr_local, NULL);
    13361528  CuAssertPtrNotNull(tc, portent);
    13371529
    1338   portent = sh_portchk_get_from_list("tcp",  8000, haddr_local, "foo1");
     1530  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo1");
    13391531  CuAssertTrue(tc, NULL == portent);
    13401532
    1341   portent = sh_portchk_get_from_list("tcp",  8000, haddr_local, "foo2");
     1533  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo2");
    13421534  CuAssertPtrNotNull(tc, portent);
    13431535  CuAssertTrue(tc, 0 == strcmp(portent->service, "foo2"));
    13441536
    1345   portent = sh_portchk_get_from_list("tcp",  8000, haddr_local, "foo3");
     1537  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo3");
    13461538  CuAssertTrue(tc, NULL == portent);
    13471539
    1348   portent = sh_portchk_get_from_list("tcp",  8000, haddr_local, "foo4");
     1540  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo4");
    13491541  CuAssertPtrNotNull(tc, portent);
    13501542  CuAssertTrue(tc, 0 == strcmp(portent->service, "foo4"));
    13511543
    1352   portent = sh_portchk_get_from_list("tcp",  8000, haddr_local, "foo5");
     1544  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo5");
    13531545  CuAssertPtrNotNull(tc, portent);
    13541546  CuAssertTrue(tc, 0 == strcmp(portent->service, "foo5"));
     1547
     1548  CuAssertTrue(tc, 0 == sh_portchk_blacklist(666, haddr_local, IPPROTO_TCP));
     1549  CuAssertTrue(tc, 0 != sh_portchk_blacklist(666, haddr_local, IPPROTO_TCP));
     1550  CuAssertTrue(tc, 0 == sh_portchk_blacklist(667, haddr_local, IPPROTO_TCP));
     1551  CuAssertTrue(tc, 0 == sh_portchk_blacklist(668, haddr_local, IPPROTO_TCP));
     1552  CuAssertTrue(tc, 0 == sh_portchk_blacklist(666, haddr_local, IPPROTO_UDP));
     1553  CuAssertTrue(tc, 0 != sh_portchk_blacklist(666, haddr_local, IPPROTO_UDP));
     1554  CuAssertTrue(tc, 0 == sh_portchk_blacklist(667, haddr_local, IPPROTO_UDP));
     1555  CuAssertTrue(tc, 0 == sh_portchk_blacklist(668, haddr_local, IPPROTO_UDP));
     1556
     1557  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(668, haddr_local, IPPROTO_UDP));
     1558  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(667, haddr_local, IPPROTO_UDP));
     1559  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(666, haddr_local, IPPROTO_UDP));
     1560  CuAssertTrue(tc, 0 == sh_portchk_is_blacklisted(665, haddr_local, IPPROTO_UDP));
     1561
     1562  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(668, haddr_local, IPPROTO_TCP));
     1563  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(667, haddr_local, IPPROTO_TCP));
     1564  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(666, haddr_local, IPPROTO_TCP));
     1565  CuAssertTrue(tc, 0 == sh_portchk_is_blacklisted(665, haddr_local, IPPROTO_TCP));
    13551566#else
    13561567  (void) tc; /* fix compiler warning */

  • trunk/src/sh_suidchk.c

    r143 r149  
    164164
    165165extern unsigned long sh_files_maskof (int class);
     166
     167static void set_defaults (void)
     168{
     169  ShSuidchkActive   = S_TRUE;
     170  ShSuidchkInterval = 7200;
     171  ShSuidchkFps      = 0;
     172  ShSuidchkNosuid   = S_FALSE;
     173  ShSuidchkYield    = S_FALSE;
     174  ShSuidchkQEnable  = S_FALSE;
     175  ShSuidchkQMethod  = SH_Q_CHANGEPERM;
     176  ShSuidchkQDelete  = S_FALSE;
     177  ShSuidchkSeverity = SH_ERR_SEVERE;
     178  if (ShSuidchkExclude != NULL)
     179    SH_FREE(ShSuidchkExclude);
     180  ShSuidchkExclude  = NULL;
     181  ExcludeLen        = 0;
     182
     183  FileLimNow        = 0;
     184  FileLimStart      = 0;
     185  FileLimNum        = 0;
     186  FileLimTotal      = 0;
     187
     188  return;
     189}
    166190
    167191/* Recursively descend into the directory to make sure that
    … …  
    13201344
    13211345
    1322 int sh_suidchk_free_schedule ()
     1346static void sh_suidchk_free_schedule ()
    13231347{
    13241348  sh_schedule_t * current = ShSuidchkSched;
    … …  
    13321356    }
    13331357  ShSuidchkSched = NULL;
    1334   return 0;
     1358  return;
     1359}
     1360
     1361int sh_suidchk_reconf ()
     1362{
     1363  sh_suidchk_free_schedule();
     1364  set_defaults();
    13351365}
    13361366

  • trunk/src/sh_unix.c

    r143 r149  
    28812881int sh_unix_get_ftype(char * fullpath)
    28822882{
    2883   char        c_mode[16];
     2883  char        c_mode[CMODE_SIZE];
    28842884  struct stat buf;
    28852885  ShFileType  type;
    … …  
    34493449  /* --- Determine file type. ---
    34503450   */
    3451   memset (theFile->c_mode, '-', 10);
    3452   theFile->c_mode[10] = '\0';
    3453 
    3454   memset (theFile->link_c_mode, '-', 10);
    3455   theFile->link_c_mode[10] = '\0';
     3451  memset (theFile->c_mode, '-', CMODE_SIZE-1);
     3452  theFile->c_mode[CMODE_SIZE-1] = '\0';
     3453
     3454  memset (theFile->link_c_mode, '-', CMODE_SIZE-1);
     3455  theFile->link_c_mode[CMODE_SIZE-1] = '\0';
    34563456
    34573457  sh_unix_getinfo_type (&buf, &type, theFile->c_mode);
    … …  
    34623462  /* --- Determine file attributes. ---
    34633463   */
    3464   memset (theFile->c_attributes, '-', 12);
    3465   theFile->c_attributes[12] = '\0';
     3464  memset (theFile->c_attributes, '-', ATTRBUF_SIZE);
     3465  theFile->c_attributes[ATTRBUF_USED] = '\0';
    34663466  theFile->attributes      =    0;
    34673467

  • trunk/src/sh_userfiles.c

    r140 r149  
    390390    userFiles = NULL;
    391391
     392    ShUserfilesActive   = S_TRUE;
     393
    392394    SL_RETURN(0, _("sh_userfiles_reconf"));
    393395}

  • trunk/src/sh_utils.c

    r148 r149  
    20202020}
    20212021
    2022 int sh_util_isnum (char *str)
    2023 {
    2024   char *p = str;
     2022int sh_util_isnum (const char *str)
     2023{
     2024  const char *p = str;
    20252025
    20262026  SL_ENTER(_("sh_util_isnum"));
    … …  
    20362036}
    20372037
    2038 char * sh_util_strconcat (const char * arg1, ...) 
     2038char * sh_util_strconcat (const char * arg1, ...)
    20392039{
    20402040  size_t    length, l2;

  • trunk/src/sh_utmp.c

    r144 r149  
    227227};
    228228
    229 int sh_utmp_null()
    230 {
    231   return 0;
    232 }
    233 
    234 
     229static void set_defaults(void)
     230{
     231  ShUtmpLoginSolo    = SH_ERR_INFO;
     232  ShUtmpLoginMulti   = SH_ERR_WARN;
     233  ShUtmpLogout       = SH_ERR_INFO;
     234  ShUtmpActive       = S_TRUE;
     235  ShUtmpInterval     = 300;
     236  return;
     237}
    235238
    236239
    … …  
    535538   * can be re-enabled.
    536539   */
    537   ShUtmpActive       = S_TRUE;
     540  set_defaults();
    538541  init_done          = 0;
    539542  SL_RETURN( (0), _("sh_utmp_end"));
     543}
     544
     545int sh_utmp_reconf()
     546{
     547  set_defaults();
     548  return 0;
    540549}
    541550
Note: See TracChangeset for help on using the changeset viewer.