/*

 * Copyright (C) 2004, 2005, 2007, 2011  Internet Systems Consortium, Inc. ("ISC")

 * Copyright (C) 2000, 2001, 2003  Internet Software Consortium.

 *

 * Permission to use, copy, modify, and/or distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH

 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY

 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,

 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM

 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE

 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

 * PERFORMANCE OF THIS SOFTWARE.

 */

/*! \file

 * SHA-1 in C

 * \author By Steve Reid <steve@edmweb.com>

 * 100% Public Domain

 * \verbatim

 * Test Vectors

 * "abc"

 *   A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D

 * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"

 *   84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1

 * A million repetitions of "a"

 *   34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F

 * \endverbatim

 */

#include "config.h"

#include "hash.h"

#include <assert.h>

#include <stdarg.h>

#include <stdint.h>

#include <string.h>

/* This code is based on the public domain MurmurHash3 from Austin Appleby:

 * http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp

 *

 * We use only the 32 bit variant, and slow it down a bit to support unaligned

 * reads.

 */

#if !defined(__cplusplus) && (__GNUC__ > 2)

#define GNUC_INLINE __attribute__((always_inline))

#else

#define GNUC_INLINE

#endif

GNUC_INLINE static inline uint32_t

rotl (uint32_t x,

      int8_t r)

{

  return (x << r) | (x >> (32 - r));

}

/*

 * Finalization mix - force all bits of a hash block to avalanche

 */

GNUC_INLINE static inline uint32_t

fmix (uint32_t h)

{

  h ^= h >> 16;

  h *= 0x85ebca6b;

  h ^= h >> 13;

  h *= 0xc2b2ae35;

  h ^= h >> 16;

  return h;

}

void

p11_hash_murmur3 (void *hash,

                  const void *input,

                  size_t len,

                  ...)

{

  uint8_t overflow[4];

  const uint8_t *data;

  va_list va;

  uint32_t h1;

  uint32_t k1;

  uint32_t c1;

  uint32_t c2;

  h1 = 42; /* arbitrary choice of seed */

  c1 = 0xcc9e2d51;

  c2 = 0x1b873593;

  data = input;

  /* body */

  /* Mix 4 bytes at a time into the hash */

  va_start (va, len);

  for (;;) {

    if (len >= 4) {

      memcpy (&k1, data, 4);

      data += 4;

      len -= 4;

    } else {

      size_t num = len;

      memcpy (overflow, data, len);

      while (num < 4) {

        size_t part;

        data = va_arg (va, const void *);

        if (!data)

          break;

        /* Combine uint32 from old and new */

        len = va_arg (va, size_t);

        part = 4 - num;

        if (part > len)

          part = len;

        memcpy (overflow + num, data, part);

        data += part;

        len -= part;

        num += part;

      }

      if (num < 4) {

        len = num;

        break;

      }

      memcpy (&k1, overflow, 4);

    }

    k1 *= c1;

    k1 = rotl (k1, 15);

    k1 *= c2;

    h1 ^= k1;

    h1 = rotl (h1, 13);

    h1 = h1 * 5 + 0xe6546b64;

  }

  va_end (va);

  /* tail */

  k1 = 0;

  switch (len) {

  case 3:

    k1 ^= overflow[2] << 16;

  case 2:

    k1 ^= overflow[1] << 8;

  case 1:

    k1 ^= overflow[0];

    k1 *= c1;

    k1 = rotl (k1, 15);

    k1 *= c2;

    h1 ^= k1;

  default:

    break;

  }

  /* finalization */

  h1 ^= len;

  h1 = fmix(h1);

  assert (sizeof (h1) == P11_HASH_MURMUR3_LEN);

  memcpy (hash, &h1, sizeof (h1));

}