Changeset 137


Ignore:
Timestamp:
Oct 28, 2007, 1:17:58 AM (12 years ago)
Author:
rainer
Message:

Fix compile errors.

Location:
trunk/src
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/CuTest.c

    r96 r137  
    3232#include <string.h>
    3333#include <math.h>
     34#include <unistd.h>
    3435
    3536#include "CuTest.h"
  • trunk/src/cutest_sh_tiger0.c

    r133 r137  
    99#include "sh_tiger.h"
    1010
     11#if defined(HAVE_PTHREAD) && defined(SH_STEALTH)
     12extern void sh_g_init();
     13#endif
     14
     15
    1116static void init() {
    1217
     
    1621  int i;
    1722
     23#if defined(HAVE_PTHREAD) && defined(SH_STEALTH)
     24  sh_g_init();
     25#endif
    1826  skey = (sh_key_t *) malloc (sizeof(sh_key_t));
    1927  if (skey != NULL)
     
    6977  char hashbuf[KEYBUF_SIZE];
    7078
     79#if defined(HAVE_PTHREAD) && defined(SH_STEALTH)
     80  sh_g_init();
     81#endif
     82
    7183  input  = "";
    7284  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
  • trunk/src/samhain.c

    r134 r137  
    139139
    140140#ifdef HAVE_PTHREAD
    141 typedef struct gt {
     141struct gt {
    142142  size_t g_count;
    143143  char * g_glob;
     
    149149{
    150150  struct gt * ptr = malloc(sizeof(struct gt));
    151   if (!gt)
     151  if (!ptr)
    152152    return -1;
    153153  ptr->g_count    = 0;
     
    166166}
    167167
    168 static void sh_g_init()
     168void sh_g_init()
    169169{
    170170  if (0 != pthread_key_create(&g_key, sh_g_destroy))
     
    176176  if (0 != sh_g_thread())
    177177    {
    178       perror("1");
     178      perror("2");
    179179      exit(EXIT_FAILURE);
    180180    }
     
    191191  size_t j;
    192192
    193 #ifdef HAVE_PTHREAD
    194   struct gt * ptr = pthread_getspecific(g_key);
    195   size_t count = ptr->g_count;
    196   char *  glob = ptr->g_glob;
    197 #else
     193#ifndef HAVE_PTHREAD
    198194  static   size_t  count = 0;
    199195  static   char glob[SH_MAX_GLOBS * (GLOB_LEN+1)];
    200 #
    201 
    202   if (str == NULL)
     196#else
     197  struct gt * ptr = pthread_getspecific(g_key);
     198  size_t count;
     199  char *  glob;
     200
     201  if (ptr) {
     202    count = ptr->g_count;
     203    glob  = ptr->g_glob;
     204  } else {
    203205    return NULL;
     206  }
     207#endif
     208
     209  if (str != NULL)
     210    j = strlen(str);
    204211  else
    205     j = strlen(str);
     212    return NULL;
    206213
    207214  ASSERT((j <= GLOB_LEN), _("j <= GLOB_LEN"))
     
    228235  i     = count;
    229236#ifdef HAVE_PTHREAD
    230   ptr->count = count + j + 1;
     237  ptr->g_count = count + j + 1;
    231238#else
    232239  count = count + j + 1;
     
    248255}
    249256
     257#else
     258/* not stealth */
     259#define SH_G_INIT ((void)0)
    250260#endif
    251261
     
    815825    }
    816826
    817   SH_MUTEX_LOCK(readdir_lock);
     827  SH_MUTEX_LOCK(mutex_readdir);
    818828
    819829  while (NULL != (d = readdir(dp)) && i < 65535)
     
    838848    }
    839849
    840   SH_MUTEX_UNLOCK(readdir_lock);
     850  SH_MUTEX_UNLOCK(mutex_readdir);
    841851
    842852  closedir(dp);
  • trunk/src/sh_calls.c

    r134 r137  
    781781    if (i < 0)
    782782      sh_error_handle ((-1), file, line, error, MSG_ERR_PIPE,
    783                        sh_error_message(error),
     783                       sh_error_message(error, errbuf, sizeof(errbuf)),
    784784                       (long) 0, (long) 0);
    785785    else
  • trunk/src/sh_err_console.c

    r132 r137  
    7070  key_t            key;
    7171  int              error;
     72#if defined(WITH_TPT)
    7273  char errbuf[SH_ERRBUF_SIZE];
     74#endif
    7375
    7476  SL_ENTER(_("open_ipc"));
     
    132134  int              error;
    133135  int              count    = 0;
     136#if defined(WITH_TPT)
    134137  char errbuf[SH_ERRBUF_SIZE];
     138#endif
    135139
    136140  SL_ENTER(_("push_message_queue"));
  • trunk/src/sh_err_log.c

    r133 r137  
    649649  char               * sigkey_old;
    650650  char               * crypto;
     651  char                 hashbuf[KEYBUF_SIZE];
    651652
    652653  SL_ENTER(_("sh_log_file"));
     
    865866  if (current->log_start == S_TRUE)
    866867    {
    867       char hashbuf[KEYBUF_SIZE];
    868 
    869868      if (sh.real.user[0] == '\0')
    870869        (void) sh_unix_getUser();
     
    948947      log_msg.timestamp[0] = '\0';
    949948      (void) sl_strlcpy (sigkey_new,
    950                          sh_tiger_hash (sigkey_old, TIGER_DATA, KEY_LEN),
     949                         sh_tiger_hash (sigkey_old, TIGER_DATA, KEY_LEN, hashbuf, sizeof(hashbuf)),
    951950                         KEY_LEN+1);
    952951    }
     
    954953  /* --- Sign the message with the signature key. ---
    955954   */
     955  sh_tiger_hash (log_msg.msg, -1, 10, hashbuf, 10);
     956  sh_tiger_hash (log_msg.msg, TIGER_DATA,
     957                 (unsigned long)(status + KEY_LEN), (char *) hashbuf, (size_t) sizeof(hashbuf));
    956958
    957959  (void) sl_strlcat (log_msg.msg, sigkey_new, (size_t)(status + KEY_LEN + 2));
    958  
    959960  (void) sl_strlcpy (log_msg.signature,
    960                      sh_tiger_hash (log_msg.msg, TIGER_DATA,
    961                                     (unsigned long)(status + KEY_LEN)),
     961                     sh_tiger_hash (log_msg.msg, (TigerType) TIGER_DATA,
     962                                    (unsigned long)(status + KEY_LEN), hashbuf, sizeof(hashbuf)),
    962963                     KEY_LEN+1);
    963964  (void) sl_strlcpy (sigkey_old, sigkey_new, KEY_LEN+1);
  • trunk/src/sh_files.c

    r132 r137  
    5151#endif
    5252#endif
     53#define NEED_ADD_DIRENT
    5354
    5455#ifdef HAVE_GLOB_H
     
    16361637  /* ---- read ----
    16371638   */
    1638   SH_MUTEX_LOCK(readdir_lock);
     1639  SH_MUTEX_LOCK(mutex_readdir);
    16391640
    16401641  do {
     
    16571658  } while (thisEntry != NULL);
    16581659
    1659   SH_MUTEX_UNLOCK(readdir_lock);
     1660  SH_MUTEX_UNLOCK(mutex_readdir);
    16601661
    16611662  closedir (thisDir);
  • trunk/src/sh_forward.c

    r133 r137  
    277277  register int i;
    278278  unsigned char * dez = NULL;
     279  char hashbuf[KEYBUF_SIZE];
    279280
    280281  if (password == NULL)
     
    297298        }
    298299      (void) sl_strlcpy (skey->vernam,
    299                          sh_tiger_hash(skey->vernam, TIGER_DATA, PW_LEN),
     300                         sh_tiger_hash(skey->vernam, TIGER_DATA, PW_LEN,
     301                                       hashbuf, sizeof(hashbuf)),
    300302                         KEY_LEN+1);
    301303    }
     
    320322  (void) sl_strlcpy (hash,
    321323                     sh_tiger_hash(combi, TIGER_DATA,
    322                                    (unsigned long) sl_strlen(combi)),
     324                                   (unsigned long) sl_strlen(combi),
     325                                   hashbuf, sizeof(hashbuf)),
    323326                     KEY_LEN+1);
    324327
     
    10121015      /* --- Create own nonce. ---
    10131016       */
    1014       ticks = (UINT32) taus_get (&(skey->rng0[0]),
    1015                                  &(skey->rng1[0]),
    1016                                  &(skey->rng2[0]));
     1017      ticks = (UINT32) taus_get ();
     1018
    10171019      (void) sl_strlcpy(nonce_u,
    10181020                        sh_tiger_hash((char *) &ticks,
     
    15911593              /* --- Generate a nonce. ---
    15921594               */
    1593               ticks = (UINT32) taus_get (&(skey->rng0[0]),
    1594                                          &(skey->rng1[0]),
    1595                                          &(skey->rng2[0]));
     1595              ticks = (UINT32) taus_get ();
    15961596             
    15971597              (void) sl_strlcpy(nclt,
     
    18971897  char hashbuf[KEYBUF_SIZE];
    18981898
    1899   val[0] = taus_get (&(skey->rng0[0]), &(skey->rng0[1]), &(skey->rng0[2]));
    1900   val[1] = taus_get (&(skey->rng0[0]), &(skey->rng0[1]), &(skey->rng0[2]));
     1899  val[0] = taus_get ();
     1900  val[1] = taus_get ();
    19011901
    19021902  sl_strlcpy (output,
     
    29702970              sl_strlcpy (conn->peer, &(conn->buf[KEY_LEN]), SH_MINIBUF+1);
    29712971
    2972               ticks = (UINT32) taus_get (&(skey->rng0[0]),
    2973                                          &(skey->rng1[0]),
    2974                                          &(skey->rng2[0]));
     2972              ticks = (UINT32) taus_get ();
     2973
    29752974              if (conn->K != NULL)
    29762975                {
     
    34303429              sl_strlcpy (conn->peer, &(conn->buf[KEY_LEN]), SH_MINIBUF+1);
    34313430
    3432               ticks = (UINT32) taus_get (&(skey->rng0[0]),
    3433                                          &(skey->rng1[0]),
    3434                                          &(skey->rng2[0]));
     3431              ticks = (UINT32) taus_get ();
     3432
    34353433              test = (char *) &ticks;
    34363434              sh_util_cpylong (conn->challenge, test, 4);
     
    37903788              /* -- create server nounce v --
    37913789               */
    3792               ticks = (UINT32) taus_get (&(skey->rng0[0]),
    3793                                          &(skey->rng1[0]),
    3794                                          &(skey->rng2[0]));
     3790              ticks = (UINT32) taus_get ();
    37953791             
    37963792              if (conn->A != NULL)
     
    41164112                   * create nonce u
    41174113                   */
    4118                   ticks = (UINT32) taus_get (&(skey->rng0[0]),
    4119                                              &(skey->rng1[0]),
    4120                                              &(skey->rng2[0]));
     4114                  ticks = (UINT32) taus_get ();
     4115
    41214116                  test = (char *) &ticks;
    41224117                  sh_util_cpylong (u, test, 4);  /* u        nounce        */
  • trunk/src/sh_gpg.c

    r133 r137  
    554554       * between the integrity check and the execve
    555555       */
    556       myrand = (int) taus_get (&(skey->rng0[0]), &(skey->rng1[0]),
    557                                &(skey->rng2[0]));
     556      myrand = (int) taus_get ();
     557
    558558      myrand = (myrand < 0) ? (-myrand) : myrand;
    559559      myrand = (myrand % 32) + 2;
  • trunk/src/sh_hash.c

    r133 r137  
    20102010  int         i = 0;
    20112011  char      * p;
     2012  char        i2h[2];
    20122013
    20132014  tmpFile.attr_string = NULL;
     
    20352036      for (i = 0; i < size; ++i)
    20362037        {
    2037           p = sh_util_charhex (str[i]);
     2038          p = sh_util_charhex (str[i],i2h);
    20382039          tmpFile.linkpath[2*i]   = p[0];
    20392040          tmpFile.linkpath[2*i+1] = p[1];
  • trunk/src/sh_kern.c

    r132 r137  
    202202  char  *linkpath_old;
    203203  char  *linkpath_new;
     204  char   i2h[2];
    204205
    205206#ifdef SH_USE_XML
     
    226227  for (k = 0; k < old_len; ++k)
    227228    {
    228       p = sh_util_charhex (old[k]);
     229      p = sh_util_charhex (old[k], i2h);
    229230      linkpath_old[2*k]   = p[0];
    230231      linkpath_old[2*k+1] = p[1];
     
    234235  for (k = 0; k < new_len; ++k)
    235236    {
    236       p = sh_util_charhex (new[k]);
     237      p = sh_util_charhex (new[k], i2h);
    237238      linkpath_new[2*k]   = p[0];
    238239      linkpath_new[2*k+1] = p[1];
     
    967968  if (df)
    968969    {
    969       SH_MUTEX_LOCK(readdir_lock);
     970      SH_MUTEX_LOCK(mutex_readdir);
    970971
    971972      while (NULL != (entry = readdir(df)))
     
    981982        }
    982983
    983       SH_MUTEX_UNLOCK(readdir_lock);
     984      SH_MUTEX_UNLOCK(mutex_readdir);
    984985
    985986      closedir(df);
  • trunk/src/sh_mail.c

    r134 r137  
    5858#include "sh_fifo.h"
    5959#include "sh_tools.h"
     60#include "sh_pthread.h"
    6061
    6162#undef  FIL__
     
    12461247#endif
    12471248
    1248 static int sh_mail_wait(int code, FILE * m_socket);
     1249static int sh_mail_wait(int code, int ma_socket);
    12491250
    12501251static char * relay_host = NULL;
     
    16801681    g = (int) c;
    16811682
    1682     if ( (g=fgetc(ma_socket)) == EOF)
     1683    /*
     1684    if (g == EOF)
    16831685      {
    16841686        TPT((0, FIL__, __LINE__, _("msg=<mail_wait: EOF>\n")));
    16851687        SL_RETURN( 0, _("mail_wait"));
    16861688      }
     1689    */
    16871690
    16881691    switch(state) {
     
    21012104  dnsrep * answers = NULL;
    21022105  mx     * result;
    2103   dnsrep * retval;
     2106  dnsrep * retval  = NULL;
    21042107  char     errmsg[128];
    21052108  size_t   len;
  • trunk/src/sh_mem.c

    r134 r137  
    2020#include "config_xor.h"
    2121
     22/* With glibc, _XOPEN_SOURCE 500 is required for
     23 * pthread_mutexattr_settype/PTHREAD_MUTEX_RECURSIVE
     24 */
     25#if defined(HAVE_PTHREAD) && defined(MEM_DEBUG)
     26#define _XOPEN_SOURCE 500
     27#endif
    2228
    2329#include <stdio.h>
     
    108114static pthread_mutex_t mutex_mem;
    109115
    110 static int initialize_mem(void)
     116static void initialize_mem(void)
    111117{
    112118  pthread_mutexattr_t   mta;
     
    114120  pthread_mutex_init(&mutex_mem, &mta);
    115121  pthread_mutexattr_destroy(&mta);
    116   return 0;
     122  return;
    117123}
    118124#define MEM_MUTEX_INIT  (void) pthread_once(&mem_is_initialized, initialize_mem)
  • trunk/src/sh_portcheck.c

    r134 r137  
    115115#include "sh_utils.h"
    116116#include "sh_modules.h"
     117#include "sh_pthread.h"
    117118
    118119static int sh_portchk_severity  = SH_ERR_SEVERE;
  • trunk/src/sh_srp.c

    r133 r137  
    341341
    342342  for (i = 0; i < 6; ++i)
    343     randl[i] = (UINT32) taus_get (&(skey->rng0[0]),
    344                                   &(skey->rng1[0]),
    345                                   &(skey->rng2[0]));
     343    randl[i] = (UINT32) taus_get ();
     344
    346345  (void) sl_strlcpy (hash,
    347346                     sh_tiger_hash((char *)&randl[0], TIGER_DATA,
  • trunk/src/sh_suidchk.c

    r132 r137  
    6969#endif
    7070#endif
     71#define NEED_ADD_DIRENT
    7172
    7273#include "samhain.h"
     
    869870  /* Loop over directory entries
    870871   */
    871   SH_MUTEX_LOCK(readdir_lock);
     872  SH_MUTEX_LOCK(mutex_readdir);
    872873
    873874  do {
     
    892893  } while (thisEntry != NULL);
    893894
    894   SH_MUTEX_UNLOCK(readdir_lock);
     895  SH_MUTEX_UNLOCK(mutex_readdir);
    895896
    896897  closedir(thisDir);
     
    10801081                        if (-1 == fflags)
    10811082                          {
    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));
     1083                            (void) sh_unix_gmttime (theFile.ctime, timestrc, sizeof(timestrc));
     1084                            (void) sh_unix_gmttime (theFile.atime, timestra, sizeof(timestra));
     1085                            (void) sh_unix_gmttime (theFile.mtime, timestrm, sizeof(timestrm));
    10851086
    10861087                            report_file(tmpcat, &theFile, timestrc, timestra, timestrm);
  • trunk/src/sh_tiger0.c

    r134 r137  
    2424#include "sh_error.h"
    2525#include "sh_utils.h"
     26#include "sh_pthread.h"
    2627
    2728#define PRIV_MAX  32768
     
    121122  UINT64    bcount = 0;
    122123
    123   char * buffer = SH_ALLOC(PRIV_MAX + 72);
     124  sh_byte * buffer = SH_ALLOC(PRIV_MAX + 72);
    124125
    125126  unsigned long pages_read;
     
    156157  if (what >= TIGER_FILE)
    157158    {
    158       if (what > TIGER_FD)
     159      if (what > TIGER_FILE)
    159160        {
    160161          fd = what;
     
    829830  size_t sum;
    830831
    831   SL_TICKET  fd;
    832832  char * tmp;
    833833  uid_t   euid;
     
    869869
    870870      n = (off_t) sl_read_timeout (fd, buffer + sum,
    871                                    (size_t) BLOCKSIZE - sum, timeout);
     871                                   (size_t) BLOCKSIZE - sum, timeout, SL_FALSE);
    872872
    873873      if (SL_ISERROR (n))
     
    13391339  char buffer[4168]; /* BLOCKSIZE + 72 AIX compiler chokes */
    13401340  off_t sum = 0;
    1341   SL_TICKET  fd;
    13421341  char * tmp;
    13431342  uid_t  euid;
     
    13791378    do {
    13801379      n = (off_t) sl_read_timeout(fd, buffer + sum,
    1381                                   (size_t) BLOCKSIZE - sum, timeout);
     1380                                  (size_t) BLOCKSIZE - sum, timeout, SL_FALSE);
    13821381
    13831382      if (SL_ISERROR (n))
  • trunk/src/sh_tools.c

    r134 r137  
    8888#define SH_NEED_GETHOSTBYXXX
    8989#include "sh_static.h"
     90#include "sh_pthread.h"
    9091
    9192#undef  FIL__
     
    723724  struct  sigaction  new_act;
    724725  struct  sigaction  old_act;
     726#if defined(WITH_TPT)
    725727  char    errbuf[SH_ERRBUF_SIZE];
     728#endif
    726729
    727730  SL_ENTER(_("sh_write_select"));
     
    11441147  /* random_pad
    11451148   */
    1146   rpad[1] = taus_get (&(skey->rng0[0]), &(skey->rng1[0]), &(skey->rng2[0]));
     1149  rpad[1] = taus_get ();
    11471150  memcpy (head,      &rpad[1],    4);
    1148   rpad[0] = taus_get (&(skey->rng0[0]), &(skey->rng1[0]), &(skey->rng2[0]));
     1151  rpad[0] = taus_get ();
    11491152  memcpy (&head[4],  &rpad[0],    4);
    1150   rpad[2] = taus_get (&(skey->rng0[0]), &(skey->rng1[0]), &(skey->rng2[0]));
     1153  rpad[2] = taus_get ();
    11511154  memcpy (&head[8],  &rpad[2],    4);
    11521155
     
    16341637    /* create random filename in effective users home directory
    16351638     */
    1636     ticks = taus_get (&(skey->rng0[0]), &(skey->rng1[0]), &(skey->rng2[0]));
     1639    ticks = taus_get ();
    16371640    if (my_tmp_dir[0] == '/' && my_tmp_dir[1] == '\0')
    16381641      file = sh_util_strconcat (my_tmp_dir,
  • trunk/src/sh_unix.c

    r134 r137  
    9494#include "sh_tiger.h"
    9595#include "sh_prelink.h"
     96#include "sh_pthread.h"
    9697
    9798/* moved here from far below
     
    956957static int tf_add_trusted_user_int(const char * c)
    957958{
    958   register struct passwd *          w;
     959  struct passwd *          w;
    959960  int                           count;
    960961  uid_t                     pwid  = (uid_t)-1;
     
    970971   */
    971972#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    972   status = sh_getpwnam_r(c, &pwd, buffer, sizeof(buffer), &w);
     973  sh_getpwnam_r(c, &pwd, buffer, sizeof(buffer), &w);
    973974#else
    974975  w = sh_getpwnam(c);
     
    32433244  ShFileType    type;
    32443245  unsigned int  mode;
    3245   char        * name;
    32463246  char        * tmp;
    32473247  char        * tmp2;
     
    35453545
    35463546 
    3547   if (NULL == sh_unix_getUIDname(SH_ERR_ALL, buf.st_uid, theFile->c_owner, USER_MAX+)) {
     3547  if (NULL == sh_unix_getUIDname(SH_ERR_ALL, buf.st_uid, theFile->c_owner, USER_MAX+1)) {
    35483548
    35493549    tmp2 = sh_util_safe_name (theFile->fullpath);
     
    35713571      tmp2 = sh_util_safe_name ((filename == NULL) ?
    35723572                                theFile->fullpath : filename);
    3573       (void) sh_unix_time(theFile->mtime, timestr, sizeof(timestring));
     3573      (void) sh_unix_time(theFile->mtime, timestr, sizeof(timestr));
    35743574      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_LIST,
    35753575                       theFile->c_mode,
  • trunk/src/sh_userfiles.c

    r134 r137  
    3030#include <pwd.h>
    3131
    32 
    3332#include "samhain.h"
    3433#include "sh_modules.h"
     
    4140#define SH_NEED_PWD_GRP 1
    4241#include "sh_static.h"
     42#include "sh_pthread.h"
    4343
    4444#ifdef SH_USE_USERFILES
  • trunk/src/sh_utils.c

    r133 r137  
    4545#include "sh_tiger.h"
    4646#include "sh_entropy.h"
     47#include "sh_pthread.h"
    4748
    4849#undef  FIL__
     
    570571}
    571572
    572 char * sh_util_charhex( unsigned char i )
    573 {
    574   static char i2h[2];
     573char * sh_util_charhex( unsigned char i , char * i2h)
     574{
    575575  int j, k;
    576576
     
    669669  UINT32    * h2;
    670670  UINT32      cc[KEY_LEN/4];
    671   char      * res;
    672671  UINT32      kbuf[KEY_BYT/sizeof(UINT32)];
    673672  char hashbuf[KEYBUF_SIZE];
     
    681680  if (KEY_BLOCK > (KEY_LEN/2))
    682681    {
    683       res = sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
     682      (void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
     683      sl_strlcpy(res, hashbuf, len);
    684684      SL_RETURN(res, _("sh_util_hmac_tiger"));
    685685    }
     
    689689  if (sh_util_hextobinary (K, hexkey, KEY_LEN) < 0)
    690690    {
    691       res = sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
     691      (void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
     692      sl_strlcpy(res, hashbuf, len);
    692693      SL_RETURN(res, _("sh_util_hmac_tiger"));
    693694    }
     
    712713                      _("integer overflow"),
    713714                      _("sh_util_hmac_tiger"));
    714       res = sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
     715      (void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
     716      sl_strlcpy(res, hashbuf, len);
    715717      SL_RETURN(res, _("sh_util_hmac_tiger"));
    716718    }
     
    749751
    750752static char * sh_util_hash_tiger ( char * hexkey, 
    751                                    char * text, size_t textlen
     753                                   char * text, size_t textlen,
    752754                                   char * res, size_t len)
    753755{
    754756  char           h2[2*KEY_LEN+1];
     757  char hashbuf[KEYBUF_SIZE];
     758
    755759  SL_ENTER(_("sh_util_hash_tiger"));
    756760
     
    760764                                  (unsigned long) textlen,
    761765                                  hashbuf, sizeof(hashbuf)),
    762                     2*KEY_LEN+1,
     766                    2*KEY_LEN+1
    763767                    );
    764768
     
    917921  UINT32 * state = (UINT32 *) vstate;
    918922
     923  /*
    919924  if (skey->rngI == BAD)
    920925    (void)taus_seed();
     926  */
    921927
    922928#define TAUSWORTHE(s,a,b,c,d) ((s &c) <<d) ^ (((s <<a) ^s) >>b)
     
    932938 * input for a one-way hash function.
    933939 */
    934 UINT32   taus_svec[6];
    935 
    936 UINT32 taus_get (void *state1, void *state2, void *state3)
    937 {
     940
     941UINT32 taus_get ()
     942{
     943  UINT32   taus_svec[6];
    938944  UINT32   retval;
    939945  UINT32 * res;
     
    943949  UINT32       kbuf[KEY_BYT/sizeof(UINT32)];
    944950
     951  SH_MUTEX_LOCK_UNSAFE(mutex_skey);
    945952  if (res_num > 0)
    946953    {
    947954      retval  = res_vec[res_num];
    948955      res_num = (res_num == 5) ? 0 : (res_num + 1);
     956      SH_MUTEX_UNLOCK_UNSAFE(mutex_skey); /* alternative path */
    949957      return  retval;
    950958    }
    951 
    952   taus_svec[0] = taus_get_long (state1);
    953   taus_svec[1] = taus_get_long (state2);
    954   taus_svec[2] = taus_get_long (state3);
    955   taus_svec[3] = taus_get_long (state1);
    956   taus_svec[4] = taus_get_long (state2);
    957   taus_svec[5] = taus_get_long (state3);
     959  SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
     960
     961  (void)taus_seed();
     962
     963  SH_MUTEX_LOCK_UNSAFE(mutex_skey);
     964  taus_svec[0] = taus_get_long (&(skey->rng0[0]));
     965  taus_svec[1] = taus_get_long (&(skey->rng1[0]));
     966  taus_svec[2] = taus_get_long (&(skey->rng2[2]));
     967  taus_svec[3] = taus_get_long (&(skey->rng0[0]));
     968  taus_svec[4] = taus_get_long (&(skey->rng1[0]));
     969  taus_svec[5] = taus_get_long (&(skey->rng2[0]));
     970  SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    958971
    959972  res     = sh_tiger_hash_uint32 ( (char *) &taus_svec[0],
     
    962975                                   kbuf, KEY_BYT/sizeof(UINT32));
    963976
     977  SH_MUTEX_LOCK_UNSAFE(mutex_skey);
    964978  for (i = 1; i < 6; ++i)
    965979    {
     
    968982  retval  = taus_svec[0];
    969983  res_num = 1;
     984  SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    970985
    971986  taus_svec[0] = 0; taus_svec[1] = 0; taus_svec[2] = 0;
     
    10271042  int                  status;
    10281043  static unsigned long seed_time = 0;
     1044  unsigned long        gtime;
    10291045
    10301046  SL_ENTER(_("taus_seed"));
     
    10321048  if (skey->rngI == GOOD)
    10331049    {
    1034       if ( (sh_unix_longtime () - seed_time) < 3600)
     1050      if ( (sh_unix_longtime () - seed_time) < 7200)
    10351051        SL_RETURN( (0), _("taus_seed"));
    10361052    }
     
    10421058  if (!SL_ISERROR(status))
    10431059    {
    1044       skey->rngI = GOOD;
     1060      SH_MUTEX_LOCK_UNSAFE(mutex_skey);
    10451061      memcpy (&skey->rng0[0], &bufx[0],                  2*sizeof(UINT32));
    10461062      memcpy (&skey->rng1[0], &bufx[2*sizeof(UINT32)],   2*sizeof(UINT32));
     
    10561072      taus_set_from_state( &(skey->rng2[0]), &(skey->rng2[0]));
    10571073
     1074      skey->rngI = GOOD;
     1075      SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    10581076      SL_RETURN( (0), _("taus_seed"));
    10591077    }
     
    10641082  /* emergency backup - unsafe !
    10651083   */
    1066   skey->rngI = GOOD;
    10671084#ifdef HAVE_GETTIMEOFDAY
    1068   taus_set_from_ulong ( &(skey->rng0[0]), LCG (sh_unix_notime())      );
     1085  gtime = sh_unix_notime();
    10691086#else
    1070   taus_set_from_ulong ( &(skey->rng0[0]), LCG (seed_time)      );
     1087  gtime = seed_time;
    10711088#endif
     1089
     1090  SH_MUTEX_LOCK_UNSAFE(mutex_skey);
     1091  taus_set_from_ulong ( &(skey->rng0[0]), LCG (gtime)          );
    10721092  taus_set_from_ulong ( &(skey->rng1[0]), LCG (skey->rng0[0])  );
    10731093  taus_set_from_ulong ( &(skey->rng2[0]), LCG (skey->rng1[0])  );
    10741094  skey->rngI = BAD;
     1095  SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    10751096
    10761097  SL_RETURN( (-1), _("taus_seed"));
  • trunk/src/slib.c

    r131 r137  
    14661466int sl_policy_get_user(char * user)
    14671467{
    1468   struct passwd * tempres;
    1469 
    14701468  SL_ENTER(_("sl_policy_get_user"));
    14711469
     
    21262124                        int timeout, int is_nonblocking)
    21272125{
    2128   int sflags;
     2126  int sflags = 0;
    21292127  fd_set readfds;
    21302128  struct timeval tv;
     
    21322130  int retval;
    21332131
    2134   int    fd;
    21352132  int    byteread = 0;
    21362133  int    bytes    = 0;
  • trunk/src/trustfile.c

    r134 r137  
    103103#define SH_NEED_PWD_GRP 1
    104104#include "sh_static.h"
    105 #define SH_GRBUF_SIZE 4096
    106 #define SH_PWBUF_SIZE 4096
     105#include "sh_pthread.h"
    107106
    108107#else
     
    411410int isingrp(gid_t grp, uid_t *ulist)
    412411{
    413   register struct passwd *w;    /* info about group member */
     412  struct passwd *w;             /* info about group member */
    414413  register uid_t *u;            /* points to current ulist member */
    415414  register char **p;            /* points to current group member */
    416   register struct group *g;     /* pointer to group information */
     415  struct group *g;              /* pointer to group information */
    417416 
    418417#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
     
    494493int onlytrustedingrp(gid_t grp, uid_t *ulist)
    495494{
    496   register struct passwd *w;    /* info about group member */
     495  struct passwd *w;             /* info about group member */
    497496  register uid_t *u;            /* points to current ulist member */
    498497  register char **p;            /* points to current group member */
    499   register struct group *g;     /* pointer to group information */
     498  struct group *g;              /* pointer to group information */
    500499  register int flag = -1;       /* group member found */
    501500
     
    503502  struct group    gr;
    504503  char            buffer[SH_GRBUF_SIZE];
    505   struct group    pw;
     504  struct passwd   pw;
    506505  char            pbuffer[SH_PWBUF_SIZE];
    507506#endif
Note: See TracChangeset for help on using the changeset viewer.