hash.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	sha1_context

Functions
unsigned int	lhash_val_of_name_sys (syskind_t skind, int lcid, const char *lpStr)
void	sha1_init (struct sha1_context *ctx)
void	sha1_update (struct sha1_context *ctx, const char *data, size_t data_size)
void	sha1_finalize (struct sha1_context *ctx, unsigned int hash[5])

Function Documentation

lhash_val_of_name_sys()

unsigned int lhash_val_of_name_sys	(	syskind_t	skind,
		int	lcid,
		const char *	lpStr
	)

Definition at line 511 of file hash.c.

{
  unsigned int nOffset, nMask = skind == SYS_MAC ? 1 : 0;
  unsigned int nHiWord, nLoWord = 0x0deadbee;
  const unsigned char *str = (const unsigned char *)lpStr, *pnLookup = NULL;
 
  if (!str)
    return 0;
 
  switch (PRIMARYLANGID(LANGIDFROMLCID(lcid)))
  {
  default:
    nOffset = 16;
    pnLookup = Lookup_16;
    break;
  case LANG_CZECH:  case LANG_HUNGARIAN:  case LANG_POLISH:
  case LANG_SLOVAK: case LANG_SPANISH:
    nOffset = 32;
    pnLookup = Lookup_32;
    break;
  case LANG_HEBREW:
    nOffset = 48;
    pnLookup = Lookup_48;
    break;
  case LANG_JAPANESE:
    nOffset = 64;
    pnLookup = Lookup_64;
    break;
  case LANG_KOREAN:
    nOffset = 80;
    pnLookup = Lookup_80;
    break;
  case LANG_CHINESE:
    nOffset = 112;
    pnLookup = Lookup_112;
    break;
  case LANG_GREEK:
    nOffset = 128;
    pnLookup = Lookup_128;
    break;
  case LANG_ICELANDIC:
    nOffset = 144;
    pnLookup = Lookup_144;
    break;
  case LANG_TURKISH:
    nOffset = 160;
    pnLookup = Lookup_160;
    break;
  case LANG_NORWEGIAN:
    if (SUBLANGID(LANGIDFROMLCID(lcid)) == SUBLANG_NORWEGIAN_NYNORSK)
    {
      nOffset = 176;
      pnLookup = Lookup_176;
    }
    else
    {
      nOffset = 16;
      pnLookup = Lookup_16;
    }
    break;
  case LANG_ARABIC:
  case LANG_FARSI:
    nOffset = 208;
    pnLookup = Lookup_208;
    break;
  case LANG_RUSSIAN:
    nOffset = 224;
    pnLookup = Lookup_224;
    break;
  }
 
  nHiWord = (nOffset | nMask) << 16;
 
  while (*str)
  {
    nLoWord = 37 * nLoWord + pnLookup[*str > 0x7f && nMask ? *str + 0x80 : *str];
    str++;
  }
  /* Constrain to a prime modulo and sizeof(WORD) */
  nLoWord = (nLoWord % 65599) & 0xffff;
 
  return nHiWord | nLoWord;
}

Referenced by ctl2_encode_name().

sha1_finalize()

void sha1_finalize	(	struct sha1_context *	ctx,
		unsigned int	hash[5]
	)

Definition at line 703 of file hash.c.

{
   unsigned int *count, length_hi, length_lo, i;
   size_t pad_size, buffer_size;
   char pad[72];
 
   buffer_size = ctx->count[1] & 63;
   if (buffer_size >= 56) pad_size = 56 + 64 - buffer_size;
   else pad_size = 56 - buffer_size;
 
   length_hi = (ctx->count[0] << 3) | (ctx->count[1] >> (32 - 3));
   length_lo = (ctx->count[1] << 3);
 
   memset(pad + 1, 0, pad_size - 1);
   pad[0] = 0x80;
   count = (unsigned int*)(pad + pad_size);
   count[0] = DWORD2BE(length_hi);
   count[1] = DWORD2BE(length_lo);
   sha1_update(ctx, pad, pad_size + 8);
 
   for (i = 0; i < 5; i++) result[i] = DWORD2BE(ctx->state[i]);
 
   sha1_init(ctx);
}

Referenced by compute_interface_signature_uuid().

sha1_init()

void sha1_init

(

struct sha1_context *

ctx

)

Definition at line 666 of file hash.c.

{
   /* SHA1 initialization constants */
   ctx->state[0] = 0x67452301;
   ctx->state[1] = 0xEFCDAB89;
   ctx->state[2] = 0x98BADCFE;
   ctx->state[3] = 0x10325476;
   ctx->state[4] = 0xC3D2E1F0;
   ctx->count[0] = 0;
   ctx->count[1] = 0;
}

sha1_update()

void sha1_update	(	struct sha1_context *	ctx,
		const char *	data,
		size_t	data_size
	)

Definition at line 678 of file hash.c.

{
   size_t buffer_size;
 
   buffer_size = ctx->count[1] & 63;
   ctx->count[1] += data_size;
   if (ctx->count[1] < data_size) ctx->count[0]++;
   ctx->count[0] += (data_size >> 29);
 
   if (buffer_size + data_size < 64)
      memcpy(&ctx->buffer[buffer_size], data, data_size);
   else
   {
      while (buffer_size + data_size >= 64)
      {
         memcpy(ctx->buffer + buffer_size, data, 64 - buffer_size);
         data += 64 - buffer_size;
         data_size -= 64 - buffer_size;
         sha1_transform(ctx);
         buffer_size = 0;
      }
      memcpy(ctx->buffer + buffer_size, data, data_size);
   }
}