Changeset 132

Timestamp:

Oct 23, 2007, 11:44:41 PM (17 years ago)

Author:

rainer

Message:

Make utility functions thread-safe.

Location:

trunk

Files:

• configure.ac (modified) (1 diff)
• docs/TODO (modified) (1 diff)
• include/samhain.h (modified) (1 diff)
• include/sh_error.h (modified) (1 diff)
• include/sh_pthread.h (modified) (2 diffs)
• include/sh_tools.h (modified) (3 diffs)
• include/sh_unix.h (modified) (2 diffs)
• include/sh_utils.h (modified) (3 diffs)
• src/sh_calls.c (modified) (42 diffs)
• src/sh_entropy.c (modified) (6 diffs)
• src/sh_err_console.c (modified) (5 diffs)
• src/sh_err_log.c (modified) (1 diff)
• src/sh_error.c (modified) (3 diffs)
• src/sh_extern.c (modified) (8 diffs)
• src/sh_files.c (modified) (4 diffs)
• src/sh_forward.c (modified) (35 diffs)
• src/sh_gpg.c (modified) (2 diffs)
• src/sh_hash.c (modified) (14 diffs)
• src/sh_kern.c (modified) (4 diffs)
• src/sh_mail.c (modified) (6 diffs)
• src/sh_portcheck.c (modified) (11 diffs)
• src/sh_prelink.c (modified) (1 diff)
• src/sh_processcheck.c (modified) (4 diffs)
• src/sh_socket.c (modified) (20 diffs)
• src/sh_suidchk.c (modified) (23 diffs)
• src/sh_tools.c (modified) (19 diffs)
• src/sh_unix.c (modified) (42 diffs)
• src/sh_utmp.c (modified) (6 diffs)

trunk/configure.ac

@@ -274 +274 @@
         ttyname fchmod \
         getsid getpriority getpgid statvfs \
-        fpathconf dirfd \
+        strerror_r \
         getgrgid_r getpwnam_r getpwuid_r gmtime_r localtime_r rand_r readdir_r strtok_r
 )

trunk/docs/TODO

@@ -1 +1 @@
 
-sh_unix_time: not thread_safe (static buffer)
-sh_error_message: not thread_safe (static buffer)
+not thread-safe: checksum function (returns static memory),
+                 sh_util_siggen
+                 sh_util_hash_tiger
+                 sh_util_hmac_tiger
 
 check thread_safe sh_entropy
+check thread_safe rng
 
-lock NEED_LOCK
+lock globber
 
-globber
+lock sh_alloc/sh_free
 
-sh_alloc/sh_free
-

trunk/include/samhain.h

@@ -45 +45 @@
 #define SH_GRBUF_SIZE  4096
 #define SH_PWBUF_SIZE  4096
+#define SH_ERRBUF_SIZE   64
 
 /* Sizes for arrays (user, group, timestamp).

trunk/include/sh_error.h

@@ -176 +176 @@
 /* error messages
  */
-/*@owned@*/char * sh_error_message (int tellme);
+/*@owned@*/char * sh_error_message (int tellme, char * str, size_t len);
 
 /* switch on/off log to file temporarily

trunk/include/sh_pthread.h

@@ -23 +23 @@
         } while (0)
 
+#define SH_MUTEX_LOCK_UNSAFE(M) pthread_mutex_lock(&(M))
+#define SH_MUTEX_UNLOCK_UNSAFE(M) pthread_mutex_unlock(&(M))
 
 #else
@@ -32 +34 @@
 #define SH_MUTEX_LOCK(M)                        ((void)0)
 #define SH_MUTEX_UNLOCK(M)                      ((void)0)
+#define SH_MUTEX_LOCK_UNSAFE(M)                 ((void)0)
+#define SH_MUTEX_UNLOCK_UNSAFE(M)               ((void)0)
 
 /* #ifdef HAVE_PTHREAD */

trunk/include/sh_tools.h

@@ -16 +16 @@
 
 #ifdef SH_ENCRYPT
-char * errorExplain (int err_num);
+/* returns pointer to errbuf
+ */
+char * errorExplain (int err_num, char * errbuf, size_t len);
 #endif
 
+/* returns allocated buffer
+ */
 char * sh_tools_safe_name(const char * str, int flag);
 int is_numeric (const char * address);
@@ -26 +30 @@
                     char * ecall, int * errnum, char * errmsg, int errsiz);
 void delete_cache(void);
-char * sh_tools_errmessage (int tellme);
+
+/* returns pointer to errbuf
+ */
+char * sh_tools_errmessage (int tellme, char * errbuf, size_t len);
 
 
@@ -41 +48 @@
 int check_request_nerr (char * have, char * need);
 
+/* returns allocated buffer
+ */
 char * hash_me (char * key, char * buf,   int buflen);
 int sh_tools_hash_vfy(char * key, char * buf, int buflen);
 
+/* returns allocated buffer
+ */
 char * get_client_conf_file (char * peer, unsigned long * length);
+
+/* returns allocated buffer
+ */
 char * get_client_data_file (char * peer, unsigned long * length);
 

trunk/include/sh_unix.h

@@ -291 +291 @@
 int  sh_unix_init(int goDaemon);
 
-/* for local time use thetime = 0 
- */
-/*@owned@*/ char * sh_unix_time (time_t thetime);
-
-/* convert to GMT time
- */
-char * sh_unix_gmttime (time_t thetime);
+/* for local time use thetime = 0, returns pointer to buffer 
+ */
+char * sh_unix_time (time_t thetime, char * buffer, size_t len);
+
+/* convert to GMT time, returns pointer to buffer
+ */
+char * sh_unix_gmttime (time_t thetime, char * buffer, size_t len);
 
 /* effective user info
@@ -303 +303 @@
 int  sh_unix_getUser (void);
 
-/* get home directory
- */
-char *  sh_unix_getUIDdir (int level, uid_t uid);
+/* get home directory, , returns pointer to out
+ */
+char *  sh_unix_getUIDdir (int level, uid_t uid, char * out, size_t len);
 
 

trunk/include/sh_utils.h

@@ -43 +43 @@
 } st_format;
 
+/* returns allocated string
+ */
 char * sh_util_formatted (const char * fmt, st_format * ftab);
 
@@ -60 +62 @@
 int    taus_seed           (void);
 
+/* returns allocated memory
+ */
 char * sh_util_strdup (const char * str);
+
+/* returns allocated memory
+ */
 char * sh_util_strdup_l (const char * str, size_t len);
+
+/* returns pointer within str
+ */
 char * sh_util_strsep (char **str, const char *delim);
 
-/* compactify verbose acl text
+/* compactify verbose acl text, returns allocated memory
  */
 char * sh_util_acl_compact (char * buf, ssize_t len);
@@ -146 +156 @@
 
 /* returns freshly allocated memory, return value should be free'd.
- * Arhument list must be NULL terminated.
+ * Argument list must be NULL terminated.
  */
 char * sh_util_strconcat (const char * arg1, ...) SH_GNUC_NULL_TERMINATED;

trunk/src/sh_calls.c

@@ -115 +115 @@
   int error;
   long int val_retry = -1;
+  char errbuf[SH_ERRBUF_SIZE];
   errno              = 0;
 
@@ -126 +127 @@
   if (val_retry < 0) {
       sh_error_handle ((-1), file, line, error, MSG_ERR_SIGACT, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        (long) signum );
   }
@@ -161 +162 @@
   long int val_retry = 0;
   static struct sockaddr_in new_addr;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("retry_connect"));
@@ -189 +191 @@
      */
     sh_error_handle ((-1), file, line, error, MSG_ERR_CONNECT, 
-                     sh_error_message(error),
+                     sh_error_message(error, errbuf, sizeof(errbuf)),
                      (long) sockfd,
                      /*@-unrecog -type@*/
@@ -212 +214 @@
   int  error;
   long int val_retry = -1;
+  char errbuf[SH_ERRBUF_SIZE];
+
   ACCEPT_TYPE_ARG3 my_addrlen = (ACCEPT_TYPE_ARG3) *addrlen;
 
@@ -225 +229 @@
   if (val_retry < 0) {
       sh_error_handle ((-1), file, line, error, MSG_ERR_ACCEPT, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        (long) fd );
   }
@@ -237 +241 @@
   int error;
   long int val_retry = -1;
+  char errbuf[SH_ERRBUF_SIZE];
  
   SL_ENTER(_("retry_lstat"));
@@ -245 +250 @@
   error = errno;
   if (val_retry < 0) {
-      (void) sl_strlcpy(aud_err_message, sh_error_message(error), 64);
+      (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
       sh_error_handle ((-1), file, line, error, MSG_ERR_LSTAT, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        file_name );
   }
@@ -259 +264 @@
   int error;
   long int val_retry = -1;
+  char errbuf[SH_ERRBUF_SIZE];
  
   SL_ENTER(_("retry_stat"));
@@ -267 +273 @@
   error = errno;
   if (val_retry < 0) {
-      (void) sl_strlcpy(aud_err_message, sh_error_message(error), 64);
+      (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
       sh_error_handle ((-1), file, line, error, MSG_ERR_STAT, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        file_name );
   }
@@ -280 +286 @@
   int error;
   long int val_retry = -1;
+  char errbuf[SH_ERRBUF_SIZE];
  
   SL_ENTER(_("retry_fstat"));
@@ -289 +296 @@
   if (val_retry < 0) {
       sh_error_handle ((-1), file, line, error, MSG_ERR_FSTAT, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        (long) filed );
   }
@@ -300 +307 @@
   int error;
   long int val_retry = -1;
+  char errbuf[SH_ERRBUF_SIZE];
   errno              = 0;
 
@@ -319 +327 @@
   if (val_retry < 0) {
       sh_error_handle ((-1), file, line, error, MSG_ERR_FCNTL, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        (long) fd, (long) cmd, arg );
   }
@@ -389 +397 @@
   int   i;
   int   error;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("retry_aud_execve"));
@@ -401 +410 @@
   error = errno;
   if (i < 0) {
-      sh_error_handle ((-1), file, line, error, MSG_ERR_EXEC, sh_error_message(error),
+      sh_error_handle ((-1), file, line, error, MSG_ERR_EXEC, 
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        dateiname, (long) a, (long) b );
   }
@@ -414 +424 @@
   long int val_return;
   int  error;
+  char errbuf[SH_ERRBUF_SIZE];
   errno      = 0;
 
@@ -430 +441 @@
   if (val_return < 0) {
       sh_error_handle ((-1), file, line, error, MSG_ERR_UTIME, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        path, 
                        (unsigned long) buf->actime, 
@@ -444 +455 @@
   long int val_return;
   int error;
+  char errbuf[SH_ERRBUF_SIZE];
   errno      = 0;
 
@@ -457 +469 @@
                      path);
   if (val_return < 0) {
-      sh_error_handle ((-1), file, line, error, MSG_ERR_UNLINK, sh_error_message(error),
+      sh_error_handle ((-1), file, line, error, MSG_ERR_UNLINK, 
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        path);
   }
@@ -469 +482 @@
   long int val_return;
   int error;
+  char errbuf[SH_ERRBUF_SIZE];
   errno      = 0;
 
@@ -483 +497 @@
   if (val_return < 0) {
       sh_error_handle ((-1), file, line, error, MSG_ERR_DUP, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        (long) fd, val_return);
   }
@@ -495 +509 @@
   long int val_return;
   int error;
+  char errbuf[SH_ERRBUF_SIZE];
   errno      = 0;
 
@@ -508 +523 @@
   if (val_return < 0) {
       sh_error_handle ((-1), file, line, error, MSG_ERR_DUP, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        (long) fd, val_return);
   }
@@ -522 +537 @@
   long int val_return;
   int      error      = 0;
+  char errbuf[SH_ERRBUF_SIZE];
   errno      = 0;
 
@@ -535 +551 @@
                      path);
   if (val_return < 0) {
-      sh_error_handle ((-1), file, line, error, MSG_ERR_CHDIR, sh_error_message(error),
+      sh_error_handle ((-1), file, line, error, MSG_ERR_CHDIR, 
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        path);
   }
@@ -549 +566 @@
   long int val_return;
   int error;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("aud_open"));
@@ -566 +584 @@
   if (val_return < 0)
     {
-      (void) sl_strlcpy(aud_err_message, sh_error_message(error), 64);
+      (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
     }
 
@@ -576 +594 @@
   if (val_return < 0) {
     sh_error_handle ((-1), file, line, error, MSG_ERR_OPEN, 
-                     sh_error_message(error),
+                     sh_error_message(error, errbuf, sizeof(errbuf)),
                      pathname, (long) flags, (long) mode, val_return);
   }
@@ -588 +606 @@
   long int val_return;
   int error;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("aud_open"));
@@ -599 +618 @@
   if (val_return < 0)
     {
-      (void) sl_strlcpy(aud_err_message, sh_error_message(error), 64);
+      (void) sl_strlcpy(aud_err_message, sh_error_message(error, errbuf, sizeof(errbuf)), 64);
     }
 
@@ -609 +628 @@
   if (val_return < 0) {
     sh_error_handle ((-1), file, line, error, MSG_ERR_OPEN, 
-                     sh_error_message(error),
+                     sh_error_message(error, errbuf, sizeof(errbuf)),
                      pathname, (long) flags, (long) mode, val_return);
   }
@@ -620 +639 @@
   int  myerror;
   long int val_return = kill (pid, sig);
+  char errbuf[SH_ERRBUF_SIZE];
   myerror = errno;
 
@@ -629 +649 @@
   if (val_return < 0) {
       sh_error_handle ((-1), file, line, myerror, MSG_ERR_KILL, 
-                       sh_error_message(myerror),
+                       sh_error_message(myerror, errbuf, sizeof(errbuf)),
                        (long) pid, (long) sig);
   }
@@ -666 +686 @@
   int error;
   pid_t i = fork();
+  char errbuf[SH_ERRBUF_SIZE];
 
   error = errno;
@@ -675 +696 @@
   if (i == (pid_t) -1) {
     sh_error_handle ((-1), file, line, error, MSG_ERR_FORK, 
-                     sh_error_message(error),
+                     sh_error_message(error, errbuf, sizeof(errbuf)),
                      (long) i);
   }
@@ -686 +707 @@
   int error = 0;
   int i = 0;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("aud_setuid"));
@@ -702 +724 @@
   if (i < 0) {
     sh_error_handle ((-1), file, line, error, MSG_ERR_SETUID, 
-                     sh_error_message(error),
+                     sh_error_message(error, errbuf, sizeof(errbuf)),
                      (long) uid);
   }
@@ -713 +735 @@
   int error = 0;
   int i = 0;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("aud_setgid"));
@@ -730 +753 @@
   if (i < 0) {
     sh_error_handle ((-1), file, line, error, MSG_ERR_SETGID, 
-                     sh_error_message(error),
+                     sh_error_message(error, errbuf, sizeof(errbuf)),
                      (long) gid);
   }
@@ -741 +764 @@
   int error;
   int i = pipe (modus);
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("aud_pipe"));
@@ -761 +785 @@
     else
       sh_error_handle ((-1), file, line, error, MSG_ERR_PIPE, 
-                       sh_error_message(error),
+                       sh_error_message(error, errbuf, sizeof(errbuf)),
                        (long) modus[0], (long) modus[1]);
   }

trunk/src/sh_entropy.c

@@ -645 +645 @@
     int retval;
     char msg[128];
+    char errbuf[SH_ERRBUF_SIZE];
 
     SL_ENTER(_("sh_pclose"));
@@ -653 +654 @@
         sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, retval, 
                          MSG_E_SUBGEN,
-                         sh_error_message(retval),
+                         sh_error_message(retval, errbuf, sizeof(errbuf)),
                          _("sh_pclose"));
         SL_RETURN((-1), _("sh_pclose"));
@@ -663 +664 @@
         sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, retval, 
                          MSG_E_SUBGEN,
-                         sh_error_message(retval),
+                         sh_error_message(retval, errbuf, sizeof(errbuf)),
                          _("sh_pclose"));
 
@@ -707 +708 @@
   int    maxFD = 0;
   int    imax, selcount;
-
+  char errbuf[SH_ERRBUF_SIZE];
+  
   SL_ENTER(_("sh_entropy"));
 
@@ -738 +740 @@
     {
       sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
-                      sh_error_message (caperr), 
+                      sh_error_message (caperr, errbuf, sizeof(errbuf)), 
                       _("sl_get_cap_sub"));
     }
@@ -876 +878 @@
     {
       sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
-                      sh_error_message (caperr), 
+                      sh_error_message (caperr, errbuf, sizeof(errbuf)), 
                       _("sl_drop_cap_sub"));
     }

trunk/src/sh_err_console.c

@@ -70 +70 @@
   key_t            key;
   int              error;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("open_ipc"));
@@ -80 +81 @@
       error = errno;
       TPT(( 0, FIL__, __LINE__, _("msg=<ftok: %s> errno=<%d>\n"), 
-            sh_error_message(error), error));
+            sh_error_message(error, errbuf, sizeof(errbuf)), error));
       SL_RETURN(-1, _("open_ipc"));
     }
@@ -92 +93 @@
       error = errno;
       TPT(( 0, FIL__, __LINE__, _("msg=<msgget: %s> errno=<%d>\n"), 
-            sh_error_message(error), error));
+            sh_error_message(error, errbuf, sizeof(errbuf)), error));
       SL_RETURN(-1, _("open_ipc"));
     }
@@ -131 +132 @@
   int              error;
   int              count    = 0;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("push_message_queue"));
@@ -201 +203 @@
           error = errno;
           TPT(( 0, FIL__, __LINE__, _("msg=<msgsnd: %s> errno=<%d>\n"), 
-                sh_error_message(error), error));
+                sh_error_message(error, errbuf, sizeof(errbuf)), error));
           SH_FREE(recv_msg);
           SL_RETURN(-1, _("push_message_queue"));

trunk/src/sh_err_log.c

@@ -885 +885 @@
       /* Send out the key.
        */
-      (void) sl_strlcpy(log_msg.timestamp, sh_unix_time(0), KEY_LEN+1); 
+      (void) sh_unix_time(0, log_msg.timestamp, KEY_LEN+1); 
 
       store1               = errFlags.loglevel;

trunk/src/sh_error.c

@@ -20 +20 @@
 #include "config_xor.h"
 
+/* required on linux to get the correct strerror_r function
+ */
+#define _XOPEN_SOURCE 600
+#include <string.h>
 #include <stdio.h>     
 #include <stdlib.h>     
 #include <stdarg.h>
-#include <string.h>
 #include <ctype.h>
 #include <limits.h>
@@ -335 +338 @@
 
 
-/*@owned@*/char * sh_error_message (int tellme)
-{
-
-#if defined(HAVE_STRERROR)
-  /*@i@*/return strerror(tellme);
+char * sh_error_message (int tellme, char * str, size_t len)
+{
+
+#if defined(HAVE_STRERROR_R)
+  strerror_r(tellme, str, len);
+  return str;
+#elif defined(HAVE_STRERROR)
+  sl_strlcpy(str, strerror(tellme), len);
+  return str;
 #else
 
+  char *p = NULL;
 #ifdef EACCES
-    if (tellme == EACCES)  return _("Permission denied.");
+    if (tellme == EACCES)  p = _("Permission denied.");
 #endif
 #ifdef EAGAIN
-    if (tellme == EAGAIN)  return _("Try again.");
+    if (tellme == EAGAIN)  p = _("Try again.");
 #endif
 #ifdef EBADF
-    if (tellme == EBADF)   return _("File descriptor in bad state.");
+    if (tellme == EBADF)   p = _("File descriptor in bad state.");
 #endif
 #ifdef EEXIST
-    if (tellme == EEXIST)  return _("File exists.");
+    if (tellme == EEXIST)  p = _("File exists.");
 #endif
 #ifdef EFAULT
-    if (tellme == EFAULT)  return _("Bad address.");
+    if (tellme == EFAULT)  p = _("Bad address.");
 #endif
 #ifdef EINVAL
-    if (tellme == EINVAL)  return _("Invalid argument.");
+    if (tellme == EINVAL)  p = _("Invalid argument.");
 #endif
 #ifdef EISDIR
-    if (tellme == EISDIR)  return _("Is a directory.");
+    if (tellme == EISDIR)  p = _("Is a directory.");
 #endif
 #ifdef EINTR
-    if (tellme == EINTR)   return _("System call was interrupted.");
+    if (tellme == EINTR)   p = _("System call was interrupted.");
 #endif
 #ifdef EIO
-    if (tellme == EIO)     return _("Low-level I/O error.");
+    if (tellme == EIO)     p = _("Low-level I/O error.");
 #endif
 #ifdef ELOOP
-    if (tellme == ELOOP)   return _("Too many symbolic links encountered.");
+    if (tellme == ELOOP)   p = _("Too many symbolic links encountered.");
 #endif
 #ifdef EMFILE
-    if (tellme == EMFILE)  return _("Too many open files.");
+    if (tellme == EMFILE)  p = _("Too many open files.");
 #endif
 #ifdef EMLINK
-    if (tellme == EMLINK)  return _("Too many links.");
+    if (tellme == EMLINK)  p = _("Too many links.");
 #endif
 #ifdef ENAMETOOLONG
     if (tellme == ENAMETOOLONG) 
-                           return _("File name too long."); 
+                           p = _("File name too long."); 
 #endif
 #ifdef ENFILE
-    if (tellme == ENFILE)  return _("File table overflow.");
+    if (tellme == ENFILE)  p = _("File table overflow.");
 #endif
 #ifdef ENOENT
-    if (tellme == ENOENT)  return _("File does not exist.");
+    if (tellme == ENOENT)  p = _("File does not exist.");
 #endif
 #ifdef ENOMEM
-    if (tellme == ENOMEM)  return _("Out of memory.");
+    if (tellme == ENOMEM)  p = _("Out of memory.");
 #endif
 #ifdef ENOSPC
-    if (tellme == ENOSPC)  return _("No space on device.");
+    if (tellme == ENOSPC)  p = _("No space on device.");
 #endif
 #ifdef ENOTDIR
-    if (tellme == ENOTDIR) return _("Not a directory.");
+    if (tellme == ENOTDIR) p = _("Not a directory.");
 #endif
 #ifdef ENOTSOCK
-    if (tellme == ENOTSOCK) return _("Not a socket.");
+    if (tellme == ENOTSOCK) p = _("Not a socket.");
 #endif
 #ifdef EOPNOTSUPP
-    if (tellme == EOPNOTSUPP) return _("Socket is not of type SOCK_STREAM.");
+    if (tellme == EOPNOTSUPP) p = _("Socket is not of type SOCK_STREAM.");
 #endif
 #ifdef EPERM
-    if (tellme == EPERM)   return _("Permission denied.");
+    if (tellme == EPERM)   p = _("Permission denied.");
 #endif
 #ifdef EPIPE
-    if (tellme == EPIPE)   return _("No read on pipe.");
+    if (tellme == EPIPE)   p = _("No read on pipe.");
 #endif
 #ifdef EROFS
-    if (tellme == EROFS)    return _("Read-only file system.");
+    if (tellme == EROFS)    p = _("Read-only file system.");
 #endif
 #ifdef ETXTBSY
-    if (tellme == ETXTBSY) return _("Text file busy.");
+    if (tellme == ETXTBSY) p = _("Text file busy.");
 #endif
 #ifdef EWOULDBLOCK
     if (tellme == EWOULDBLOCK) 
-      return _("No connections on non-blocking socket.");
+      p = _("No connections on non-blocking socket.");
 #endif
 #ifdef EXDEV
-    if (tellme == EXDEV)    return _("Not on same file system.");
-#endif
-    return _("Unknown error");
+    if (tellme == EXDEV)    p = _("Not on same file system.");
+#endif
+    if (!p) p = _("Unknown error");
+    sl_strlcpy(str, p, len);
+    return str;
 #endif /* ifndef HAVE_STRERROR */
 }
@@ -1477 +1487 @@
   }
 
-  (void) sl_strlcpy (tst, sh_unix_time (0), 64);
+  (void) sh_unix_time (0, tst, 64);
   line = (unsigned long) lmsg->line;
   (void) sl_strlcpy (cla, _(class_cat[lmsg->class]), 11);

trunk/src/sh_extern.c

@@ -118 +118 @@
 
   char * errfile;
+  char errbuf[SH_ERRBUF_SIZE];
 
   static int some_error = 0;
@@ -213 +214 @@
       errnum = errno;
       sh_error_handle((-1), FIL__, __LINE__, errnum, MSG_E_SUBGEN, 
-                      sh_error_message(errnum), _("pipe"));
+                      sh_error_message(errnum, errbuf, sizeof(errbuf)), _("pipe"));
       SL_RETURN ((-1), _("sh_ext_popen"));
     }
@@ -235 +236 @@
       errnum = errno;
       sh_error_handle((-1), FIL__, __LINE__, errnum, MSG_E_SUBGEN, 
-                      sh_error_message(errnum), _("fork"));
+                      sh_error_message(errnum, errbuf, sizeof(errbuf)), _("fork"));
       SL_RETURN ((-1), _("sh_ext_popen"));
     }
@@ -1103 +1104 @@
   char * p = NULL;
   int    i;
+  char   dir[SH_PATHBUF];
 
   SL_ENTER(_("sh_ext_add_default"));
@@ -1110 +1112 @@
       SL_RETURN(0, _("sh_ext_add_default"));
     }
-  p = sh_unix_getUIDdir (SH_ERR_ERR, (uid_t) ext_coms->tas.run_user_uid);
+  p = sh_unix_getUIDdir (SH_ERR_ERR, (uid_t) ext_coms->tas.run_user_uid, 
+                         dir, sizeof(dir));
   if (p)
     (void) sh_ext_add_envv (_("HOME"), p);
@@ -1325 +1328 @@
   int        status = 0;
   char     * tmp;
+  char errbuf[SH_ERRBUF_SIZE];
 
   static  int some_error = 0;
@@ -1364 +1368 @@
             {
               sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
-                              sh_error_message (caperr), 
+                              sh_error_message (caperr, errbuf, sizeof(errbuf)), 
                               _("sl_get_cap_sub"));
             }
@@ -1443 +1447 @@
             {
               sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
-                              sh_error_message (caperr), 
+                              sh_error_message (caperr, errbuf, sizeof(errbuf)), 
                               _("sl_drop_cap_sub"));
             }

trunk/src/sh_files.c

@@ -721 +721 @@
 {
   char * p;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("sh_files_globerr"));
@@ -731 +732 @@
   p = sh_util_safe_name (epath);
   sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, errnum, MSG_FI_GLOB,
-                   sh_error_message (errnum), p);
+                   sh_error_message (errnum, errbuf, sizeof(errbuf)), p);
   SH_FREE(p);
 
@@ -1491 +1492 @@
   char          * tmpname;
   char          * tmpcat;
+  char errbuf[SH_ERRBUF_SIZE];
 
   int             rdepth = 0;
@@ -1611 +1613 @@
       sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0, 
                        MSG_E_OPENDIR,
-                       sh_error_message (status), tmpname);
+                       sh_error_message (status, errbuf, sizeof(errbuf)), tmpname);
       SH_FREE(tmpname); 
 

trunk/src/sh_forward.c

@@ -386 +386 @@
   cipherInstance          cipherInst;
   int                     err_num;
+  char expbuf[SH_ERRBUF_SIZE];
 #else
   docrypt = SL_FALSE; /* dummy to fix compiler warning */
@@ -422 +423 @@
       if (err_num < 0)
         sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                        errorExplain(err_num), 
+                        errorExplain(err_num, expbuf, sizeof(expbuf)), 
                         _("sh_forward_send_intern: cipherInit"));
 
@@ -433 +434 @@
           if (err_num < 0)
             sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                            errorExplain(err_num), 
+                            errorExplain(err_num, expbuf, sizeof(expbuf)), 
                             _("sh_forward_send_intern: blockEncrypt"));
           memcpy(q, outBlock, B_SIZ);
@@ -447 +448 @@
           if (err_num < 0)
             sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                            errorExplain(err_num), 
+                            errorExplain(err_num, expbuf, sizeof(expbuf)), 
                             _("sh_forward_send_intern: blockEncrypt"));
           memcpy(q, outBlock, B_SIZ);
@@ -549 +550 @@
   cipherInstance          cipherInst;
   int                     err_num;
+  char expbuf[SH_ERRBUF_SIZE];
 #else
   docrypt = SL_FALSE; /* dummy to fix compiler warning */
@@ -655 +657 @@
       if (err_num < 0)
         sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                        errorExplain(err_num), 
+                        errorExplain(err_num, expbuf, sizeof(expbuf)), 
                         _("sh_forward_receive_intern: cipherInit"));
 
@@ -668 +670 @@
           if (err_num < 0)
             sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                            errorExplain(err_num), 
+                            errorExplain(err_num, expbuf, sizeof(expbuf)), 
                             _("sh_forward_receive_intern: blockDecrypt"));
           memcpy(q, outBlock, B_SIZ);
@@ -881 +883 @@
 #ifdef SH_ENCRYPT
   int err_num;
+  char expbuf[SH_ERRBUF_SIZE];
 #endif
 
@@ -1053 +1056 @@
           if (err_num < 0)
             sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                            errorExplain(err_num), 
+                            errorExplain(err_num, expbuf, sizeof(expbuf)), 
                             _("sh_forward_try_impl: makeKey"));
 
@@ -1060 +1063 @@
           if (err_num < 0)
             sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                            errorExplain(err_num), 
+                            errorExplain(err_num, expbuf, sizeof(expbuf)), 
                             _("sh_forward_try_impl: make_key"));
 #endif
@@ -1233 +1236 @@
                                 sh_error_handle((-1), FIL__, __LINE__, -1, 
                                                 MSG_E_SUBGEN,
-                                                errorExplain(err_num), 
+                                                errorExplain(err_num, expbuf, sizeof(expbuf)), 
                                                 _("sh_forward_try_impl: makeKey"));
                               err_num = makeKey(&(skey->keyInstD), 
@@ -1241 +1244 @@
                                 sh_error_handle((-1), FIL__, __LINE__, -1, 
                                                 MSG_E_SUBGEN,
-                                                errorExplain(err_num), 
+                                                errorExplain(err_num, expbuf, sizeof(expbuf)), 
                                                 _("sh_forward_try_impl: makeKey"));
 #endif
@@ -1741 +1744 @@
   if (flag_err != 0)
     {
+      char errbuf[SH_ERRBUF_SIZE];
       conn_state = BAD;
       timeout_val *= 2;
-      if (flag_err < 0 || NULL == sh_error_message(flag_err))
+      if (flag_err < 0 || NULL == sh_error_message(flag_err, errbuf, sizeof(errbuf)))
         flag_err = EIO;
       sh_error_handle((-1), FIL__, __LINE__, flag_err, MSG_TCP_ECONN,
-                      sh_error_message(flag_err));
+                      sh_error_message(flag_err, errbuf, sizeof(errbuf)));
       SL_RETURN( (-1), _("sh_forward_try_impl"));
     }
@@ -2053 +2057 @@
       for (i = 0; i < CLT_MAX; ++i) 
         newclt->status_arr[i] = CLT_INACTIVE;
-      sl_strlcpy(newclt->timestamp[CLT_INACTIVE],   sh_unix_time(0), TIM_MAX);
+      (void) sh_unix_time(0, newclt->timestamp[CLT_INACTIVE], TIM_MAX);
       /* truncate */
       sl_strlcpy(newclt->hostname,  &str[0],        sep[0]+1);
@@ -2257 +2261 @@
   cipherInstance          cipherInst;
   int                     err_num;
+  char expbuf[SH_ERRBUF_SIZE];
 #else
   (void) docrypt;
@@ -2329 +2334 @@
       if (err_num < 0)
         sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                        errorExplain(err_num), 
+                        errorExplain(err_num, expbuf, sizeof(expbuf)), 
                         _("sh_forward_prep_send_int: cipherInit"));
 
@@ -2339 +2344 @@
           if (err_num < 0)
             sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                            errorExplain(err_num), 
+                            errorExplain(err_num, expbuf, sizeof(expbuf)), 
                             _("sh_forward_prep_send_int: blockEncrypt"));
           memcpy(q, outBlock, B_SIZ);
@@ -2355 +2360 @@
           if (err_num < 0)
             sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                            errorExplain(err_num), 
+                            errorExplain(err_num, expbuf, sizeof(expbuf)), 
                             _("sh_forward_prep_send_int: blockEncrypt"));
           memcpy(q, outBlock, B_SIZ);
@@ -2438 +2443 @@
   conn->status_now = status;
   conn->status_arr[status] = status;
-  sl_strlcpy(conn->timestamp[status],
-             sh_unix_time(0), 
-             TIM_MAX);
+  (void) sh_unix_time(0, conn->timestamp[status], TIM_MAX);
 
 #if defined(WITH_EXTERNAL)
@@ -2806 +2809 @@
   int        send_bytes;
   int        err_num;
+  char expbuf[SH_ERRBUF_SIZE];
 #endif
 
@@ -3880 +3884 @@
                if (err_num < 0)
                  sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                                 errorExplain(err_num), 
+                                 errorExplain(err_num, expbuf, sizeof(expbuf)), 
                                  _("check_protocol: makeKey"));
                err_num = makeKey(&(conn->client_entry->keyInstD), 
@@ -3887 +3891 @@
                if (err_num < 0)
                  sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                                 errorExplain(err_num), 
+                                 errorExplain(err_num, expbuf, sizeof(expbuf)), 
                                  _("check_protocol: makeKey"));
 #endif
@@ -4211 +4215 @@
                   if (err_num < 0)
                     sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                                    errorExplain(err_num), 
+                                    errorExplain(err_num, expbuf, sizeof(expbuf)), 
                                     _("sh_forward_prep_send_int: makeKey"));
                   err_num = makeKey(&(conn->client_entry->keyInstD), 
@@ -4218 +4222 @@
                   if (err_num < 0)
                     sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                                    errorExplain(err_num), 
+                                    errorExplain(err_num, expbuf, sizeof(expbuf)), 
                                     _("sh_forward_prep_send_int: makeKey"));
 #endif
@@ -4312 +4316 @@
   cipherInstance          cipherInst;
   int                     err_num;
+  char expbuf[SH_ERRBUF_SIZE];
 #endif
 
@@ -4410 +4415 @@
                   if (err_num < 0)
                     sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                                    errorExplain(err_num), 
+                                    errorExplain(err_num, expbuf, sizeof(expbuf)), 
                                     _("sh_forward_do_read: cipherInit"));
 
@@ -4422 +4427 @@
                         sh_error_handle((-1), FIL__, __LINE__, -1, 
                                         MSG_E_SUBGEN,
-                                        errorExplain(err_num), 
+                                        errorExplain(err_num, expbuf, sizeof(expbuf)), 
                                         _("sh_forward_do_read: blockDecrypt"));
                       memcpy(q, outBlock, B_SIZ);
@@ -4650 +4655 @@
   else
     {
+      char err_buf[SH_ERRBUF_SIZE];
       errflag = errno;
       sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
-                      sh_error_message(errflag), _("accept"));
+                      sh_error_message(errflag,err_buf, sizeof(err_buf)), _("accept"));
       newconn->fd    = -1;
       newconn->state = CONN_FREE;
@@ -4732 +4738 @@
 int sh_forward_printerr_final(int slot)
 {
+  char errbuf[SH_ERRBUF_SIZE];
+
   SL_ENTER(_("sh_forward_printerr_final"));
   if (sock_err[slot].msg[0] != '\0')
@@ -4737 +4745 @@
       dlog(1, FIL__, __LINE__, 
            _("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"),
-           sh_error_message(sock_err[slot].errnum), sock_err[slot].euid, 
+           sh_error_message(sock_err[slot].errnum, errbuf, sizeof(errbuf)), 
+           sock_err[slot].euid, 
            sock_err[slot].port);
       sh_error_handle((-1), FIL__, sock_err[slot].line, 
                       sock_err[slot].errnum, MSG_EXIT_ABORTS,
-                      sh_error_message(sock_err[slot].errnum),
+                      sh_error_message(sock_err[slot].errnum, errbuf, sizeof(errbuf)),
                       sh.prg_name,
                       sock_err[slot].msg);
@@ -5180 +5189 @@
       if ( num_sel < 0 )        /* some error             */
         {
+          char errbuf[SH_ERRBUF_SIZE];
+
           if (sig_raised == 1)
             {
@@ -5207 +5218 @@
 
           sh_error_handle((-1), FIL__, __LINE__, errnum, MSG_EXIT_ABORTS,
-                          sh_error_message(errnum), 
+                          sh_error_message(errnum, errbuf, sizeof(errbuf)), 
                           sh.prg_name,
                           _("select"));
@@ -5535 +5546 @@
   char               buf[1048];
   struct sockaddr_in from;
+  char errbuf[SH_ERRBUF_SIZE];
 
   /* The 6th argument in recvfrom is *socklen_t in Linux and *BSD, 
@@ -5575 +5587 @@
           TPT(( 0, FIL__, __LINE__, _("msg=<UDP error: %d>\n"), res));
           sh_error_handle((-1), FIL__, __LINE__, res, MSG_ERR_SYSLOG,
-                          sh_error_message(res), my_inet_ntoa(from.sin_addr));
+                          sh_error_message(res, errbuf, sizeof(errbuf)), 
+                          my_inet_ntoa(from.sin_addr));
           SL_RETURN( (-1), _("recv_syslog_socket"));
         }      
@@ -5634 +5647 @@
       TPT(( 0, FIL__, __LINE__, _("msg=<UDP error: %d>\n"), res));
       sh_error_handle((-1), FIL__, __LINE__, res, MSG_ERR_SYSLOG,
-                      sh_error_message(res), my_inet_ntoa(from.sin_addr));
+                      sh_error_message(res, errbuf, sizeof(errbuf)), 
+                      my_inet_ntoa(from.sin_addr));
 
       /* don't accept anything the next 2 seconds

trunk/src/sh_gpg.c

@@ -660 +660 @@
   if (0 != retry_lstat(FIL__, __LINE__, DEFAULT_GPG_PATH, &buf))
     {
+      char errbuf[SH_ERRBUF_SIZE];
+
       status = errno;
       sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_ERR_LSTAT,
-                      sh_error_message(status), DEFAULT_GPG_PATH);
+                      sh_error_message(status, errbuf, sizeof(errbuf)), DEFAULT_GPG_PATH);
       SL_RETURN( SH_GPG_BAD, _("sh_gpg_check_file_sign"));
     }
@@ -690 +692 @@
   if (0 != retry_lstat(FIL__, __LINE__, DEFAULT_PGP_PATH, &buf))
     {
+      char errbuf[SH_ERRBUF_SIZE];
+
       status = errno;
       sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_ERR_LSTAT,
-                      sh_error_message(status), DEFAULT_PGP_PATH);
+                      sh_error_message(status, errbuf, sizeof(errbuf)), DEFAULT_PGP_PATH);
       SL_RETURN( SH_GPG_BAD, _("sh_gpg_check_file_sign"));
     }

trunk/src/sh_hash.c

@@ -1404 +1404 @@
 
   char   timestring[81];
-  char * timep;
 
 #if !defined(__linux__) && !defined(HAVE_STAT_FLAGS)
@@ -1706 +1705 @@
                             sl_strlen(sh_db_version_string));
                   sl_write (pushdata_fd, _(" Date "), 6);
-                  timep = sh_unix_time(0);
-                  sl_strlcpy(timestring, timep, sizeof(timestring));
+                  (void) sh_unix_time(0, timestring, sizeof(timestring));
                   sl_write (pushdata_fd, timestring, sl_strlen(timestring));
                   sl_write (pushdata_fd,        "\n", 1);
@@ -1716 +1714 @@
                   printf ("%s", sh_db_version_string);
                   printf (_(" Date "));
-                  timep = sh_unix_time(0);
-                  sl_strlcpy(timestring, timep, sizeof(timestring));
+                  (void) sh_unix_time(0, timestring, sizeof(timestring));
                   printf ("%s\n", timestring);
                 }
@@ -2343 +2340 @@
 
 
-  sl_strlcpy (timstr1c, sh_unix_gmttime (theFile->ctime),   32);
+  (void) sh_unix_gmttime (theFile->ctime, timstr1c,  sizeof(timstr1c));
   if (is_new)
     sl_snprintf(tmp, SH_BUFSIZE, _("ctime_new=\"%s\" "), timstr1c);
@@ -2350 +2347 @@
   sl_strlcat(msg, tmp, SH_BUFSIZE); 
 
-  sl_strlcpy (timstr1a, sh_unix_gmttime (theFile->atime),   32);
+  (void) sh_unix_gmttime (theFile->atime, timstr1a,  sizeof(timstr1a));
   if (is_new)
     sl_snprintf(tmp, SH_BUFSIZE, _("atime_new=\"%s\" "), timstr1a);
@@ -2357 +2354 @@
   sl_strlcat(msg, tmp, SH_BUFSIZE); 
 
-  sl_strlcpy (timstr1m, sh_unix_gmttime (theFile->mtime),   32);
+  (void) sh_unix_gmttime (theFile->mtime, timstr1m,  sizeof(timstr1m));
   if (is_new)
     sl_snprintf(tmp, SH_BUFSIZE, _("mtime_new=\"%s\" "), timstr1m);
@@ -2509 +2506 @@
 
 
-  sl_strlcpy (timstr1c, sh_unix_gmttime (theFile->ctime),   32);
+  (void) sh_unix_gmttime (theFile->ctime, timstr1c,  sizeof(timstr1c));
   if (is_new)
     sl_snprintf(tmp, SH_BUFSIZE, _("ctime_new=<%s>, "), timstr1c);
@@ -2516 +2513 @@
   sl_strlcat(msg, tmp, SH_BUFSIZE); 
 
-  sl_strlcpy (timstr1a, sh_unix_gmttime (theFile->atime),   32);
+  (void) sh_unix_gmttime (theFile->atime, timstr1a,  sizeof(timstr1a));
   if (is_new)
     sl_snprintf(tmp, SH_BUFSIZE, _("atime_new=<%s>, "), timstr1a);
@@ -2523 +2520 @@
   sl_strlcat(msg, tmp, SH_BUFSIZE); 
 
-  sl_strlcpy (timstr1m, sh_unix_gmttime (theFile->mtime),   32);
+  (void) sh_unix_gmttime (theFile->mtime, timstr1m,  sizeof(timstr1m));
   if (is_new)
     sl_snprintf(tmp, SH_BUFSIZE, _("mtime_new=<%s>, "), timstr1m);
@@ -3145 +3142 @@
       if ((modi_mask & MODI_CTM) != 0)
         {
-          sl_strlcpy (timstr1c, sh_unix_gmttime (p->theFile.ctime), 32);
-          sl_strlcpy (timstr2c, sh_unix_gmttime (theFile->ctime),   32);
+          (void) sh_unix_gmttime (p->theFile.ctime, timstr1c, sizeof(timstr1c));
+          (void) sh_unix_gmttime (theFile->ctime,   timstr2c, sizeof(timstr2c));
 #ifdef SH_USE_XML
           sl_snprintf(tmp, SH_BUFSIZE, _("ctime_old=\"%s\" ctime_new=\"%s\" "),
@@ -3163 +3160 @@
       if ((modi_mask & MODI_ATM) != 0)
         {
-          sl_strlcpy (timstr1a, sh_unix_gmttime (p->theFile.atime), 32);
-          sl_strlcpy (timstr2a, sh_unix_gmttime (theFile->atime),   32);
+          (void) sh_unix_gmttime (p->theFile.atime, timstr1a, sizeof(timstr1a));
+          (void) sh_unix_gmttime (theFile->atime,   timstr2a, sizeof(timstr2a));
 #ifdef SH_USE_XML
           sl_snprintf(tmp, SH_BUFSIZE, _("atime_old=\"%s\" atime_new=\"%s\" "),
@@ -3181 +3178 @@
       if ((modi_mask & MODI_MTM) != 0)
         {
-          sl_strlcpy (timstr1m, sh_unix_gmttime (p->theFile.mtime), 32);
-          sl_strlcpy (timstr2m, sh_unix_gmttime (theFile->mtime),   32);
+          (void) sh_unix_gmttime (p->theFile.mtime, timstr1m, sizeof(timstr1m));
+          (void) sh_unix_gmttime (theFile->mtime,   timstr2m, sizeof(timstr2m));
 #ifdef SH_USE_XML
           sl_snprintf(tmp, SH_BUFSIZE, _("mtime_old=\"%s\" mtime_new=\"%s\" "),
@@ -3579 +3576 @@
 
   if ('c' == p->theFile.c_mode[0] || 'b' == p->theFile.c_mode[0])
-    sl_snprintf(str, 80, "%"PRIu64, p->theFile.rdev);
-  else
-    sl_snprintf(str, 80, "%"PRIu64, p->theFile.size);
+    sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.rdev);
+  else
+    sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.size);
 
   printf( _(" %8s"), str);
@@ -3587 +3584 @@
     putchar(',');
 
-  printf( _(" %s"), sh_unix_gmttime (p->theFile.ctime));
+  printf( _(" %s"), sh_unix_gmttime (p->theFile.ctime, str, sizeof(str)));
   if (ListWithDelimiter == S_TRUE)
     putchar(',');
-  printf( _(" %s"), sh_unix_gmttime (p->theFile.mtime));
+  printf( _(" %s"), sh_unix_gmttime (p->theFile.mtime, str, sizeof(str)));
   if (ListWithDelimiter == S_TRUE)
     putchar(',');
-  printf( _(" %s"), sh_unix_gmttime (p->theFile.atime));
+  printf( _(" %s"), sh_unix_gmttime (p->theFile.atime, str, sizeof(str)));
   if (ListWithDelimiter == S_TRUE)
     putchar(',');

trunk/src/sh_kern.c

@@ -1222 +1222 @@
               if (mod_syscall_code != 0)
                 {
-                  sl_strlcpy (timstr_o, sh_unix_gmttime (ctime_old), 32);
-                  sl_strlcpy (timstr_n, sh_unix_gmttime (ctime_new), 32);
+                  (void) sh_unix_gmttime (ctime_old, timstr_o, sizeof(timstr_o));
+                  (void) sh_unix_gmttime (ctime_new, timstr_n, sizeof(timstr_n));
 #ifdef SH_USE_XML
                   sl_snprintf(tmp, 128, 
@@ -1234 +1234 @@
 #endif
                   sl_strlcat(msg, tmp, SH_BUFSIZE); 
-                  sl_strlcpy (timstr_o, sh_unix_gmttime (mtime_old), 32);
-                  sl_strlcpy (timstr_n, sh_unix_gmttime (mtime_new), 32);
+                  (void) sh_unix_gmttime (mtime_old, timstr_o, sizeof(timstr_o));
+                  (void) sh_unix_gmttime (mtime_new, timstr_n, sizeof(timstr_n));
 #ifdef SH_USE_XML
                   sl_snprintf(tmp, 128, 
@@ -1693 +1693 @@
                   sl_strlcpy(msg, tmp, SH_BUFSIZE);
 
-                  sl_strlcpy (timstr_o, sh_unix_gmttime (ctime_old), 32);
-                  sl_strlcpy (timstr_n, sh_unix_gmttime (ctime_new), 32);
+                  (void) sh_unix_gmttime (ctime_old, timstr_o, sizeof(timstr_o));
+                  (void) sh_unix_gmttime (ctime_new, timstr_n, sizeof(timstr_n));
 #ifdef SH_USE_XML
                   sl_snprintf(tmp, 128, 
@@ -1705 +1705 @@
 #endif
                   sl_strlcat(msg, tmp, SH_BUFSIZE); 
-                  sl_strlcpy (timstr_o, sh_unix_gmttime (mtime_old), 32);
-                  sl_strlcpy (timstr_n, sh_unix_gmttime (mtime_new), 32);
+                  (void) sh_unix_gmttime (mtime_old, timstr_o, sizeof(timstr_o));
+                  (void) sh_unix_gmttime (mtime_new, timstr_n, sizeof(timstr_n));
 #ifdef SH_USE_XML
                   sl_snprintf(tmp, 128, 

trunk/src/sh_mail.c

@@ -810 +810 @@
     size_t    msgbufsize = SH_MAILBUF;
     size_t    combufsize = SH_MAILBUF;
+    char      timebuf[81];
 
     SL_ENTER(_("sh_mail_msg"));
@@ -887 +888 @@
       {
         (void) sl_strlcpy(mheader, _("Subject: "),       sizeof(mheader)-5);
-        (void) sl_strlcat(mheader, sh_unix_time (0),     sizeof(mheader)-5);
+        (void) sl_strlcat(mheader, sh_unix_time (0, timebuf, sizeof(timebuf)),
+                          sizeof(mheader)-5);
         (void) sl_strlcat(mheader, " ",                  sizeof(mheader)-5);
         (void) sl_strlcat(mheader, sh.host.name,         sizeof(mheader)-5);
@@ -909 +911 @@
           {
             (void) sl_strlcpy(mheader, _("Subject: "),     sizeof(mheader)-5);
-            (void) sl_strlcat(mheader, sh_unix_time (0),   sizeof(mheader)-5);
+            (void) sl_strlcat(mheader, sh_unix_time (0, timebuf, sizeof(timebuf)),
+                              sizeof(mheader)-5);
             (void) sl_strlcat(mheader, " ",                sizeof(mheader)-5);
             (void) sl_strlcat(mheader, sh.host.name,       sizeof(mheader)-5);
@@ -921 +924 @@
     /* ---------- Message  --------------------------------------- */
 
-    (void) sl_strlcpy(subject, sh_unix_time (0),          sizeof(subject));
+    (void) sl_strlcpy(subject, sh_unix_time (0, timebuf, sizeof(timebuf)),
+                      sizeof(subject));
     (void) sl_strlcat(subject, " ",                       sizeof(subject));
     (void) sl_strlcat(subject, sh.host.name,              sizeof(subject));
@@ -1885 +1889 @@
   if (length < 1)
     {
+      char errbuf[SH_ERRBUF_SIZE];
+
       /* error handling
        */
@@ -1897 +1903 @@
           sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, status, MSG_E_SUBGEN,
                            (errno == ECONNREFUSED) ? 
-                           sh_error_message (status) : 
-                           sh_tools_errmessage(status),
+                           sh_error_message (status, errbuf, sizeof(errbuf)) : 
+                           sh_tools_errmessage(status, errbuf, sizeof(errbuf)),
                            _("res_query"));
 #else
           if (errno == ECONNREFUSED)
-            fprintf(stderr, " ERROR: %s: \n", strerror(errno));
+            fprintf(stderr, " ERROR: %s: \n", strerror(errno)); /* TESTONLY */
           else
-            fprintf(stderr, "HERROR: %s\n", hstrerror(h_errno));
+            fprintf(stderr, "HERROR: %s\n", hstrerror(h_errno));/* TESTONLY */
 #endif
         }

trunk/src/sh_portcheck.c

@@ -608 +608 @@
   int                nerr;
 #endif
+  char errbuf[SH_ERRBUF_SIZE];
 
   /* inet_aton(interface, &haddr); */
@@ -627 +628 @@
       nerr = errno;
       sl_snprintf(errmsg, sizeof(errmsg), _("check port: %5d/udp on %15s: %s"),
-                  port, inet_ntoa(haddr), sh_error_message(errno));
+                  port, inet_ntoa(haddr), sh_error_message(errno, errbuf, sizeof(errbuf)));
       sh_error_handle((-1), FIL__, __LINE__, nerr, MSG_E_SUBGEN, 
                       errmsg, _("connect"));
@@ -693 +694 @@
   int                nerr;
 #endif
-
+  char errbuf[SH_ERRBUF_SIZE];
 
   /* inet_aton(interface, &haddr); */
@@ -719 +720 @@
       nerr = errno;
       sl_snprintf(errmsg, sizeof(errmsg), _("check port: %5d/tcp on %15s: %s"),
-                  port, inet_ntoa(haddr), sh_error_message(errno));
+                  port, inet_ntoa(haddr), sh_error_message(errno, errbuf, sizeof(errbuf)));
       sh_error_handle((-1), FIL__, __LINE__, nerr, MSG_E_SUBGEN, 
                       errmsg, _("connect"));
@@ -889 +890 @@
   int              flag =  1; /* non-zero to enable an option */
   struct in_addr   haddr;
- 
+  char errbuf[SH_ERRBUF_SIZE];
+
   /* Check all interfaces for this host
    */
@@ -901 +903 @@
 #else
           sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN, 
-                          sh_error_message(errno), _("socket"));
+                          sh_error_message(errno, errbuf, sizeof(errbuf)), _("socket"));
 #endif
         }
@@ -912 +914 @@
 #else
           sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN, 
-                          sh_error_message(errno), _("setsockopt"));
+                          sh_error_message(errno, errbuf, sizeof(errbuf)),_("setsockopt"));
 #endif
         }
@@ -957 +959 @@
   struct sockaddr_in addr;
   int addrlen      = sizeof(addr);
+  char errbuf[SH_ERRBUF_SIZE];
 
   if (min_port == -1)
@@ -973 +976 @@
 #else
           sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN, 
-                          sh_error_message(errno), _("socket"));
+                          sh_error_message(errno, errbuf, sizeof(errbuf)), _("socket"));
 #endif
         }
@@ -984 +987 @@
 #else
           sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN, 
-                          sh_error_message(errno), _("setsockopt"));
+                          sh_error_message(errno, errbuf, sizeof(errbuf)),_("setsockopt"));
 #endif
         }
@@ -1018 +1021 @@
 #else
               sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN, 
-                              sh_error_message(errno), _("bind"));
+                              sh_error_message(errno, errbuf, sizeof(errbuf)), _("bind"));
 #endif
             }

trunk/src/sh_prelink.c

@@ -179 +179 @@
   if (init == S_FALSE)
     {
+      char dir[SH_PATHBUF];
+
       sh_ext_tas_init(&task);
-      p = sh_unix_getUIDdir (SH_ERR_ERR, task.run_user_uid);
+      p = sh_unix_getUIDdir (SH_ERR_ERR, task.run_user_uid, dir, sizeof(dir));
       if (p)
         {

trunk/src/sh_processcheck.c

@@ -185 +185 @@
 static char * get_user_and_path (pid_t pid, char * user, size_t usrlen)
 {
-  extern char *  sh_unix_getUIDname (int level, uid_t uid);
+  extern char *  sh_unix_getUIDname (int level, uid_t uid, char * out, size_t len);
 
   char        path[128];
@@ -232 +232 @@
     }
 
-  tmp = sh_unix_getUIDname (SH_ERR_ALL, sbuf.st_uid);
-
-  if (tmp)
-    sl_strlcpy(user, tmp, usrlen);
-  else
+  tmp = sh_unix_getUIDname (SH_ERR_ALL, sbuf.st_uid, user, usrlen);
+
+  if (!tmp)
     sl_snprintf (user, usrlen, "%ld", (unsigned long) sbuf.st_uid);
 
@@ -826 +824 @@
           else
             {
+              char errbuf[SH_ERRBUF_SIZE];
+
               sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                              sh_error_message(errno),
+                              sh_error_message(errno, errbuf, sizeof(errbuf)),
                               _("sh_processes_readps"));
               break;
@@ -951 +951 @@
   struct  sigaction  old_act;
   int retval = 0;
+  char  dir[SH_PATHBUF];
 
   SL_ENTER(_("sh_processes_runps"));
 
   sh_ext_tas_init(&task);
-  p = sh_unix_getUIDdir (SH_ERR_ERR, task.run_user_uid);
+  p = sh_unix_getUIDdir (SH_ERR_ERR, task.run_user_uid, dir, sizeof(dir));
   if (p)
     {

trunk/src/sh_socket.c

@@ -342 +342 @@
 #endif
   struct stat buf;
+  char errbuf[SH_ERRBUF_SIZE];
   
   SL_ENTER(_("sh_socket_open_int"));
@@ -364 +365 @@
     {
       sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                       sh_error_message (errno), 
+                       sh_error_message (errno, errbuf, sizeof(errbuf)), 
                        _("sh_socket_open_int: socket"));
       SL_RETURN( (-1), _("sh_socket_open_int"));
@@ -405 +406 @@
       close(pf_unix_fd); pf_unix_fd = -1;
       sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                       sh_error_message (errno), 
+                       sh_error_message (errno, errbuf, sizeof(errbuf)), 
                        _("sh_socket_open_int: bind"));
       SL_RETURN( (-1), _("sh_socket_open_int"));
@@ -416 +417 @@
       close(pf_unix_fd); pf_unix_fd = -1;
       sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                       sh_error_message (errno), 
+                       sh_error_message (errno, errbuf, sizeof(errbuf)), 
                        _("sh_socket_open_int: setsockopt"));
       SL_RETURN( (-1), _("sh_socket_open_int"));
@@ -427 +428 @@
       close(pf_unix_fd); pf_unix_fd = -1;
       sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                       sh_error_message (errno), 
+                       sh_error_message (errno, errbuf, sizeof(errbuf)), 
                        _("sh_socket_open_int: fcntl1"));
       SL_RETURN( (-1), _("sh_socket_open_int"));
@@ -437 +438 @@
       close(pf_unix_fd); pf_unix_fd = -1;
       sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                      sh_error_message (errno), 
+                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
                       _("sh_socket_open_int: fcntl2"));
       SL_RETURN( (-1), _("sh_socket_open_int"));
@@ -446 +447 @@
       close(pf_unix_fd); pf_unix_fd = -1;
       sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                       sh_error_message (errno), 
+                       sh_error_message (errno, errbuf, sizeof(errbuf)), 
                        _("sh_socket_open_int: listen"));
       SL_RETURN( (-1), _("sh_socket_open_int"));
@@ -509 +510 @@
 
   int  client_uid = -1;
+  char errbuf[SH_ERRBUF_SIZE];
 
 
@@ -588 +590 @@
     {
       sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                      sh_error_message (errno), 
+                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
                       _("sh_socket_read: accept"));
       return -1;
@@ -602 +604 @@
       {
         sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                        sh_error_message (errno), 
+                        sh_error_message (errno, errbuf, sizeof(errbuf)), 
                         _("sh_socket_read: setsockopt"));
         close(talkfd);
@@ -615 +617 @@
       {
         sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                        sh_error_message (errno),
+                        sh_error_message (errno, errbuf, sizeof(errbuf)),
                         _("sh_socket_read: recvmsg"));
         close(talkfd);  
@@ -644 +646 @@
         }
       sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                      sh_error_message (errno), 
+                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
                       _("sh_socket_read: recvfrom"));
       close(talkfd);
@@ -654 +656 @@
     {
       sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                      sh_error_message (errno), 
+                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
                       _("sh_socket_read: getpeereid"));
       close(talkfd);
@@ -665 +667 @@
     {
       sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                      sh_error_message (errno), 
+                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
                       _("sh_socket_read: getsockopt"));
       close(talkfd);
@@ -843 +845 @@
     {
       sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                      sh_error_message (errno), 
+                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
                       _("sh_socket_read: send"));
       return -1;
@@ -876 +878 @@
             {
               sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                              sh_error_message (errno), 
+                              sh_error_message (errno, errbuf, sizeof(errbuf)), 
                               _("sh_socket_read: sendto"));
               close(talkfd);
@@ -907 +909 @@
         {
           sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                          sh_error_message (errno), 
+                          sh_error_message (errno, errbuf, sizeof(errbuf)), 
                           _("sh_socket_read: sendto"));
           close(talkfd);
@@ -933 +935 @@
   sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
   sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
-  sl_strlcpy (new->cti, sh_unix_time(0), sizeof(new->cti));
+  (void) sh_unix_time(0, new->cti, sizeof(new->cti));
   new->next = cmdlist;
   cmdlist   = new;
@@ -951 +953 @@
           sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
           sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
-          sl_strlcpy (new->cti, sh_unix_time(0), sizeof(new->cti));
+          (void) sh_unix_time(0, new->cti, sizeof(new->cti));
           return;
         }
@@ -960 +962 @@
   sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
   sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
-  sl_strlcpy (new->cti, sh_unix_time(0), sizeof(new->cti));
+  (void) sh_unix_time(0, new->cti, sizeof(new->cti));
   new->next = runlist;
   runlist   = new;

trunk/src/sh_suidchk.c

@@ -173 +173 @@
   struct stat two;
   int         fd;
+  char errbuf[SH_ERRBUF_SIZE];
 
   if (depth > 99)
@@ -198 +199 @@
           sh_error_handle ((-1), FIL__, __LINE__, errno,
                            MSG_SUID_ERROR,
-                           sh_error_message(errno));
+                           sh_error_message(errno, errbuf, sizeof(errbuf)));
           *q = '/'; 
           return -1; 
@@ -217 +218 @@
           sh_error_handle ((-1), FIL__, __LINE__, errno,
                            MSG_SUID_ERROR,
-                           sh_error_message(errno));
+                           sh_error_message(errno, errbuf, sizeof(errbuf)));
           *q = '/';
           return -1;
@@ -226 +227 @@
           sh_error_handle ((-1), FIL__, __LINE__, errno,
                            MSG_SUID_ERROR,
-                           sh_error_message(errno));
+                           sh_error_message(errno, errbuf, sizeof(errbuf)));
           return -1; 
         }
@@ -252 +253 @@
           sh_error_handle ((-1), FIL__, __LINE__, errno,
                            MSG_SUID_ERROR,
-                           sh_error_message(errno));
+                           sh_error_message(errno, errbuf, sizeof(errbuf)));
           return -1;
         } 
@@ -260 +261 @@
           sh_error_handle ((-1), FIL__, __LINE__, errno,
                            MSG_SUID_ERROR,
-                           sh_error_message(errno));
+                           sh_error_message(errno, errbuf, sizeof(errbuf)));
           return -1;
         } 
@@ -267 +268 @@
           sh_error_handle ((-1), FIL__, __LINE__, errno,
                            MSG_SUID_ERROR,
-                           sh_error_message(errno));
+                           sh_error_message(errno, errbuf, sizeof(errbuf)));
           (void) close(fd);
           return -1; 
@@ -307 +308 @@
               sh_error_handle ((-1), FIL__, __LINE__, errno,
                                MSG_SUID_ERROR,
-                               sh_error_message(errno));
+                               sh_error_message(errno, errbuf, sizeof(errbuf)));
               (void) close(fd); 
               return -1;
@@ -332 +333 @@
               sh_error_handle ((-1), FIL__, __LINE__, errno,
                                MSG_SUID_ERROR,
-                               sh_error_message(errno));
+                               sh_error_message(errno, errbuf, sizeof(errbuf)));
               (void) close(fd); 
               return -1;
@@ -343 +344 @@
               sh_error_handle ((-1), FIL__, __LINE__, errno,
                                MSG_SUID_ERROR,
-                               sh_error_message(errno));
+                               sh_error_message(errno, errbuf, sizeof(errbuf)));
               (void) close(fd); 
               return -1;
@@ -358 +359 @@
   int    result;
   char * path;
+  char errbuf[SH_ERRBUF_SIZE];
 
   if (0 != chdir("/"))
@@ -363 +365 @@
       sh_error_handle ((-1), FIL__, __LINE__, errno,
                        MSG_SUID_ERROR,
-                       sh_error_message(errno));
+                       sh_error_message(errno, errbuf, sizeof(errbuf)));
     }
 
@@ -369 +371 @@
     {
       sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
-                      sh_error_message (caperr), 
+                      sh_error_message (caperr, errbuf, sizeof(errbuf)), 
                       _("sl_get_cap_qdel"));
     }
@@ -380 +382 @@
     {
       sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
-                      sh_error_message (caperr), 
+                      sh_error_message (caperr, errbuf, sizeof(errbuf)), 
                       _("sl_drop_cap_qdel"));
     }
@@ -388 +390 @@
       sh_error_handle ((-1), FIL__, __LINE__, errno,
                        MSG_SUID_ERROR,
-                       sh_error_message(errno));
+                       sh_error_message(errno, errbuf, sizeof(errbuf)));
     }
   return result;
@@ -616 +618 @@
   int             cperm_status = 0;
   int             file_d       = -1;
+  char errbuf[SH_ERRBUF_SIZE];
 
   if (retry_lstat(FIL__, __LINE__, fullpath, &fileInfo) == -1)
@@ -640 +643 @@
           sh_error_handle((-1), FIL__, __LINE__, 
                           caperr, MSG_E_SUBGEN,
-                          sh_error_message (caperr), 
+                          sh_error_message (caperr, errbuf, sizeof(errbuf)), 
                           _("sl_get_cap_qdel"));
           cperm_status = -1;
@@ -753 +756 @@
       sh_error_handle((-1), FIL__, __LINE__, 
                       caperr, MSG_E_SUBGEN,
-                      sh_error_message (caperr), 
+                      sh_error_message (caperr, errbuf, sizeof(errbuf)), 
                       _("sl_drop_cap_qdel"));
     }
@@ -792 +795 @@
   msg[0] = '\0';
   /*@-usedef@*/
-  (void) sl_strlcpy (timestrc, 
-                     sh_unix_gmttime (theFile->ctime), 
-                     32);
-  (void) sl_strlcpy (timestra, 
-                     sh_unix_gmttime (theFile->atime), 
-                     32);
-  (void) sl_strlcpy (timestrm, 
-                     sh_unix_gmttime (theFile->mtime), 
-                     32);
+
 #ifdef SH_USE_XML
   (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\""), 
@@ -845 +840 @@
   struct sh_dirent * dirlist = NULL;
   struct sh_dirent * dirlist_orig = NULL;
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("sh_suidchk_check_internal"));
@@ -866 +862 @@
       sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, status, 
                        MSG_E_OPENDIR,
-                       sh_error_message (status), tmp);
+                       sh_error_message (status, errbuf, sizeof(errbuf)), tmp);
       SH_FREE(tmp);
       SL_RETURN( (-1), _("sh_suidchk_check_internal"));
@@ -961 +957 @@
         tmp = sh_util_safe_name(tmpcat);
         sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, status, MSG_ERR_LSTAT,
-                         sh_error_message(status),
+                         sh_error_message(status, errbuf, sizeof(errbuf)),
                          tmpcat );
         SH_FREE(tmp);
@@ -1083 +1079 @@
                       {
                         if (-1 == fflags)
-                          report_file(tmpcat, &theFile, timestrc, timestra, timestrm);
-                        
+                          {
+                            (void) sh_unix_gmttime (theFile->ctime, timestrc, sizeof(timestrc)); 
+                            (void) sh_unix_gmttime (theFile->atime, timestra, sizeof(timestra)); 
+                            (void) sh_unix_gmttime (theFile->mtime, timestrm, sizeof(timestrm));
+
+                            report_file(tmpcat, &theFile, timestrc, timestra, timestrm);
+                          }
                         /* Quarantine file according to configured method
                          */

trunk/src/sh_tools.c

@@ -94 +94 @@
 #ifdef SH_ENCRYPT
 #include "rijndael-api-fst.h"
-char * errorExplain (int err_num)
-{
+char * errorExplain (int err_num, char * buffer, size_t len)
+{
+  char * p;
+
   if      (err_num == BAD_KEY_DIR)
-    return (_("Key direction is invalid"));
+    p = (_("Key direction is invalid"));
   else if (err_num == BAD_KEY_MAT) 
-    return (_("Key material not of correct length"));
+    p = (_("Key material not of correct length"));
   else if (err_num == BAD_KEY_INSTANCE) 
-    return (_("Key passed is not valid"));
+    p = (_("Key passed is not valid"));
   else if (err_num == BAD_CIPHER_MODE) 
-    return (_("Params struct passed to cipherInit invalid"));
+    p = (_("Params struct passed to cipherInit invalid"));
   else if (err_num == BAD_CIPHER_STATE) 
-    return (_("Cipher in wrong state"));
+    p = (_("Cipher in wrong state"));
   else if (err_num == BAD_BLOCK_LENGTH) 
-    return (_("Bad block length"));
+    p = (_("Bad block length"));
   else if (err_num == BAD_CIPHER_INSTANCE) 
-    return (_("Bad cipher instance"));
+    p = (_("Bad cipher instance"));
   else if (err_num == BAD_DATA) 
-    return (_("Data contents are invalid"));
+    p = (_("Data contents are invalid"));
   else  
-    return (_("Unknown error"));
+    p = (_("Unknown error"));
+  sl_strlcpy (buffer, p, len);
+  return buffer;
 }
 
@@ -361 +365 @@
 /* extern int h_errno; */ 
 
-char * sh_tools_errmessage (int tellme)
-{
-
+char * sh_tools_errmessage (int tellme, char * errbuf, size_t len)
+{
+  char * p = NULL;
 #ifdef HOST_NOT_FOUND
     if (tellme == HOST_NOT_FOUND)  
-      return _("The specified host is unknown: ");
+      p = _("The specified host is unknown: ");
 #endif
 #ifdef NO_ADDRESS
     if (tellme == NO_ADDRESS)  
-      return _("The requested name is valid but does not have an IP address: ");
+      p = _("The requested name is valid but does not have an IP address: ");
 #endif
 #ifdef NO_RECOVERY
     if (tellme == NO_RECOVERY)  
-      return _("A non-recoverable name server error occurred: ");
+      p = _("A non-recoverable name server error occurred: ");
 #endif
 #ifdef TRY_AGAIN
     if (tellme == TRY_AGAIN)  
-      return _("A temporary error occurred on an authoritative name server. The specified host is unknown: ");
-#endif
-    return _("Unknown error");
+      p = _("A temporary error occurred on an authoritative name server. The specified host is unknown: ");
+#endif
+    if (!p) p =  _("Unknown error");
+    sl_strlcpy(errbuf, p, len);
+    return errbuf;
 }
 
@@ -474 +480 @@
 
   int    retval;
+  char   errbuf[SH_ERRBUF_SIZE];
 
   sin_cache * check_cache = conn_cache;
@@ -525 +532 @@
               *errnum = 666;
 #endif
-              sl_strlcpy(errmsg, sh_tools_errmessage (*errnum), errsiz);
+              (void) sh_tools_errmessage (*errnum, errmsg, errsiz);
               sl_strlcat(errmsg, address, errsiz); 
               fail = (-1);
@@ -561 +568 @@
                       *errnum = 666;
 #endif
-                      sl_strlcpy(errmsg, 
-                                 sh_tools_errmessage (*errnum), errsiz);
+                      (void) sh_tools_errmessage (*errnum, errmsg, errsiz);
                       sl_strlcat(errmsg, 
                                  inet_ntoa (*(struct in_addr *) &(sinr.sin_addr)),
@@ -637 +643 @@
         sl_strlcpy(ecall, _("socket"), SH_MINIBUF);
         *errnum = status;
-        sl_strlcpy(errmsg, sh_error_message (status), errsiz);
+        sl_strlcpy(errmsg, sh_error_message (status, errbuf, sizeof(errbuf)), errsiz);
         sl_strlcat(errmsg, _(", address "), errsiz);
         sl_strlcat(errmsg, address, errsiz);
@@ -651 +657 @@
         sl_strlcpy(ecall, _("connect"), SH_MINIBUF);
         *errnum = status;
-        sl_strlcpy(errmsg, sh_error_message (status), errsiz);
+        sl_strlcpy(errmsg, sh_error_message (status, errbuf, sizeof(errbuf)), errsiz);
         sl_strlcat(errmsg, _(", address "), errsiz);
         sl_strlcat(errmsg, address, errsiz);
@@ -715 +721 @@
   struct  sigaction  new_act;
   struct  sigaction  old_act;
+  char    errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("sh_write_select"));
@@ -753 +760 @@
             *w_error = errno;
             TPT(( 0, FIL__, __LINE__, _("msg=<select: %s>\n"), 
-                  sh_error_message(*w_error)));
+                  sh_error_message(*w_error, errbuf, sizeof(errbuf))));
             sigaction (SIGPIPE, &old_act, NULL);
             SL_RETURN( countbytes, _("sh_write_select"));
@@ -771 +778 @@
             *w_error = errno;
             TPT(( 0, FIL__, __LINE__, _("msg=<select: %s>\n"), 
-                  sh_error_message(*w_error)));
+                  sh_error_message(*w_error, errbuf, sizeof(errbuf))));
             sigaction (SIGPIPE, &old_act, NULL);
             SL_RETURN( countbytes, _("sh_write_select"));
@@ -853 +860 @@
 {
   unsigned long bytes;
-  char errmsg[256];
 
   SL_ENTER(_("write_port"));
@@ -860 +866 @@
   if (*w_error != 0)
     {
-      sl_strlcpy(errmsg, sh_error_message (*w_error), sizeof(errmsg));
+      char errbuf[SH_ERRBUF_SIZE];
       sh_error_handle((-1), FIL__, __LINE__, *w_error, MSG_TCP_NETRP, 
-                      errmsg, (long) sockfd, _("write_port"));
+                      sh_error_message (*w_error, errbuf, sizeof(errbuf)),
+                      (long) sockfd, _("write_port"));
     }
   SL_RETURN( bytes, _("write_port"));
@@ -874 +881 @@
 {
   unsigned long bytes;
-  char errmsg[256];
 
   SL_ENTER(_("read_port"));
@@ -881 +887 @@
   if (*w_error != 0)
     {
-      sl_strlcpy(errmsg, sh_error_message (*w_error), sizeof(errmsg));
+      char errbuf[SH_ERRBUF_SIZE];
       sh_error_handle((-1), FIL__, __LINE__, *w_error, MSG_TCP_NETRP, 
-                      errmsg, (long) sockfd, _("read_port"));
+                      sh_error_message (*w_error, errbuf, sizeof(errbuf)),
+                      (long) sockfd, _("read_port"));
     }
   SL_RETURN( bytes, _("read_port"));
@@ -1216 +1223 @@
   if (err_num < 0) 
     {
+      char expbuf[SH_ERRBUF_SIZE];
       sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                      errorExplain(err_num), 
+                      errorExplain(err_num, expbuf, sizeof(expbuf)), 
                       _("sh_tools_makePack: cipherInit"));
     }
@@ -1227 +1235 @@
       if (err_num < 0)
         {
+          char expbuf[SH_ERRBUF_SIZE];
           sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                          errorExplain(err_num), 
+                          errorExplain(err_num, expbuf, sizeof(expbuf)), 
                           _("sh_tools_makePack: blockEncrypt"));
         }
@@ -1255 +1264 @@
   int                     err_num;
   int                     blkfac;
+  char expbuf[SH_ERRBUF_SIZE];
 
   msg_size = (256 * (unsigned int)header[1] + (unsigned int)header[2]);
@@ -1274 +1284 @@
     {
       sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                      errorExplain(err_num), 
+                      errorExplain(err_num, expbuf, sizeof(expbuf)), 
                       _("sh_tools_revertPack: cipherInit"));
     }
@@ -1285 +1295 @@
         {
           sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
-                          errorExplain(err_num), 
+                          errorExplain(err_num, expbuf, sizeof(expbuf)), 
                           _("sh_tools_revertPack: blockDecrypt"));
         }

trunk/src/sh_unix.c

@@ -797 +797 @@
 #endif
 #ifdef SIGPIPE
+#ifdef HAVE_PTHREAD
+  retry_sigaction(FIL__, __LINE__, SIGPIPE,   &ignact, &oldact);
+#else
   retry_sigaction(FIL__, __LINE__, SIGPIPE,      &act, &oldact);
+#endif
 #endif
 #ifdef SIGALRM
@@ -1181 +1185 @@
 
 #ifdef HAVE_INITGROUPS
-char *  sh_unix_getUIDname (int level, uid_t uid);
+char *  sh_unix_getUIDname (int level, uid_t uid, char * out, size_t len);
 int  sh_unix_initgroups2 (uid_t in_pid, gid_t in_gid)
 {
   int status  = -1;
-  char * user = NULL;
+  char user[SH_MINIBUF];
 
   SL_ENTER(_("sh_unix_initgroups2"));
 
-  user = sh_unix_getUIDname (SH_ERR_ERR, in_pid);
-  if (user == NULL)
+  if (NULL == sh_unix_getUIDname (SH_ERR_ERR, in_pid, user, sizeof(user)))
     SL_RETURN((-1), _("sh_unix_initgroups2"));
   status = sh_initgroups (user, in_gid);
@@ -1481 +1484 @@
       if ((test == -1) && (errno != EINVAL)) 
         {
+          char errbuf[SH_ERRBUF_SIZE];
           status = errno;
           sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_SIG,
-                           sh_error_message (status), sig_num);
+                           sh_error_message (status, errbuf, sizeof(errbuf)), sig_num);
         }
     }
@@ -1734 +1738 @@
       if ( (-1) == status ) 
         {
+          char errbuf[SH_ERRBUF_SIZE];
           status = errno;
           sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_CHDIR,
-                           sh_error_message (status), chroot_dir);
+                           sh_error_message (status, errbuf, sizeof(errbuf)), chroot_dir);
           aud_exit(FIL__, __LINE__, EXIT_FAILURE);
         }
@@ -1779 +1784 @@
 {
   int    res = 0;
-
+  
   SL_ENTER(_("sh_unix_setnodeamon"));
 
@@ -1804 +1809 @@
   extern int sh_socket_open_int ();
 #endif
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("sh_unix_init"));
@@ -1849 +1855 @@
       status = errno;
       sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_CHDIR,
-                       sh_error_message (status), "/");
+                       sh_error_message (status, errbuf, sizeof(errbuf)), "/");
       aud_exit(FIL__, __LINE__, EXIT_FAILURE);
     }
@@ -1897 +1903 @@
           status = errno;
           sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN, 
-                          sh_error_message(status), _("open"));
+                          sh_error_message(status, errbuf, sizeof(errbuf)), _("open"));
           aud_exit(FIL__, __LINE__, EXIT_FAILURE);
         }
@@ -1909 +1915 @@
           status = errno;
           sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN, 
-                          sh_error_message(status), _("dup"));
+                          sh_error_message(status, errbuf, sizeof(errbuf)), _("dup"));
           aud_exit(FIL__, __LINE__, EXIT_FAILURE);
         }
@@ -1962 +1968 @@
       status = errno;
       sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN, 
-                          sh_error_message(status), _("chroot"));
+                          sh_error_message(status, errbuf, sizeof(errbuf)), _("chroot"));
       aud_exit(FIL__, __LINE__, EXIT_FAILURE);
     }
@@ -2095 +2101 @@
 #endif
 
-char * sh_unix_time (time_t thetime)
+char * sh_unix_time (time_t thetime, char * buffer, size_t len)
 {
 
   int           status;
-
+  char          AsciiTime[81];                       /* local time   */
   time_t        time_now;
   struct tm   * time_ptr;
@@ -2105 +2111 @@
   struct tm     time_tm;
 #endif
-  static char   AsciiTime[81];                       /* local time   */
-  static char   RetTime[81];                         /* local time   */
 #ifdef SH_USE_XML
   static char   deftime[] = N_("0000-00-00T00:00:00"); /* default time */
@@ -2202 +2206 @@
 #endif
 
-  if (time_now == (-1) ) 
-    SL_RETURN( _(deftime), _("sh_unix_time"));
+  if (time_now == (-1) )
+    {
+      sl_strlcpy(buffer, _(deftime), len);
+      SL_RETURN(buffer, _("sh_unix_time"));
+    }
   else
     {
@@ -2214 +2221 @@
   if (time_ptr != NULL) 
     {
-      status = strftime (AsciiTime, 80,
+      status = strftime (AsciiTime, sizeof(AsciiTime),
 #ifdef SH_USE_XML
                          _("%Y-%m-%dT%H:%M:%S%%s"),
@@ -2222 +2229 @@
                          time_ptr);
 
-      sl_snprintf(RetTime, 80, AsciiTime, t_zone(&time_now));
-
-      if ( (status == 0) || (status == 80) ) 
-        SL_RETURN( _(deftime), _("sh_unix_time"));
+      sl_snprintf(buffer, len, AsciiTime, t_zone(&time_now));
+
+      if ( (status == 0) || (status == sizeof(AsciiTime)) )
+        {
+          sl_strlcpy(buffer, _(deftime), len);
+          SL_RETURN( buffer, _("sh_unix_time"));
+        }
       else
-        SL_RETURN( &RetTime[0], _("sh_unix_time"));
+        {
+          SL_RETURN(buffer, _("sh_unix_time"));
+        }
     }
 
   /* last resort
    */
-  SL_RETURN( _(deftime), _("sh_unix_time"));
+  sl_strlcpy(buffer, _(deftime), len);
+  SL_RETURN( buffer, _("sh_unix_time"));
 }
 
@@ -2248 +2261 @@
 }
     
-char * sh_unix_gmttime (time_t thetime)
+char * sh_unix_gmttime (time_t thetime, char * buffer, size_t len)
 {
 
@@ -2257 +2270 @@
   struct tm     time_tm;
 #endif
-  static char   AsciiTime[81];                       /* GMT time   */
+  char   AsciiTime[81];                       /* GMT time   */
 #ifdef SH_USE_XML
   static char   deftime[] = N_("0000-00-00T00:00:00"); /* default time */
@@ -2292 +2305 @@
                          time_ptr);
 
-      if ( (status == 0) || (status == 80) ) 
-        SL_RETURN( _(deftime), _("sh_unix_gmttime"));
+      if ( (status == 0) || (status == 80) )
+        sl_strlcpy(buffer, _(deftime), len);
       else
-        SL_RETURN( &AsciiTime[0], _("sh_unix_gmttime"));
+        sl_strlcpy(buffer, AsciiTime, len);
+      SL_RETURN( buffer, _("sh_unix_gmttime"));
     }
 
   /* last resort
    */
-  SL_RETURN( _(deftime), _("sh_unix_gmttime"));
-}
-
-
-
-char *  sh_unix_getUIDdir (int level, uid_t uid)
+  sl_strlcpy(buffer, _(deftime), len);
+  SL_RETURN( buffer, _("sh_unix_gmttime"));
+}
+
+
+char *  sh_unix_getUIDdir (int level, uid_t uid, char * out, size_t len)
 {
   struct passwd * tempres;
@@ -2313 +2327 @@
   char   buffer[SH_PWBUF_SIZE];
 #endif
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("sh_unix_getUIDdir"));
@@ -2326 +2341 @@
   if (tempres == NULL) {
     sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
-                     sh_error_message(status),
+                     sh_error_message(status, errbuf, sizeof(errbuf)),
                      _("getpwuid"), (long) uid, _("completely missing"));
     SL_RETURN( NULL, _("sh_unix_getUIDdir"));
@@ -2332 +2347 @@
 
   if (tempres->pw_dir != NULL) {
-    SL_RETURN( tempres->pw_dir, _("sh_unix_getUIDdir"));
+    sl_strlcpy(out, tempres->pw_dir, len);
+    SL_RETURN( out, _("sh_unix_getUIDdir"));
   } else {
     sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
-                     sh_error_message(status),
+                     sh_error_message(status, errbuf, sizeof(errbuf)),
                      _("getpwuid"), (long) uid, _("pw_dir"));
     SL_RETURN( NULL, _("sh_unix_getUIDdir"));
@@ -2341 +2357 @@
 }
 
-char *  sh_unix_getUIDname (int level, uid_t uid)
+SH_MUTEX_STATIC(getUIDname, PTHREAD_MUTEX_INITIALIZER);
+
+char *  sh_unix_getUIDname (int level, uid_t uid, char * out, size_t len)
 {
   struct passwd * tempres;
@@ -2351 +2369 @@
   static uid_t    old_uid;
   static char     name[32] = { '\0' };
+  char errbuf[SH_ERRBUF_SIZE];
 
   SL_ENTER(_("sh_unix_getUIDname"));
 
   if ((uid == old_uid) && (name[0] != '\0')) {
-    SL_RETURN( name, _("sh_unix_getUIDname"));
+    out[0] = '\0';
+    SH_MUTEX_LOCK_UNSAFE(getUIDname);
+    if ((uid == old_uid) && (name[0] != '\0')) {
+      sl_strlcpy(out, name, len);
+    }
+    SH_MUTEX_UNLOCK_UNSAFE(getUIDname);
+    if (out[0] != '\0')
+      SL_RETURN( out, _("sh_unix_getUIDname"));
   }
 
@@ -2368 +2394 @@
   if (tempres == NULL) {
     sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
-                     sh_error_message(status),
+                     sh_error_message(status, errbuf, sizeof(errbuf)),
                      _("getpwuid"), (long) uid, _("completely missing"));
     SL_RETURN( NULL, _("sh_unix_getUIDname"));
@@ -2375 +2401 @@
 
   if (tempres->pw_name != NULL) {
-    /* NEED_LOCK */
+    SH_MUTEX_LOCK_UNSAFE(getUIDname);
     sl_strlcpy(name, tempres->pw_name, sizeof(name));
     old_uid = uid;
-    /* END_LOCK  */
-    SL_RETURN( name, _("sh_unix_getUIDname"));
+    sl_strlcpy(out, name, len);
+    SH_MUTEX_UNLOCK_UNSAFE(getUIDname);
+    SL_RETURN( out, _("sh_unix_getUIDname"));
   } else {
     sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
-                     sh_error_message(status),
+                     sh_error_message(status, errbuf, sizeof(errbuf)),
                      _("getpwuid"), (long) uid, _("pw_user"));
     SL_RETURN( NULL, _("sh_unix_getUIDname"));
@@ -2388 +2415 @@
 }
 
-char *  sh_unix_getGIDname (int level, gid_t gid)
+SH_MUTEX_STATIC(getGIDname, PTHREAD_MUTEX_INITIALIZER);
+
+char *  sh_unix_getGIDname (int level, gid_t gid, char * out, size_t len)
 {
   struct group  * tempres;
@@ -2398 +2427 @@
   char            buffer[SH_GRBUF_SIZE];
 #endif
+  char errbuf[SH_ERRBUF_SIZE];
   
 
@@ -2403 +2433 @@
 
   if ((gid == old_gid) && (name[0] != '\0')) {
-    SL_RETURN( name, _("sh_unix_getUIDname"));
+    out[0] = '\0';
+    SH_MUTEX_LOCK_UNSAFE(getGIDname);
+    if ((gid == old_gid) && (name[0] != '\0')) {
+      sl_strlcpy(out, name, len);
+    }
+    SH_MUTEX_UNLOCK_UNSAFE(getGIDname);
+    if (out[0] != '\0')
+      SL_RETURN( out, _("sh_unix_getGIDname"));
   }
-  
+
 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
   status = sh_getgrgid_r(gid, &grp, buffer, sizeof(buffer), &tempres);
@@ -2416 +2453 @@
   if (tempres == NULL) {
     sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
-                     sh_error_message(status),
+                     sh_error_message(status, errbuf, sizeof(errbuf)),
                      _("getgrgid"), (long) gid, _("completely missing"));
       
@@ -2422 +2459 @@
   }
 
+  /* FIXME: need to return caller-supplied buffer */
   if (tempres->gr_name != NULL) {
-    /* NEED_LOCK */
+    SH_MUTEX_LOCK_UNSAFE(getGIDname);
     sl_strlcpy(name, tempres->gr_name, sizeof(name));
     old_gid = gid;
-    /* END_LOCK  */
-    SL_RETURN( name, _("sh_unix_getGIDname"));
+    sl_strlcpy(out, name, len);
+    SH_MUTEX_UNLOCK_UNSAFE(getGIDname);
+    SL_RETURN( out, _("sh_unix_getGIDname"));
   } else {
     sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
-                     sh_error_message(status),
+                     sh_error_message(status, errbuf, sizeof(errbuf)),
                      _("getgrgid"), (long) gid, _("gr_name"));
     SL_RETURN( NULL, _("sh_unix_getGIDname"));
@@ -2440 +2479 @@
   char          * p;
   uid_t  seuid, sruid;
+  char   user[USER_MAX];
+  char   dir[SH_PATHBUF];
 
   SL_ENTER(_("sh_unix_getUser"));
@@ -2447 +2488 @@
   sh.effective.uid = seuid;
 
-  p = sh_unix_getUIDdir (SH_ERR_ERR, seuid);
+  p = sh_unix_getUIDdir (SH_ERR_ERR, seuid, dir, sizeof(dir));
 
   if (p == NULL)
@@ -2466 +2507 @@
   sh.real.uid = sruid;
 
-  p = sh_unix_getUIDname (SH_ERR_ERR, sruid);
+  p = sh_unix_getUIDname (SH_ERR_ERR, sruid, user, sizeof(user));
   if (p == NULL)
     SL_RETURN((-1), _("sh_unix_getUser"));
@@ -2480 +2521 @@
     }
 
-  p = sh_unix_getUIDdir (SH_ERR_ERR, sruid);
+  p = sh_unix_getUIDdir (SH_ERR_ERR, sruid, dir, sizeof(dir));
 
   if (p == NULL)
@@ -3270 +3311 @@
         {
           if (S_FALSE == sh_ignore_chk_del(theFile->fullpath)) {
+            char errbuf[SH_ERRBUF_SIZE];
             tmp2 = sh_util_safe_name (theFile->fullpath);
             sh_error_handle (level, FIL__, __LINE__, stat_return, MSG_FI_LSTAT,
-                             sh_error_message (stat_return), tmp2);
+                             sh_error_message (stat_return, errbuf, sizeof(errbuf)), 
+                             tmp2);
             SH_FREE(tmp2);
           }
@@ -3465 +3508 @@
    */
 
-  if ( (name = sh_unix_getGIDname(SH_ERR_ALL,
-                                  buf.st_gid)) != NULL) {
-    sl_strlcpy (theFile->c_group, name, GROUP_MAX+1);
-  } else {
+  if (NULL == sh_unix_getGIDname(SH_ERR_ALL, buf.st_gid, theFile->c_group, GROUP_MAX+1)) {
 
     tmp2 = sh_util_safe_name (theFile->fullpath);
@@ -3489 +3529 @@
 
   
-  if ( (name = sh_unix_getUIDname(SH_ERR_ALL,
-                                  buf.st_uid)) != NULL) {
-    sl_strlcpy (theFile->c_owner, name, USER_MAX+1);
-  } else {
+  if (NULL == sh_unix_getUIDname(SH_ERR_ALL, buf.st_uid, theFile->c_owner, USER_MAX+)) {
 
     tmp2 = sh_util_safe_name (theFile->fullpath);
@@ -3518 +3555 @@
       tmp2 = sh_util_safe_name ((filename == NULL) ? 
                                 theFile->fullpath : filename);
-      sl_strlcpy(timestr, sh_unix_time(theFile->mtime), 81);
+      (void) sh_unix_time(theFile->mtime, timestr, sizeof(timestring));
       sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_LIST,
                        theFile->c_mode,
@@ -3547 +3584 @@
       if (linksize < 0) 
         {
+          char errbuf[SH_ERRBUF_SIZE];
           linksize = errno;
           tmp2 = sh_util_safe_name (theFile->fullpath);
           sh_error_handle (level, FIL__, __LINE__, linksize, MSG_FI_RDLNK,
-                           sh_error_message (linksize), tmp2);
+                           sh_error_message (linksize, errbuf, sizeof(errbuf)), tmp2);
           SH_FREE(tmp2);
           SH_FREE(linknamebuf);
@@ -3598 +3636 @@
         if (stat_return != ENOENT)
           { 
+            char errbuf[SH_ERRBUF_SIZE];
             sh_error_handle (level, FIL__, __LINE__, stat_return, 
                              MSG_FI_LSTAT,
-                             sh_error_message (stat_return), tmp2);
+                             sh_error_message (stat_return,errbuf, sizeof(errbuf)), 
+                             tmp2);
           }
         else 
@@ -3873 +3913 @@
   else if (flag != NULL)
     {
+      char errbuf[SH_ERRBUF_SIZE];
       error = errno;
       sh_error_handle ((-1), FIL__, __LINE__, error, MSG_E_UNLNK,
-                       sh_error_message(error), lockfile);
+                       sh_error_message(error, errbuf, sizeof(errbuf)), 
+                       lockfile);
       SL_RETURN((-1),_("sh_unix_unlock"));
     }
@@ -4211 +4253 @@
         {
 #ifdef TEST_MLOCK
-          fprintf(stderr, "mlock: error: %s\n", sh_error_message(errno));
+          char errbuf[SH_ERRBUF_SIZE];
+          fprintf(stderr, "mlock: error: %s\n", 
+                  sh_error_message(errno, errbuf, sizeof(errbuf)));
 #endif
           SH_FREE(page_list);

trunk/src/sh_utmp.c

@@ -799 +799 @@
           ) {
         status = sh_utmp_login_a(user->name);
-        (void) sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX);
+        (void) sh_unix_time (user->time, ttt, TIM_MAX);
         sh_error_handle( ShUtmpLoginSolo, FIL__, __LINE__, 0,
 #if defined(HAVE_UTHOST) && defined(HAVE_UTADDR)
@@ -823 +823 @@
           {       
             status = sh_utmp_login_a(user->name);
-            (void) sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX);
+            (void) sh_unix_time (user->time, ttt, TIM_MAX);
             sh_error_handle( ShUtmpLoginMulti, FIL__, __LINE__, 0,
 #if defined(HAVE_UTHOST) && defined(HAVE_UTADDR)
@@ -858 +858 @@
         {
           status = sh_utmp_login_r(user->name);
-          /* sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX); */
-          (void) sl_strlcpy(ttt, sh_unix_time (ut->ut_time), TIM_MAX);
+          (void) sh_unix_time (ut->ut_time, ttt, TIM_MAX);
           sh_error_handle( ShUtmpLogout, FIL__, __LINE__, 0,
 #if defined(HAVE_UTHOST) && defined(HAVE_UTADDR)
@@ -889 +888 @@
         {
           (void) sl_strlcpy(terminated_line, ut->ut_line, UT_HOSTSIZE);
-          (void) sl_strlcpy(ttt, sh_unix_time (ut->ut_time), TIM_MAX);
+          (void) sh_unix_time (ut->ut_time, ttt, TIM_MAX);
           sh_error_handle( ShUtmpLogout, FIL__, __LINE__, 0,
                            MSG_UT_LG3C,
@@ -920 +919 @@
       userlist         = user;
 
-      sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX);
+      (void) sh_unix_time (user->time, ttt, TIM_MAX);
 
 
@@ -946 +945 @@
   else  /* probably a logout */
     {
-      sl_strlcpy(ttt, sh_unix_time (ut->ut_time), TIM_MAX);
-      /* sl_strlcpy(ttt, sh_unix_time (user->time), TIM_MAX); */
+      (void) sh_unix_time (ut->ut_time, ttt, TIM_MAX);
 
       sh_error_handle( ShUtmpLogout, FIL__, __LINE__, 0,