Changeset 227


Ignore:
Timestamp:
Apr 20, 2009, 5:59:31 PM (11 years ago)
Author:
katerina
Message:

Fix warnings with -fstack-check

Location:
trunk
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/aclocal.m4

    r202 r227  
    12021202])
    12031203
     1204AC_DEFUN([GCC_STACK_CHECK_CC],[
     1205  AC_LANG_ASSERT(C)
     1206  if test "X$CC" != "X"; then
     1207    AC_CACHE_CHECK([whether ${CC} accepts -fstack-check],
     1208      stackcheck_cv_cc,
     1209      [stackcheck_old_cflags="$CFLAGS"
     1210       CFLAGS="$CFLAGS -fstack-check"
     1211       AC_TRY_COMPILE(,, stackcheck_cv_cc=yes, stackcheck_cv_cc=no)
     1212       CFLAGS="$stackcheck_old_cflags"
     1213      ])
     1214    if test $stackcheck_cv_cc = yes; then
     1215      CFLAGS="$CFLAGS -fstack-check"
     1216    fi
     1217  fi
     1218])
     1219
    12041220AC_DEFUN([GCC_WEMPTY_BODY],[
    12051221  AC_LANG_ASSERT(C)
  • trunk/configure.ac

    r226 r227  
    637637   GCC_STACK_PROTECT_LIB
    638638   GCC_STACK_PROTECT_CC
     639dnl   GCC_STACK_CHECK_CC
    639640   GCC_PIE_CC
    640641fi
  • trunk/docs/Changelog

    r226 r227  
    112.5.5:
     2        * fix warnings with -fstack-check (too large stack frames)
    23        * fix for incorrect handling of hostnames in database insertion
    34          (reported by byron)
  • trunk/src/CuTest.c

    r158 r227  
    120120{
    121121        va_list argp;
    122         char buf[HUGE_STRING_LEN];
     122        char buf[2048];
    123123        va_start(argp, format);
    124         vsprintf(buf, format, argp);
     124        vsnprintf(buf, sizeof(buf), format, argp);
    125125        va_end(argp);
    126126        CuStringAppend(str, buf);
     
    174174static void CuFailInternal(CuTest* tc, const char* file, int line, CuString* string)
    175175{
    176         char buf[HUGE_STRING_LEN];
    177 
    178         sprintf(buf, "%s:%d: ", file, line);
     176        char buf[256];
     177
     178        snprintf(buf, sizeof(buf), "%s:%d: ", file, line);
    179179        CuStringInsert(string, buf, 0);
    180180
  • trunk/src/sh_entropy.c

    r174 r227  
    594594#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    595595          struct passwd    pwd;
    596           char             buffer[SH_PWBUF_SIZE];
     596          char           * buffer = SH_ALLOC(SH_PWBUF_SIZE);
    597597          struct passwd *  tempres;
    598           sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres);
     598          sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    599599#else
    600600          struct passwd * tempres = sh_getpwnam(DEFAULT_IDENT);
     
    614614            i = -1;
    615615          }
     616#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     617          SH_FREE(buffer);
     618#endif
    616619        }
    617620     
  • trunk/src/sh_extern.c

    r215 r227  
    10031003#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    10041004  struct passwd    pwd;
    1005   char             buffer[SH_PWBUF_SIZE];
     1005  char           * buffer = SH_ALLOC(SH_PWBUF_SIZE);
    10061006#endif
    10071007
     
    10121012  if (user == NULL)
    10131013    {
     1014#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1015      SH_FREE(buffer);
     1016#endif
    10141017      SL_RETURN (-1, _("sh_ext_uid"));
    10151018    }
    10161019
    10171020#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    1018   sh_getpwnam_r(user, &pwd, buffer, sizeof(buffer), &tempres);
     1021  sh_getpwnam_r(user, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    10191022#else
    10201023  tempres = sh_getpwnam(user);
     
    10251028      *uid = tempres->pw_uid; 
    10261029      *gid = tempres->pw_gid;
     1030#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1031      SH_FREE(buffer);
     1032#endif
    10271033      SL_RETURN (0, _("sh_ext_uid"));
    10281034    }
    10291035
     1036#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1037  SH_FREE(buffer);
     1038#endif
    10301039  SL_RETURN (-1, _("sh_ext_uid"));
    10311040}
  • trunk/src/sh_files.c

    r171 r227  
    14891489  int             status;
    14901490  int             dummy = S_FALSE;
    1491   dir_type        theDir;
     1491  dir_type      * theDir;
    14921492  ShFileType      checkit;
    14931493  static unsigned int state = 1;
    14941494
    1495   file_type       theFile;
     1495  file_type     * theFile;
    14961496  char          * tmpname;
    14971497  char          * tmpcat;
     
    15711571  /* ---- stat the directory ----
    15721572   */
    1573   sl_strlcpy (theFile.fullpath, iname, PATH_MAX);
    1574   theFile.attr_string = NULL;
    1575   theFile.link_path   = NULL;
     1573  theFile = SH_ALLOC(sizeof(file_type));
     1574  sl_strlcpy (theFile->fullpath, iname, PATH_MAX);
     1575  theFile->attr_string = NULL;
     1576  theFile->link_path   = NULL;
    15761577
    15771578  (void) relativeName;
    15781579  status = sh_unix_getinfo (ShDFLevel[SH_ERR_T_DIR],
    15791580                            iname,
    1580                             &theFile, NULL, iclass);
     1581                            theFile, NULL, iclass);
    15811582
    15821583  if ((sig_termfast == 1) || (sig_terminate == 1))
    15831584    {
    1584       if (theFile.attr_string) SH_FREE(theFile.attr_string);
    1585       if (theFile.link_path)   SH_FREE(theFile.link_path);
     1585      if (theFile->attr_string) SH_FREE(theFile->attr_string);
     1586      if (theFile->link_path)   SH_FREE(theFile->link_path);
     1587      SH_FREE(theFile);
    15861588      SL_RETURN((0), _("sh_files_checkdir"));
    15871589    }
     
    15901592    {
    15911593      SH_FREE(tmpname);
    1592       if (theFile.attr_string) SH_FREE(theFile.attr_string);
    1593       if (theFile.link_path)   SH_FREE(theFile.link_path);
    1594      SL_RETURN((-1), _("sh_files_checkdir"));
    1595     }
    1596 
    1597   if (theFile.c_mode[0] != 'd')
     1594      if (theFile->attr_string) SH_FREE(theFile->attr_string);
     1595      if (theFile->link_path)   SH_FREE(theFile->link_path);
     1596      SH_FREE(theFile);
     1597      SL_RETURN((-1), _("sh_files_checkdir"));
     1598    }
     1599
     1600  if (theFile->c_mode[0] != 'd')
    15981601    {
    15991602      sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
     
    16011604                       tmpname);
    16021605      SH_FREE(tmpname);
    1603       if (theFile.attr_string) SH_FREE(theFile.attr_string);
    1604       if (theFile.link_path)   SH_FREE(theFile.link_path);
     1606      if (theFile->attr_string) SH_FREE(theFile->attr_string);
     1607      if (theFile->link_path)   SH_FREE(theFile->link_path);
     1608      SH_FREE(theFile);
    16051609      SL_RETURN((-1), _("sh_files_checkdir"));
    16061610    }
    16071611
    1608   hardlink_num = theFile.hardlinks;
    1609 
     1612  hardlink_num = theFile->hardlinks;
     1613
     1614  if (theFile->attr_string) SH_FREE(theFile->attr_string);
     1615  if (theFile->link_path)   SH_FREE(theFile->link_path);
     1616  SH_FREE(theFile);
    16101617
    16111618  /* ---- open directory for reading ----
     
    16231630                       sh_error_message (status, errbuf, sizeof(errbuf)), tmpname);
    16241631      SH_FREE(tmpname);
    1625 
    1626       if (theFile.attr_string) SH_FREE(theFile.attr_string);
    1627       if (theFile.link_path)   SH_FREE(theFile.link_path);
    16281632      SL_RETURN((-1), _("sh_files_checkdir"));
    16291633    }
    16301634
    1631   theDir.NumRegular  = 0;
    1632   theDir.NumDirs     = 0;
    1633   theDir.NumSymlinks = 0;
    1634   theDir.NumFifos    = 0;
    1635   theDir.NumSockets  = 0;
    1636   theDir.NumCDev     = 0;
    1637   theDir.NumBDev     = 0;
    1638   theDir.NumDoor     = 0;
    1639   theDir.NumPort     = 0;
    1640   theDir.NumAll      = 0;
    1641   theDir.TotalBytes  = 0;
    1642   sl_strlcpy (theDir.DirPath, iname, PATH_MAX);
     1635  theDir = SH_ALLOC(sizeof(dir_type));
     1636
     1637  theDir->NumRegular  = 0;
     1638  theDir->NumDirs     = 0;
     1639  theDir->NumSymlinks = 0;
     1640  theDir->NumFifos    = 0;
     1641  theDir->NumSockets  = 0;
     1642  theDir->NumCDev     = 0;
     1643  theDir->NumBDev     = 0;
     1644  theDir->NumDoor     = 0;
     1645  theDir->NumPort     = 0;
     1646  theDir->NumAll      = 0;
     1647  theDir->TotalBytes  = 0;
     1648  sl_strlcpy (theDir->DirPath, iname, PATH_MAX);
    16431649
    16441650
     
    16541660      if (thisEntry != NULL)
    16551661        {
    1656           ++theDir.NumAll;
     1662          ++theDir->NumAll;
    16571663          if (sl_strcmp (thisEntry->d_name, ".") == 0)
    16581664            {
    1659               ++theDir.NumDirs;
     1665              ++theDir->NumDirs;
    16601666              continue;
    16611667            }
    16621668          if (sl_strcmp (thisEntry->d_name, "..") == 0)
    16631669            {
    1664               ++theDir.NumDirs;
     1670              ++theDir->NumDirs;
    16651671              continue;
    16661672            }
     
    16861692    if (sig_termfast == 1)
    16871693      {
    1688         if (theFile.attr_string) SH_FREE(theFile.attr_string);
    1689         if (theFile.link_path)   SH_FREE(theFile.link_path);
     1694        SH_FREE(theDir);
    16901695        SL_RETURN((0), _("sh_files_checkdir"));
    16911696      }
     
    17691774        if (checkit == SH_FILE_DIRECTORY)
    17701775          {
    1771             ++theDir.NumDirs;
     1776            ++theDir->NumDirs;
    17721777          }
    17731778        SH_FREE(tmpcat);
     
    18051810   
    18061811    if      (checkit == SH_FILE_REGULAR)   
    1807       ++theDir.NumRegular;
     1812      ++theDir->NumRegular;
    18081813   
    18091814    else if (checkit == SH_FILE_DIRECTORY)
    18101815      {
    1811         ++theDir.NumDirs;
     1816        ++theDir->NumDirs;
    18121817        if (rdepth_next >= 0 && cchecked_flag != S_TRUE)
    18131818          {
     
    18701875      }
    18711876   
    1872     else if (checkit == SH_FILE_SYMLINK)   ++theDir.NumSymlinks;
    1873     else if (checkit == SH_FILE_FIFO)      ++theDir.NumFifos;
    1874     else if (checkit == SH_FILE_SOCKET)    ++theDir.NumSockets;
    1875     else if (checkit == SH_FILE_CDEV)      ++theDir.NumCDev;
    1876     else if (checkit == SH_FILE_BDEV)      ++theDir.NumBDev;
    1877     else if (checkit == SH_FILE_DOOR)      ++theDir.NumDoor;
    1878     else if (checkit == SH_FILE_PORT)      ++theDir.NumPort;
     1877    else if (checkit == SH_FILE_SYMLINK)   ++theDir->NumSymlinks;
     1878    else if (checkit == SH_FILE_FIFO)      ++theDir->NumFifos;
     1879    else if (checkit == SH_FILE_SOCKET)    ++theDir->NumSockets;
     1880    else if (checkit == SH_FILE_CDEV)      ++theDir->NumCDev;
     1881    else if (checkit == SH_FILE_BDEV)      ++theDir->NumBDev;
     1882    else if (checkit == SH_FILE_DOOR)      ++theDir->NumDoor;
     1883    else if (checkit == SH_FILE_PORT)      ++theDir->NumPort;
    18791884   
    18801885    SH_FREE(tmpcat);
     
    18821887    if ((sig_termfast == 1) || (sig_terminate == 1))
    18831888      {
    1884         if (theFile.attr_string) SH_FREE(theFile.attr_string);
    1885         if (theFile.link_path)   SH_FREE(theFile.link_path);
     1889        SH_FREE(theDir);
    18861890        SL_RETURN((0), _("sh_files_checkdir"));
    18871891      }
     
    18971901    {
    18981902      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DSUM,
    1899                        theDir.NumDirs,
    1900                        theDir.NumRegular,
    1901                        theDir.NumSymlinks,
    1902                        theDir.NumFifos,
    1903                        theDir.NumSockets,
    1904                        theDir.NumCDev,
    1905                        theDir.NumBDev);
     1903                       theDir->NumDirs,
     1904                       theDir->NumRegular,
     1905                       theDir->NumSymlinks,
     1906                       theDir->NumFifos,
     1907                       theDir->NumSockets,
     1908                       theDir->NumCDev,
     1909                       theDir->NumBDev);
    19061910    }
    19071911
     
    19121916   * Hardlink check; not done on MacOS X because of resource forks
    19131917   */
    1914   if ((sh_check_hardlinks == S_TRUE) && (hardlink_num != theDir.NumDirs))
    1915     {
    1916       if (0 != sh_files_hle_test(hardlink_num-theDir.NumDirs, iname))
     1918  if ((sh_check_hardlinks == S_TRUE) && (hardlink_num != theDir->NumDirs))
     1919    {
     1920      if (0 != sh_files_hle_test(hardlink_num-theDir->NumDirs, iname))
    19171921        {
    19181922          len = strlen(tmpname);
     
    19221926          sl_snprintf(tmpcat, len,
    19231927                      _("%s: subdirectory count (%d) != hardlinks (%d)"),
    1924                       tmpname, theDir.NumDirs, hardlink_num);
     1928                      tmpname, theDir->NumDirs, hardlink_num);
    19251929          sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
    19261930                           MSG_E_SUBGEN, tmpcat, _("sh_files_checkdir"));
     
    19301934#endif
    19311935
    1932   if (theFile.attr_string) SH_FREE(theFile.attr_string);
    1933   if (theFile.link_path)   SH_FREE(theFile.link_path);
    19341936  SH_FREE(tmpname);
     1937  SH_FREE(theDir);
    19351938
    19361939  SL_RETURN((0), _("sh_files_checkdir"));
     
    19471950  /* 28 Aug 2001 allow NULL fileName
    19481951   */
    1949   char            fullpath[PATH_MAX];
     1952  char          * fullpath;
    19501953  char            fileHash[2*(KEY_LEN + 1)];
    19511954  int             status;
    1952   file_type       theFile;
     1955  file_type     * theFile;
    19531956  char          * tmpdir;
    19541957  char          * tmpname;
     
    19561959  struct utimbuf  utime_buf;
    19571960  static unsigned int state = 1;
     1961  char            sc;
    19581962
    19591963  SL_ENTER(_("sh_files_filecheck"));
     1964
     1965  fullpath = SH_ALLOC(PATH_MAX);
     1966  theFile  = SH_ALLOC(sizeof(file_type));
    19601967
    19611968  BREAKEXIT(sh_derr);
     
    19821989    {
    19831990      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_NULL);
     1991      SH_FREE(fullpath);
     1992      SH_FREE(theFile);
    19841993      SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
    19851994    }
     
    20202029      SH_FREE(tmpname);
    20212030      SH_FREE(tmpdir);
     2031      SH_FREE(fullpath);
     2032      SH_FREE(theFile);
    20222033      SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
    20232034    }
     
    20262037  /* stat the file and determine checksum (if a regular file)
    20272038   */
    2028   sl_strlcpy (theFile.fullpath, fullpath, PATH_MAX);
    2029   theFile.check_mask    = sh_files_maskof(class);
    2030   theFile.file_reported = (*reported);
    2031   theFile.attr_string   = NULL;
    2032   theFile.link_path     = NULL;
     2039  sl_strlcpy (theFile->fullpath, fullpath, PATH_MAX);
     2040  theFile->check_mask    = sh_files_maskof(class);
     2041  theFile->file_reported = (*reported);
     2042  theFile->attr_string   = NULL;
     2043  theFile->link_path     = NULL;
    20332044
    20342045  TPT(( 0, FIL__, __LINE__, _("msg=<checking file: %s>\n"),  fullpath));
     
    20372048                             ShDFLevel[class] : ShDFLevel[SH_ERR_T_FILE],
    20382049                             fileName,
    2039                              &theFile, fileHash, class);
     2050                             theFile, fileHash, class);
    20402051 
    20412052  if (status != 0)
     
    20452056      if (class == SH_LEVEL_ALLIGNORE && sh.flag.checkSum != SH_CHECK_INIT)
    20462057        sh_hash_set_visited_true (fullpath);
    2047       if (theFile.attr_string) SH_FREE(theFile.attr_string);
    2048       if (theFile.link_path)   SH_FREE(theFile.link_path);
     2058      if (theFile->attr_string) SH_FREE(theFile->attr_string);
     2059      if (theFile->link_path)   SH_FREE(theFile->link_path);
     2060      SH_FREE(fullpath);
     2061      SH_FREE(theFile);
    20492062      SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
    20502063    }
     
    20562069  /* report
    20572070   */
    2058   if ((flag_err_debug == SL_TRUE) && (theFile.c_mode[0] == '-'))
     2071  if ((flag_err_debug == SL_TRUE) && (theFile->c_mode[0] == '-'))
    20592072    {
    20602073      tmpname = sh_util_safe_name (fullpath); /* fixed in 1.5.4 */
     
    20672080  if ( sh.flag.checkSum == SH_CHECK_INIT /* && sh.flag.update == S_FALSE */)
    20682081    {
    2069       sh_hash_pushdata (&theFile, fileHash);
     2082      sh_hash_pushdata (theFile, fileHash);
    20702083    }
    20712084  else if (sh.flag.checkSum == SH_CHECK_CHECK
     
    20742087           )
    20752088    {
    2076       sh_hash_compdata (class, &theFile, fileHash, NULL, -1);
     2089      sh_hash_compdata (class, theFile, fileHash, NULL, -1);
    20772090    }
    20782091 
    2079   (*reported) = theFile.file_reported;
     2092  (*reported) = theFile->file_reported;
    20802093
    20812094  /* reset the access time
    20822095   */
    2083   if (class == SH_LEVEL_NOIGNORE && (theFile.check_mask & MODI_ATM) != 0)
    2084     {
    2085       utime_buf.actime   = (time_t) theFile.atime;
    2086       utime_buf.modtime  = (time_t) theFile.mtime;
     2096  if (class == SH_LEVEL_NOIGNORE && (theFile->check_mask & MODI_ATM) != 0)
     2097    {
     2098      utime_buf.actime   = (time_t) theFile->atime;
     2099      utime_buf.modtime  = (time_t) theFile->mtime;
    20872100#if !defined(O_NOATIME)
    20882101      retry_aud_utime (FIL__, __LINE__, fullpath, &utime_buf);
     
    20942107   * Check for resource fork
    20952108   */
    2096   if ( (theFile.c_mode[0] != 'd') && (rsrcflag == 0) )
     2109  if ( (theFile->c_mode[0] != 'd') && (rsrcflag == 0) )
    20972110    {
    20982111      int  dummy;
    20992112      static int rsrc_init = 0;
    21002113      static char rsrc[17];
    2101       char testpath[PATH_MAX];
     2114      char testpath = SH_ALLOC(PATH_MAX);
    21022115
    21032116      if (rsrc_init == 0) {
     
    21162129            }
    21172130        }
     2131      SH_FREE(testpath);
    21182132    }
    21192133#else
     
    21232137 ret_point:
    21242138
    2125   if (theFile.attr_string) SH_FREE(theFile.attr_string);
    2126   if (theFile.link_path)   SH_FREE(theFile.link_path);
    2127 
    2128   switch (theFile.c_mode[0])
     2139  sc = theFile->c_mode[0];
     2140
     2141  if (theFile->attr_string) SH_FREE(theFile->attr_string);
     2142  if (theFile->link_path)   SH_FREE(theFile->link_path);
     2143  SH_FREE(fullpath);
     2144  SH_FREE(theFile);
     2145
     2146  switch (sc)
    21292147    {
    21302148    case '-': SL_RETURN(SH_FILE_REGULAR, _("sh_files_filecheck"));   
  • trunk/src/sh_gpg.c

    r203 r227  
    295295#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    296296      struct passwd    pwd;
    297       char             buffer[SH_PWBUF_SIZE];
     297      char          *  buffer = SH_ALLOC(SH_PWBUF_SIZE);
    298298      struct passwd *  tempres;
    299       sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres);
     299      sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    300300#else
    301301      struct passwd * tempres = sh_getpwnam(DEFAULT_IDENT);
     
    363363      sl_strlcpy (cc4, tempres->pw_dir, SH_PATHBUF+32);
    364364      sl_strlcat (cc4,   _("/.gnupg"),      SH_PATHBUF+32);
     365#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     366      SH_FREE(buffer);
     367#endif
    365368    }
    366369#endif
     
    964967#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    965968  struct passwd    pwd;
    966   char             buffer[SH_PWBUF_SIZE];
     969  char           * buffer = SH_ALLOC(SH_PWBUF_SIZE);
    967970#endif
    968971#endif
     
    989992      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1, sh.prg_name);
    990993      aud_exit (FIL__, __LINE__, EXIT_FAILURE);
     994#if defined(SH_WITH_SERVER)
     995#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     996      SH_FREE(buffer);
     997#endif
     998#endif
    991999      SL_RETURN( (-1), _("sh_gpg_check_sign"));
    9921000    }
     
    9971005#if defined(SH_WITH_SERVER)
    9981006#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    999       sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres);
     1007      sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    10001008#else
    10011009      tempres = sh_getpwnam(DEFAULT_IDENT);
     
    10181026#if defined(SH_WITH_SERVER)
    10191027#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    1020       sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres);
     1028      sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    10211029#else
    10221030      tempres = sh_getpwnam(DEFAULT_IDENT);
     
    10651073            }
    10661074          smsg = S_TRUE;
     1075#if defined(SH_WITH_SERVER)
     1076#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1077          SH_FREE(buffer);
     1078#endif
     1079#endif
    10671080          SL_RETURN(0, _("sh_gpg_check_sign"));
    10681081        }
     
    10931106        }
    10941107      smsg = S_TRUE;
     1108#if defined(SH_WITH_SERVER)
     1109#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1110      SH_FREE(buffer);
     1111#endif
     1112#endif
    10951113      SL_RETURN(0, _("sh_gpg_check_sign"));
    10961114#endif
     
    11021120          (sl_strcmp(gp.data_fp, gp.conf_fp) == 0))
    11031121        {
     1122#if defined(SH_WITH_SERVER)
     1123#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1124          SH_FREE(buffer);
     1125#endif
     1126#endif
    11041127          SL_RETURN(0, _("sh_gpg_check_sign"));
    11051128        }
     
    11311154#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    11321155      struct passwd    e_pwd;
    1133       char             e_buffer[SH_PWBUF_SIZE];
     1156      char          *  e_buffer = SH_ALLOC(SH_PWBUF_SIZE);
    11341157      struct passwd *  e_tempres;
    1135       sh_getpwnam_r(DEFAULT_IDENT, &e_pwd, e_buffer, sizeof(e_buffer), &e_tempres);
     1158      sh_getpwnam_r(DEFAULT_IDENT, &e_pwd, e_buffer, SH_PWBUF_SIZE, &e_tempres);
    11361159#else
    11371160      struct passwd * e_tempres = sh_getpwnam(DEFAULT_IDENT);
     
    11531176#endif
    11541177           (int) e_uid, e_home);
     1178
     1179#if defined(SH_WITH_SERVER)
     1180#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1181      SH_FREE(e_buffer);
     1182#endif
     1183#endif
    11551184    }
    11561185
  • trunk/src/sh_hash.c

    r212 r227  
    13381338          --sig_raised; --sig_urgent;
    13391339          retval = 1; exitval = EXIT_SUCCESS;
     1340          SH_FREE(line);
     1341          line = NULL;
    13401342          goto unlock_and_return;
    13411343        }
     
    21732175                      unsigned char * str, int size)
    21742176{
    2175   file_type   tmpFile;
    21762177  int         i = 0;
    21772178  char      * p;
    21782179  char        i2h[2];
    2179 
    2180   tmpFile.attr_string = NULL;
    2181   tmpFile.link_path   = NULL;
    2182 
    2183   sl_strlcpy(tmpFile.fullpath, key, PATH_MAX);
    2184   tmpFile.size  = val1;
    2185   tmpFile.mtime = val2;
    2186   tmpFile.ctime = val3;
    2187 
    2188   tmpFile.atime = 0;
    2189   tmpFile.mode  = 0;
    2190   tmpFile.owner = 0;
    2191   tmpFile.group = 0;
    2192   sl_strlcpy(tmpFile.c_owner, _("root"), 5);
    2193   sl_strlcpy(tmpFile.c_group, _("root"), 5);
     2180  file_type * tmpFile = SH_ALLOC(sizeof(file_type));
     2181
     2182  tmpFile->attr_string = NULL;
     2183  tmpFile->link_path   = NULL;
     2184
     2185  sl_strlcpy(tmpFile->fullpath, key, PATH_MAX);
     2186  tmpFile->size  = val1;
     2187  tmpFile->mtime = val2;
     2188  tmpFile->ctime = val3;
     2189
     2190  tmpFile->atime = 0;
     2191  tmpFile->mode  = 0;
     2192  tmpFile->owner = 0;
     2193  tmpFile->group = 0;
     2194  sl_strlcpy(tmpFile->c_owner, _("root"), 5);
     2195  sl_strlcpy(tmpFile->c_group, _("root"), 5);
    21942196
    21952197  if ((str != NULL) && (size < (PATH_MAX/2)-1))
    21962198    {
    2197       tmpFile.c_mode[0] = 'l'; 
    2198       tmpFile.c_mode[1] = 'r'; tmpFile.c_mode[2]  = 'w';
    2199       tmpFile.c_mode[3] = 'x'; tmpFile.c_mode[4]  = 'r';
    2200       tmpFile.c_mode[5] = 'w'; tmpFile.c_mode[6]  = 'x';
    2201       tmpFile.c_mode[7] = 'r'; tmpFile.c_mode[8]  = 'w';
    2202       tmpFile.c_mode[9] = 'x'; tmpFile.c_mode[10] = '\0';
    2203       tmpFile.link_path = SH_ALLOC((size * 2) + 2);
     2199      tmpFile->c_mode[0] = 'l'; 
     2200      tmpFile->c_mode[1] = 'r'; tmpFile->c_mode[2]  = 'w';
     2201      tmpFile->c_mode[3] = 'x'; tmpFile->c_mode[4]  = 'r';
     2202      tmpFile->c_mode[5] = 'w'; tmpFile->c_mode[6]  = 'x';
     2203      tmpFile->c_mode[7] = 'r'; tmpFile->c_mode[8]  = 'w';
     2204      tmpFile->c_mode[9] = 'x'; tmpFile->c_mode[10] = '\0';
     2205      tmpFile->link_path = SH_ALLOC((size * 2) + 2);
    22042206      for (i = 0; i < size; ++i)
    22052207        {
    22062208          p = sh_util_charhex (str[i],i2h);
    2207           tmpFile.link_path[2*i]   = p[0];
    2208           tmpFile.link_path[2*i+1] = p[1];
    2209           tmpFile.link_path[2*i+2] = '\0';
     2209          tmpFile->link_path[2*i]   = p[0];
     2210          tmpFile->link_path[2*i+1] = p[1];
     2211          tmpFile->link_path[2*i+2] = '\0';
    22102212        }
    22112213    }
     
    22132215    {
    22142216      for (i = 0; i < 10; ++i)
    2215         tmpFile.c_mode[i] = '-';
    2216       tmpFile.c_mode[10] = '\0';
    2217       tmpFile.link_path = sh_util_strdup("-");
     2217        tmpFile->c_mode[i] = '-';
     2218      tmpFile->c_mode[10] = '\0';
     2219      tmpFile->link_path = sh_util_strdup("-");
    22182220    }
    22192221
    22202222  if (sh.flag.checkSum == SH_CHECK_CHECK &&
    22212223      sh.flag.update == S_TRUE)
    2222     sh_hash_pushdata_memory (&tmpFile, SH_KEY_NULL);
    2223   else
    2224     sh_hash_pushdata (&tmpFile, SH_KEY_NULL);
    2225 
    2226   if (tmpFile.link_path) SH_FREE(tmpFile.link_path);
     2224    sh_hash_pushdata_memory (tmpFile, SH_KEY_NULL);
     2225  else
     2226    sh_hash_pushdata (tmpFile, SH_KEY_NULL);
     2227
     2228  if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
     2229  SH_FREE(tmpFile);
    22272230  return;
    22282231}
     
    22342237                       int * size)
    22352238{
    2236   file_type   tmpFile;
    22372239  size_t      len;
    22382240  char      * p;
    22392241  int         i;
    22402242  char      * retval = NULL;
     2243  file_type * tmpFile = SH_ALLOC(sizeof(file_type));
    22412244 
    22422245  *size = 0;
    22432246
    2244   if (0 == sh_hash_get_it (key, &tmpFile))
    2245     {
    2246       *val1 = tmpFile.size;
    2247       *val2 = tmpFile.mtime;
    2248       *val3 = tmpFile.ctime;
    2249 
    2250       if (tmpFile.link_path && tmpFile.link_path[0] != '-')
    2251         {
    2252           len = strlen(tmpFile.link_path);
     2247  if (0 == sh_hash_get_it (key, tmpFile))
     2248    {
     2249      *val1 = tmpFile->size;
     2250      *val2 = tmpFile->mtime;
     2251      *val3 = tmpFile->ctime;
     2252
     2253      if (tmpFile->link_path && tmpFile->link_path[0] != '-')
     2254        {
     2255          len = strlen(tmpFile->link_path);
    22532256
    22542257          p = SH_ALLOC((len/2)+1);
    2255           i = sh_util_hextobinary (p, tmpFile.link_path, len);
     2258          i = sh_util_hextobinary (p, tmpFile->link_path, len);
    22562259
    22572260          if (i == 0)
     
    22792282      *val3 =  0;
    22802283    }
    2281   if (tmpFile.link_path) SH_FREE(tmpFile.link_path);
     2284  if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
     2285  SH_FREE(tmpFile);
    22822286  return retval;
    22832287}
     
    39903994      decompressed[clen] = '\0';
    39913995      fputs( (char*) decompressed, stdout);
     3996      SH_FREE(decompressed);
    39923997      return 0;
    39933998    }
  • trunk/src/sh_prelude.c

    r206 r227  
    707707#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    708708        struct passwd pwd;
    709         char buffer[SH_PWBUF_SIZE];
     709        char * buffer;
    710710#endif
    711711
     
    896896
    897897#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    898                 sh_getpwnam_r(ptr, &pwd, buffer, sizeof(buffer), &pw);
     898                buffer = SH_ALLOC(SH_PWBUF_SIZE);
     899                sh_getpwnam_r(ptr, &pwd, buffer, SH_PWBUF_SIZE, &pw);
    899900#else
    900901                pw = sh_getpwnam(ptr);
     
    906907                if ( ret < 0 ) {
    907908                        free(ptr);
     909#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     910                        SH_FREE(buffer);
     911#endif
    908912                        return ret;
    909913                }
    910914                prelude_string_set_nodup(str, ptr);
    911915
     916#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     917                SH_FREE(buffer);
     918#endif
    912919        }
     920
    913921
    914922        ptr = get_value(msg, _("path"), NULL);
     
    967975#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    968976        struct passwd pwd;
    969         char buffer[SH_PWBUF_SIZE];
     977        char * buffer;
    970978#endif
    971979        prelude_string_t *str;
     
    10541062               
    10551063#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    1056                 sh_getpwnam_r(ptr, &pwd, buffer, sizeof(buffer), &pw);
     1064                buffer = SH_ALLOC(SH_PWBUF_SIZE);
     1065                sh_getpwnam_r(ptr, &pwd, buffer, SH_PWBUF_SIZE, &pw);
    10571066#else
    10581067                pw = sh_getpwnam(ptr);
     
    10641073                if ( ret < 0 ) {
    10651074                        free(ptr);
     1075#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1076                        SH_FREE(buffer);
     1077#endif
    10661078                        return ret;
    10671079                }
     
    10731085                        if ( ret < 0 ) {
    10741086                                free(ptr);
     1087#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1088                                SH_FREE(buffer);
     1089#endif
    10751090                                return ret;
    10761091                        }
     
    10781093                        prelude_string_set_nodup(str, ptr);
    10791094                }
     1095#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1096                SH_FREE(buffer);
     1097#endif
    10801098        }
    10811099
  • trunk/src/sh_suidchk.c

    r199 r227  
    860860  char          * fs;
    861861  long            sl_status;
    862   file_type       theFile;
     862  file_type     * theFile = NULL;
    863863  char            fileHash[2*(KEY_LEN + 1)];
    864864
     
    959959                         _("sh_suidchk_check_internal"), tmp );
    960960        SH_FREE(tmp);
     961        SH_FREE(tmpcat);
    961962        dirlist = dirlist->next;
    962963        continue;
     
    10321033                 )
    10331034          {
    1034            
    1035             (void) sl_strlcpy (theFile.fullpath, tmpcat, PATH_MAX);
    1036             theFile.check_mask  = sh_files_maskof(SH_LEVEL_READONLY);
    1037             CLEAR_SH_FFLAG_REPORTED(theFile.file_reported);
    1038             theFile.attr_string = NULL;
    1039             theFile.link_path   = NULL;
     1035            theFile = SH_ALLOC(sizeof(file_type));
     1036
     1037            (void) sl_strlcpy (theFile->fullpath, tmpcat, PATH_MAX);
     1038            theFile->check_mask  = sh_files_maskof(SH_LEVEL_READONLY);
     1039            CLEAR_SH_FFLAG_REPORTED(theFile->file_reported);
     1040            theFile->attr_string = NULL;
     1041            theFile->link_path   = NULL;
    10401042           
    10411043            status = sh_unix_getinfo (ShDFLevel[SH_ERR_T_RO],
    10421044                                      dirlist->sh_d_name,
    1043                                       &theFile, fileHash, 0);
     1045                                      theFile, fileHash, 0);
    10441046           
    10451047            tmp = sh_util_safe_name(tmpcat);
     
    10761078                   
    10771079                    if (0 == sh_hash_compdata (SH_LEVEL_READONLY,
    1078                                                &theFile, fileHash,
     1080                                               theFile, fileHash,
    10791081                                               _("[SuidCheck]"),
    10801082                                               ShSuidchkSeverity))
    10811083                      {
    1082                         sh_hash_pushdata_memory (&theFile, fileHash);
     1084                        sh_hash_pushdata_memory (theFile, fileHash);
    10831085                      }
    10841086                   
     
    10921094                    /* Running init. Report on files detected.
    10931095                     */
    1094                     sh_hash_pushdata (&theFile, fileHash);
     1096                    sh_hash_pushdata (theFile, fileHash);
    10951097                    sh_error_handle ((-1), FIL__, __LINE__,
    10961098                                     0, MSG_SUID_FOUND, tmp );
     
    11111113                        if (-1 == fflags)
    11121114                          {
    1113                             (void) sh_unix_gmttime (theFile.ctime, timestrc, sizeof(timestrc));
    1114                             (void) sh_unix_gmttime (theFile.atime, timestra, sizeof(timestra));
    1115                             (void) sh_unix_gmttime (theFile.mtime, timestrm, sizeof(timestrm));
    1116 
    1117                             report_file(tmpcat, &theFile, timestrc, timestra, timestrm);
     1115                            (void) sh_unix_gmttime (theFile->ctime, timestrc, sizeof(timestrc));
     1116                            (void) sh_unix_gmttime (theFile->atime, timestra, sizeof(timestra));
     1117                            (void) sh_unix_gmttime (theFile->mtime, timestrm, sizeof(timestrm));
     1118
     1119                            report_file(tmpcat, theFile, timestrc, timestra, timestrm);
    11181120                          }
    11191121                        /* Quarantine file according to configured method
     
    11241126                              {
    11251127                              case SH_Q_DELETE:
    1126                                 sh_q_delete(theFile.fullpath);
     1128                                sh_q_delete(theFile->fullpath);
    11271129                                break;
    11281130                              case SH_Q_CHANGEPERM:
    1129                                 sh_q_changeperm(theFile.fullpath);
     1131                                sh_q_changeperm(theFile->fullpath);
    11301132                                break;
    11311133                              case SH_Q_MOVE:
    1132                                 sh_q_move(theFile.fullpath, &theFile, timestrc, timestra, timestrm);
     1134                                sh_q_move(theFile->fullpath, theFile, timestrc, timestra, timestrm);
    11331135                                break;
    11341136                              default:
     
    11441146                             */
    11451147                            (void) sh_hash_compdata (SH_LEVEL_READONLY,
    1146                                                      &theFile, fileHash,
     1148                                                     theFile, fileHash,
    11471149                                                     _("[SuidCheck]"),
    11481150                                                     ShSuidchkSeverity);
     
    11571159                         */
    11581160                        (void) sh_hash_compdata (SH_LEVEL_READONLY,
    1159                                                  &theFile, fileHash,
     1161                                                 theFile, fileHash,
    11601162                                                 _("[SuidCheck]"),
    11611163                                                 ShSuidchkSeverity);
     
    11671169              }
    11681170            SH_FREE(tmp);
    1169             if (theFile.attr_string) SH_FREE(theFile.attr_string);
    1170             if (theFile.link_path)   SH_FREE(theFile.link_path);
     1171            if (theFile->attr_string) SH_FREE(theFile->attr_string);
     1172            if (theFile->link_path)   SH_FREE(theFile->link_path);
     1173            SH_FREE(theFile);
    11711174          }
    11721175      }
  • trunk/src/sh_unix.c

    r221 r227  
    990990#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    991991  struct passwd    pwd;
    992   char             buffer[SH_PWBUF_SIZE];
     992  char           * buffer;
    993993#endif
    994994 
     
    998998   */
    999999#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    1000   sh_getpwnam_r(c, &pwd, buffer, sizeof(buffer), &w);
     1000  buffer = SH_ALLOC(SH_PWBUF_SIZE);
     1001  sh_getpwnam_r(c, &pwd, buffer, SH_PWBUF_SIZE, &w);
    10011002#else
    10021003  w = sh_getpwnam(c);
     
    10141015  sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
    10151016                   _("add trusted user"), c);
     1017#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1018  SH_FREE(buffer);
     1019#endif
    10161020  SL_RETURN((-1), _("tf_add_trusted_user_int"));
    10171021
    10181022 succe:
    10191023  count = sl_trust_add_user(pwid);
     1024#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1025  SH_FREE(buffer);
     1026#endif
    10201027  SL_RETURN((count), _("tf_add_trusted_user_int"));
    10211028}
     
    10921099#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    10931100      struct passwd    pwd;
    1094       char             buffer[SH_PWBUF_SIZE];
     1101      char          *  buffer = SH_ALLOC(SH_PWBUF_SIZE);
    10951102      struct passwd *  tempres;
    1096       sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, sizeof(buffer), &tempres);
     1103      sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    10971104#else
    10981105      struct passwd * tempres = sh_getpwnam(DEFAULT_IDENT);
     
    11071114        }
    11081115      ff_euid = tempres->pw_uid;
     1116#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1117      SH_FREE(buffer);
     1118#endif
    11091119    }
    11101120#endif
     
    24692479#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R)
    24702480  struct passwd pwd;
    2471   char   buffer[SH_PWBUF_SIZE];
     2481  char   * buffer;
    24722482#endif
    24732483  char errbuf[SH_ERRBUF_SIZE];
     
    24762486
    24772487#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R)
    2478   sh_getpwuid_r(uid, &pwd, buffer, sizeof(buffer), &tempres);
     2488  buffer = SH_ALLOC(SH_PWBUF_SIZE);
     2489  sh_getpwuid_r(uid, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    24792490#else
    24802491  errno = 0;
     
    24872498                     sh_error_message(status, errbuf, sizeof(errbuf)),
    24882499                     _("getpwuid"), (long) uid, _("completely missing"));
     2500#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     2501    SH_FREE(buffer);
     2502#endif
    24892503    SL_RETURN( NULL, _("sh_unix_getUIDdir"));
    24902504  }
     
    24922506  if (tempres->pw_dir != NULL) {
    24932507    sl_strlcpy(out, tempres->pw_dir, len);
     2508#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     2509    SH_FREE(buffer);
     2510#endif
    24942511    SL_RETURN( out, _("sh_unix_getUIDdir"));
    24952512  } else {
     
    24972514                     sh_error_message(status, errbuf, sizeof(errbuf)),
    24982515                     _("getpwuid"), (long) uid, _("pw_dir"));
     2516#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     2517    SH_FREE(buffer);
     2518#endif
    24992519    SL_RETURN( NULL, _("sh_unix_getUIDdir"));
    25002520  }
     
    25082528#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R)
    25092529  struct passwd pwd;
    2510   char   buffer[SH_PWBUF_SIZE];
     2530  char   * buffer;
    25112531#endif
    25122532  int             status = 0;
     
    25292549
    25302550#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R)
    2531   sh_getpwuid_r(uid, &pwd, buffer, sizeof(buffer), &tempres);
     2551  buffer = SH_ALLOC(SH_PWBUF_SIZE);
     2552  sh_getpwuid_r(uid, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    25322553#else
    25332554  errno = 0;
     
    25402561                     sh_error_message(status, errbuf, sizeof(errbuf)),
    25412562                     _("getpwuid"), (long) uid, _("completely missing"));
     2563#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     2564    SH_FREE(buffer);
     2565#endif
    25422566    SL_RETURN( NULL, _("sh_unix_getUIDname"));
    25432567  }
     
    25502574    sl_strlcpy(out, name, len);
    25512575    SH_MUTEX_UNLOCK_UNSAFE(mutex_getUIDname);
     2576#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     2577    SH_FREE(buffer);
     2578#endif
    25522579    SL_RETURN( out, _("sh_unix_getUIDname"));
    25532580  } else {
     
    25552582                     sh_error_message(status, errbuf, sizeof(errbuf)),
    25562583                     _("getpwuid"), (long) uid, _("pw_user"));
     2584#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     2585    SH_FREE(buffer);
     2586#endif
    25572587    SL_RETURN( NULL, _("sh_unix_getUIDname"));
    25582588  }
     
    25692599#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
    25702600  struct group    grp;
    2571   char            buffer[SH_GRBUF_SIZE];
     2601  char          * buffer;
    25722602#endif
    25732603  char errbuf[SH_ERRBUF_SIZE];
     
    25882618
    25892619#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
    2590   status = sh_getgrgid_r(gid, &grp, buffer, sizeof(buffer), &tempres);
     2620  buffer = SH_ALLOC(SH_GRBUF_SIZE);
     2621  status = sh_getgrgid_r(gid, &grp, buffer, SH_GRBUF_SIZE, &tempres);
    25912622#else
    25922623  errno = 0;
     
    26002631                     _("getgrgid"), (long) gid, _("completely missing"));
    26012632     
     2633#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     2634    SH_FREE(buffer);
     2635#endif
    26022636    SL_RETURN( NULL, _("sh_unix_getGIDname"));
    26032637  }
     
    26092643    sl_strlcpy(out, name, len);
    26102644    SH_MUTEX_UNLOCK_UNSAFE(mutex_getGIDname);
     2645#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     2646    SH_FREE(buffer);
     2647#endif
    26112648    SL_RETURN( out, _("sh_unix_getGIDname"));
    26122649  } else {
     
    26142651                     sh_error_message(status, errbuf, sizeof(errbuf)),
    26152652                     _("getgrgid"), (long) gid, _("gr_name"));
     2653#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     2654    SH_FREE(buffer);
     2655#endif
    26162656    SL_RETURN( NULL, _("sh_unix_getGIDname"));
    26172657  }
     
    31363176                           char * fileHash, int alert_timeout, SL_TICKET fd)
    31373177{
    3138   file_type tmpFile;
     3178  file_type * tmpFile;
    31393179  int status;
    31403180
    31413181  SL_ENTER(_("sh_unix_checksum_size"));
    31423182
    3143   tmpFile.link_path = NULL;
     3183  tmpFile = SH_ALLOC(sizeof(file_type));
     3184  tmpFile->link_path = NULL;
    31443185
    31453186  if (sh.flag.checkSum != SH_CHECK_INIT)
    31463187    {
    31473188      /* lookup file in database */
    3148       status = sh_hash_get_it (filename, &tmpFile);
     3189      status = sh_hash_get_it (filename, tmpFile);
    31493190      if (status != 0) {
    31503191        goto out;
     
    31533194  else
    31543195    {
    3155       tmpFile.size = fbuf->st_size;
     3196      tmpFile->size = fbuf->st_size;
    31563197    }
    31573198
    31583199  /* if last < current get checksum */
    3159   if (tmpFile.size < fbuf->st_size)
     3200  if (tmpFile->size < fbuf->st_size)
    31603201    {
    31613202      char hashbuf[KEYBUF_SIZE];
    3162       UINT64 local_length = (UINT64) (tmpFile.size < 0 ? 0 : tmpFile.size);
     3203      UINT64 local_length = (UINT64) (tmpFile->size < 0 ? 0 : tmpFile->size);
    31633204      sl_strlcpy(fileHash,
    31643205                 sh_tiger_generic_hash (filename, fd, &(local_length),
     
    31673208     
    31683209       /* return */
    3169       if (tmpFile.link_path)   SH_FREE(tmpFile.link_path);
     3210      if (tmpFile->link_path)   SH_FREE(tmpFile->link_path);
     3211      SH_FREE(tmpFile);
    31703212      SL_RETURN( 0, _("sh_unix_checksum_size"));
    31713213    }
    31723214
    31733215 out:
    3174   if (tmpFile.link_path)   SH_FREE(tmpFile.link_path);
     3216  if (tmpFile->link_path)   SH_FREE(tmpFile->link_path);
     3217  SH_FREE(tmpFile);
    31753218  sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
    31763219  SL_RETURN( -1, _("sh_unix_checksum_size"));
  • trunk/src/sh_userfiles.c

    r203 r227  
    251251    struct userhomeslist *new;
    252252    struct userhomeslist *homes;
     253    char * filepath;
    253254    (void) arg;
    254255
     
    297298    SH_MUTEX_UNLOCK(mutex_pwent);
    298299
     300    filepath = SH_ALLOC(PATH_MAX);
     301
    299302    for (homes = userHomes; homes != NULL; homes = homes->next ) {
    300303        struct userfileslist *file_ptr;
    301         char filepath[PATH_MAX];
    302304
    303305        for (file_ptr = userFiles; file_ptr != NULL; file_ptr = file_ptr->next) {
     
    348350        }
    349351    }
     352
     353    SH_FREE(filepath);
    350354
    351355    SL_RETURN(0, _("sh_userfiles_init"));
  • trunk/src/slib.c

    r214 r227  
    14731473#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    14741474      struct passwd    pwd;
    1475       char             buffer[SH_PWBUF_SIZE];
     1475      char          *  buffer;
    14761476      struct passwd *  tempres;
    1477       sh_getpwnam_r(user, &pwd, buffer, sizeof(buffer), &tempres);
     1477      buffer = malloc(SH_PWBUF_SIZE);
     1478      SL_REQUIRE (buffer != NULL, _("buffer != NULL"));
     1479      sh_getpwnam_r(user, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    14781480#else
    14791481      struct passwd * tempres = sh_getpwnam(user);
     
    14841486      rgid_orig = tempres->pw_gid;
    14851487      ruid_orig = tempres->pw_uid;
     1488#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1489      free(buffer);
     1490#endif
    14861491    }
    14871492  else
     
    15161521#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    15171522      struct passwd    pwd;
    1518       char             buffer[SH_PWBUF_SIZE];
     1523      char          *  buffer;
    15191524      struct passwd *  tempres;
    1520       sh_getpwnam_r(user, &pwd, buffer, sizeof(buffer), &tempres);
     1525      buffer = malloc(SH_PWBUF_SIZE);
     1526      SL_REQUIRE (buffer != NULL, _("buffer != NULL"));
     1527      sh_getpwnam_r(user, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    15211528#else
    15221529      struct passwd * tempres = sh_getpwnam(user);
     
    15271534      SL_REQUIRE (sl_drop_privileges() == SL_ENONE,
    15281535                  _("sl_drop_privileges() == SL_ENONE"));
     1536#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     1537      free(buffer);
     1538#endif
    15291539    }
    15301540  SL_IRETURN(SL_ENONE, _("sl_policy_get_user"));
  • trunk/src/trustfile.c

    r221 r227  
    422422#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
    423423  struct group    gr;
    424   char            buffer[SH_GRBUF_SIZE];
     424  char          * buffer = NULL;
    425425  struct passwd   pwd;
    426   char            pbuffer[SH_PWBUF_SIZE];
     426  char          * pbuffer = NULL;
    427427#endif
    428428
     
    430430
    431431#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
    432   sh_getgrgid_r(grp, &gr, buffer, sizeof(buffer), &g);
     432  buffer = malloc(SH_GRBUF_SIZE);
     433  sh_getgrgid_r(grp, &gr, buffer, SH_GRBUF_SIZE, &g);
    433434#else
    434435  g = sh_getgrgid(grp);
     
    437438  if (g == NULL)
    438439    {
    439       SL_IRETURN(SL_FALSE, _("isingrp") );
    440     }
    441   /*
    442   if(g->gr_mem == NULL || g->gr_mem[0] == NULL )
    443     SL_IRETURN(SL_FALSE, _("isingrp") );
    444   */
     440      goto end_false;
     441    }
    445442
    446443  /* this will return at the first match
    447444   */
     445#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     446  pbuffer = malloc(SH_PWBUF_SIZE);
     447#endif
     448
    448449  for(p = g->gr_mem; *p != NULL; p++)
    449450    {
     
    452453          /* map user name to UID and compare */
    453454#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    454           sh_getpwnam_r(*p, &pwd, pbuffer, sizeof(pbuffer), &w);
     455          sh_getpwnam_r(*p, &pwd, pbuffer, SH_PWBUF_SIZE, &w);
    455456#else
    456457          w = sh_getpwnam(*p);
     
    459460#ifdef TRUST_MAIN
    460461          if (w != NULL && *u == (uid_t)(w->pw_uid) )
    461             SL_IRETURN(SL_TRUE, _("isingrp"));
     462            goto end_true;
    462463#else
    463464          if (w != NULL && *u == (uid_t)(w->pw_uid) )
    464465            {
    465               SL_IRETURN(SL_TRUE, _("isingrp"));
     466              goto end_true;
    466467            }
    467468#endif
     
    474475    {
    475476#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R)
    476       sh_getpwuid_r(*u, &pwd, pbuffer, sizeof(pbuffer), &w);
     477      sh_getpwuid_r(*u, &pwd, pbuffer, SH_PWBUF_SIZE, &w);
    477478#else
    478479      w = sh_getpwuid(*u);
     
    480481#ifdef TRUST_MAIN
    481482      if (w != NULL && grp == (gid_t)(w->pw_gid) )
    482         SL_IRETURN(SL_TRUE, _("isingrp"));
     483        goto end_true;
    483484#else
    484485      if (w != NULL && grp == (gid_t)(w->pw_gid) )
    485486        {
    486           SL_IRETURN(SL_TRUE, _("isingrp"));
    487         }
    488 #endif
    489     }
    490 
     487          goto end_true;
     488        }
     489#endif
     490    }
     491
     492 end_false:
     493#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     494  if (buffer)  free(buffer);
     495  if (pbuffer) free(pbuffer);
     496#endif
    491497  SL_IRETURN(SL_FALSE, _("isingrp"));
     498
     499 end_true:
     500#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     501  if (buffer)  free(buffer);
     502  if (pbuffer) free(pbuffer);
     503#endif
     504  SL_IRETURN(SL_TRUE, _("isingrp"));
    492505}
    493506
     
    506519#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
    507520  struct group    gr;
    508   char            buffer[SH_GRBUF_SIZE];
     521  char          * buffer  = NULL;
    509522  struct passwd   pw;
    510   char            pbuffer[SH_PWBUF_SIZE];
     523  char          * pbuffer = NULL;
    511524#endif
    512525
     
    521534
    522535#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
    523   sh_getgrgid_r(grp, &gr, buffer, sizeof(buffer), &g);
     536  buffer = malloc(SH_GRBUF_SIZE);
     537  sh_getgrgid_r(grp, &gr, buffer, SH_GRBUF_SIZE, &g);
    524538#else
    525539  g = sh_getgrgid(grp);
     
    533547              (UID_CAST)grp);
    534548#endif
    535       SL_IRETURN(SL_FALSE, _("onlytrustedingrp") );
     549      retval = SL_FALSE;
     550      goto end_retval;
    536551    }
    537552
     
    544559  /* check for untrusted members of the group
    545560   */
     561#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     562  pbuffer = malloc(SH_PWBUF_SIZE);
     563#endif
     564
    546565  for(p = g->gr_mem; *p != NULL; p++)
    547566    {
     
    553572       */
    554573#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    555       sh_getpwnam_r(*p, &pw, pbuffer, sizeof(pbuffer), &w);
     574      sh_getpwnam_r(*p, &pw, pbuffer, SH_PWBUF_SIZE, &w);
    556575#else
    557576      w = sh_getpwnam(*p);
     
    601620#endif
    602621          tf_baduid = w->pw_uid;
    603           SL_IRETURN(SL_FALSE, _("onlytrustedingrp"));
    604         }
    605     }
     622          retval = SL_FALSE;
     623#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     624          if (pbuffer) free(pbuffer);
     625#endif
     626          goto end_retval;
     627        }
     628    }
     629
     630#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     631  if (pbuffer) free(pbuffer);
     632#endif
    606633
    607634#ifndef TEST_ONLY       
     
    680707  /* all found
    681708   */
     709 end_retval:
     710#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     711  if (buffer)  free(buffer);
     712#endif
    682713  SL_IRETURN(retval, _("onlytrustedingrp"));
    683714}
     
    685716int sl_trustfile(const char *fname, uid_t *okusers, uid_t *badusers)
    686717{
    687   char fexp[MAXFILENAME];       /* file name fully expanded        */
    688   register char *p = fexp;      /* used to hold name to be checked */
     718  char * fexp = NULL;           /* file name fully expanded        */
     719  register char *p;             /* used to hold name to be checked */
    689720  struct stat stbuf;            /* used to check file permissions  */
    690721  char c;                       /* used to hold temp char          */
     
    693724  if (fname == NULL)
    694725    SL_IRETURN(SL_EBADFILE, _("sl_trustfile"));
     726
     727  fexp = malloc( MAXFILENAME );
     728  if (!fexp)
     729    SL_IRETURN(SL_EMEM, _("sl_trustfile"));
     730
     731  p = fexp;
    695732
    696733  /*
     
    701738  sl_errno = getfname(fname, fexp, MAXFILENAME);
    702739  if (sl_errno != 0)
    703     return sl_errno;
     740    {
     741      free(fexp);
     742      return sl_errno;
     743    }
    704744#else
    705745  if (SL_ISERROR(getfname(fname, fexp, MAXFILENAME)))
     746    {
     747      free(fexp);
    706748      SL_IRETURN(sl_errno, _("sl_trustfile"));
     749    }
    707750#endif
    708751
     
    755798          fprintf(stderr, "---------------------------------------------\n");
    756799#endif
     800          free(fexp);
    757801          SL_IRETURN(SL_ESTAT, _("sl_trustfile"));
    758802        }
     
    781825           * got it?
    782826           */
    783           char csym[MAXFILENAME];       /* contents of symlink file  */
    784           char full[MAXFILENAME];       /* "full" name of symlink    */
     827          char * csym;                  /* contents of symlink file  */
     828          char * full;                  /* "full" name of symlink    */
    785829          register char *b, *t;         /* used to copy stuff around */
    786830          register int lsym;            /* num chars in symlink ref  */
     
    797841           * R.W. Tue May 29 22:05:16 CEST 2001
    798842           */
     843          csym = malloc( MAXFILENAME );
     844          if (!csym)
     845            {
     846              free(fexp);
     847              SL_IRETURN(SL_EMEM, _("sl_trustfile"));
     848            }
     849
    799850          lsym = readlink(fexp, csym, MAXFILENAME-1);
    800851          if (lsym >= 0)
     
    808859              fprintf(stderr, "---------------------------------------------\n");
    809860#endif
     861              free(csym);
     862              free(fexp);
    810863              SL_IRETURN(SL_EBADNAME, _("sl_trustfile"));
     864            }
     865
     866          full = malloc( MAXFILENAME );
     867          if (!full)
     868            {
     869              free(csym);
     870              free(fexp);
     871              SL_IRETURN(SL_EMEM, _("sl_trustfile"));
    811872            }
    812873
     
    857918                  fprintf(stderr, "---------------------------------------------\n");
    858919#endif
     920                  free(full);
     921                  free(csym);
     922                  free(fexp);
    859923                  SL_IRETURN(SL_ETRUNC, _("sl_trustfile"));
    860924                }
     
    872936           */
    873937          if ((i = sl_trustfile(full, okusers, badusers)) != SL_ENONE)
    874             SL_IRETURN(i, _("sl_trustfile"));
     938            {
     939              free(full);
     940              free(csym);
     941              free(fexp);
     942              SL_IRETURN(i, _("sl_trustfile"));
     943            }
    875944
    876945          /*
     
    891960                p++;
    892961            }
     962          free(full);
     963          free(csym);
    893964          continue;
    894965        }
     
    922993
    923994          tf_baduid = (uid_t) stbuf.st_uid;
     995          free(fexp);
    924996          SL_IRETURN(SL_EBADUID, _("sl_trustfile"));
    925997        }
     
    9611033
    9621034          tf_badgid = (gid_t) stbuf.st_gid;
     1035          free(fexp);
    9631036          SL_IRETURN(SL_EBADGID, _("sl_trustfile"));
    9641037        }
     
    9841057          tf_path[sizeof(tf_path)-1] = '\0';
    9851058
     1059          free(fexp);
    9861060          SL_IRETURN(SL_EBADOTH, _("sl_trustfile"));
    9871061        }
     
    10091083  tf_path[sizeof(tf_path)-1] = '\0';
    10101084
     1085  free(fexp);
    10111086  SL_IRETURN(SL_ENONE, _("sl_trustfile"));
    10121087}
  • trunk/test/testcompile.sh

    r210 r227  
    178178                echo malloc >  list_null_funcs_uniq;
    179179                echo getenv >> list_null_funcs_uniq;
    180                 cat $i | ./deference_check.pl;
     180                cat $i | ./deference_check.pl |\
     181                     egrep -v 'x_trustfile.c ... ... sl_trustfile';
    181182                rm -f list_null_funcs_uniq;
    182                 rm -f $i
     183                # rm -f $i
    183184            done
    184185        ) >test_log_smatch 2>&1
Note: See TracChangeset for help on using the changeset viewer.