/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#define _RTL_RANDOM_C_ "$Revision$"

#include <sal/types.h>
#include <osl/thread.h>
#include <osl/time.h>
#include <rtl/alloc.h>
#include <rtl/digest.h>
#include <rtl/random.h>
#include <osl/time.h>

/*========================================================================
 *
 * rtlRandom internals.
 *
 *======================================================================*/
#define RTL_RANDOM_RNG_1(a) ((a) * 16807L)
#define RTL_RANDOM_RNG_2(a) ((a) * 65539L)

#define RTL_RANDOM_RNG(x, y, z) \
{ \
	(x) = 170 * ((x) % 178) - 63 * ((x) / 178); \
	if ((x) < 0) (x) += 30328L; \
	\
	(y) = 171 * ((y) % 177) -  2 * ((y) / 177); \
	if ((y) < 0) (y) += 30269L; \
	\
	(z) = 172 * ((z) % 176) - 35 * ((z) / 176); \
	if ((z) < 0) (z) += 30307L; \
}

/** RandomData_Impl.
 */
typedef struct random_data_impl_st
{
	sal_Int16 m_nX;
	sal_Int16 m_nY;
	sal_Int16 m_nZ;
} RandomData_Impl;

/** __rtl_random_data.
 */
static double __rtl_random_data (RandomData_Impl *pImpl);

/** RandomPool_Impl.
 */
#define RTL_RANDOM_DIGEST      rtl_Digest_AlgorithmMD5
#define RTL_RANDOM_SIZE_DIGEST RTL_DIGEST_LENGTH_MD5
#define RTL_RANDOM_SIZE_POOL   1023

typedef struct random_pool_impl_st
{
	rtlDigest  m_hDigest;
	sal_uInt8  m_pDigest[RTL_RANDOM_SIZE_DIGEST];
	sal_uInt8  m_pData[RTL_RANDOM_SIZE_POOL + 1];
	sal_uInt32 m_nData;
	sal_uInt32 m_nIndex;
	sal_uInt32 m_nCount;
} RandomPool_Impl;

/** __rtl_random_initPool.
 */
static sal_Bool __rtl_random_initPool (
	RandomPool_Impl *pImpl);

/** __rtl_random_seedPool.
 */
static void __rtl_random_seedPool (
	RandomPool_Impl *pImpl, const sal_uInt8 *pBuffer, sal_Size nBufLen);

/** __rtl_random_readPool.
 */
static void __rtl_random_readPool (
	RandomPool_Impl *pImpl, sal_uInt8 *pBuffer, sal_Size nBufLen);

/*
 * __rtl_random_data.
 */
static double __rtl_random_data (RandomData_Impl *pImpl)
{
	register double random;

	RTL_RANDOM_RNG (pImpl->m_nX, pImpl->m_nY, pImpl->m_nZ);
	random = (((double)(pImpl->m_nX) / 30328.0) +
			  ((double)(pImpl->m_nY) / 30269.0) +
			  ((double)(pImpl->m_nZ) / 30307.0)   );

	random -= ((double)((sal_uInt32)(random)));
	return (random);
}

/*
 * __rtl_random_initPool.
 */
static sal_Bool __rtl_random_initPool (RandomPool_Impl *pImpl)
{
	pImpl->m_hDigest = rtl_digest_create (RTL_RANDOM_DIGEST);
	if (pImpl->m_hDigest)
	{
		oslThreadIdentifier id;
		TimeValue           tv;
		RandomData_Impl     rd;
		double              seed;

        /* The use of uninitialized stack variables as a way to
         * enhance the entropy of the random pool triggers
         * memory checkers like purify and valgrind.
         */

        /*
		__rtl_random_seedPool (pImpl, (sal_uInt8*)&id, sizeof(id));
		__rtl_random_seedPool (pImpl, (sal_uInt8*)&tv, sizeof(tv));
		__rtl_random_seedPool (pImpl, (sal_uInt8*)&rd, sizeof(rd));
        */

		id = osl_getThreadIdentifier (NULL);
		id = RTL_RANDOM_RNG_2(RTL_RANDOM_RNG_1(id));
		__rtl_random_seedPool (pImpl, (sal_uInt8*)&id, sizeof(id));

		osl_getSystemTime (&tv);
		tv.Seconds = RTL_RANDOM_RNG_2(tv.Seconds);
		tv.Nanosec = RTL_RANDOM_RNG_2(tv.Nanosec);
		__rtl_random_seedPool (pImpl, (sal_uInt8*)&tv, sizeof(tv));

		rd.m_nX = (sal_Int16)(((id         >> 1) << 1) + 1);
		rd.m_nY = (sal_Int16)(((tv.Seconds >> 1) << 1) + 1);
		rd.m_nZ = (sal_Int16)(((tv.Nanosec >> 1) << 1) + 1);
		__rtl_random_seedPool (pImpl, (sal_uInt8*)&rd, sizeof(rd));

		while (pImpl->m_nData < RTL_RANDOM_SIZE_POOL)
		{
			seed = __rtl_random_data (&rd);
			__rtl_random_seedPool (pImpl, (sal_uInt8*)&seed, sizeof(seed));
		}
		return sal_True;
	}
	return sal_False;
}

/*
 * __rtl_random_seedPool.
 */
static void __rtl_random_seedPool (
	RandomPool_Impl *pImpl, const sal_uInt8 *pBuffer, sal_Size nBufLen)
{
	sal_Size i;
	sal_sSize  j, k;

	for (i = 0; i < nBufLen; i += RTL_RANDOM_SIZE_DIGEST)
	{
		j = nBufLen - i;
		if (j > RTL_RANDOM_SIZE_DIGEST)
			j = RTL_RANDOM_SIZE_DIGEST;

		rtl_digest_update (
			pImpl->m_hDigest, pImpl->m_pDigest, RTL_RANDOM_SIZE_DIGEST);

		k = (pImpl->m_nIndex + j) - RTL_RANDOM_SIZE_POOL;
		if (k > 0)
		{
			rtl_digest_update (
				pImpl->m_hDigest, &(pImpl->m_pData[pImpl->m_nIndex]), j - k);
			rtl_digest_update (
				pImpl->m_hDigest, &(pImpl->m_pData[0]), k);
		}
		else
		{
			rtl_digest_update (
				pImpl->m_hDigest, &(pImpl->m_pData[pImpl->m_nIndex]), j);
		}

		rtl_digest_update (pImpl->m_hDigest, pBuffer, j);
		pBuffer += j;

		rtl_digest_get (
			pImpl->m_hDigest, pImpl->m_pDigest, RTL_RANDOM_SIZE_DIGEST);
		for (k = 0; k < j; k++)
		{
			pImpl->m_pData[pImpl->m_nIndex++] ^= pImpl->m_pDigest[k];
			if (pImpl->m_nIndex >= RTL_RANDOM_SIZE_POOL)
			{
				pImpl->m_nData  = RTL_RANDOM_SIZE_POOL;
				pImpl->m_nIndex = 0;
			}
		}
	}

	if (pImpl->m_nIndex > pImpl->m_nData)
		pImpl->m_nData = pImpl->m_nIndex;
}

/*
 * __rtl_random_readPool.
 */
static void __rtl_random_readPool (
	RandomPool_Impl *pImpl, sal_uInt8 *pBuffer, sal_Size nBufLen)
{
	sal_Int32 j, k;

	while (nBufLen > 0)
	{
		j = nBufLen;
		if (j > RTL_RANDOM_SIZE_DIGEST/2)
			j = RTL_RANDOM_SIZE_DIGEST/2;
		nBufLen -= j;

		rtl_digest_update (
			pImpl->m_hDigest,
			&(pImpl->m_pDigest[RTL_RANDOM_SIZE_DIGEST/2]),
			RTL_RANDOM_SIZE_DIGEST/2);

		k = (pImpl->m_nIndex + j) - pImpl->m_nData;
		if (k > 0)
		{
			rtl_digest_update (
				pImpl->m_hDigest, &(pImpl->m_pData[pImpl->m_nIndex]), j - k);
			rtl_digest_update (
				pImpl->m_hDigest, &(pImpl->m_pData[0]), k);
		}
		else
		{
			rtl_digest_update (
				pImpl->m_hDigest, &(pImpl->m_pData[pImpl->m_nIndex]), j);
		}

		rtl_digest_get (
			pImpl->m_hDigest, pImpl->m_pDigest, RTL_RANDOM_SIZE_DIGEST);
		for (k = 0; k < j; k++)
		{
			if (pImpl->m_nIndex >= pImpl->m_nData) pImpl->m_nIndex = 0;
			pImpl->m_pData[pImpl->m_nIndex++] ^= pImpl->m_pDigest[k];
			*pBuffer++ = pImpl->m_pDigest[k + RTL_RANDOM_SIZE_DIGEST/2];
		}
	}

	pImpl->m_nCount++;
	rtl_digest_update (
		pImpl->m_hDigest, &(pImpl->m_nCount), sizeof(pImpl->m_nCount));
	rtl_digest_update (
		pImpl->m_hDigest, pImpl->m_pDigest, RTL_RANDOM_SIZE_DIGEST);
	rtl_digest_get (
		pImpl->m_hDigest, pImpl->m_pDigest, RTL_RANDOM_SIZE_DIGEST);
}

/*========================================================================
 *
 * rtlRandom implementation.
 *
 *======================================================================*/
/*
 * rtl_random_createPool.
 */
rtlRandomPool SAL_CALL rtl_random_createPool (void)
{
	RandomPool_Impl *pImpl = (RandomPool_Impl*)NULL;
	pImpl = (RandomPool_Impl*)rtl_allocateZeroMemory (sizeof(RandomPool_Impl));
	if (pImpl)
	{
		if (!__rtl_random_initPool (pImpl))
		{
			rtl_freeZeroMemory (pImpl, sizeof(RandomPool_Impl));
			pImpl = (RandomPool_Impl*)NULL;
		}
	}
	return ((rtlRandomPool)pImpl);
}

/*
 * rtl_random_destroyPool.
 */
void SAL_CALL rtl_random_destroyPool (rtlRandomPool Pool)
{
	RandomPool_Impl *pImpl = (RandomPool_Impl *)Pool;
	if (pImpl)
	{
		rtl_digest_destroy (pImpl->m_hDigest);
		rtl_freeZeroMemory (pImpl, sizeof (RandomPool_Impl));
	}
}

/*
 * rtl_random_addBytes.
 */
rtlRandomError SAL_CALL rtl_random_addBytes (
	rtlRandomPool Pool, const void *Buffer, sal_Size Bytes)
{
	RandomPool_Impl *pImpl   = (RandomPool_Impl *)Pool;
	const sal_uInt8 *pBuffer = (const sal_uInt8 *)Buffer;

	if ((pImpl == NULL) || (pBuffer == NULL))
		return rtl_Random_E_Argument;

	__rtl_random_seedPool (pImpl, pBuffer, Bytes);
	return rtl_Random_E_None;
}

/*
 * rtl_random_getBytes.
 */
rtlRandomError SAL_CALL rtl_random_getBytes (
	rtlRandomPool Pool, void *Buffer, sal_Size Bytes)
{
	RandomPool_Impl *pImpl   = (RandomPool_Impl *)Pool;
	sal_uInt8       *pBuffer = (sal_uInt8 *)Buffer;

	if ((pImpl == NULL) || (pBuffer == NULL))
		return rtl_Random_E_Argument;

	__rtl_random_readPool (pImpl, pBuffer, Bytes);
	return rtl_Random_E_None;
}