/*

 * 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));

}