Changeset 132


Ignore:
Timestamp:
Oct 23, 2007, 11:44:41 PM (12 years ago)
Author:
rainer
Message:

Make utility functions thread-safe.

Location:
trunk
Files:
28 edited

Legend:

Unmodified
Added
Removed
  • trunk/configure.ac

    r131 r132  
    274274        ttyname fchmod \
    275275        getsid getpriority getpgid statvfs \
    276         fpathconf dirfd \
     276        strerror_r \
    277277        getgrgid_r getpwnam_r getpwuid_r gmtime_r localtime_r rand_r readdir_r strtok_r
    278278)
  • trunk/docs/TODO

    r131 r132  
    11
    2 sh_unix_time: not thread_safe (static buffer)
    3 sh_error_message: not thread_safe (static buffer)
     2not thread-safe: checksum function (returns static memory),
     3                 sh_util_siggen
     4                 sh_util_hash_tiger
     5                 sh_util_hmac_tiger
    46
    57check thread_safe sh_entropy
     8check thread_safe rng
    69
    7 lock NEED_LOCK
     10lock globber
    811
    9 globber
     12lock sh_alloc/sh_free
    1013
    11 sh_alloc/sh_free
    12 
  • trunk/include/samhain.h

    r131 r132  
    4545#define SH_GRBUF_SIZE  4096
    4646#define SH_PWBUF_SIZE  4096
     47#define SH_ERRBUF_SIZE   64
    4748
    4849/* Sizes for arrays (user, group, timestamp).
  • trunk/include/sh_error.h

    r86 r132  
    176176/* error messages
    177177 */
    178 /*@owned@*/char * sh_error_message (int tellme);
     178/*@owned@*/char * sh_error_message (int tellme, char * str, size_t len);
    179179
    180180/* switch on/off log to file temporarily
  • trunk/include/sh_pthread.h

    r130 r132  
    2323        } while (0)
    2424
     25#define SH_MUTEX_LOCK_UNSAFE(M) pthread_mutex_lock(&(M))
     26#define SH_MUTEX_UNLOCK_UNSAFE(M) pthread_mutex_unlock(&(M))
    2527
    2628#else
     
    3234#define SH_MUTEX_LOCK(M)                        ((void)0)
    3335#define SH_MUTEX_UNLOCK(M)                      ((void)0)
     36#define SH_MUTEX_LOCK_UNSAFE(M)                 ((void)0)
     37#define SH_MUTEX_UNLOCK_UNSAFE(M)               ((void)0)
    3438
    3539/* #ifdef HAVE_PTHREAD */
  • trunk/include/sh_tools.h

    r27 r132  
    1616
    1717#ifdef SH_ENCRYPT
    18 char * errorExplain (int err_num);
     18/* returns pointer to errbuf
     19 */
     20char * errorExplain (int err_num, char * errbuf, size_t len);
    1921#endif
    2022
     23/* returns allocated buffer
     24 */
    2125char * sh_tools_safe_name(const char * str, int flag);
    2226int is_numeric (const char * address);
     
    2630                    char * ecall, int * errnum, char * errmsg, int errsiz);
    2731void delete_cache(void);
    28 char * sh_tools_errmessage (int tellme);
     32
     33/* returns pointer to errbuf
     34 */
     35char * sh_tools_errmessage (int tellme, char * errbuf, size_t len);
    2936
    3037
     
    4148int check_request_nerr (char * have, char * need);
    4249
     50/* returns allocated buffer
     51 */
    4352char * hash_me (char * key, char * buf,   int buflen);
    4453int sh_tools_hash_vfy(char * key, char * buf, int buflen);
    4554
     55/* returns allocated buffer
     56 */
    4657char * get_client_conf_file (char * peer, unsigned long * length);
     58
     59/* returns allocated buffer
     60 */
    4761char * get_client_data_file (char * peer, unsigned long * length);
    4862
  • trunk/include/sh_unix.h

    r114 r132  
    291291int  sh_unix_init(int goDaemon);
    292292
    293 /* for local time use thetime = 0
    294  */
    295 /*@owned@*/ char * sh_unix_time (time_t thetime);
    296 
    297 /* convert to GMT time
    298  */
    299 char * sh_unix_gmttime (time_t thetime);
     293/* for local time use thetime = 0, returns pointer to buffer
     294 */
     295char * sh_unix_time (time_t thetime, char * buffer, size_t len);
     296
     297/* convert to GMT time, returns pointer to buffer
     298 */
     299char * sh_unix_gmttime (time_t thetime, char * buffer, size_t len);
    300300
    301301/* effective user info
     
    303303int  sh_unix_getUser (void);
    304304
    305 /* get home directory
    306  */
    307 char *  sh_unix_getUIDdir (int level, uid_t uid);
     305/* get home directory, , returns pointer to out
     306 */
     307char *  sh_unix_getUIDdir (int level, uid_t uid, char * out, size_t len);
    308308
    309309
  • trunk/include/sh_utils.h

    r93 r132  
    4343} st_format;
    4444
     45/* returns allocated string
     46 */
    4547char * sh_util_formatted (const char * fmt, st_format * ftab);
    4648
     
    6062int    taus_seed           (void);
    6163
     64/* returns allocated memory
     65 */
    6266char * sh_util_strdup (const char * str);
     67
     68/* returns allocated memory
     69 */
    6370char * sh_util_strdup_l (const char * str, size_t len);
     71
     72/* returns pointer within str
     73 */
    6474char * sh_util_strsep (char **str, const char *delim);
    6575
    66 /* compactify verbose acl text
     76/* compactify verbose acl text, returns allocated memory
    6777 */
    6878char * sh_util_acl_compact (char * buf, ssize_t len);
     
    146156
    147157/* returns freshly allocated memory, return value should be free'd.
    148  * Arhument list must be NULL terminated.
     158 * Argument list must be NULL terminated.
    149159 */
    150160char * sh_util_strconcat (const char * arg1, ...) SH_GNUC_NULL_TERMINATED;
  • trunk/src/sh_calls.c

    r22 r132  
    115115  int error;
    116116  long int val_retry = -1;
     117  char errbuf[SH_ERRBUF_SIZE];
    117118  errno              = 0;
    118119
     
    126127  if (val_retry < 0) {
    127128      sh_error_handle ((-1), file, line, error, MSG_ERR_SIGACT,
    128                        sh_error_message(error),
     129                       sh_error_message(error, errbuf, sizeof(errbuf)),
    129130                       (long) signum );
    130131  }
     
    161162  long int val_retry = 0;
    162163  static struct sockaddr_in new_addr;
     164  char errbuf[SH_ERRBUF_SIZE];
    163165
    164166  SL_ENTER(_("retry_connect"));
     
    189191     */
    190192    sh_error_handle ((-1), file, line, error, MSG_ERR_CONNECT,
    191                      sh_error_message(error),
     193                     sh_error_message(error, errbuf, sizeof(errbuf)),
    192194                     (long) sockfd,
    193195                     /*@-unrecog -type@*/
     
    212214  int  error;
    213215  long int val_retry = -1;
     216  char errbuf[SH_ERRBUF_SIZE];
     217
    214218  ACCEPT_TYPE_ARG3 my_addrlen = (ACCEPT_TYPE_ARG3) *addrlen;
    215219
     
    225229  if (val_retry < 0) {
    226230      sh_error_handle ((-1), file, line, error, MSG_ERR_ACCEPT,
    227                        sh_error_message(error),
     231                       sh_error_message(error, errbuf, sizeof(errbuf)),
    228232                       (long) fd );
    229233  }
     
    237241  int error;
    238242  long int val_retry = -1;
     243  char errbuf[SH_ERRBUF_SIZE];
    239244 
    240245  SL_ENTER(_("retry_lstat"));
     
    245250  error = errno;
    246251  if (val_retry < 0) {
    247       (void) sl_strlcpy(aud_err_message, sh_error_message(error), 64);
     252      (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
    248253      sh_error_handle ((-1), file, line, error, MSG_ERR_LSTAT,
    249                        sh_error_message(error),
     254                       sh_error_message(error, errbuf, sizeof(errbuf)),
    250255                       file_name );
    251256  }
     
    259264  int error;
    260265  long int val_retry = -1;
     266  char errbuf[SH_ERRBUF_SIZE];
    261267 
    262268  SL_ENTER(_("retry_stat"));
     
    267273  error = errno;
    268274  if (val_retry < 0) {
    269       (void) sl_strlcpy(aud_err_message, sh_error_message(error), 64);
     275      (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
    270276      sh_error_handle ((-1), file, line, error, MSG_ERR_STAT,
    271                        sh_error_message(error),
     277                       sh_error_message(error, errbuf, sizeof(errbuf)),
    272278                       file_name );
    273279  }
     
    280286  int error;
    281287  long int val_retry = -1;
     288  char errbuf[SH_ERRBUF_SIZE];
    282289 
    283290  SL_ENTER(_("retry_fstat"));
     
    289296  if (val_retry < 0) {
    290297      sh_error_handle ((-1), file, line, error, MSG_ERR_FSTAT,
    291                        sh_error_message(error),
     298                       sh_error_message(error, errbuf, sizeof(errbuf)),
    292299                       (long) filed );
    293300  }
     
    300307  int error;
    301308  long int val_retry = -1;
     309  char errbuf[SH_ERRBUF_SIZE];
    302310  errno              = 0;
    303311
     
    319327  if (val_retry < 0) {
    320328      sh_error_handle ((-1), file, line, error, MSG_ERR_FCNTL,
    321                        sh_error_message(error),
     329                       sh_error_message(error, errbuf, sizeof(errbuf)),
    322330                       (long) fd, (long) cmd, arg );
    323331  }
     
    389397  int   i;
    390398  int   error;
     399  char errbuf[SH_ERRBUF_SIZE];
    391400
    392401  SL_ENTER(_("retry_aud_execve"));
     
    401410  error = errno;
    402411  if (i < 0) {
    403       sh_error_handle ((-1), file, line, error, MSG_ERR_EXEC, sh_error_message(error),
     412      sh_error_handle ((-1), file, line, error, MSG_ERR_EXEC,
     413                       sh_error_message(error, errbuf, sizeof(errbuf)),
    404414                       dateiname, (long) a, (long) b );
    405415  }
     
    414424  long int val_return;
    415425  int  error;
     426  char errbuf[SH_ERRBUF_SIZE];
    416427  errno      = 0;
    417428
     
    430441  if (val_return < 0) {
    431442      sh_error_handle ((-1), file, line, error, MSG_ERR_UTIME,
    432                        sh_error_message(error),
     443                       sh_error_message(error, errbuf, sizeof(errbuf)),
    433444                       path,
    434445                       (unsigned long) buf->actime,
     
    444455  long int val_return;
    445456  int error;
     457  char errbuf[SH_ERRBUF_SIZE];
    446458  errno      = 0;
    447459
     
    457469                     path);
    458470  if (val_return < 0) {
    459       sh_error_handle ((-1), file, line, error, MSG_ERR_UNLINK, sh_error_message(error),
     471      sh_error_handle ((-1), file, line, error, MSG_ERR_UNLINK,
     472                       sh_error_message(error, errbuf, sizeof(errbuf)),
    460473                       path);
    461474  }
     
    469482  long int val_return;
    470483  int error;
     484  char errbuf[SH_ERRBUF_SIZE];
    471485  errno      = 0;
    472486
     
    483497  if (val_return < 0) {
    484498      sh_error_handle ((-1), file, line, error, MSG_ERR_DUP,
    485                        sh_error_message(error),
     499                       sh_error_message(error, errbuf, sizeof(errbuf)),
    486500                       (long) fd, val_return);
    487501  }
     
    495509  long int val_return;
    496510  int error;
     511  char errbuf[SH_ERRBUF_SIZE];
    497512  errno      = 0;
    498513
     
    508523  if (val_return < 0) {
    509524      sh_error_handle ((-1), file, line, error, MSG_ERR_DUP,
    510                        sh_error_message(error),
     525                       sh_error_message(error, errbuf, sizeof(errbuf)),
    511526                       (long) fd, val_return);
    512527  }
     
    522537  long int val_return;
    523538  int      error      = 0;
     539  char errbuf[SH_ERRBUF_SIZE];
    524540  errno      = 0;
    525541
     
    535551                     path);
    536552  if (val_return < 0) {
    537       sh_error_handle ((-1), file, line, error, MSG_ERR_CHDIR, sh_error_message(error),
     553      sh_error_handle ((-1), file, line, error, MSG_ERR_CHDIR,
     554                       sh_error_message(error, errbuf, sizeof(errbuf)),
    538555                       path);
    539556  }
     
    549566  long int val_return;
    550567  int error;
     568  char errbuf[SH_ERRBUF_SIZE];
    551569
    552570  SL_ENTER(_("aud_open"));
     
    566584  if (val_return < 0)
    567585    {
    568       (void) sl_strlcpy(aud_err_message, sh_error_message(error), 64);
     586      (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
    569587    }
    570588
     
    576594  if (val_return < 0) {
    577595    sh_error_handle ((-1), file, line, error, MSG_ERR_OPEN,
    578                      sh_error_message(error),
     596                     sh_error_message(error, errbuf, sizeof(errbuf)),
    579597                     pathname, (long) flags, (long) mode, val_return);
    580598  }
     
    588606  long int val_return;
    589607  int error;
     608  char errbuf[SH_ERRBUF_SIZE];
    590609
    591610  SL_ENTER(_("aud_open"));
     
    599618  if (val_return < 0)
    600619    {
    601       (void) sl_strlcpy(aud_err_message, sh_error_message(error), 64);
     620      (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
    602621    }
    603622
     
    609628  if (val_return < 0) {
    610629    sh_error_handle ((-1), file, line, error, MSG_ERR_OPEN,
    611                      sh_error_message(error),
     630                     sh_error_message(error, errbuf, sizeof(errbuf)),
    612631                     pathname, (long) flags, (long) mode, val_return);
    613632  }
     
    620639  int  myerror;
    621640  long int val_return = kill (pid, sig);
     641  char errbuf[SH_ERRBUF_SIZE];
    622642  myerror = errno;
    623643
     
    629649  if (val_return < 0) {
    630650      sh_error_handle ((-1), file, line, myerror, MSG_ERR_KILL,
    631                        sh_error_message(myerror),
     651                       sh_error_message(myerror, errbuf, sizeof(errbuf)),
    632652                       (long) pid, (long) sig);
    633653  }
     
    666686  int error;
    667687  pid_t i = fork();
     688  char errbuf[SH_ERRBUF_SIZE];
    668689
    669690  error = errno;
     
    675696  if (i == (pid_t) -1) {
    676697    sh_error_handle ((-1), file, line, error, MSG_ERR_FORK,
    677                      sh_error_message(error),
     698                     sh_error_message(error, errbuf, sizeof(errbuf)),
    678699                     (long) i);
    679700  }
     
    686707  int error = 0;
    687708  int i = 0;
     709  char errbuf[SH_ERRBUF_SIZE];
    688710
    689711  SL_ENTER(_("aud_setuid"));
     
    702724  if (i < 0) {
    703725    sh_error_handle ((-1), file, line, error, MSG_ERR_SETUID,
    704                      sh_error_message(error),
     726                     sh_error_message(error, errbuf, sizeof(errbuf)),
    705727                     (long) uid);
    706728  }
     
    713735  int error = 0;
    714736  int i = 0;
     737  char errbuf[SH_ERRBUF_SIZE];
    715738
    716739  SL_ENTER(_("aud_setgid"));
     
    730753  if (i < 0) {
    731754    sh_error_handle ((-1), file, line, error, MSG_ERR_SETGID,
    732                      sh_error_message(error),
     755                     sh_error_message(error, errbuf, sizeof(errbuf)),
    733756                     (long) gid);
    734757  }
     
    741764  int error;
    742765  int i = pipe (modus);
     766  char errbuf[SH_ERRBUF_SIZE];
    743767
    744768  SL_ENTER(_("aud_pipe"));
     
    761785    else
    762786      sh_error_handle ((-1), file, line, error, MSG_ERR_PIPE,
    763                        sh_error_message(error),
     787                       sh_error_message(error, errbuf, sizeof(errbuf)),
    764788                       (long) modus[0], (long) modus[1]);
    765789  }
  • trunk/src/sh_entropy.c

    r131 r132  
    645645    int retval;
    646646    char msg[128];
     647    char errbuf[SH_ERRBUF_SIZE];
    647648
    648649    SL_ENTER(_("sh_pclose"));
     
    653654        sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, retval,
    654655                         MSG_E_SUBGEN,
    655                          sh_error_message(retval),
     656                         sh_error_message(retval, errbuf, sizeof(errbuf)),
    656657                         _("sh_pclose"));
    657658        SL_RETURN((-1), _("sh_pclose"));
     
    663664        sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, retval,
    664665                         MSG_E_SUBGEN,
    665                          sh_error_message(retval),
     666                         sh_error_message(retval, errbuf, sizeof(errbuf)),
    666667                         _("sh_pclose"));
    667668
     
    707708  int    maxFD = 0;
    708709  int    imax, selcount;
    709 
     710  char errbuf[SH_ERRBUF_SIZE];
     711 
    710712  SL_ENTER(_("sh_entropy"));
    711713
     
    738740    {
    739741      sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
    740                       sh_error_message (caperr),
     742                      sh_error_message (caperr, errbuf, sizeof(errbuf)),
    741743                      _("sl_get_cap_sub"));
    742744    }
     
    876878    {
    877879      sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
    878                       sh_error_message (caperr),
     880                      sh_error_message (caperr, errbuf, sizeof(errbuf)),
    879881                      _("sl_drop_cap_sub"));
    880882    }
  • trunk/src/sh_err_console.c

    r22 r132  
    7070  key_t            key;
    7171  int              error;
     72  char errbuf[SH_ERRBUF_SIZE];
    7273
    7374  SL_ENTER(_("open_ipc"));
     
    8081      error = errno;
    8182      TPT(( 0, FIL__, __LINE__, _("msg=<ftok: %s> errno=<%d>\n"),
    82             sh_error_message(error), error));
     83            sh_error_message(error, errbuf, sizeof(errbuf)), error));
    8384      SL_RETURN(-1, _("open_ipc"));
    8485    }
     
    9293      error = errno;
    9394      TPT(( 0, FIL__, __LINE__, _("msg=<msgget: %s> errno=<%d>\n"),
    94             sh_error_message(error), error));
     95            sh_error_message(error, errbuf, sizeof(errbuf)), error));
    9596      SL_RETURN(-1, _("open_ipc"));
    9697    }
     
    131132  int              error;
    132133  int              count    = 0;
     134  char errbuf[SH_ERRBUF_SIZE];
    133135
    134136  SL_ENTER(_("push_message_queue"));
     
    201203          error = errno;
    202204          TPT(( 0, FIL__, __LINE__, _("msg=<msgsnd: %s> errno=<%d>\n"),
    203                 sh_error_message(error), error));
     205                sh_error_message(error, errbuf, sizeof(errbuf)), error));
    204206          SH_FREE(recv_msg);
    205207          SL_RETURN(-1, _("push_message_queue"));
  • trunk/src/sh_err_log.c

    r34 r132  
    885885      /* Send out the key.
    886886       */
    887       (void) sl_strlcpy(log_msg.timestamp, sh_unix_time(0), KEY_LEN+1);
     887      (void) sh_unix_time(0, log_msg.timestamp, KEY_LEN+1);
    888888
    889889      store1               = errFlags.loglevel;
  • trunk/src/sh_error.c

    r131 r132  
    2020#include "config_xor.h"
    2121
     22/* required on linux to get the correct strerror_r function
     23 */
     24#define _XOPEN_SOURCE 600
     25#include <string.h>
    2226#include <stdio.h>     
    2327#include <stdlib.h>     
    2428#include <stdarg.h>
    25 #include <string.h>
    2629#include <ctype.h>
    2730#include <limits.h>
     
    335338
    336339
    337 /*@owned@*/char * sh_error_message (int tellme)
    338 {
    339 
    340 #if defined(HAVE_STRERROR)
    341   /*@i@*/return strerror(tellme);
     340char * sh_error_message (int tellme, char * str, size_t len)
     341{
     342
     343#if defined(HAVE_STRERROR_R)
     344  strerror_r(tellme, str, len);
     345  return str;
     346#elif defined(HAVE_STRERROR)
     347  sl_strlcpy(str, strerror(tellme), len);
     348  return str;
    342349#else
    343350
     351  char *p = NULL;
    344352#ifdef EACCES
    345     if (tellme == EACCES)  return _("Permission denied.");
     353    if (tellme == EACCES)  p = _("Permission denied.");
    346354#endif
    347355#ifdef EAGAIN
    348     if (tellme == EAGAIN)  return _("Try again.");
     356    if (tellme == EAGAIN)  p = _("Try again.");
    349357#endif
    350358#ifdef EBADF
    351     if (tellme == EBADF)   return _("File descriptor in bad state.");
     359    if (tellme == EBADF)   p = _("File descriptor in bad state.");
    352360#endif
    353361#ifdef EEXIST
    354     if (tellme == EEXIST)  return _("File exists.");
     362    if (tellme == EEXIST)  p = _("File exists.");
    355363#endif
    356364#ifdef EFAULT
    357     if (tellme == EFAULT)  return _("Bad address.");
     365    if (tellme == EFAULT)  p = _("Bad address.");
    358366#endif
    359367#ifdef EINVAL
    360     if (tellme == EINVAL)  return _("Invalid argument.");
     368    if (tellme == EINVAL)  p = _("Invalid argument.");
    361369#endif
    362370#ifdef EISDIR
    363     if (tellme == EISDIR)  return _("Is a directory.");
     371    if (tellme == EISDIR)  p = _("Is a directory.");
    364372#endif
    365373#ifdef EINTR
    366     if (tellme == EINTR)   return _("System call was interrupted.");
     374    if (tellme == EINTR)   p = _("System call was interrupted.");
    367375#endif
    368376#ifdef EIO
    369     if (tellme == EIO)     return _("Low-level I/O error.");
     377    if (tellme == EIO)     p = _("Low-level I/O error.");
    370378#endif
    371379#ifdef ELOOP
    372     if (tellme == ELOOP)   return _("Too many symbolic links encountered.");
     380    if (tellme == ELOOP)   p = _("Too many symbolic links encountered.");
    373381#endif
    374382#ifdef EMFILE
    375     if (tellme == EMFILE)  return _("Too many open files.");
     383    if (tellme == EMFILE)  p = _("Too many open files.");
    376384#endif
    377385#ifdef EMLINK
    378     if (tellme == EMLINK)  return _("Too many links.");
     386    if (tellme == EMLINK)  p = _("Too many links.");
    379387#endif
    380388#ifdef ENAMETOOLONG
    381389    if (tellme == ENAMETOOLONG)
    382                            return _("File name too long.");
     390                           p = _("File name too long.");
    383391#endif
    384392#ifdef ENFILE
    385     if (tellme == ENFILE)  return _("File table overflow.");
     393    if (tellme == ENFILE)  p = _("File table overflow.");
    386394#endif
    387395#ifdef ENOENT
    388     if (tellme == ENOENT)  return _("File does not exist.");
     396    if (tellme == ENOENT)  p = _("File does not exist.");
    389397#endif
    390398#ifdef ENOMEM
    391     if (tellme == ENOMEM)  return _("Out of memory.");
     399    if (tellme == ENOMEM)  p = _("Out of memory.");
    392400#endif
    393401#ifdef ENOSPC
    394     if (tellme == ENOSPC)  return _("No space on device.");
     402    if (tellme == ENOSPC)  p = _("No space on device.");
    395403#endif
    396404#ifdef ENOTDIR
    397     if (tellme == ENOTDIR) return _("Not a directory.");
     405    if (tellme == ENOTDIR) p = _("Not a directory.");
    398406#endif
    399407#ifdef ENOTSOCK
    400     if (tellme == ENOTSOCK) return _("Not a socket.");
     408    if (tellme == ENOTSOCK) p = _("Not a socket.");
    401409#endif
    402410#ifdef EOPNOTSUPP
    403     if (tellme == EOPNOTSUPP) return _("Socket is not of type SOCK_STREAM.");
     411    if (tellme == EOPNOTSUPP) p = _("Socket is not of type SOCK_STREAM.");
    404412#endif
    405413#ifdef EPERM
    406     if (tellme == EPERM)   return _("Permission denied.");
     414    if (tellme == EPERM)   p = _("Permission denied.");
    407415#endif
    408416#ifdef EPIPE
    409     if (tellme == EPIPE)   return _("No read on pipe.");
     417    if (tellme == EPIPE)   p = _("No read on pipe.");
    410418#endif
    411419#ifdef EROFS
    412     if (tellme == EROFS)    return _("Read-only file system.");
     420    if (tellme == EROFS)    p = _("Read-only file system.");
    413421#endif
    414422#ifdef ETXTBSY
    415     if (tellme == ETXTBSY) return _("Text file busy.");
     423    if (tellme == ETXTBSY) p = _("Text file busy.");
    416424#endif
    417425#ifdef EWOULDBLOCK
    418426    if (tellme == EWOULDBLOCK)
    419       return _("No connections on non-blocking socket.");
     427      p = _("No connections on non-blocking socket.");
    420428#endif
    421429#ifdef EXDEV
    422     if (tellme == EXDEV)    return _("Not on same file system.");
    423 #endif
    424     return _("Unknown error");
     430    if (tellme == EXDEV)    p = _("Not on same file system.");
     431#endif
     432    if (!p) p = _("Unknown error");
     433    sl_strlcpy(str, p, len);
     434    return str;
    425435#endif /* ifndef HAVE_STRERROR */
    426436}
     
    14771487  }
    14781488
    1479   (void) sl_strlcpy (tst, sh_unix_time (0), 64);
     1489  (void) sh_unix_time (0, tst, 64);
    14801490  line = (unsigned long) lmsg->line;
    14811491  (void) sl_strlcpy (cla, _(class_cat[lmsg->class]), 11);
  • trunk/src/sh_extern.c

    r131 r132  
    118118
    119119  char * errfile;
     120  char errbuf[SH_ERRBUF_SIZE];
    120121
    121122  static int some_error = 0;
     
    213214      errnum = errno;
    214215      sh_error_handle((-1), FIL__, __LINE__, errnum, MSG_E_SUBGEN,
    215                       sh_error_message(errnum), _("pipe"));
     216                      sh_error_message(errnum, errbuf, sizeof(errbuf)), _("pipe"));
    216217      SL_RETURN ((-1), _("sh_ext_popen"));
    217218    }
     
    235236      errnum = errno;
    236237      sh_error_handle((-1), FIL__, __LINE__, errnum, MSG_E_SUBGEN,
    237                       sh_error_message(errnum), _("fork"));
     238                      sh_error_message(errnum, errbuf, sizeof(errbuf)), _("fork"));
    238239      SL_RETURN ((-1), _("sh_ext_popen"));
    239240    }
     
    11031104  char * p = NULL;
    11041105  int    i;
     1106  char   dir[SH_PATHBUF];
    11051107
    11061108  SL_ENTER(_("sh_ext_add_default"));
     
    11101112      SL_RETURN(0, _("sh_ext_add_default"));
    11111113    }
    1112   p = sh_unix_getUIDdir (SH_ERR_ERR, (uid_t) ext_coms->tas.run_user_uid);
     1114  p = sh_unix_getUIDdir (SH_ERR_ERR, (uid_t) ext_coms->tas.run_user_uid,
     1115                         dir, sizeof(dir));
    11131116  if (p)
    11141117    (void) sh_ext_add_envv (_("HOME"), p);
     
    13251328  int        status = 0;
    13261329  char     * tmp;
     1330  char errbuf[SH_ERRBUF_SIZE];
    13271331
    13281332  static  int some_error = 0;
     
    13641368            {
    13651369              sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
    1366                               sh_error_message (caperr),
     1370                              sh_error_message (caperr, errbuf, sizeof(errbuf)),
    13671371                              _("sl_get_cap_sub"));
    13681372            }
     
    14431447            {
    14441448              sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
    1445                               sh_error_message (caperr),
     1449                              sh_error_message (caperr, errbuf, sizeof(errbuf)),
    14461450                              _("sl_drop_cap_sub"));
    14471451            }
  • trunk/src/sh_files.c

    r131 r132  
    721721{
    722722  char * p;
     723  char errbuf[SH_ERRBUF_SIZE];
    723724
    724725  SL_ENTER(_("sh_files_globerr"));
     
    731732  p = sh_util_safe_name (epath);
    732733  sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, errnum, MSG_FI_GLOB,
    733                    sh_error_message (errnum), p);
     734                   sh_error_message (errnum, errbuf, sizeof(errbuf)), p);
    734735  SH_FREE(p);
    735736
     
    14911492  char          * tmpname;
    14921493  char          * tmpcat;
     1494  char errbuf[SH_ERRBUF_SIZE];
    14931495
    14941496  int             rdepth = 0;
     
    16111613      sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
    16121614                       MSG_E_OPENDIR,
    1613                        sh_error_message (status), tmpname);
     1615                       sh_error_message (status, errbuf, sizeof(errbuf)), tmpname);
    16141616      SH_FREE(tmpname);
    16151617
  • trunk/src/sh_forward.c

    r34 r132  
    386386  cipherInstance          cipherInst;
    387387  int                     err_num;
     388  char expbuf[SH_ERRBUF_SIZE];
    388389#else
    389390  docrypt = SL_FALSE; /* dummy to fix compiler warning */
     
    422423      if (err_num < 0)
    423424        sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    424                         errorExplain(err_num),
     425                        errorExplain(err_num, expbuf, sizeof(expbuf)),
    425426                        _("sh_forward_send_intern: cipherInit"));
    426427
     
    433434          if (err_num < 0)
    434435            sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    435                             errorExplain(err_num),
     436                            errorExplain(err_num, expbuf, sizeof(expbuf)),
    436437                            _("sh_forward_send_intern: blockEncrypt"));
    437438          memcpy(q, outBlock, B_SIZ);
     
    447448          if (err_num < 0)
    448449            sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    449                             errorExplain(err_num),
     450                            errorExplain(err_num, expbuf, sizeof(expbuf)),
    450451                            _("sh_forward_send_intern: blockEncrypt"));
    451452          memcpy(q, outBlock, B_SIZ);
     
    549550  cipherInstance          cipherInst;
    550551  int                     err_num;
     552  char expbuf[SH_ERRBUF_SIZE];
    551553#else
    552554  docrypt = SL_FALSE; /* dummy to fix compiler warning */
     
    655657      if (err_num < 0)
    656658        sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    657                         errorExplain(err_num),
     659                        errorExplain(err_num, expbuf, sizeof(expbuf)),
    658660                        _("sh_forward_receive_intern: cipherInit"));
    659661
     
    668670          if (err_num < 0)
    669671            sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    670                             errorExplain(err_num),
     672                            errorExplain(err_num, expbuf, sizeof(expbuf)),
    671673                            _("sh_forward_receive_intern: blockDecrypt"));
    672674          memcpy(q, outBlock, B_SIZ);
     
    881883#ifdef SH_ENCRYPT
    882884  int err_num;
     885  char expbuf[SH_ERRBUF_SIZE];
    883886#endif
    884887
     
    10531056          if (err_num < 0)
    10541057            sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    1055                             errorExplain(err_num),
     1058                            errorExplain(err_num, expbuf, sizeof(expbuf)),
    10561059                            _("sh_forward_try_impl: makeKey"));
    10571060
     
    10601063          if (err_num < 0)
    10611064            sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    1062                             errorExplain(err_num),
     1065                            errorExplain(err_num, expbuf, sizeof(expbuf)),
    10631066                            _("sh_forward_try_impl: make_key"));
    10641067#endif
     
    12331236                                sh_error_handle((-1), FIL__, __LINE__, -1,
    12341237                                                MSG_E_SUBGEN,
    1235                                                 errorExplain(err_num),
     1238                                                errorExplain(err_num, expbuf, sizeof(expbuf)),
    12361239                                                _("sh_forward_try_impl: makeKey"));
    12371240                              err_num = makeKey(&(skey->keyInstD),
     
    12411244                                sh_error_handle((-1), FIL__, __LINE__, -1,
    12421245                                                MSG_E_SUBGEN,
    1243                                                 errorExplain(err_num),
     1246                                                errorExplain(err_num, expbuf, sizeof(expbuf)),
    12441247                                                _("sh_forward_try_impl: makeKey"));
    12451248#endif
     
    17411744  if (flag_err != 0)
    17421745    {
     1746      char errbuf[SH_ERRBUF_SIZE];
    17431747      conn_state = BAD;
    17441748      timeout_val *= 2;
    1745       if (flag_err < 0 || NULL == sh_error_message(flag_err))
     1749      if (flag_err < 0 || NULL == sh_error_message(flag_err, errbuf, sizeof(errbuf)))
    17461750        flag_err = EIO;
    17471751      sh_error_handle((-1), FIL__, __LINE__, flag_err, MSG_TCP_ECONN,
    1748                       sh_error_message(flag_err));
     1752                      sh_error_message(flag_err, errbuf, sizeof(errbuf)));
    17491753      SL_RETURN( (-1), _("sh_forward_try_impl"));
    17501754    }
     
    20532057      for (i = 0; i < CLT_MAX; ++i)
    20542058        newclt->status_arr[i] = CLT_INACTIVE;
    2055       sl_strlcpy(newclt->timestamp[CLT_INACTIVE],   sh_unix_time(0), TIM_MAX);
     2059      (void) sh_unix_time(0, newclt->timestamp[CLT_INACTIVE], TIM_MAX);
    20562060      /* truncate */
    20572061      sl_strlcpy(newclt->hostname,  &str[0],        sep[0]+1);
     
    22572261  cipherInstance          cipherInst;
    22582262  int                     err_num;
     2263  char expbuf[SH_ERRBUF_SIZE];
    22592264#else
    22602265  (void) docrypt;
     
    23292334      if (err_num < 0)
    23302335        sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    2331                         errorExplain(err_num),
     2336                        errorExplain(err_num, expbuf, sizeof(expbuf)),
    23322337                        _("sh_forward_prep_send_int: cipherInit"));
    23332338
     
    23392344          if (err_num < 0)
    23402345            sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    2341                             errorExplain(err_num),
     2346                            errorExplain(err_num, expbuf, sizeof(expbuf)),
    23422347                            _("sh_forward_prep_send_int: blockEncrypt"));
    23432348          memcpy(q, outBlock, B_SIZ);
     
    23552360          if (err_num < 0)
    23562361            sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    2357                             errorExplain(err_num),
     2362                            errorExplain(err_num, expbuf, sizeof(expbuf)),
    23582363                            _("sh_forward_prep_send_int: blockEncrypt"));
    23592364          memcpy(q, outBlock, B_SIZ);
     
    24382443  conn->status_now = status;
    24392444  conn->status_arr[status] = status;
    2440   sl_strlcpy(conn->timestamp[status],
    2441              sh_unix_time(0),
    2442              TIM_MAX);
     2445  (void) sh_unix_time(0, conn->timestamp[status], TIM_MAX);
    24432446
    24442447#if defined(WITH_EXTERNAL)
     
    28062809  int        send_bytes;
    28072810  int        err_num;
     2811  char expbuf[SH_ERRBUF_SIZE];
    28082812#endif
    28092813
     
    38803884               if (err_num < 0)
    38813885                 sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    3882                                  errorExplain(err_num),
     3886                                 errorExplain(err_num, expbuf, sizeof(expbuf)),
    38833887                                 _("check_protocol: makeKey"));
    38843888               err_num = makeKey(&(conn->client_entry->keyInstD),
     
    38873891               if (err_num < 0)
    38883892                 sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    3889                                  errorExplain(err_num),
     3893                                 errorExplain(err_num, expbuf, sizeof(expbuf)),
    38903894                                 _("check_protocol: makeKey"));
    38913895#endif
     
    42114215                  if (err_num < 0)
    42124216                    sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    4213                                     errorExplain(err_num),
     4217                                    errorExplain(err_num, expbuf, sizeof(expbuf)),
    42144218                                    _("sh_forward_prep_send_int: makeKey"));
    42154219                  err_num = makeKey(&(conn->client_entry->keyInstD),
     
    42184222                  if (err_num < 0)
    42194223                    sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    4220                                     errorExplain(err_num),
     4224                                    errorExplain(err_num, expbuf, sizeof(expbuf)),
    42214225                                    _("sh_forward_prep_send_int: makeKey"));
    42224226#endif
     
    43124316  cipherInstance          cipherInst;
    43134317  int                     err_num;
     4318  char expbuf[SH_ERRBUF_SIZE];
    43144319#endif
    43154320
     
    44104415                  if (err_num < 0)
    44114416                    sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    4412                                     errorExplain(err_num),
     4417                                    errorExplain(err_num, expbuf, sizeof(expbuf)),
    44134418                                    _("sh_forward_do_read: cipherInit"));
    44144419
     
    44224427                        sh_error_handle((-1), FIL__, __LINE__, -1,
    44234428                                        MSG_E_SUBGEN,
    4424                                         errorExplain(err_num),
     4429                                        errorExplain(err_num, expbuf, sizeof(expbuf)),
    44254430                                        _("sh_forward_do_read: blockDecrypt"));
    44264431                      memcpy(q, outBlock, B_SIZ);
     
    46504655  else
    46514656    {
     4657      char err_buf[SH_ERRBUF_SIZE];
    46524658      errflag = errno;
    46534659      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
    4654                       sh_error_message(errflag), _("accept"));
     4660                      sh_error_message(errflag,err_buf, sizeof(err_buf)), _("accept"));
    46554661      newconn->fd    = -1;
    46564662      newconn->state = CONN_FREE;
     
    47324738int sh_forward_printerr_final(int slot)
    47334739{
     4740  char errbuf[SH_ERRBUF_SIZE];
     4741
    47344742  SL_ENTER(_("sh_forward_printerr_final"));
    47354743  if (sock_err[slot].msg[0] != '\0')
     
    47374745      dlog(1, FIL__, __LINE__,
    47384746           _("Could not set up the listening socket for the server because of the\nfollowing error: %s\nPossible reasons include:\n - insufficient privilege for UID %d, or\n - the port %d is already used by another program.\n"),
    4739            sh_error_message(sock_err[slot].errnum), sock_err[slot].euid,
     4747           sh_error_message(sock_err[slot].errnum, errbuf, sizeof(errbuf)),
     4748           sock_err[slot].euid,
    47404749           sock_err[slot].port);
    47414750      sh_error_handle((-1), FIL__, sock_err[slot].line,
    47424751                      sock_err[slot].errnum, MSG_EXIT_ABORTS,
    4743                       sh_error_message(sock_err[slot].errnum),
     4752                      sh_error_message(sock_err[slot].errnum, errbuf, sizeof(errbuf)),
    47444753                      sh.prg_name,
    47454754                      sock_err[slot].msg);
     
    51805189      if ( num_sel < 0 )        /* some error             */
    51815190        {
     5191          char errbuf[SH_ERRBUF_SIZE];
     5192
    51825193          if (sig_raised == 1)
    51835194            {
     
    52075218
    52085219          sh_error_handle((-1), FIL__, __LINE__, errnum, MSG_EXIT_ABORTS,
    5209                           sh_error_message(errnum),
     5220                          sh_error_message(errnum, errbuf, sizeof(errbuf)),
    52105221                          sh.prg_name,
    52115222                          _("select"));
     
    55355546  char               buf[1048];
    55365547  struct sockaddr_in from;
     5548  char errbuf[SH_ERRBUF_SIZE];
    55375549
    55385550  /* The 6th argument in recvfrom is *socklen_t in Linux and *BSD,
     
    55755587          TPT(( 0, FIL__, __LINE__, _("msg=<UDP error: %d>\n"), res));
    55765588          sh_error_handle((-1), FIL__, __LINE__, res, MSG_ERR_SYSLOG,
    5577                           sh_error_message(res), my_inet_ntoa(from.sin_addr));
     5589                          sh_error_message(res, errbuf, sizeof(errbuf)),
     5590                          my_inet_ntoa(from.sin_addr));
    55785591          SL_RETURN( (-1), _("recv_syslog_socket"));
    55795592        }     
     
    56345647      TPT(( 0, FIL__, __LINE__, _("msg=<UDP error: %d>\n"), res));
    56355648      sh_error_handle((-1), FIL__, __LINE__, res, MSG_ERR_SYSLOG,
    5636                       sh_error_message(res), my_inet_ntoa(from.sin_addr));
     5649                      sh_error_message(res, errbuf, sizeof(errbuf)),
     5650                      my_inet_ntoa(from.sin_addr));
    56375651
    56385652      /* don't accept anything the next 2 seconds
  • trunk/src/sh_gpg.c

    r131 r132  
    660660  if (0 != retry_lstat(FIL__, __LINE__, DEFAULT_GPG_PATH, &buf))
    661661    {
     662      char errbuf[SH_ERRBUF_SIZE];
     663
    662664      status = errno;
    663665      sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_ERR_LSTAT,
    664                       sh_error_message(status), DEFAULT_GPG_PATH);
     666                      sh_error_message(status, errbuf, sizeof(errbuf)), DEFAULT_GPG_PATH);
    665667      SL_RETURN( SH_GPG_BAD, _("sh_gpg_check_file_sign"));
    666668    }
     
    690692  if (0 != retry_lstat(FIL__, __LINE__, DEFAULT_PGP_PATH, &buf))
    691693    {
     694      char errbuf[SH_ERRBUF_SIZE];
     695
    692696      status = errno;
    693697      sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_ERR_LSTAT,
    694                       sh_error_message(status), DEFAULT_PGP_PATH);
     698                      sh_error_message(status, errbuf, sizeof(errbuf)), DEFAULT_PGP_PATH);
    695699      SL_RETURN( SH_GPG_BAD, _("sh_gpg_check_file_sign"));
    696700    }
  • trunk/src/sh_hash.c

    r131 r132  
    14041404
    14051405  char   timestring[81];
    1406   char * timep;
    14071406
    14081407#if !defined(__linux__) && !defined(HAVE_STAT_FLAGS)
     
    17061705                            sl_strlen(sh_db_version_string));
    17071706                  sl_write (pushdata_fd, _(" Date "), 6);
    1708                   timep = sh_unix_time(0);
    1709                   sl_strlcpy(timestring, timep, sizeof(timestring));
     1707                  (void) sh_unix_time(0, timestring, sizeof(timestring));
    17101708                  sl_write (pushdata_fd, timestring, sl_strlen(timestring));
    17111709                  sl_write (pushdata_fd,        "\n", 1);
     
    17161714                  printf ("%s", sh_db_version_string);
    17171715                  printf (_(" Date "));
    1718                   timep = sh_unix_time(0);
    1719                   sl_strlcpy(timestring, timep, sizeof(timestring));
     1716                  (void) sh_unix_time(0, timestring, sizeof(timestring));
    17201717                  printf ("%s\n", timestring);
    17211718                }
     
    23432340
    23442341
    2345   sl_strlcpy (timstr1c, sh_unix_gmttime (theFile->ctime),   32);
     2342  (void) sh_unix_gmttime (theFile->ctime, timstr1c,  sizeof(timstr1c));
    23462343  if (is_new)
    23472344    sl_snprintf(tmp, SH_BUFSIZE, _("ctime_new=\"%s\" "), timstr1c);
     
    23502347  sl_strlcat(msg, tmp, SH_BUFSIZE);
    23512348
    2352   sl_strlcpy (timstr1a, sh_unix_gmttime (theFile->atime),   32);
     2349  (void) sh_unix_gmttime (theFile->atime, timstr1a,  sizeof(timstr1a));
    23532350  if (is_new)
    23542351    sl_snprintf(tmp, SH_BUFSIZE, _("atime_new=\"%s\" "), timstr1a);
     
    23572354  sl_strlcat(msg, tmp, SH_BUFSIZE);
    23582355
    2359   sl_strlcpy (timstr1m, sh_unix_gmttime (theFile->mtime),   32);
     2356  (void) sh_unix_gmttime (theFile->mtime, timstr1m,  sizeof(timstr1m));
    23602357  if (is_new)
    23612358    sl_snprintf(tmp, SH_BUFSIZE, _("mtime_new=\"%s\" "), timstr1m);
     
    25092506
    25102507
    2511   sl_strlcpy (timstr1c, sh_unix_gmttime (theFile->ctime),   32);
     2508  (void) sh_unix_gmttime (theFile->ctime, timstr1c,  sizeof(timstr1c));
    25122509  if (is_new)
    25132510    sl_snprintf(tmp, SH_BUFSIZE, _("ctime_new=<%s>, "), timstr1c);
     
    25162513  sl_strlcat(msg, tmp, SH_BUFSIZE);
    25172514
    2518   sl_strlcpy (timstr1a, sh_unix_gmttime (theFile->atime),   32);
     2515  (void) sh_unix_gmttime (theFile->atime, timstr1a,  sizeof(timstr1a));
    25192516  if (is_new)
    25202517    sl_snprintf(tmp, SH_BUFSIZE, _("atime_new=<%s>, "), timstr1a);
     
    25232520  sl_strlcat(msg, tmp, SH_BUFSIZE);
    25242521
    2525   sl_strlcpy (timstr1m, sh_unix_gmttime (theFile->mtime),   32);
     2522  (void) sh_unix_gmttime (theFile->mtime, timstr1m,  sizeof(timstr1m));
    25262523  if (is_new)
    25272524    sl_snprintf(tmp, SH_BUFSIZE, _("mtime_new=<%s>, "), timstr1m);
     
    31453142      if ((modi_mask & MODI_CTM) != 0)
    31463143        {
    3147           sl_strlcpy (timstr1c, sh_unix_gmttime (p->theFile.ctime), 32);
    3148           sl_strlcpy (timstr2c, sh_unix_gmttime (theFile->ctime),   32);
     3144          (void) sh_unix_gmttime (p->theFile.ctime, timstr1c, sizeof(timstr1c));
     3145          (void) sh_unix_gmttime (theFile->ctime,   timstr2c, sizeof(timstr2c));
    31493146#ifdef SH_USE_XML
    31503147          sl_snprintf(tmp, SH_BUFSIZE, _("ctime_old=\"%s\" ctime_new=\"%s\" "),
     
    31633160      if ((modi_mask & MODI_ATM) != 0)
    31643161        {
    3165           sl_strlcpy (timstr1a, sh_unix_gmttime (p->theFile.atime), 32);
    3166           sl_strlcpy (timstr2a, sh_unix_gmttime (theFile->atime),   32);
     3162          (void) sh_unix_gmttime (p->theFile.atime, timstr1a, sizeof(timstr1a));
     3163          (void) sh_unix_gmttime (theFile->atime,   timstr2a, sizeof(timstr2a));
    31673164#ifdef SH_USE_XML
    31683165          sl_snprintf(tmp, SH_BUFSIZE, _("atime_old=\"%s\" atime_new=\"%s\" "),
     
    31813178      if ((modi_mask & MODI_MTM) != 0)
    31823179        {
    3183           sl_strlcpy (timstr1m, sh_unix_gmttime (p->theFile.mtime), 32);
    3184           sl_strlcpy (timstr2m, sh_unix_gmttime (theFile->mtime),   32);
     3180          (void) sh_unix_gmttime (p->theFile.mtime, timstr1m, sizeof(timstr1m));
     3181          (void) sh_unix_gmttime (theFile->mtime,   timstr2m, sizeof(timstr2m));
    31853182#ifdef SH_USE_XML
    31863183          sl_snprintf(tmp, SH_BUFSIZE, _("mtime_old=\"%s\" mtime_new=\"%s\" "),
     
    35793576
    35803577  if ('c' == p->theFile.c_mode[0] || 'b' == p->theFile.c_mode[0])
    3581     sl_snprintf(str, 80, "%"PRIu64, p->theFile.rdev);
    3582   else
    3583     sl_snprintf(str, 80, "%"PRIu64, p->theFile.size);
     3578    sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.rdev);
     3579  else
     3580    sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.size);
    35843581
    35853582  printf( _(" %8s"), str);
     
    35873584    putchar(',');
    35883585
    3589   printf( _(" %s"), sh_unix_gmttime (p->theFile.ctime));
     3586  printf( _(" %s"), sh_unix_gmttime (p->theFile.ctime, str, sizeof(str)));
    35903587  if (ListWithDelimiter == S_TRUE)
    35913588    putchar(',');
    3592   printf( _(" %s"), sh_unix_gmttime (p->theFile.mtime));
     3589  printf( _(" %s"), sh_unix_gmttime (p->theFile.mtime, str, sizeof(str)));
    35933590  if (ListWithDelimiter == S_TRUE)
    35943591    putchar(',');
    3595   printf( _(" %s"), sh_unix_gmttime (p->theFile.atime));
     3592  printf( _(" %s"), sh_unix_gmttime (p->theFile.atime, str, sizeof(str)));
    35963593  if (ListWithDelimiter == S_TRUE)
    35973594    putchar(',');
  • trunk/src/sh_kern.c

    r131 r132  
    12221222              if (mod_syscall_code != 0)
    12231223                {
    1224                   sl_strlcpy (timstr_o, sh_unix_gmttime (ctime_old), 32);
    1225                   sl_strlcpy (timstr_n, sh_unix_gmttime (ctime_new), 32);
     1224                  (void) sh_unix_gmttime (ctime_old, timstr_o, sizeof(timstr_o));
     1225                  (void) sh_unix_gmttime (ctime_new, timstr_n, sizeof(timstr_n));
    12261226#ifdef SH_USE_XML
    12271227                  sl_snprintf(tmp, 128,
     
    12341234#endif
    12351235                  sl_strlcat(msg, tmp, SH_BUFSIZE);
    1236                   sl_strlcpy (timstr_o, sh_unix_gmttime (mtime_old), 32);
    1237                   sl_strlcpy (timstr_n, sh_unix_gmttime (mtime_new), 32);
     1236                  (void) sh_unix_gmttime (mtime_old, timstr_o, sizeof(timstr_o));
     1237                  (void) sh_unix_gmttime (mtime_new, timstr_n, sizeof(timstr_n));
    12381238#ifdef SH_USE_XML
    12391239                  sl_snprintf(tmp, 128,
     
    16931693                  sl_strlcpy(msg, tmp, SH_BUFSIZE);
    16941694
    1695                   sl_strlcpy (timstr_o, sh_unix_gmttime (ctime_old), 32);
    1696                   sl_strlcpy (timstr_n, sh_unix_gmttime (ctime_new), 32);
     1695                  (void) sh_unix_gmttime (ctime_old, timstr_o, sizeof(timstr_o));
     1696                  (void) sh_unix_gmttime (ctime_new, timstr_n, sizeof(timstr_n));
    16971697#ifdef SH_USE_XML
    16981698                  sl_snprintf(tmp, 128,
     
    17051705#endif
    17061706                  sl_strlcat(msg, tmp, SH_BUFSIZE);
    1707                   sl_strlcpy (timstr_o, sh_unix_gmttime (mtime_old), 32);
    1708                   sl_strlcpy (timstr_n, sh_unix_gmttime (mtime_new), 32);
     1707                  (void) sh_unix_gmttime (mtime_old, timstr_o, sizeof(timstr_o));
     1708                  (void) sh_unix_gmttime (mtime_new, timstr_n, sizeof(timstr_n));
    17091709#ifdef SH_USE_XML
    17101710                  sl_snprintf(tmp, 128,
  • trunk/src/sh_mail.c

    r131 r132  
    810810    size_t    msgbufsize = SH_MAILBUF;
    811811    size_t    combufsize = SH_MAILBUF;
     812    char      timebuf[81];
    812813
    813814    SL_ENTER(_("sh_mail_msg"));
     
    887888      {
    888889        (void) sl_strlcpy(mheader, _("Subject: "),       sizeof(mheader)-5);
    889         (void) sl_strlcat(mheader, sh_unix_time (0),     sizeof(mheader)-5);
     890        (void) sl_strlcat(mheader, sh_unix_time (0, timebuf, sizeof(timebuf)),
     891                          sizeof(mheader)-5);
    890892        (void) sl_strlcat(mheader, " ",                  sizeof(mheader)-5);
    891893        (void) sl_strlcat(mheader, sh.host.name,         sizeof(mheader)-5);
     
    909911          {
    910912            (void) sl_strlcpy(mheader, _("Subject: "),     sizeof(mheader)-5);
    911             (void) sl_strlcat(mheader, sh_unix_time (0),   sizeof(mheader)-5);
     913            (void) sl_strlcat(mheader, sh_unix_time (0, timebuf, sizeof(timebuf)),
     914                              sizeof(mheader)-5);
    912915            (void) sl_strlcat(mheader, " ",                sizeof(mheader)-5);
    913916            (void) sl_strlcat(mheader, sh.host.name,       sizeof(mheader)-5);
     
    921924    /* ---------- Message  --------------------------------------- */
    922925
    923     (void) sl_strlcpy(subject, sh_unix_time (0),          sizeof(subject));
     926    (void) sl_strlcpy(subject, sh_unix_time (0, timebuf, sizeof(timebuf)),
     927                      sizeof(subject));
    924928    (void) sl_strlcat(subject, " ",                       sizeof(subject));
    925929    (void) sl_strlcat(subject, sh.host.name,              sizeof(subject));
     
    18851889  if (length < 1)
    18861890    {
     1891      char errbuf[SH_ERRBUF_SIZE];
     1892
    18871893      /* error handling
    18881894       */
     
    18971903          sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, status, MSG_E_SUBGEN,
    18981904                           (errno == ECONNREFUSED) ?
    1899                            sh_error_message (status) :
    1900                            sh_tools_errmessage(status),
     1905                           sh_error_message (status, errbuf, sizeof(errbuf)) :
     1906                           sh_tools_errmessage(status, errbuf, sizeof(errbuf)),
    19011907                           _("res_query"));
    19021908#else
    19031909          if (errno == ECONNREFUSED)
    1904             fprintf(stderr, " ERROR: %s: \n", strerror(errno));
     1910            fprintf(stderr, " ERROR: %s: \n", strerror(errno)); /* TESTONLY */
    19051911          else
    1906             fprintf(stderr, "HERROR: %s\n", hstrerror(h_errno));
     1912            fprintf(stderr, "HERROR: %s\n", hstrerror(h_errno));/* TESTONLY */
    19071913#endif
    19081914        }
  • trunk/src/sh_portcheck.c

    r131 r132  
    608608  int                nerr;
    609609#endif
     610  char errbuf[SH_ERRBUF_SIZE];
    610611
    611612  /* inet_aton(interface, &haddr); */
     
    627628      nerr = errno;
    628629      sl_snprintf(errmsg, sizeof(errmsg), _("check port: %5d/udp on %15s: %s"),
    629                   port, inet_ntoa(haddr), sh_error_message(errno));
     630                  port, inet_ntoa(haddr), sh_error_message(errno, errbuf, sizeof(errbuf)));
    630631      sh_error_handle((-1), FIL__, __LINE__, nerr, MSG_E_SUBGEN,
    631632                      errmsg, _("connect"));
     
    693694  int                nerr;
    694695#endif
    695 
     696  char errbuf[SH_ERRBUF_SIZE];
    696697
    697698  /* inet_aton(interface, &haddr); */
     
    719720      nerr = errno;
    720721      sl_snprintf(errmsg, sizeof(errmsg), _("check port: %5d/tcp on %15s: %s"),
    721                   port, inet_ntoa(haddr), sh_error_message(errno));
     722                  port, inet_ntoa(haddr), sh_error_message(errno, errbuf, sizeof(errbuf)));
    722723      sh_error_handle((-1), FIL__, __LINE__, nerr, MSG_E_SUBGEN,
    723724                      errmsg, _("connect"));
     
    889890  int              flag =  1; /* non-zero to enable an option */
    890891  struct in_addr   haddr;
    891  
     892  char errbuf[SH_ERRBUF_SIZE];
     893
    892894  /* Check all interfaces for this host
    893895   */
     
    901903#else
    902904          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    903                           sh_error_message(errno), _("socket"));
     905                          sh_error_message(errno, errbuf, sizeof(errbuf)), _("socket"));
    904906#endif
    905907        }
     
    912914#else
    913915          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    914                           sh_error_message(errno), _("setsockopt"));
     916                          sh_error_message(errno, errbuf, sizeof(errbuf)),_("setsockopt"));
    915917#endif
    916918        }
     
    957959  struct sockaddr_in addr;
    958960  int addrlen      = sizeof(addr);
     961  char errbuf[SH_ERRBUF_SIZE];
    959962
    960963  if (min_port == -1)
     
    973976#else
    974977          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    975                           sh_error_message(errno), _("socket"));
     978                          sh_error_message(errno, errbuf, sizeof(errbuf)), _("socket"));
    976979#endif
    977980        }
     
    984987#else
    985988          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    986                           sh_error_message(errno), _("setsockopt"));
     989                          sh_error_message(errno, errbuf, sizeof(errbuf)),_("setsockopt"));
    987990#endif
    988991        }
     
    10181021#else
    10191022              sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    1020                               sh_error_message(errno), _("bind"));
     1023                              sh_error_message(errno, errbuf, sizeof(errbuf)), _("bind"));
    10211024#endif
    10221025            }
  • trunk/src/sh_prelink.c

    r131 r132  
    179179  if (init == S_FALSE)
    180180    {
     181      char dir[SH_PATHBUF];
     182
    181183      sh_ext_tas_init(&task);
    182       p = sh_unix_getUIDdir (SH_ERR_ERR, task.run_user_uid);
     184      p = sh_unix_getUIDdir (SH_ERR_ERR, task.run_user_uid, dir, sizeof(dir));
    183185      if (p)
    184186        {
  • trunk/src/sh_processcheck.c

    r103 r132  
    185185static char * get_user_and_path (pid_t pid, char * user, size_t usrlen)
    186186{
    187   extern char *  sh_unix_getUIDname (int level, uid_t uid);
     187  extern char *  sh_unix_getUIDname (int level, uid_t uid, char * out, size_t len);
    188188
    189189  char        path[128];
     
    232232    }
    233233
    234   tmp = sh_unix_getUIDname (SH_ERR_ALL, sbuf.st_uid);
    235 
    236   if (tmp)
    237     sl_strlcpy(user, tmp, usrlen);
    238   else
     234  tmp = sh_unix_getUIDname (SH_ERR_ALL, sbuf.st_uid, user, usrlen);
     235
     236  if (!tmp)
    239237    sl_snprintf (user, usrlen, "%ld", (unsigned long) sbuf.st_uid);
    240238
     
    826824          else
    827825            {
     826              char errbuf[SH_ERRBUF_SIZE];
     827
    828828              sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, errno, MSG_E_SUBGEN,
    829                               sh_error_message(errno),
     829                              sh_error_message(errno, errbuf, sizeof(errbuf)),
    830830                              _("sh_processes_readps"));
    831831              break;
     
    951951  struct  sigaction  old_act;
    952952  int retval = 0;
     953  char  dir[SH_PATHBUF];
    953954
    954955  SL_ENTER(_("sh_processes_runps"));
    955956
    956957  sh_ext_tas_init(&task);
    957   p = sh_unix_getUIDdir (SH_ERR_ERR, task.run_user_uid);
     958  p = sh_unix_getUIDdir (SH_ERR_ERR, task.run_user_uid, dir, sizeof(dir));
    958959  if (p)
    959960    {
  • trunk/src/sh_socket.c

    r118 r132  
    342342#endif
    343343  struct stat buf;
     344  char errbuf[SH_ERRBUF_SIZE];
    344345 
    345346  SL_ENTER(_("sh_socket_open_int"));
     
    364365    {
    365366      sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    366                        sh_error_message (errno),
     367                       sh_error_message (errno, errbuf, sizeof(errbuf)),
    367368                       _("sh_socket_open_int: socket"));
    368369      SL_RETURN( (-1), _("sh_socket_open_int"));
     
    405406      close(pf_unix_fd); pf_unix_fd = -1;
    406407      sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    407                        sh_error_message (errno),
     408                       sh_error_message (errno, errbuf, sizeof(errbuf)),
    408409                       _("sh_socket_open_int: bind"));
    409410      SL_RETURN( (-1), _("sh_socket_open_int"));
     
    416417      close(pf_unix_fd); pf_unix_fd = -1;
    417418      sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    418                        sh_error_message (errno),
     419                       sh_error_message (errno, errbuf, sizeof(errbuf)),
    419420                       _("sh_socket_open_int: setsockopt"));
    420421      SL_RETURN( (-1), _("sh_socket_open_int"));
     
    427428      close(pf_unix_fd); pf_unix_fd = -1;
    428429      sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    429                        sh_error_message (errno),
     430                       sh_error_message (errno, errbuf, sizeof(errbuf)),
    430431                       _("sh_socket_open_int: fcntl1"));
    431432      SL_RETURN( (-1), _("sh_socket_open_int"));
     
    437438      close(pf_unix_fd); pf_unix_fd = -1;
    438439      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    439                       sh_error_message (errno),
     440                      sh_error_message (errno, errbuf, sizeof(errbuf)),
    440441                      _("sh_socket_open_int: fcntl2"));
    441442      SL_RETURN( (-1), _("sh_socket_open_int"));
     
    446447      close(pf_unix_fd); pf_unix_fd = -1;
    447448      sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    448                        sh_error_message (errno),
     449                       sh_error_message (errno, errbuf, sizeof(errbuf)),
    449450                       _("sh_socket_open_int: listen"));
    450451      SL_RETURN( (-1), _("sh_socket_open_int"));
     
    509510
    510511  int  client_uid = -1;
     512  char errbuf[SH_ERRBUF_SIZE];
    511513
    512514
     
    588590    {
    589591      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    590                       sh_error_message (errno),
     592                      sh_error_message (errno, errbuf, sizeof(errbuf)),
    591593                      _("sh_socket_read: accept"));
    592594      return -1;
     
    602604      {
    603605        sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    604                         sh_error_message (errno),
     606                        sh_error_message (errno, errbuf, sizeof(errbuf)),
    605607                        _("sh_socket_read: setsockopt"));
    606608        close(talkfd);
     
    615617      {
    616618        sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    617                         sh_error_message (errno),
     619                        sh_error_message (errno, errbuf, sizeof(errbuf)),
    618620                        _("sh_socket_read: recvmsg"));
    619621        close(talkfd); 
     
    644646        }
    645647      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    646                       sh_error_message (errno),
     648                      sh_error_message (errno, errbuf, sizeof(errbuf)),
    647649                      _("sh_socket_read: recvfrom"));
    648650      close(talkfd);
     
    654656    {
    655657      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    656                       sh_error_message (errno),
     658                      sh_error_message (errno, errbuf, sizeof(errbuf)),
    657659                      _("sh_socket_read: getpeereid"));
    658660      close(talkfd);
     
    665667    {
    666668      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    667                       sh_error_message (errno),
     669                      sh_error_message (errno, errbuf, sizeof(errbuf)),
    668670                      _("sh_socket_read: getsockopt"));
    669671      close(talkfd);
     
    843845    {
    844846      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    845                       sh_error_message (errno),
     847                      sh_error_message (errno, errbuf, sizeof(errbuf)),
    846848                      _("sh_socket_read: send"));
    847849      return -1;
     
    876878            {
    877879              sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    878                               sh_error_message (errno),
     880                              sh_error_message (errno, errbuf, sizeof(errbuf)),
    879881                              _("sh_socket_read: sendto"));
    880882              close(talkfd);
     
    907909        {
    908910          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    909                           sh_error_message (errno),
     911                          sh_error_message (errno, errbuf, sizeof(errbuf)),
    910912                          _("sh_socket_read: sendto"));
    911913          close(talkfd);
     
    933935  sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
    934936  sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
    935   sl_strlcpy (new->cti, sh_unix_time(0), sizeof(new->cti));
     937  (void) sh_unix_time(0, new->cti, sizeof(new->cti));
    936938  new->next = cmdlist;
    937939  cmdlist   = new;
     
    951953          sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
    952954          sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
    953           sl_strlcpy (new->cti, sh_unix_time(0), sizeof(new->cti));
     955          (void) sh_unix_time(0, new->cti, sizeof(new->cti));
    954956          return;
    955957        }
     
    960962  sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
    961963  sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
    962   sl_strlcpy (new->cti, sh_unix_time(0), sizeof(new->cti));
     964  (void) sh_unix_time(0, new->cti, sizeof(new->cti));
    963965  new->next = runlist;
    964966  runlist   = new;
  • trunk/src/sh_suidchk.c

    r131 r132  
    173173  struct stat two;
    174174  int         fd;
     175  char errbuf[SH_ERRBUF_SIZE];
    175176
    176177  if (depth > 99)
     
    198199          sh_error_handle ((-1), FIL__, __LINE__, errno,
    199200                           MSG_SUID_ERROR,
    200                            sh_error_message(errno));
     201                           sh_error_message(errno, errbuf, sizeof(errbuf)));
    201202          *q = '/';
    202203          return -1;
     
    217218          sh_error_handle ((-1), FIL__, __LINE__, errno,
    218219                           MSG_SUID_ERROR,
    219                            sh_error_message(errno));
     220                           sh_error_message(errno, errbuf, sizeof(errbuf)));
    220221          *q = '/';
    221222          return -1;
     
    226227          sh_error_handle ((-1), FIL__, __LINE__, errno,
    227228                           MSG_SUID_ERROR,
    228                            sh_error_message(errno));
     229                           sh_error_message(errno, errbuf, sizeof(errbuf)));
    229230          return -1;
    230231        }
     
    252253          sh_error_handle ((-1), FIL__, __LINE__, errno,
    253254                           MSG_SUID_ERROR,
    254                            sh_error_message(errno));
     255                           sh_error_message(errno, errbuf, sizeof(errbuf)));
    255256          return -1;
    256257        }
     
    260261          sh_error_handle ((-1), FIL__, __LINE__, errno,
    261262                           MSG_SUID_ERROR,
    262                            sh_error_message(errno));
     263                           sh_error_message(errno, errbuf, sizeof(errbuf)));
    263264          return -1;
    264265        }
     
    267268          sh_error_handle ((-1), FIL__, __LINE__, errno,
    268269                           MSG_SUID_ERROR,
    269                            sh_error_message(errno));
     270                           sh_error_message(errno, errbuf, sizeof(errbuf)));
    270271          (void) close(fd);
    271272          return -1;
     
    307308              sh_error_handle ((-1), FIL__, __LINE__, errno,
    308309                               MSG_SUID_ERROR,
    309                                sh_error_message(errno));
     310                               sh_error_message(errno, errbuf, sizeof(errbuf)));
    310311              (void) close(fd);
    311312              return -1;
     
    332333              sh_error_handle ((-1), FIL__, __LINE__, errno,
    333334                               MSG_SUID_ERROR,
    334                                sh_error_message(errno));
     335                               sh_error_message(errno, errbuf, sizeof(errbuf)));
    335336              (void) close(fd);
    336337              return -1;
     
    343344              sh_error_handle ((-1), FIL__, __LINE__, errno,
    344345                               MSG_SUID_ERROR,
    345                                sh_error_message(errno));
     346                               sh_error_message(errno, errbuf, sizeof(errbuf)));
    346347              (void) close(fd);
    347348              return -1;
     
    358359  int    result;
    359360  char * path;
     361  char errbuf[SH_ERRBUF_SIZE];
    360362
    361363  if (0 != chdir("/"))
     
    363365      sh_error_handle ((-1), FIL__, __LINE__, errno,
    364366                       MSG_SUID_ERROR,
    365                        sh_error_message(errno));
     367                       sh_error_message(errno, errbuf, sizeof(errbuf)));
    366368    }
    367369
     
    369371    {
    370372      sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
    371                       sh_error_message (caperr),
     373                      sh_error_message (caperr, errbuf, sizeof(errbuf)),
    372374                      _("sl_get_cap_qdel"));
    373375    }
     
    380382    {
    381383      sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
    382                       sh_error_message (caperr),
     384                      sh_error_message (caperr, errbuf, sizeof(errbuf)),
    383385                      _("sl_drop_cap_qdel"));
    384386    }
     
    388390      sh_error_handle ((-1), FIL__, __LINE__, errno,
    389391                       MSG_SUID_ERROR,
    390                        sh_error_message(errno));
     392                       sh_error_message(errno, errbuf, sizeof(errbuf)));
    391393    }
    392394  return result;
     
    616618  int             cperm_status = 0;
    617619  int             file_d       = -1;
     620  char errbuf[SH_ERRBUF_SIZE];
    618621
    619622  if (retry_lstat(FIL__, __LINE__, fullpath, &fileInfo) == -1)
     
    640643          sh_error_handle((-1), FIL__, __LINE__,
    641644                          caperr, MSG_E_SUBGEN,
    642                           sh_error_message (caperr),
     645                          sh_error_message (caperr, errbuf, sizeof(errbuf)),
    643646                          _("sl_get_cap_qdel"));
    644647          cperm_status = -1;
     
    753756      sh_error_handle((-1), FIL__, __LINE__,
    754757                      caperr, MSG_E_SUBGEN,
    755                       sh_error_message (caperr),
     758                      sh_error_message (caperr, errbuf, sizeof(errbuf)),
    756759                      _("sl_drop_cap_qdel"));
    757760    }
     
    792795  msg[0] = '\0';
    793796  /*@-usedef@*/
    794   (void) sl_strlcpy (timestrc,
    795                      sh_unix_gmttime (theFile->ctime),
    796                      32);
    797   (void) sl_strlcpy (timestra,
    798                      sh_unix_gmttime (theFile->atime),
    799                      32);
    800   (void) sl_strlcpy (timestrm,
    801                      sh_unix_gmttime (theFile->mtime),
    802                      32);
     797
    803798#ifdef SH_USE_XML
    804799  (void) sl_snprintf(msg, SH_BUFSIZE, _("owner_new=\"%s\" iowner_new=\"%ld\" group_new=\"%s\" igroup_new=\"%ld\" size_new=\"%lu\" ctime_new=\"%s\" atime_new=\"%s\" mtime_new=\"%s\""),
     
    845840  struct sh_dirent * dirlist = NULL;
    846841  struct sh_dirent * dirlist_orig = NULL;
     842  char errbuf[SH_ERRBUF_SIZE];
    847843
    848844  SL_ENTER(_("sh_suidchk_check_internal"));
     
    866862      sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, status,
    867863                       MSG_E_OPENDIR,
    868                        sh_error_message (status), tmp);
     864                       sh_error_message (status, errbuf, sizeof(errbuf)), tmp);
    869865      SH_FREE(tmp);
    870866      SL_RETURN( (-1), _("sh_suidchk_check_internal"));
     
    961957        tmp = sh_util_safe_name(tmpcat);
    962958        sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, status, MSG_ERR_LSTAT,
    963                          sh_error_message(status),
     959                         sh_error_message(status, errbuf, sizeof(errbuf)),
    964960                         tmpcat );
    965961        SH_FREE(tmp);
     
    10831079                      {
    10841080                        if (-1 == fflags)
    1085                           report_file(tmpcat, &theFile, timestrc, timestra, timestrm);
    1086                        
     1081                          {
     1082                            (void) sh_unix_gmttime (theFile->ctime, timestrc, sizeof(timestrc));
     1083                            (void) sh_unix_gmttime (theFile->atime, timestra, sizeof(timestra));
     1084                            (void) sh_unix_gmttime (theFile->mtime, timestrm, sizeof(timestrm));
     1085
     1086                            report_file(tmpcat, &theFile, timestrc, timestra, timestrm);
     1087                          }
    10871088                        /* Quarantine file according to configured method
    10881089                         */
  • trunk/src/sh_tools.c

    r81 r132  
    9494#ifdef SH_ENCRYPT
    9595#include "rijndael-api-fst.h"
    96 char * errorExplain (int err_num)
    97 {
     96char * errorExplain (int err_num, char * buffer, size_t len)
     97{
     98  char * p;
     99
    98100  if      (err_num == BAD_KEY_DIR)
    99     return (_("Key direction is invalid"));
     101    p = (_("Key direction is invalid"));
    100102  else if (err_num == BAD_KEY_MAT)
    101     return (_("Key material not of correct length"));
     103    p = (_("Key material not of correct length"));
    102104  else if (err_num == BAD_KEY_INSTANCE)
    103     return (_("Key passed is not valid"));
     105    p = (_("Key passed is not valid"));
    104106  else if (err_num == BAD_CIPHER_MODE)
    105     return (_("Params struct passed to cipherInit invalid"));
     107    p = (_("Params struct passed to cipherInit invalid"));
    106108  else if (err_num == BAD_CIPHER_STATE)
    107     return (_("Cipher in wrong state"));
     109    p = (_("Cipher in wrong state"));
    108110  else if (err_num == BAD_BLOCK_LENGTH)
    109     return (_("Bad block length"));
     111    p = (_("Bad block length"));
    110112  else if (err_num == BAD_CIPHER_INSTANCE)
    111     return (_("Bad cipher instance"));
     113    p = (_("Bad cipher instance"));
    112114  else if (err_num == BAD_DATA)
    113     return (_("Data contents are invalid"));
     115    p = (_("Data contents are invalid"));
    114116  else 
    115     return (_("Unknown error"));
     117    p = (_("Unknown error"));
     118  sl_strlcpy (buffer, p, len);
     119  return buffer;
    116120}
    117121
     
    361365/* extern int h_errno; */
    362366
    363 char * sh_tools_errmessage (int tellme)
    364 {
    365 
     367char * sh_tools_errmessage (int tellme, char * errbuf, size_t len)
     368{
     369  char * p = NULL;
    366370#ifdef HOST_NOT_FOUND
    367371    if (tellme == HOST_NOT_FOUND) 
    368       return _("The specified host is unknown: ");
     372      p = _("The specified host is unknown: ");
    369373#endif
    370374#ifdef NO_ADDRESS
    371375    if (tellme == NO_ADDRESS) 
    372       return _("The requested name is valid but does not have an IP address: ");
     376      p = _("The requested name is valid but does not have an IP address: ");
    373377#endif
    374378#ifdef NO_RECOVERY
    375379    if (tellme == NO_RECOVERY) 
    376       return _("A non-recoverable name server error occurred: ");
     380      p = _("A non-recoverable name server error occurred: ");
    377381#endif
    378382#ifdef TRY_AGAIN
    379383    if (tellme == TRY_AGAIN) 
    380       return _("A temporary error occurred on an authoritative name server. The specified host is unknown: ");
    381 #endif
    382     return _("Unknown error");
     384      p = _("A temporary error occurred on an authoritative name server. The specified host is unknown: ");
     385#endif
     386    if (!p) p =  _("Unknown error");
     387    sl_strlcpy(errbuf, p, len);
     388    return errbuf;
    383389}
    384390
     
    474480
    475481  int    retval;
     482  char   errbuf[SH_ERRBUF_SIZE];
    476483
    477484  sin_cache * check_cache = conn_cache;
     
    525532              *errnum = 666;
    526533#endif
    527               sl_strlcpy(errmsg, sh_tools_errmessage (*errnum), errsiz);
     534              (void) sh_tools_errmessage (*errnum, errmsg, errsiz);
    528535              sl_strlcat(errmsg, address, errsiz);
    529536              fail = (-1);
     
    561568                      *errnum = 666;
    562569#endif
    563                       sl_strlcpy(errmsg,
    564                                  sh_tools_errmessage (*errnum), errsiz);
     570                      (void) sh_tools_errmessage (*errnum, errmsg, errsiz);
    565571                      sl_strlcat(errmsg,
    566572                                 inet_ntoa (*(struct in_addr *) &(sinr.sin_addr)),
     
    637643        sl_strlcpy(ecall, _("socket"), SH_MINIBUF);
    638644        *errnum = status;
    639         sl_strlcpy(errmsg, sh_error_message (status), errsiz);
     645        sl_strlcpy(errmsg, sh_error_message (status, errbuf, sizeof(errbuf)), errsiz);
    640646        sl_strlcat(errmsg, _(", address "), errsiz);
    641647        sl_strlcat(errmsg, address, errsiz);
     
    651657        sl_strlcpy(ecall, _("connect"), SH_MINIBUF);
    652658        *errnum = status;
    653         sl_strlcpy(errmsg, sh_error_message (status), errsiz);
     659        sl_strlcpy(errmsg, sh_error_message (status, errbuf, sizeof(errbuf)), errsiz);
    654660        sl_strlcat(errmsg, _(", address "), errsiz);
    655661        sl_strlcat(errmsg, address, errsiz);
     
    715721  struct  sigaction  new_act;
    716722  struct  sigaction  old_act;
     723  char    errbuf[SH_ERRBUF_SIZE];
    717724
    718725  SL_ENTER(_("sh_write_select"));
     
    753760            *w_error = errno;
    754761            TPT(( 0, FIL__, __LINE__, _("msg=<select: %s>\n"),
    755                   sh_error_message(*w_error)));
     762                  sh_error_message(*w_error, errbuf, sizeof(errbuf))));
    756763            sigaction (SIGPIPE, &old_act, NULL);
    757764            SL_RETURN( countbytes, _("sh_write_select"));
     
    771778            *w_error = errno;
    772779            TPT(( 0, FIL__, __LINE__, _("msg=<select: %s>\n"),
    773                   sh_error_message(*w_error)));
     780                  sh_error_message(*w_error, errbuf, sizeof(errbuf))));
    774781            sigaction (SIGPIPE, &old_act, NULL);
    775782            SL_RETURN( countbytes, _("sh_write_select"));
     
    853860{
    854861  unsigned long bytes;
    855   char errmsg[256];
    856862
    857863  SL_ENTER(_("write_port"));
     
    860866  if (*w_error != 0)
    861867    {
    862       sl_strlcpy(errmsg, sh_error_message (*w_error), sizeof(errmsg));
     868      char errbuf[SH_ERRBUF_SIZE];
    863869      sh_error_handle((-1), FIL__, __LINE__, *w_error, MSG_TCP_NETRP,
    864                       errmsg, (long) sockfd, _("write_port"));
     870                      sh_error_message (*w_error, errbuf, sizeof(errbuf)),
     871                      (long) sockfd, _("write_port"));
    865872    }
    866873  SL_RETURN( bytes, _("write_port"));
     
    874881{
    875882  unsigned long bytes;
    876   char errmsg[256];
    877883
    878884  SL_ENTER(_("read_port"));
     
    881887  if (*w_error != 0)
    882888    {
    883       sl_strlcpy(errmsg, sh_error_message (*w_error), sizeof(errmsg));
     889      char errbuf[SH_ERRBUF_SIZE];
    884890      sh_error_handle((-1), FIL__, __LINE__, *w_error, MSG_TCP_NETRP,
    885                       errmsg, (long) sockfd, _("read_port"));
     891                      sh_error_message (*w_error, errbuf, sizeof(errbuf)),
     892                      (long) sockfd, _("read_port"));
    886893    }
    887894  SL_RETURN( bytes, _("read_port"));
     
    12161223  if (err_num < 0)
    12171224    {
     1225      char expbuf[SH_ERRBUF_SIZE];
    12181226      sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    1219                       errorExplain(err_num),
     1227                      errorExplain(err_num, expbuf, sizeof(expbuf)),
    12201228                      _("sh_tools_makePack: cipherInit"));
    12211229    }
     
    12271235      if (err_num < 0)
    12281236        {
     1237          char expbuf[SH_ERRBUF_SIZE];
    12291238          sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    1230                           errorExplain(err_num),
     1239                          errorExplain(err_num, expbuf, sizeof(expbuf)),
    12311240                          _("sh_tools_makePack: blockEncrypt"));
    12321241        }
     
    12551264  int                     err_num;
    12561265  int                     blkfac;
     1266  char expbuf[SH_ERRBUF_SIZE];
    12571267
    12581268  msg_size = (256 * (unsigned int)header[1] + (unsigned int)header[2]);
     
    12741284    {
    12751285      sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    1276                       errorExplain(err_num),
     1286                      errorExplain(err_num, expbuf, sizeof(expbuf)),
    12771287                      _("sh_tools_revertPack: cipherInit"));
    12781288    }
     
    12851295        {
    12861296          sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    1287                           errorExplain(err_num),
     1297                          errorExplain(err_num, expbuf, sizeof(expbuf)),
    12881298                          _("sh_tools_revertPack: blockDecrypt"));
    12891299        }
  • trunk/src/sh_unix.c

    r131 r132  
    797797#endif
    798798#ifdef SIGPIPE
     799#ifdef HAVE_PTHREAD
     800  retry_sigaction(FIL__, __LINE__, SIGPIPE,   &ignact, &oldact);
     801#else
    799802  retry_sigaction(FIL__, __LINE__, SIGPIPE,      &act, &oldact);
     803#endif
    800804#endif
    801805#ifdef SIGALRM
     
    11811185
    11821186#ifdef HAVE_INITGROUPS
    1183 char *  sh_unix_getUIDname (int level, uid_t uid);
     1187char *  sh_unix_getUIDname (int level, uid_t uid, char * out, size_t len);
    11841188int  sh_unix_initgroups2 (uid_t in_pid, gid_t in_gid)
    11851189{
    11861190  int status  = -1;
    1187   char * user = NULL;
     1191  char user[SH_MINIBUF];
    11881192
    11891193  SL_ENTER(_("sh_unix_initgroups2"));
    11901194
    1191   user = sh_unix_getUIDname (SH_ERR_ERR, in_pid);
    1192   if (user == NULL)
     1195  if (NULL == sh_unix_getUIDname (SH_ERR_ERR, in_pid, user, sizeof(user)))
    11931196    SL_RETURN((-1), _("sh_unix_initgroups2"));
    11941197  status = sh_initgroups (user, in_gid);
     
    14811484      if ((test == -1) && (errno != EINVAL))
    14821485        {
     1486          char errbuf[SH_ERRBUF_SIZE];
    14831487          status = errno;
    14841488          sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_SIG,
    1485                            sh_error_message (status), sig_num);
     1489                           sh_error_message (status, errbuf, sizeof(errbuf)), sig_num);
    14861490        }
    14871491    }
     
    17341738      if ( (-1) == status )
    17351739        {
     1740          char errbuf[SH_ERRBUF_SIZE];
    17361741          status = errno;
    17371742          sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_CHDIR,
    1738                            sh_error_message (status), chroot_dir);
     1743                           sh_error_message (status, errbuf, sizeof(errbuf)), chroot_dir);
    17391744          aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    17401745        }
     
    17791784{
    17801785  int    res = 0;
    1781 
     1786 
    17821787  SL_ENTER(_("sh_unix_setnodeamon"));
    17831788
     
    18041809  extern int sh_socket_open_int ();
    18051810#endif
     1811  char errbuf[SH_ERRBUF_SIZE];
    18061812
    18071813  SL_ENTER(_("sh_unix_init"));
     
    18491855      status = errno;
    18501856      sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_CHDIR,
    1851                        sh_error_message (status), "/");
     1857                       sh_error_message (status, errbuf, sizeof(errbuf)), "/");
    18521858      aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    18531859    }
     
    18971903          status = errno;
    18981904          sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
    1899                           sh_error_message(status), _("open"));
     1905                          sh_error_message(status, errbuf, sizeof(errbuf)), _("open"));
    19001906          aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    19011907        }
     
    19091915          status = errno;
    19101916          sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
    1911                           sh_error_message(status), _("dup"));
     1917                          sh_error_message(status, errbuf, sizeof(errbuf)), _("dup"));
    19121918          aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    19131919        }
     
    19621968      status = errno;
    19631969      sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
    1964                           sh_error_message(status), _("chroot"));
     1970                          sh_error_message(status, errbuf, sizeof(errbuf)), _("chroot"));
    19651971      aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    19661972    }
     
    20952101#endif
    20962102
    2097 char * sh_unix_time (time_t thetime)
     2103char * sh_unix_time (time_t thetime, char * buffer, size_t len)
    20982104{
    20992105
    21002106  int           status;
    2101 
     2107  char          AsciiTime[81];                       /* local time   */
    21022108  time_t        time_now;
    21032109  struct tm   * time_ptr;
     
    21052111  struct tm     time_tm;
    21062112#endif
    2107   static char   AsciiTime[81];                       /* local time   */
    2108   static char   RetTime[81];                         /* local time   */
    21092113#ifdef SH_USE_XML
    21102114  static char   deftime[] = N_("0000-00-00T00:00:00"); /* default time */
     
    22022206#endif
    22032207
    2204   if (time_now == (-1) )
    2205     SL_RETURN( _(deftime), _("sh_unix_time"));
     2208  if (time_now == (-1) )
     2209    {
     2210      sl_strlcpy(buffer, _(deftime), len);
     2211      SL_RETURN(buffer, _("sh_unix_time"));
     2212    }
    22062213  else
    22072214    {
     
    22142221  if (time_ptr != NULL)
    22152222    {
    2216       status = strftime (AsciiTime, 80,
     2223      status = strftime (AsciiTime, sizeof(AsciiTime),
    22172224#ifdef SH_USE_XML
    22182225                         _("%Y-%m-%dT%H:%M:%S%%s"),
     
    22222229                         time_ptr);
    22232230
    2224       sl_snprintf(RetTime, 80, AsciiTime, t_zone(&time_now));
    2225 
    2226       if ( (status == 0) || (status == 80) )
    2227         SL_RETURN( _(deftime), _("sh_unix_time"));
     2231      sl_snprintf(buffer, len, AsciiTime, t_zone(&time_now));
     2232
     2233      if ( (status == 0) || (status == sizeof(AsciiTime)) )
     2234        {
     2235          sl_strlcpy(buffer, _(deftime), len);
     2236          SL_RETURN( buffer, _("sh_unix_time"));
     2237        }
    22282238      else
    2229         SL_RETURN( &RetTime[0], _("sh_unix_time"));
     2239        {
     2240          SL_RETURN(buffer, _("sh_unix_time"));
     2241        }
    22302242    }
    22312243
    22322244  /* last resort
    22332245   */
    2234   SL_RETURN( _(deftime), _("sh_unix_time"));
     2246  sl_strlcpy(buffer, _(deftime), len);
     2247  SL_RETURN( buffer, _("sh_unix_time"));
    22352248}
    22362249
     
    22482261}
    22492262   
    2250 char * sh_unix_gmttime (time_t thetime)
     2263char * sh_unix_gmttime (time_t thetime, char * buffer, size_t len)
    22512264{
    22522265
     
    22572270  struct tm     time_tm;
    22582271#endif
    2259   static char   AsciiTime[81];                       /* GMT time   */
     2272  char   AsciiTime[81];                       /* GMT time   */
    22602273#ifdef SH_USE_XML
    22612274  static char   deftime[] = N_("0000-00-00T00:00:00"); /* default time */
     
    22922305                         time_ptr);
    22932306
    2294       if ( (status == 0) || (status == 80) ) 
    2295         SL_RETURN( _(deftime), _("sh_unix_gmttime"));
     2307      if ( (status == 0) || (status == 80) )
     2308        sl_strlcpy(buffer, _(deftime), len);
    22962309      else
    2297         SL_RETURN( &AsciiTime[0], _("sh_unix_gmttime"));
     2310        sl_strlcpy(buffer, AsciiTime, len);
     2311      SL_RETURN( buffer, _("sh_unix_gmttime"));
    22982312    }
    22992313
    23002314  /* last resort
    23012315   */
    2302   SL_RETURN( _(deftime), _("sh_unix_gmttime"));
    2303 }
    2304 
    2305 
    2306 
    2307 char *  sh_unix_getUIDdir (int level, uid_t uid)
     2316  sl_strlcpy(buffer, _(deftime), len);
     2317  SL_RETURN( buffer, _("sh_unix_gmttime"));
     2318}
     2319
     2320
     2321char *  sh_unix_getUIDdir (int level, uid_t uid, char * out, size_t len)
    23082322{
    23092323  struct passwd * tempres;
     
    23132327  char   buffer[SH_PWBUF_SIZE];
    23142328#endif
     2329  char errbuf[SH_ERRBUF_SIZE];
    23152330
    23162331  SL_ENTER(_("sh_unix_getUIDdir"));
     
    23262341  if (tempres == NULL) {
    23272342    sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
    2328                      sh_error_message(status),
     2343                     sh_error_message(status, errbuf, sizeof(errbuf)),
    23292344                     _("getpwuid"), (long) uid, _("completely missing"));
    23302345    SL_RETURN( NULL, _("sh_unix_getUIDdir"));
     
    23322347
    23332348  if (tempres->pw_dir != NULL) {
    2334     SL_RETURN( tempres->pw_dir, _("sh_unix_getUIDdir"));
     2349    sl_strlcpy(out, tempres->pw_dir, len);
     2350    SL_RETURN( out, _("sh_unix_getUIDdir"));
    23352351  } else {
    23362352    sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
    2337                      sh_error_message(status),
     2353                     sh_error_message(status, errbuf, sizeof(errbuf)),
    23382354                     _("getpwuid"), (long) uid, _("pw_dir"));
    23392355    SL_RETURN( NULL, _("sh_unix_getUIDdir"));
     
    23412357}
    23422358
    2343 char *  sh_unix_getUIDname (int level, uid_t uid)
     2359SH_MUTEX_STATIC(getUIDname, PTHREAD_MUTEX_INITIALIZER);
     2360
     2361char *  sh_unix_getUIDname (int level, uid_t uid, char * out, size_t len)
    23442362{
    23452363  struct passwd * tempres;
     
    23512369  static uid_t    old_uid;
    23522370  static char     name[32] = { '\0' };
     2371  char errbuf[SH_ERRBUF_SIZE];
    23532372
    23542373  SL_ENTER(_("sh_unix_getUIDname"));
    23552374
    23562375  if ((uid == old_uid) && (name[0] != '\0')) {
    2357     SL_RETURN( name, _("sh_unix_getUIDname"));
     2376    out[0] = '\0';
     2377    SH_MUTEX_LOCK_UNSAFE(getUIDname);
     2378    if ((uid == old_uid) && (name[0] != '\0')) {
     2379      sl_strlcpy(out, name, len);
     2380    }
     2381    SH_MUTEX_UNLOCK_UNSAFE(getUIDname);
     2382    if (out[0] != '\0')
     2383      SL_RETURN( out, _("sh_unix_getUIDname"));
    23582384  }
    23592385
     
    23682394  if (tempres == NULL) {
    23692395    sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
    2370                      sh_error_message(status),
     2396                     sh_error_message(status, errbuf, sizeof(errbuf)),
    23712397                     _("getpwuid"), (long) uid, _("completely missing"));
    23722398    SL_RETURN( NULL, _("sh_unix_getUIDname"));
     
    23752401
    23762402  if (tempres->pw_name != NULL) {
    2377     /* NEED_LOCK */
     2403    SH_MUTEX_LOCK_UNSAFE(getUIDname);
    23782404    sl_strlcpy(name, tempres->pw_name, sizeof(name));
    23792405    old_uid = uid;
    2380     /* END_LOCK  */
    2381     SL_RETURN( name, _("sh_unix_getUIDname"));
     2406    sl_strlcpy(out, name, len);
     2407    SH_MUTEX_UNLOCK_UNSAFE(getUIDname);
     2408    SL_RETURN( out, _("sh_unix_getUIDname"));
    23822409  } else {
    23832410    sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
    2384                      sh_error_message(status),
     2411                     sh_error_message(status, errbuf, sizeof(errbuf)),
    23852412                     _("getpwuid"), (long) uid, _("pw_user"));
    23862413    SL_RETURN( NULL, _("sh_unix_getUIDname"));
     
    23882415}
    23892416
    2390 char *  sh_unix_getGIDname (int level, gid_t gid)
     2417SH_MUTEX_STATIC(getGIDname, PTHREAD_MUTEX_INITIALIZER);
     2418
     2419char *  sh_unix_getGIDname (int level, gid_t gid, char * out, size_t len)
    23912420{
    23922421  struct group  * tempres;
     
    23982427  char            buffer[SH_GRBUF_SIZE];
    23992428#endif
     2429  char errbuf[SH_ERRBUF_SIZE];
    24002430 
    24012431
     
    24032433
    24042434  if ((gid == old_gid) && (name[0] != '\0')) {
    2405     SL_RETURN( name, _("sh_unix_getUIDname"));
     2435    out[0] = '\0';
     2436    SH_MUTEX_LOCK_UNSAFE(getGIDname);
     2437    if ((gid == old_gid) && (name[0] != '\0')) {
     2438      sl_strlcpy(out, name, len);
     2439    }
     2440    SH_MUTEX_UNLOCK_UNSAFE(getGIDname);
     2441    if (out[0] != '\0')
     2442      SL_RETURN( out, _("sh_unix_getGIDname"));
    24062443  }
    2407  
     2444
    24082445#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
    24092446  status = sh_getgrgid_r(gid, &grp, buffer, sizeof(buffer), &tempres);
     
    24162453  if (tempres == NULL) {
    24172454    sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
    2418                      sh_error_message(status),
     2455                     sh_error_message(status, errbuf, sizeof(errbuf)),
    24192456                     _("getgrgid"), (long) gid, _("completely missing"));
    24202457     
     
    24222459  }
    24232460
     2461  /* FIXME: need to return caller-supplied buffer */
    24242462  if (tempres->gr_name != NULL) {
    2425     /* NEED_LOCK */
     2463    SH_MUTEX_LOCK_UNSAFE(getGIDname);
    24262464    sl_strlcpy(name, tempres->gr_name, sizeof(name));
    24272465    old_gid = gid;
    2428     /* END_LOCK  */
    2429     SL_RETURN( name, _("sh_unix_getGIDname"));
     2466    sl_strlcpy(out, name, len);
     2467    SH_MUTEX_UNLOCK_UNSAFE(getGIDname);
     2468    SL_RETURN( out, _("sh_unix_getGIDname"));
    24302469  } else {
    24312470    sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
    2432                      sh_error_message(status),
     2471                     sh_error_message(status, errbuf, sizeof(errbuf)),
    24332472                     _("getgrgid"), (long) gid, _("gr_name"));
    24342473    SL_RETURN( NULL, _("sh_unix_getGIDname"));
     
    24402479  char          * p;
    24412480  uid_t  seuid, sruid;
     2481  char   user[USER_MAX];
     2482  char   dir[SH_PATHBUF];
    24422483
    24432484  SL_ENTER(_("sh_unix_getUser"));
     
    24472488  sh.effective.uid = seuid;
    24482489
    2449   p = sh_unix_getUIDdir (SH_ERR_ERR, seuid);
     2490  p = sh_unix_getUIDdir (SH_ERR_ERR, seuid, dir, sizeof(dir));
    24502491
    24512492  if (p == NULL)
     
    24662507  sh.real.uid = sruid;
    24672508
    2468   p = sh_unix_getUIDname (SH_ERR_ERR, sruid);
     2509  p = sh_unix_getUIDname (SH_ERR_ERR, sruid, user, sizeof(user));
    24692510  if (p == NULL)
    24702511    SL_RETURN((-1), _("sh_unix_getUser"));
     
    24802521    }
    24812522
    2482   p = sh_unix_getUIDdir (SH_ERR_ERR, sruid);
     2523  p = sh_unix_getUIDdir (SH_ERR_ERR, sruid, dir, sizeof(dir));
    24832524
    24842525  if (p == NULL)
     
    32703311        {
    32713312          if (S_FALSE == sh_ignore_chk_del(theFile->fullpath)) {
     3313            char errbuf[SH_ERRBUF_SIZE];
    32723314            tmp2 = sh_util_safe_name (theFile->fullpath);
    32733315            sh_error_handle (level, FIL__, __LINE__, stat_return, MSG_FI_LSTAT,
    3274                              sh_error_message (stat_return), tmp2);
     3316                             sh_error_message (stat_return, errbuf, sizeof(errbuf)),
     3317                             tmp2);
    32753318            SH_FREE(tmp2);
    32763319          }
     
    34653508   */
    34663509
    3467   if ( (name = sh_unix_getGIDname(SH_ERR_ALL,
    3468                                   buf.st_gid)) != NULL) {
    3469     sl_strlcpy (theFile->c_group, name, GROUP_MAX+1);
    3470   } else {
     3510  if (NULL == sh_unix_getGIDname(SH_ERR_ALL, buf.st_gid, theFile->c_group, GROUP_MAX+1)) {
    34713511
    34723512    tmp2 = sh_util_safe_name (theFile->fullpath);
     
    34893529
    34903530 
    3491   if ( (name = sh_unix_getUIDname(SH_ERR_ALL,
    3492                                   buf.st_uid)) != NULL) {
    3493     sl_strlcpy (theFile->c_owner, name, USER_MAX+1);
    3494   } else {
     3531  if (NULL == sh_unix_getUIDname(SH_ERR_ALL, buf.st_uid, theFile->c_owner, USER_MAX+)) {
    34953532
    34963533    tmp2 = sh_util_safe_name (theFile->fullpath);
     
    35183555      tmp2 = sh_util_safe_name ((filename == NULL) ?
    35193556                                theFile->fullpath : filename);
    3520       sl_strlcpy(timestr, sh_unix_time(theFile->mtime), 81);
     3557      (void) sh_unix_time(theFile->mtime, timestr, sizeof(timestring));
    35213558      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_LIST,
    35223559                       theFile->c_mode,
     
    35473584      if (linksize < 0)
    35483585        {
     3586          char errbuf[SH_ERRBUF_SIZE];
    35493587          linksize = errno;
    35503588          tmp2 = sh_util_safe_name (theFile->fullpath);
    35513589          sh_error_handle (level, FIL__, __LINE__, linksize, MSG_FI_RDLNK,
    3552                            sh_error_message (linksize), tmp2);
     3590                           sh_error_message (linksize, errbuf, sizeof(errbuf)), tmp2);
    35533591          SH_FREE(tmp2);
    35543592          SH_FREE(linknamebuf);
     
    35983636        if (stat_return != ENOENT)
    35993637          {
     3638            char errbuf[SH_ERRBUF_SIZE];
    36003639            sh_error_handle (level, FIL__, __LINE__, stat_return,
    36013640                             MSG_FI_LSTAT,
    3602                              sh_error_message (stat_return), tmp2);
     3641                             sh_error_message (stat_return,errbuf, sizeof(errbuf)),
     3642                             tmp2);
    36033643          }
    36043644        else
     
    38733913  else if (flag != NULL)
    38743914    {
     3915      char errbuf[SH_ERRBUF_SIZE];
    38753916      error = errno;
    38763917      sh_error_handle ((-1), FIL__, __LINE__, error, MSG_E_UNLNK,
    3877                        sh_error_message(error), lockfile);
     3918                       sh_error_message(error, errbuf, sizeof(errbuf)),
     3919                       lockfile);
    38783920      SL_RETURN((-1),_("sh_unix_unlock"));
    38793921    }
     
    42114253        {
    42124254#ifdef TEST_MLOCK
    4213           fprintf(stderr, "mlock: error: %s\n", sh_error_message(errno));
     4255          char errbuf[SH_ERRBUF_SIZE];
     4256          fprintf(stderr, "mlock: error: %s\n",
     4257                  sh_error_message(errno, errbuf, sizeof(errbuf)));
    42144258#endif
    42154259          SH_FREE(page_list);
  • trunk/src/sh_utmp.c

    r68 r132  
    799799          ) {
    800800        status = sh_utmp_login_a(user->name);
    801         (void) sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX);
     801        (void) sh_unix_time (user->time, ttt, TIM_MAX);
    802802        sh_error_handle( ShUtmpLoginSolo, FIL__, __LINE__, 0,
    803803#if defined(HAVE_UTHOST) && defined(HAVE_UTADDR)
     
    823823          {       
    824824            status = sh_utmp_login_a(user->name);
    825             (void) sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX);
     825            (void) sh_unix_time (user->time, ttt, TIM_MAX);
    826826            sh_error_handle( ShUtmpLoginMulti, FIL__, __LINE__, 0,
    827827#if defined(HAVE_UTHOST) && defined(HAVE_UTADDR)
     
    858858        {
    859859          status = sh_utmp_login_r(user->name);
    860           /* sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX); */
    861           (void) sl_strlcpy(ttt, sh_unix_time (ut->ut_time), TIM_MAX);
     860          (void) sh_unix_time (ut->ut_time, ttt, TIM_MAX);
    862861          sh_error_handle( ShUtmpLogout, FIL__, __LINE__, 0,
    863862#if defined(HAVE_UTHOST) && defined(HAVE_UTADDR)
     
    889888        {
    890889          (void) sl_strlcpy(terminated_line, ut->ut_line, UT_HOSTSIZE);
    891           (void) sl_strlcpy(ttt, sh_unix_time (ut->ut_time), TIM_MAX);
     890          (void) sh_unix_time (ut->ut_time, ttt, TIM_MAX);
    892891          sh_error_handle( ShUtmpLogout, FIL__, __LINE__, 0,
    893892                           MSG_UT_LG3C,
     
    920919      userlist         = user;
    921920
    922       sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX);
     921      (void) sh_unix_time (user->time, ttt, TIM_MAX);
    923922
    924923
     
    946945  else  /* probably a logout */
    947946    {
    948       sl_strlcpy(ttt, sh_unix_time (ut->ut_time), TIM_MAX);
    949       /* sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX); */
     947      (void) sh_unix_time (ut->ut_time, ttt, TIM_MAX);
    950948
    951949      sh_error_handle( ShUtmpLogout, FIL__, __LINE__, 0,
Note: See TracChangeset for help on using the changeset viewer.