/*
 * Copyright (c) 2001-2002 Packet Design, LLC.
 * All rights reserved.
 * 
 * Subject to the following obligations and disclaimer of warranty,
 * use and redistribution of this software, in source or object code
 * forms, with or without modifications are expressly permitted by
 * Packet Design; provided, however, that:
 * 
 *    (i)  Any and all reproductions of the source or object code
 *         must include the copyright notice above and the following
 *         disclaimer of warranties; and
 *    (ii) No rights are granted, in any manner or form, to use
 *         Packet Design trademarks, including the mark "PACKET DESIGN"
 *         on advertising, endorsements, or otherwise except as such
 *         appears in the above copyright notice or in the software.
 * 
 * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
 * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
 * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
 * OR NON-INFRINGEMENT.  PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
 * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
 * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
 * RELIABILITY OR OTHERWISE.  IN NO EVENT SHALL PACKET DESIGN BE
 * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
 * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
 * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
 * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Author: Archie Cobbs <archie@freebsd.org>
 */

#include <sys/types.h>

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <pthread.h>
#include <errno.h>

#include "structs/structs.h"
#include "structs/type/array.h"
#include "util/typed_mem.h"
#include "util/tinfo.h"

/* Per-thread tinfo data */
struct tinfo_private {
	struct tinfo	*t;
	void		*data;				/* user data */
};

/* Internal variables */
static struct	tinfo_private *tinfo_init(struct tinfo *t);
static void	tinfo_instance_destroy(void *arg);

/*
 * Get the per-thread instance, creating a new one if none there.
 *
 * Note: the returned value should NOT be free'd by the caller.
 */
void *
tinfo_get(struct tinfo *t)
{
	struct tinfo_private *priv;

	/* Get instance container */
	if ((priv = tinfo_init(t)) == NULL)
		return (NULL);

	/* Has instance been constructed yet? If not, construct one */
	if (priv->data == NULL) {

		/* Create a new instance for this thread */
		if ((priv->data = MALLOC(t->mtype, t->type->size)) == NULL)
			return (NULL);

		/* Run application initializer (if any) or else default */
		if ((t->init != NULL ? (*t->init)(t, priv->data) :
		    structs_init(t->type, NULL, priv->data)) == -1) {
			FREE(t->mtype, priv->data);
			priv->data = NULL;
		}
	}

	/* Done */
	return (priv->data);
}

/*
 * Set a new value for the per-thread variable.
 */
int
tinfo_set(struct tinfo *t, const void *data)
{
	struct tinfo_private *priv;
	void *copy;

	/* Get instance container */
	if ((priv = tinfo_init(t)) == NULL)
		return (-1);

	/* Handle case where data is NULL */
	if (data == NULL) {
		if (priv->data != NULL) {
			structs_free(t->type, NULL, priv->data);
			FREE(t->mtype, priv->data);
			priv->data = NULL;
		}
		return (0);
	}

	/* Copy new data provided by caller */
	if ((copy = MALLOC(t->mtype, t->type->size)) == NULL)
		return (-1);
	if (structs_get(t->type, NULL, data, copy) == -1) {
		FREE(t->mtype, copy);
		return (-1);
	}

	/* Set copy */
	if (tinfo_set_nocopy(t, copy) == -1) {
		structs_free(t->type, NULL, priv->data);
		FREE(t->mtype, copy);
	}

	/* Done */
	return (0);
}

/*
 * Set a new value for the per-thread variable without copying.
 */
int
tinfo_set_nocopy(struct tinfo *t, void *data)
{
	struct tinfo_private *priv;

	/* Get instance container */
	if ((priv = tinfo_init(t)) == NULL)
		return (-1);

	/* Free existing value, if any */
	if (priv->data != NULL) {
		structs_free(t->type, NULL, priv->data);
		FREE(t->mtype, priv->data);
	}

	/* Set new value */
	priv->data = data;
	return (0);
}

/*
 * Initialize per-thread variable if not already initialized.
 */
static struct tinfo_private *
tinfo_init(struct tinfo *t)
{
	struct tinfo_private *priv;

	/* Initialize key, once for all threads */
	if (t->pkey == TINFO_KEY_INIT
	    && (errno = pthread_key_create(&t->pkey,
	      tinfo_instance_destroy)) != 0) {
		t->pkey = TINFO_KEY_INIT;
		return (NULL);
	}

	/* Construct instance container for this thread if needed */
	if ((priv = pthread_getspecific(t->pkey)) == NULL) {

		/* Get new instance container (a struct tinfo_private) */
		if ((priv = MALLOC(t->mtype, sizeof(*priv))) == NULL)
			return (NULL);
		memset(priv, 0, sizeof(*priv));
		priv->t = t;

		/* Store the container as the per-thread variable */
		if ((errno = pthread_setspecific(t->pkey, priv)) != 0) {
			FREE(t->mtype, priv);
			return (NULL);
		}
	}

	/* Done */
	return (priv);
}

/*
 * Destructor called upon thread exit.
 */
static void
tinfo_instance_destroy(void *arg)
{
	struct tinfo_private *const priv = arg;
	struct tinfo *const t = priv->t;

	/* Free instance */
	if (priv->data != NULL) {
		structs_free(t->type, NULL, priv->data);
		FREE(t->mtype, priv->data);
	}

	/* Free container */
	FREE(t->mtype, priv);
}