Changeset 11


Ignore:
Timestamp:
Jan 2, 2006, 12:03:25 AM (19 years ago)
Author:
rainer
Message:

Minor optimisations for server

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/slib.h

    r8 r11  
    147147   */
    148148  void *sl_memset(void *s, int c, size_t n);
     149#if !defined(SH_REAL_SET)
    149150#undef  memset
    150151#define memset sl_memset
     152#endif
    151153
    152154  /*

  • trunk/src/sh_database.c

    r3 r11  
    3232/* define this if you want to debug the Oracle database support */
    3333/* #define DB_DEBUG  */
     34
     35#define SH_REAL_SET
    3436
    3537#include "samhain.h"

  • trunk/src/sh_error.c

    r5 r11  
    802802{
    803803  if (str == NULL)
    804     memset(inet_peer, '\0', SH_MINIBUF);
     804    inet_peer[0] = '\0';
    805805  else
    806806    sl_strlcpy(inet_peer, str, SH_MINIBUF);

  • trunk/src/sh_forward.c

    r3 r11  
    249249      else
    250250        {
    251           memset (name_2, 0, SH_MINIBUF+1);
    252251          first = name;
    253252          while (i < SH_MINIBUF && *first != '.' && *first != '\0')
    … …  
    256255              ++first; ++i;
    257256            }
    258           name_2[SH_MINIBUF] = '\0';
     257          name_2[i] = '\0';
    259258        }
    260259    }
    … …  
    20712070
    20722071
    2073 
     2072static char zap_challenge[SH_CHALLENGE_SIZE] = { 0 };
     2073 
    20742074void sh_forward_do_free (sh_conn_t * conn)
    20752075{
    … …  
    21012101      conn->fd            = -1;
    21022102    }
    2103   memset(conn->challenge, '\0', SH_CHALLENGE_SIZE);
     2103  memcpy(conn->challenge, zap_challenge, SH_CHALLENGE_SIZE);
    21042104  conn->state         = CONN_FREE;
    21052105  conn->headcount     = 0;
    … …  
    21182118  conn->FileLength     = 0;
    21192119  conn->FileSent       = 0;
    2120   memset(conn->FileType, '\0', 5);
     2120  conn->FileType[0] = '\0';
     2121  conn->FileType[1] = '\0';
     2122  conn->FileType[2] = '\0';
     2123  conn->FileType[3] = '\0';
     2124  conn->FileType[4] = '\0';
    21212125
    21222126  --server_status.conn_open;

  • trunk/src/sh_mem.c

    r1 r11  
    3232#endif
    3333
     34#define SH_REAL_SET
     35
    3436#include "samhain.h"
    3537#include "sh_error.h"

  • trunk/src/sh_tiger0.c

    r8 r11  
    422422int md5Reset(register md5Param* p)
    423423{
     424        unsigned int i;
    424425        memcpy(p->h, md5hinit, 16);
    425         memset(p->data, 0x00, 64);
     426       
     427        for (i = 0; i < 16; i += 8)
     428          {
     429            p->data[i]   = 0x00;
     430            p->data[i+1] = 0x00;
     431            p->data[i+2] = 0x00;
     432            p->data[i+3] = 0x00;
     433            p->data[i+4] = 0x00;
     434            p->data[i+5] = 0x00;
     435            p->data[i+6] = 0x00;
     436            p->data[i+7] = 0x00;
     437          }
     438       
     439        /* memset(p->data, 0x00, 64); */
    426440        p->offset = (uint8) 0;
    427441        p->nblocks = 0;
    … …  
    15271541  SL_ENTER(_("sh_tiger_hash_uint32"));
    15281542
    1529   memset(out, 0, 6 * sizeof(UINT32));
     1543  out[0] = 0; out[1] = 0; out[2] = 0;
     1544  out[3] = 0; out[4] = 0; out[5] = 0;
    15301545
    15311546  res = sh_tiger_hash_val (filename,  what,  Length, 0);

  • trunk/src/sh_tools.c

    r1 r11  
    7878#endif
    7979
     80#define SH_REAL_SET
     81
    8082#include "samhain.h"
    8183#include "sh_mem.h"
    … …  
    121123char * sh_tools_safe_name (const char * instr, int flag)
    122124{
     125  static   char ctest = ~('\\'|'&'|'='|'\'');
    123126  unsigned char c;
    124127  const  char * p;
    125128  char   tmp[4];
    126129  char * outstr;
    127   int    len;
     130  int    len = 1;
    128131  int    i = 0;
    129132  unsigned char   val_octal = '\0';
    … …  
    133136  if (instr)
    134137    len = (3 * strlen(instr)) + 4;
    135   else
    136     len = 1;
    137138
    138139  outstr = SH_ALLOC(len);
    … …  
    143144  p = instr;
    144145
    145   while (p && *p)
     146#if !defined(SH_USE_XML)
     147  (void) flag; /* fix compiler warning */
     148#endif
     149
     150  if (!p)
     151    goto end;
     152
     153  while (*p)
    146154    {
    147155      c = *p;
    … …  
    154162
    155163#ifdef SH_USE_XML
    156       if (flag == 1 && (*p) == '"')
    157         {
    158           sprintf(&outstr[i], "=%02x", c);   i+=3; ++p;  /* known to fit  */
    159           continue;
    160         }
    161       else if (flag == 1 && (*p) == '&')
    162         {
    163           sprintf(&outstr[i], "=%02x", c);   i+=3; ++p;  /* known to fit  */
    164           continue;
    165         }
    166       else if (flag == 1 && (*p) == '<')
    167         {     /* left angle       */
    168           sprintf(&outstr[i], "=%02x", c);   i+=3; ++p;  /* known to fit  */
    169           continue;
    170         }
    171       else if (flag == 1 && (*p) == '>')
    172         {     /* right angle      */
    173           sprintf(&outstr[i], "=%02x", c);   i+=3; ++p;  /* known to fit  */
    174           continue;
     164      if (flag == 1)
     165        {
     166          if ((*p) == '"')
     167            {
     168              sprintf(&outstr[i], "=%02x", c);i+=3; ++p; /* known to fit  */
     169              continue;
     170            }
     171          else if ((*p) == '&')
     172            {
     173              sprintf(&outstr[i], "=%02x", c);i+=3; ++p; /* known to fit  */
     174              continue;
     175            }
     176          else if ((*p) == '<')
     177            {     /* left angle       */
     178              sprintf(&outstr[i], "=%02x", c);i+=3; ++p; /* known to fit  */
     179              continue;
     180            }
     181          else if ((*p) == '>')
     182            {     /* right angle      */
     183              sprintf(&outstr[i], "=%02x", c);i+=3; ++p; /* known to fit  */
     184              continue;
     185            }
    175186        }
    176 #else
    177       (void) flag; /* fix compiler warning */
    178 #endif
    179 
    180       if ( (*p) != '\\' && (*p) != '&' && (*p) != '='  && (*p) != '\'')
     187#endif
     188
     189      /* if ( (*p) != '\\' && (*p) != '&' && (*p) != '='  && (*p) != '\'') */
     190      if (((*p) & ctest) != 0)
    181191        {
     192          outstr[i] = *p; ++i;
     193          ++p;
     194             
    182195          if (c < 31 || c > 126)
    183196            {
    184               sprintf(&outstr[i], "=%02x", c); i+=3; ++p;/* known to fit  */
     197              --i;
     198              sprintf(&outstr[i], "=%02x", c);          /* known to fit  */
    185199            }
    186           else
    187             {
    188               outstr[i] = *p;
    189               ++i; ++p;
    190             }
     200
    191201          continue;
    192202        }
    … …  
    272282          }
    273283        }
    274       else /* *p == '&' */
     284      else if (*p == '&')
    275285        {
    276286          ++p;
    … …  
    303313              outstr[i] = '&'; ++i;
    304314            }
    305         }     
     315        }
     316      else
     317        {
     318          outstr[i] = *p; ++i;
     319          ++p;
     320        }
    306321    } /* while (p && *p) */
     322
     323 end:
    307324 
    308325  outstr[i] = '\0';

  • trunk/src/sh_utils.c

    r1 r11  
    527527    (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36, (char)0x36
    528528  };
     529  static char  zap[KEY_BLOCK] = {
     530    (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, 
     531    (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, 
     532    (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, 
     533    (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00
     534  };
    529535  char        K[KEY_BLOCK];
    530536  char        outer[KEY_BLOCK];
    … …  
    546552    }
    547553
    548   memset (K, 0x00, KEY_BLOCK);
     554  memcpy (K, zap, KEY_BLOCK);
    549555
    550556  if (sh_util_hextobinary (K, hexkey, KEY_LEN) < 0)
    … …  
    773779 * input for a one-way hash function.
    774780 */
     781UINT32   taus_svec[6];
     782
    775783UINT32 taus_get (void *state1, void *state2, void *state3)
    776784{
    777   UINT32   svec[6];
    778785  UINT32   retval;
    779786  UINT32 * res;
    780787  register int i;
    781788
    782   svec[0] = taus_get_long (state1);
    783   svec[1] = taus_get_long (state2);
    784   svec[2] = taus_get_long (state3);
    785   svec[3] = taus_get_long (state1);
    786   svec[4] = taus_get_long (state2);
    787   svec[5] = taus_get_long (state3);
    788 
    789   res     = sh_tiger_hash_uint32 ( (char *) &svec[0],
     789  taus_svec[0] = taus_get_long (state1);
     790  taus_svec[1] = taus_get_long (state2);
     791  taus_svec[2] = taus_get_long (state3);
     792  taus_svec[3] = taus_get_long (state1);
     793  taus_svec[4] = taus_get_long (state2);
     794  taus_svec[5] = taus_get_long (state3);
     795
     796  res     = sh_tiger_hash_uint32 ( (char *) &taus_svec[0],
    790797                                   TIGER_DATA,
    791798                                   (unsigned long)(6 * sizeof(UINT32)));
    792799
    793800  for (i = 1; i < KEY_BYT/4; ++i)
    794     res[0] ^= res[i];
     801    {
     802      res[0] ^= res[i];
     803      res[i]  = 0;
     804    }
    795805  retval = res[0];
    796806
    797   memset (res,  0,            KEY_BYT);
    798   memset (svec, 0, 6 * sizeof(UINT32));
     807  taus_svec[0] = 0; taus_svec[1] = 0; taus_svec[2] = 0;
     808  taus_svec[3] = 0; taus_svec[4] = 0; taus_svec[5] = 0;
    799809
    800810  return retval;
Note: See TracChangeset for help on using the changeset viewer.