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.