Changeset 137


Ignore:
Timestamp:
Oct 28, 2007, 1:17:58 AM (11 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.