/** @file base.c
 * @brief Base faux functions.
 */

#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "faux/faux.h"


/** Portable implementation of free() function.
 *
 * The POSIX standard says the free() must check pointer for NULL value
 * and must not try to free NULL pointer. I.e. it do nothing in a case of NULL.
 * The Linux glibc do so. But some non-fully POSIX compatible systems don't.
 * For these systems our implementation of free() must check for NULL itself.
 *
 * For now function simply call free() but it can be changed while working on
 * portability.
 *
 * @param [in] ptr Memory pointer to free.
 * @sa free()
 */
void faux_free(void *ptr)
{
#if 0
	if (ptr)
#endif
	free(ptr);
}


/** Portable implementation of malloc() function.
 *
 * The faux library implements its own free() function (called faux_free()) so
 * it's suitable to implement their own complementary malloc() function.
 * The behaviour when the size is 0 must be strictly defined. This function
 * will assert() and return NULL when size is 0.
 *
 * @param [in] size Memory size to allocate.
 * @return Allocated memory or NULL on error.
 * @sa malloc()
 */
void *faux_malloc(size_t size)
{
	assert(size != 0);
	if (0 == size)
		return NULL;

	return malloc(size);
}

/** Portable implementation of bzero().
 *
 * The POSIX standard says the bzero() is legacy now. It recommends to use
 * memset() instead it. But bzero() is easier to use. So bzero() can be
 * implemented using memset().
 *
 * @param [in] ptr Pointer
 * @param [in] size Size of memory (in bytes) to zero it.
 * @sa bzero()
 */
void faux_bzero(void *ptr, size_t size)
{
	memset(ptr, '\0', size);
}


/** The malloc() implementation with writing zeroes to allocated buffer.
 *
 * The POSIX defines calloc() function to allocate memory and write zero bytes
 * to the whole buffer. But calloc() has strange set of arguments. This function
 * is simply combination of malloc() and bzero().
 *
 * @param [in] size Memory size to allocate.
 * @return Allocated zeroed memory or NULL on error.
 */
void *faux_zmalloc(size_t size)
{
	void *ptr = NULL;

	ptr = faux_malloc(size);
	if (ptr)
		faux_bzero(ptr, size);

	return ptr;
}


/** Securely clean memory buffer.
 *
 * If buffer is used for some crypto data then it's better to cleanse memory
 * before freing. It's not enough to nullify it. Instead fill it with pseudo
 * random numbers.
 *
 * @param [in] ptr Pointer
 * @param [in] size Size of memory (in bytes) to clean it.
 */

void faux_cleanse(void *ptr, size_t size)
{
	static unsigned char cleanse_ctr = 0; // It must be static
	unsigned char *p = (unsigned char *)ptr;
	size_t loop = size;
	size_t ctr = cleanse_ctr;

	if (size == 0)
		return;

	while (loop) {
		*p = (unsigned char)ctr;
		p++;
		ctr += (17 + ((size_t)p & 0x0f));
		loop--;
	}
	p = (unsigned char *)memchr(ptr, (unsigned char)ctr, size);
	if (p)
		ctr += 63 + (size_t)p;
	cleanse_ctr = (unsigned char)ctr;
}