Changeset 22 for trunk/src/sh_unix.c


Ignore:
Timestamp:
Feb 23, 2006, 12:03:58 AM (16 years ago)
Author:
rainer
Message:

Minor code revisions.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/sh_unix.c

    r20 r22  
    307307    *p = '0' + (u % 10);
    308308    u /= 10;
    309   } while (u);
    310   if (iisneg == 1) {
     309  } while (u && (p != str));
     310  if ((iisneg == 1) && (p != str)) {
    311311    --p;
    312312    *p = '-';
     
    323323extern int OnlyStderr;
    324324
    325 int safe_logger (int signal, int method, pid_t thepid)
     325int safe_logger (int signal, int method, char * details)
    326326{
    327327  int i = 0;
     
    331331  char  str[128];
    332332  char  * p;
    333 
     333 
    334334  char l0[64], l1[64], l2[64], l3[64];
    335335  char a0[32], a1[32], a2[32];
    336336  char e0[128];
    337337  char msg[128];
    338 
     338 
    339339  char * locations[] = { NULL, NULL, NULL, NULL, NULL };
    340340  char * envp[]      = { NULL, NULL };
    341341  char * argp[]      = { NULL, NULL, NULL, NULL, NULL };
    342 
     342 
     343  pid_t  thepid = getpid();
     344 
    343345  if ((sh.flag.isdaemon == S_FALSE) || (OnlyStderr == S_TRUE))
    344346    method = 1;
    345 
     347 
    346348  /* seems that solaris cc needs this way of initializing ...
    347349   */
     
    350352  locations[2] = l2;
    351353  locations[3] = l3;
    352 
     354 
    353355  envp[0] = e0;
    354 
     356 
    355357  argp[0] = a0;
    356358  argp[1] = a1;
    357359  argp[2] = a2;
    358 
    359   strcpy (l0, _("/usr/bin/logger"));                   /* known to fit  */
    360   strcpy (l1, _("/usr/sbin/logger"));                  /* known to fit  */
    361   strcpy (l2, _("/usr/ucb/logger"));                   /* known to fit  */
    362   strcpy (l3, _("/bin/logger"));                       /* known to fit  */
    363 
    364   strcpy (a0, _("logger"));                            /* known to fit  */
    365   strcpy (a1, _("-p"));                                /* known to fit  */
    366   strcpy (a2, _("daemon.alert"));                      /* known to fit  */
    367 
    368   strcpy (e0,                                          /* known to fit  */
    369           _("PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/ucb:/usr/local/bin"));
    370 
     360 
    371361  sl_strlcpy(msg, _("samhain["), 128);
    372362  p = safe_itoa((int) thepid, str, 128);
     
    375365  if (signal == 0)
    376366    {
    377       sl_strlcat(msg, _("]: out of memory"), 128);
     367      if (details == NULL) {
     368        sl_strlcat(msg, _("]: out of memory"), 128);
     369      } else {
     370        sl_strlcat(msg, _("]: "), 128);
     371        sl_strlcat(msg, details, 128);
     372      }
    378373    }
    379374  else
     
    393388    return 0;
    394389  }
     390
     391  sl_strlcpy (l0, _("/usr/bin/logger"), 64);
     392  sl_strlcpy (l1, _("/usr/sbin/logger"), 64);
     393  sl_strlcpy (l2, _("/usr/ucb/logger"), 64);
     394  sl_strlcpy (l3, _("/bin/logger"), 64);
     395
     396  sl_strlcpy (a0, _("logger"), 32);
     397  sl_strlcpy (a1, _("-p"), 32);
     398  sl_strlcpy (a2, _("daemon.alert"), 32);
     399
     400  sl_strlcpy (e0,
     401              _("PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/ucb:/usr/local/bin"),
     402              128);
     403
    395404  while (locations[i] != NULL) {
    396405    status = stat(locations[i], &buf);
     
    414423}
    415424
     425int safe_fatal (int signal, int method, char * details,
     426                char * file, int line)
     427{
     428  char msg[128];
     429  char str[128];
     430  char * p;
     431  p = safe_itoa((int) line, str, 128);
     432  sl_strlcpy(msg, _("FATAL: "), 128);
     433  sl_strlcat(msg, file, 128);
     434  sl_strlcat(msg, ": ", 128);
     435  if (p && (*p)) {
     436    sl_strlcat(msg, p   , 128);
     437    sl_strlcat(msg, ": ", 128);
     438  }
     439  sl_strlcat(msg, details, 128);
     440  safe_logger (signal, method, msg);
     441  _exit(EXIT_FAILURE);
     442}
    416443
    417444extern char sh_sig_msg[64];
     
    451478        {
    452479          chdir ("/");
    453           safe_logger (mysignal, 0, getpid());
     480          safe_logger (mysignal, 0, NULL);
    454481        }
    455482      _exit(mysignal);
     
    504531    memset (skey, '\0', sizeof(sh_key_t));
    505532  if (immediate_exit_fast < 2)
    506     safe_logger (mysignal, 0, getpid());
     533    safe_logger (mysignal, 0, NULL);
    507534  _exit(mysignal);
    508535#else
     
    518545      close_ipc ();
    519546#endif
    520       safe_logger (mysignal, 0, getpid());
     547      safe_logger (mysignal, 0, NULL);
    521548      chdir ("/");
    522549      raise(SIGFPE);
     
    819846/* checksum the own binary
    820847 */
    821 int sh_unix_self_hash (char * c)
     848int sh_unix_self_hash (const char * c)
    822849{
    823850  char message[512];
     
    891918
    892919/* added    Tue Feb 22 10:36:44 NFT 2000 Rainer Wichmann            */
    893 static int tf_add_trusted_user_int(char * c)
     920static int tf_add_trusted_user_int(const char * c)
    894921{
    895922  register struct passwd *          w;
     
    919946}
    920947
    921 int tf_add_trusted_user(char * c)
     948int tf_add_trusted_user(const char * c)
    922949{
    923950  int    i;
     
    12291256  char ** env1;
    12301257  int   envlen = 0;
     1258  size_t len;
    12311259
    12321260  SL_ENTER(_("sh_unix_copyenv"));
     
    12481276  envlen = 0;
    12491277
    1250   while (env0 != NULL && env0[envlen] != NULL) {
    1251     env1[envlen] = malloc (strlen(env0[envlen]) + 1); /* only once */
     1278  while (env0 != NULL && env0[envlen] != NULL) {
     1279    len = strlen(env0[envlen]) + 1;
     1280    env1[envlen] = malloc (len); /* only once */
    12521281    if (env1[envlen] == NULL)
    12531282      {
     
    12551284        SL_RET0(_("sh_unix_copyenv"));
    12561285      }
    1257     strcpy(env1[envlen], env0[envlen]);                /* known to fit  */
     1286    sl_strlcpy(env1[envlen], env0[envlen], len);
    12581287    ++envlen;
    12591288  }
     
    14351464
    14361465  (void) uname (&buf);
    1437 
     1466  /* flawfinder: ignore */ /* ff bug, ff sees system() */
    14381467  sl_strlcpy (sh.host.system,  buf.sysname, SH_MINIBUF);
    14391468  sl_strlcpy (sh.host.release, buf.release, SH_MINIBUF);
     
    16391668          aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    16401669        }
     1670      /* flawfinder: ignore */
    16411671      return (chroot(chroot_dir));
    16421672    }
     
    19231953}
    19241954
    1925 int sh_unix_settimeserver (char * address)
     1955int sh_unix_settimeserver (const char * address)
    19261956{
    19271957
     
    20962126/* whether to use localtime for file timesatams in logs
    20972127 */
    2098 int sh_unix_uselocaltime (char * c)
     2128int sh_unix_uselocaltime (const char * c)
    20992129{
    21002130  int i;
     
    27322762}
    27332763
    2734 int sh_unix_set_io_limit (char * c)
     2764int sh_unix_set_io_limit (const char * c)
    27352765{
    27362766  long val;
     
    27722802  if (tmpFile.size < fbuf->st_size)
    27732803    {
    2774       strcpy(fileHash,                         /* known to fit */
    2775              sh_tiger_generic_hash (filename, TIGER_FD, tmpFile.size,
    2776                                     alert_timeout));
     2804      sl_strlcpy(fileHash,
     2805                sh_tiger_generic_hash (filename, TIGER_FD, tmpFile.size,
     2806                                       alert_timeout),
     2807                KEY_LEN+1);
    27772808
    27782809      /* return */
     
    27812812
    27822813 out:
    2783   strcpy(fileHash,                              /* known to fit */
    2784          _("000000000000000000000000000000000000000000000000"));
     2814  sl_strlcpy(fileHash,
     2815             _("000000000000000000000000000000000000000000000000"),
     2816             KEY_LEN+1);
    27852817  SL_RETURN( -1, _("sh_unix_checksum_size"));
    27862818}
     
    29032935    {
    29042936      if (fileHash != NULL)
    2905         strcpy(fileHash,                              /* known to fit */
    2906                _("000000000000000000000000000000000000000000000000"));
     2937        sl_strlcpy(fileHash,
     2938                   _("000000000000000000000000000000000000000000000000"),
     2939                   KEY_LEN+1);
    29072940    }
    29082941 
     
    29202953          if ((theFile->check_mask & MODI_CHK) == 0)
    29212954            {
    2922               strcpy(fileHash,                         /* known to fit */
    2923                      _("000000000000000000000000000000000000000000000000"));
     2955              sl_strlcpy(fileHash,
     2956                         _("000000000000000000000000000000000000000000000000"),
     2957                         KEY_LEN+1);
    29242958            }
    29252959          else if ((theFile->check_mask & MODI_PREL) != 0 &&
     
    29292963              if (0 != sh_prelink_run (theFile->fullpath,
    29302964                                       fileHash, alert_timeout))
    2931                 strcpy(fileHash,                       /* known to fit */
    2932                        _("000000000000000000000000000000000000000000000000"));
     2965                sl_strlcpy(fileHash,
     2966                           _("000000000000000000000000000000000000000000000000"),
     2967                           KEY_LEN+1);
    29332968            }
    29342969          else
    29352970            {
    29362971              tiger_fd = rval_open;
    2937               strcpy(fileHash,                         /* known to fit */
    2938                      sh_tiger_generic_hash (theFile->fullpath, TIGER_FD, 0,
    2939                                             alert_timeout));
     2972              sl_strlcpy(fileHash,
     2973                         sh_tiger_generic_hash (theFile->fullpath,
     2974                                                TIGER_FD, 0,
     2975                                                alert_timeout),
     2976                         KEY_LEN+1);
    29402977              if ((theFile->check_mask & MODI_SGROW) != 0)
    29412978                {
     
    29602997          if ((theFile->check_mask & MODI_CHK) == 0)
    29612998            {
    2962               strcpy(fileHash,                         /* known to fit */
    2963                      _("000000000000000000000000000000000000000000000000"));
     2999              sl_strlcpy(fileHash,
     3000                         _("000000000000000000000000000000000000000000000000"),
     3001                         KEY_LEN+1);
    29643002            }
    29653003          else if (policy == SH_LEVEL_PRELINK &&
     
    29693007              if (0 != sh_prelink_run (theFile->fullpath,
    29703008                                       fileHash, alert_timeout))
    2971                 strcpy(fileHash,                       /* known to fit */
    2972                        _("000000000000000000000000000000000000000000000000"));
     3009                sl_strlcpy(fileHash,
     3010                           _("000000000000000000000000000000000000000000000000"),
     3011                           KEY_LEN+1);
    29733012            }
    29743013          else
     
    31453184      linknamebuf = SH_ALLOC(PATH_MAX);
    31463185
     3186      /* flawfinder: ignore */
    31473187      linksize    = readlink (theFile->fullpath, linknamebuf, PATH_MAX-1);
    31483188
     
    31603200          SH_FREE(tmp2);
    31613201          SH_FREE(linknamebuf);
     3202          theFile->linkpath[0] = '-';
     3203          theFile->linkpath[1] = '\0';
    31623204          SL_RETURN((-1),_("sh_unix_getinfo"));
    31633205        }
Note: See TracChangeset for help on using the changeset viewer.