/*
 * Copyright 2004-2008, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>

#include <OS.h>

#include <errno_private.h>
#include <libroot_private.h>
#include <locks.h>
#include <runtime_loader.h>
#include <stdlib_private.h>
#include <syscall_utils.h>
#include <user_runtime.h>


static const char* const kEnvLockName = "env lock";

static mutex sEnvLock = MUTEX_INITIALIZER(kEnvLockName);
static char **sManagedEnviron;

char **environ = NULL;


static inline void
lock_variables(void)
{
	mutex_lock(&sEnvLock);
}


static inline void
unlock_variables(void)
{
	mutex_unlock(&sEnvLock);
}


static void
free_variables(void)
{
	int32 i;

	if (sManagedEnviron == NULL)
		return;

	for (i = 0; sManagedEnviron[i] != NULL; i++) {
		free(sManagedEnviron[i]);
	}

	free(sManagedEnviron);
	sManagedEnviron = NULL;
}


static int32
count_variables(void)
{
	int32 i = 0;

	if (environ == NULL)
		return 0;

	while (environ[i])
		i++;

	return i;
}


static int32
add_variable(void)
{
	int32 count = count_variables() + 1;
	char **newEnviron = (char**)realloc(environ, (count + 1) * sizeof(char *));
	if (newEnviron == NULL)
		return B_NO_MEMORY;

	newEnviron[count] = NULL;
		// null terminate the array

	environ = sManagedEnviron = newEnviron;

	return count - 1;
}


static char *
find_variable(const char *name, int32 length, int32 *_index)
{
	int32 i;

	if (environ == NULL)
		return NULL;

	for (i = 0; environ[i] != NULL; i++) {
		if (!strncmp(name, environ[i], length) && environ[i][length] == '=') {
			if (_index != NULL)
				*_index = i;
			return environ[i];
		}
	}

	return NULL;
}


/*!	Copies the environment from its current location into a heap managed
	environment, if it's not already there.

	This is needed whenever the environment is changed, that is, when one
	of the POSIX *env() functions is called, and we either used the environment
	provided by the kernel, or by an application that changed \c environ
	directly.
*/
static status_t
copy_environ_to_heap_if_needed(void)
{
	int32 i = 0;

	if (environ == sManagedEnviron)
		return B_OK;

	// free previously used "environ" if it has been changed by an application
	free_variables();

	sManagedEnviron = (char**)malloc((count_variables() + 1) * sizeof(char *));
	if (sManagedEnviron == NULL)
		return B_NO_MEMORY;

	if (environ != NULL) {
		// copy from previous
		for (; environ[i]; i++) {
			sManagedEnviron[i] = strdup(environ[i]);
		}
	}

	sManagedEnviron[i] = NULL;
		// null terminate the array

	environ = sManagedEnviron;
	return B_OK;
}


static status_t
update_variable(const char *name, int32 length, const char *value,
	bool overwrite)
{
	bool update = false;
	int32 index;
	char *env;

	copy_environ_to_heap_if_needed();

	env = find_variable(name, length, &index);
	if (env != NULL && overwrite) {
		// change variable
		free(environ[index]);
		update = true;
	} else if (env == NULL) {
		// add variable
		index = add_variable();
		if (index < 0)
			return B_NO_MEMORY;

		update = true;
	}

	if (update) {
		environ[index] = (char*)malloc(length + 2 + strlen(value));
		if (environ[index] == NULL)
			return B_NO_MEMORY;

		memcpy(environ[index], name, length);
		environ[index][length] = '=';
		strcpy(environ[index] + length + 1, value);
	}

	return B_OK;
}


static void
environ_fork_hook(void)
{
	mutex_init(&sEnvLock, kEnvLockName);
}


//	#pragma mark - libroot initializer


void
__init_env(const struct user_space_program_args *args)
{
	// Following POSIX, there is no need to make any of the environment
	// functions thread-safe - but we do it anyway as much as possible to
	// protect our implementation
	environ = args->env;
	sManagedEnviron = NULL;
}


void
__init_env_post_heap()
{
	atfork(environ_fork_hook);
}


//	#pragma mark - public API


int
clearenv(void)
{
	lock_variables();

	free_variables();
	environ = NULL;

	unlock_variables();

	return 0;
}


char *
getenv(const char *name)
{
	int32 length = strlen(name);
	char *value;

	lock_variables();

	value = find_variable(name, length, NULL);
	unlock_variables();

	if (value == NULL)
		return NULL;

	return value + length + 1;
}


int
setenv(const char *name, const char *value, int overwrite)
{
	status_t status;

	if (name == NULL || name[0] == '\0' || strchr(name, '=') != NULL) {
		__set_errno(B_BAD_VALUE);
		return -1;
	}

	lock_variables();
	status = update_variable(name, strlen(name), value, overwrite);
	unlock_variables();

	RETURN_AND_SET_ERRNO(status);
}


int
unsetenv(const char *name)
{
	int32 index, length;
	char *env;

	if (name == NULL || name[0] == '\0' || strchr(name, '=') != NULL) {
		__set_errno(B_BAD_VALUE);
		return -1;
	}

	length = strlen(name);

	lock_variables();

	copy_environ_to_heap_if_needed();

	env = find_variable(name, length, &index);
	while (env != NULL) {
		// we don't free the memory for the slot, we just move the array
		// contents
		free(env);
		memmove(environ + index, environ + index + 1,
			sizeof(char *) * (count_variables() - index));

		// search possible another occurence, introduced via putenv()
		// and renamed since
		env = find_variable(name, length, &index);
	}

	unlock_variables();
	return 0;
}


int
putenv(char *string)
{
	char *value = strchr(string, '=');
	status_t status;

	if (value == NULL || value == string) {
		__set_errno(B_BAD_VALUE);
		return -1;
	}

	lock_variables();
	status = update_variable(string, value - string, value + 1, true);
	unlock_variables();

	RETURN_AND_SET_ERRNO(status);
}


ssize_t
__getenv_reentrant(const char* name, char* buffer, size_t bufferSize)
{
	size_t nameLength = strlen(name);

	lock_variables();

	char* value = find_variable(name, nameLength, NULL);
	ssize_t result = value != NULL
		? strlcpy(buffer, value + nameLength + 1, bufferSize)
		: B_NAME_NOT_FOUND;

	unlock_variables();

	return result;
}