/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.

 */

/*	Copyright (c) 1988 AT&T	*/

/*	  All Rights Reserved  	*/

#pragma	weak _putenv = putenv

#include "lint.h"

#include <mtlib.h>

#include <sys/types.h>

#include <thread.h>

#include <synch.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <atomic.h>

#define	MIN_ENV_SIZE		128

extern const char		**_environ;

extern void			clean_env();

/*

 * For performance and consistency reasons we expand the _environ list using

 * the trusted "power of two, drop it on the floor" method. This allows for

 * a lockless, single pass implementation of getenv(), yet the memory leak

 * is bounded - in normal circumstances total wastage is never greater than

 * 3x the space needed to hold any _environ list.

 *

 * The only abnormal circumstance is if an application modifies the _environ

 * list pointer directly. Such an application does not conform to POSIX.1

 * 2001. However, we also care about standards which did not foresee this

 * issue. For this reason we keep a working copy of our notion of _environ in

 * my_environ. If, when we are called upon to modify _environ, we ever detect

 * a mismatch between _environ and my_environ we discard all our assumptions

 * concerning the location and size of the _environ list. As an additional

 * precaution we only ever update _environ once we have finished manipulating

 * our working copy.

 *

 * The setenv() API is inherently leaky but we are completely at the mercy

 * of the application.

 *

 * To pacify leak detectors we chain all allocations which are at risk of

 * being leaked in either of the above two scenarios. chunk_list must only

 * be updated under the protection of update_lock.

 *

 * Although we don't allocate the original _environ list it is likely that

 * we will leak this too. Accordingly, we create a reference in initenv().

 * However, we can't be held responsible for such leaks in abnormal (see

 * above) circumstances.

 */

typedef struct chunk {

	struct chunk		*next;

} chunk_t;

static mutex_t			update_lock = DEFAULTMUTEX;

static const char		**orig_environ = NULL;

static const char		**my_environ = NULL;

static const char		**environ_base = NULL;

static int			environ_size = 0;

static int			environ_gen = 0;

static int			initenv_done = 0;

static chunk_t			*chunk_list = NULL;

/*

 * Compute the size an _environ list including the terminating NULL entry.

 * This is the only way we have to determine the size of an _environ list

 * we didn't allocate.

 */

static int

envsize(const char **e)

{

	int			size;

	if (e == NULL)

		return (0);

	for (size = 1; *e != NULL; e++)

		size++;

	return (size);

}

/*

 * Initialization for the following scenarios:

 * 1. The very first time we reference the _environ list we must call in the

 *    NLSPATH janitor, make a reference to the original _environ list to keep

 *    leak detectors happy, initialize my_environ and environ_base, and then

 *    compute environ_size.

 * 2. Whenever we detect that someone else has hijacked _environ (something

 *    very abnormal) we need to reinitialize my_environ and environ_base,

 *    and then recompute environ_size.

 *

 * The local globals my_environ, environ_base and environ_size may be used

 * by others only if initenv_done is true and only under the protection of

 * update_lock. However, our callers, who must NOT be holding update_lock,

 * may safely test initenv_done or my_environ against _environ just prior to

 * calling us because we test these again whilst holding update_lock.

 */

static void

initenv()

{

	if ((my_environ != _environ) || !initenv_done) {

		lmutex_lock(&update_lock);

		if ((my_environ != _environ) || !initenv_done) {

			if (!initenv_done) {

				/* Call the NLSPATH janitor in. */

				clean_env();

				/* Pacify leak detectors in normal operation. */

				orig_environ = _environ;

#ifdef __lint

				my_environ = orig_environ;

#endif

			}

			my_environ = _environ;

			environ_base = my_environ;

			environ_size = envsize(environ_base);

			membar_producer();

			initenv_done = 1;

		}

		lmutex_unlock(&update_lock);

	}

	membar_consumer();

}

/*

 * Search an _environ list for a particular entry. If name_only is set, then

 * string must be the entry name only, and we return the value of the first

 * match. Otherwise, string must be of the form "name=value", and we return

 * the address of the first matching entry.

 */

static const char **

findenv(const char **e, const char *string, int name_only, char **value)

{

	char			target;

	const char		*s1;

	const char		*s2;

	*value = NULL;

	if (e == NULL)

		return (NULL);

	target = name_only ? '\0' : '=';

	for (; (s2 = *e) != NULL; e++) {

		s1 =  string;

		/* Fast comparison for first char. */

		if (*s1 != *s2)

			continue;

		/* Slow comparison for rest of string. */

		while (*s1 == *s2 && *s2 != '=') {

			s1++;

			s2++;

		}

		if (*s1 == target && *s2 == '=') {

			*value = (char *)s2 + 1;

			return (e);

		}

	}

	return (NULL);

}

/*

 * Common code for putenv() and setenv(). We support the lockless getenv()

 * by inserting new entries at the bottom of the list, and by growing the

 * list using the trusted "power of two, drop it on the floor" method. We

 * use a lock (update_lock) to protect all updates to the _environ list, but

 * we are obliged to release this lock whenever we call malloc() or free().

 * A generation number (environ_gen) is bumped whenever names are added to,

 * or removed from, the _environ list so that we can detect collisions with

 * other updaters.

 *

 * Return values

 *   0 : success

 *  -1 : with errno set

 *  -2 : an entry already existed and overwrite was zero

 */

static int

addtoenv(char *string, int overwrite)

{

	char			*value;

	const char		**p;

	chunk_t			*new_chunk;

	const char		**new_environ;

	const char		**new_base;

	int			new_size;

	int			old_gen;

	initenv();

	lmutex_lock(&update_lock);

	for (;;) {

		/*

		 * If the name already exists just overwrite the existing

		 * entry -- except when we were called by setenv() without

		 * the overwrite flag.

		 */

		if ((p = findenv(my_environ, string, 0, &value)) != NULL) {

			if (overwrite) {

				/*

				 * Replace the value in situ. No name was

				 * added, so there is no need to bump the

				 * generation number.

				 */

				*p = string;

				lmutex_unlock(&update_lock);

				return (0);

			} else {

				/* No change. */

				lmutex_unlock(&update_lock);

				return (-2);

			}

		}

		/* Try to insert the new entry at the bottom of the list. */

		if (environ_base < my_environ) {

			/*

			 * The new value must be visible before we decrement

			 * the _environ list pointer.

			 */

			my_environ[-1] = string;

			membar_producer();

			my_environ--;

			_environ = my_environ;

			/*

			 * We've added a name, so bump the generation number.

			 */

			environ_gen++;

			lmutex_unlock(&update_lock);

			return (0);

		}

		/*

		 * There is no room. Attempt to allocate a new _environ list

		 * which is at least double the size of the current one. See

		 * comment above concerning locking and malloc() etc.

		 */

		new_size = environ_size * 2;

		if (new_size < MIN_ENV_SIZE)

			new_size = MIN_ENV_SIZE;

		old_gen = environ_gen;

		lmutex_unlock(&update_lock);

		new_chunk = malloc(sizeof (chunk_t) +

		    new_size * sizeof (char *));

		if (new_chunk == NULL) {

			errno = ENOMEM;

			return (-1);

		}

		lmutex_lock(&update_lock);

		/*

		 * If no other thread added or removed names while the lock

		 * was dropped, it is time to break out of this loop.

		 */

		if (environ_gen == old_gen)

			break;

		/*

		 * At least one name has been added or removed, so we need to

		 * try again. It is very likely that we will find sufficient

		 * space the next time around.

		 */

		lmutex_unlock(&update_lock);

		free(new_chunk);

		lmutex_lock(&update_lock);

	}

	/* Add the new chunk to chunk_list to hide potential future leak. */

	new_chunk->next = chunk_list;

	chunk_list = new_chunk;

	/* Copy the old _environ list into the top of the new _environ list. */

	new_base = (const char **)(new_chunk + 1);

	new_environ = &new_base[(new_size - 1) - environ_size];

	(void) memcpy(new_environ, my_environ, environ_size * sizeof (char *));

	/* Insert the new entry at the bottom of the new _environ list. */

	new_environ[-1] = string;

	new_environ--;

	/* Ensure that the new _environ list is visible to all. */

	membar_producer();

	/* Make the switch (dropping the old _environ list on the floor). */

	environ_base = new_base;

	my_environ = new_environ;

	_environ = my_environ;

	environ_size = new_size;

	/* We've added a name, so bump the generation number. */

	environ_gen++;

	lmutex_unlock(&update_lock);

	return (0);

}

/*

 * All the work for putenv() is done in addtoenv().

 */

int

putenv(char *string)

{

	return (addtoenv(string, 1));

}

/*

 * setenv() is a little more complex than putenv() because we have to allocate

 * and construct an _environ entry on behalf of the caller. The bulk of the

 * work is still done in addtoenv().

 */

int

setenv(const char *envname, const char *envval, int overwrite)

{

	chunk_t			*new_chunk;

	char			*new_string;

	size_t			name_len;

	size_t			val_len;

	int			res;

	if (envname == NULL || *envname == 0 || strchr(envname, '=') != NULL) {

		errno = EINVAL;

		return (-1);

	}

	name_len = strlen(envname);

	val_len = strlen(envval);

	new_chunk = malloc(sizeof (chunk_t) + name_len + val_len + 2);

	if (new_chunk == NULL) {

		errno = ENOMEM;

		return (-1);

	}

	new_string = (char *)(new_chunk + 1);

	(void) memcpy(new_string, envname, name_len);

	new_string[name_len] = '=';

	(void) memcpy(new_string + name_len + 1, envval, val_len);

	new_string[name_len + 1 + val_len] = 0;

	if ((res = addtoenv(new_string, overwrite)) < 0) {

		free(new_chunk);

		if (res == -2) {

			/* The name already existed, but not an error. */

			return (0);

		} else {

			/* i.e. res == -1 which means only one thing. */

			errno = ENOMEM;

			return (-1);

		}

	}

	/* Hide potential leak of new_string. */

	lmutex_lock(&update_lock);

	new_chunk->next = chunk_list;

	chunk_list = new_chunk;

	lmutex_unlock(&update_lock);

	return (0);

}

/*

 * unsetenv() is tricky because we need to compress the _environ list in a way

 * which supports a lockless getenv(). The approach here is to move the first

 * entry from the enrivon list into the space occupied by the entry to be

 * deleted, and then to increment _environ. This has the added advantage of

 * making _any_ incremental linear search of the _environ list consistent (i.e.

 * we will not break any naughty apps which read the list without our help).

 */

int

unsetenv(const char *name)

{

	const char		**p;

	char			*value;

	if (name == NULL || *name == 0 || strchr(name, '=') != NULL) {

		errno = EINVAL;

		return (-1);

	}

	initenv();

	lmutex_lock(&update_lock);

	/*

	 * Find the target, overwrite it with the first entry, increment the

	 * _environ pointer.

	 */

	if ((p = findenv(my_environ, name, 1, &value)) != NULL) {

		/* Overwrite target with the first entry. */

		*p = my_environ[0];

		/* Ensure that the moved entry is visible to all.  */

		membar_producer();

		/* Shrink the _environ list. */

		my_environ++;

		_environ = my_environ;

		/* Make sure addtoenv() knows that we've removed a name. */

		environ_gen++;

	}

	lmutex_unlock(&update_lock);

	return (0);

}

/*

 * Dump entire environment.

 */

int

clearenv(void)

{

	/*

	 * Just drop the entire environment list on the floor, as it

	 * would be non-trivial to try and free the used memory.

	 */

	static const char *nullp = NULL;

	lmutex_lock(&update_lock);

	_environ = &nullp;

	my_environ = NULL;

	environ_base = NULL;

	environ_size = 0;

	environ_gen++;

	membar_producer();

	lmutex_unlock(&update_lock);

	return (0);

}

/*

 * At last, a lockless implementation of getenv()!

 */

char *

getenv(const char *name)

{

	char			*value;

	initenv();

	if (findenv(_environ, name, 1, &value) != NULL)

		return (value);

	return (NULL);

}