/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdlib.h>
#include <stddef.h>
#include <sys/types.h>
#include <pthread.h>
#include <string.h>
#include <dtj_util.h>

/*
 * dtj_util.c separates functionality that is generally useful from
 * that which is specific to the Java DTrace API.  If moved to a separate
 * library, this functionality could be shared by other JNI wrappers.
 */

boolean_t g_dtj_util_debug = B_FALSE;
static boolean_t g_dtj_load_common = B_FALSE;

/* NativeException */
jclass g_nx_jc = 0;
jmethodID g_nxinit_jm = 0;

/* java.io.Serializable */
jclass g_serial_jc = 0;

/* java.lang.Number */
jclass g_number_jc = 0;
jmethodID g_shortval_jm = 0;
jmethodID g_intval_jm = 0;
jmethodID g_longval_jm = 0;

/* java.lang.Byte */
jclass g_byte_jc = 0;
jmethodID g_byteinit_jm = 0;

/* java.lang.Character */
jclass g_char_jc = 0;
jmethodID g_charinit_jm = 0;
jmethodID g_charval_jm = 0;

/* java.lang.Short */
jclass g_short_jc = 0;
jmethodID g_shortinit_jm = 0;

/* java.lang.Integer */
jclass g_int_jc = 0;
jmethodID g_intinit_jm = 0;

/* java.lang.Long */
jclass g_long_jc = 0;
jmethodID g_longinit_jm = 0;

/* java.math.BigInteger */
jclass g_bigint_jc = 0;
jmethodID g_bigint_val_jsm = 0;
jmethodID g_bigint_div_jm = 0;
jmethodID g_bigint_shl_jm = 0;
jmethodID g_bigint_or_jm = 0;
jmethodID g_bigint_setbit_jm = 0;

/* java.lang.String */
jclass g_string_jc = 0;
jmethodID g_strinit_bytes_jm = 0;
jmethodID g_strbytes_jm = 0;
jmethodID g_trim_jm = 0;

/* java.lang.StringBuilder */
jclass g_buf_jc = 0;
jmethodID g_bufinit_jm = 0;
jmethodID g_buf_append_char_jm = 0;
jmethodID g_buf_append_int_jm = 0;
jmethodID g_buf_append_long_jm = 0;
jmethodID g_buf_append_str_jm = 0;
jmethodID g_buf_append_obj_jm = 0;
jmethodID g_buflen_jm = 0;
jmethodID g_bufsetlen_jm = 0;

/* java.lang.Object */
jclass g_object_jc = 0;
jmethodID g_tostring_jm = 0;
jmethodID g_equals_jm = 0;

/* java.lang.Enum */
jclass g_enum_jc = 0;
jmethodID g_enumname_jm = 0;

/* List */
jclass g_list_jc = 0;
jmethodID g_listclear_jm = 0;
jmethodID g_listadd_jm = 0;
jmethodID g_listget_jm = 0;
jmethodID g_listsize_jm = 0;

/* Global list pools */
static uu_list_pool_t *g_pointer_pool = NULL;
static uu_list_pool_t *g_string_pool = NULL;

static dtj_status_t dtj_get_jni_classes(JNIEnv *, uu_list_t *, uu_list_pool_t *,
    uu_list_pool_t *, uu_list_pool_t *, const dtj_table_entry_t *);
static dtj_status_t dtj_cache_jni_methods(JNIEnv *, dtj_java_class_t *);
static dtj_status_t dtj_cache_jni_fields(JNIEnv *, dtj_java_class_t *);

/* Constructors */
static dtj_java_class_t *dtj_java_class_create(JNIEnv *, jclass *, char *,
    uu_list_pool_t *, uu_list_pool_t *, uu_list_pool_t *);
static dtj_java_method_t *dtj_java_method_create(JNIEnv *, jmethodID *, char *,
    char *, uu_list_pool_t *);
static dtj_java_method_t *dtj_java_static_method_create(JNIEnv *, jmethodID *,
    char *, char *, uu_list_pool_t *);
static dtj_java_field_t *dtj_java_field_create(JNIEnv *, jfieldID *, char *,
    char *, uu_list_pool_t *);
static dtj_java_field_t *dtj_java_static_field_create(JNIEnv *, jfieldID *,
    char *, char *, uu_list_pool_t *);

/* Destructors */
static void dtj_java_class_destroy(void *, void *);
static void dtj_java_method_destroy(void *, void *);
static void dtj_java_field_destroy(void *, void *);

/* Comparison functions, uu_compare_fn_t signature */
static int dtj_java_class_cmp(const void *, const void *, void *);
static int dtj_java_method_cmp(const void *, const void *, void *);
static int dtj_java_field_cmp(const void *, const void *, void *);

/* Java Throwable */
static void dtj_throw(JNIEnv *, jclass, const char *, va_list *);

/* Support for uu_list_t wrappers */
static boolean_t dtj_check_pointer_pool(void);
static boolean_t dtj_check_string_pool(void);

dtj_status_t
dtj_load_common(JNIEnv *jenv)
{
	dtj_status_t status;

	static const dtj_table_entry_t table[] = {
		/* NativeException */
		{ JCLASS,  &g_nx_jc,
			"org/opensolaris/os/dtrace/NativeException" },
		{ JMETHOD, &g_nxinit_jm, CONSTRUCTOR,
			"(Ljava/lang/String;ILjava/lang/Throwable;)V" },

		/* java.io.Serializable */
		{ JCLASS,  &g_serial_jc, "java/io/Serializable" },

		/* java.lang.Number */
		{ JCLASS,  &g_number_jc, "java/lang/Number" },
		{ JMETHOD, &g_shortval_jm, "shortValue", "()S" },
		{ JMETHOD, &g_intval_jm, "intValue", "()I" },
		{ JMETHOD, &g_longval_jm, "longValue", "()J" },

		/* java.lang.Byte */
		{ JCLASS,  &g_byte_jc, "java/lang/Byte" },
		{ JMETHOD, &g_byteinit_jm, CONSTRUCTOR, "(B)V" },

		/* java.lang.Character */
		{ JCLASS,  &g_char_jc, "java/lang/Character" },
		{ JMETHOD, &g_charinit_jm, CONSTRUCTOR, "(C)V" },
		{ JMETHOD, &g_charval_jm, "charValue", "()C" },

		/* java.lang.Short */
		{ JCLASS,  &g_short_jc, "java/lang/Short" },
		{ JMETHOD, &g_shortinit_jm, CONSTRUCTOR, "(S)V" },

		/* java.lang.Integer */
		{ JCLASS,  &g_int_jc, "java/lang/Integer" },
		{ JMETHOD, &g_intinit_jm, CONSTRUCTOR, "(I)V" },

		/* java.lang.Long */
		{ JCLASS,  &g_long_jc, "java/lang/Long" },
		{ JMETHOD, &g_longinit_jm, CONSTRUCTOR, "(J)V" },

		/* java.math.BigInteger */
		{ JCLASS,  &g_bigint_jc, "java/math/BigInteger" },
		{ JMETHOD_STATIC, &g_bigint_val_jsm, "valueOf",
			"(J)Ljava/math/BigInteger;" },
		{ JMETHOD, &g_bigint_div_jm, "divide",
			"(Ljava/math/BigInteger;)Ljava/math/BigInteger;" },
		{ JMETHOD, &g_bigint_shl_jm, "shiftLeft",
			"(I)Ljava/math/BigInteger;" },
		{ JMETHOD, &g_bigint_or_jm, "or",
			"(Ljava/math/BigInteger;)Ljava/math/BigInteger;" },
		{ JMETHOD, &g_bigint_setbit_jm, "setBit",
			"(I)Ljava/math/BigInteger;" },

		/* java.lang.String */
		{ JCLASS,  &g_string_jc, "java/lang/String" },
		{ JMETHOD, &g_strinit_bytes_jm, CONSTRUCTOR, "([B)V" },
		{ JMETHOD, &g_strbytes_jm, "getBytes", "()[B" },
		{ JMETHOD, &g_trim_jm, "trim", "()Ljava/lang/String;" },

		/* java.lang.StringBuilder */
		{ JCLASS,  &g_buf_jc, "java/lang/StringBuilder" },
		{ JMETHOD, &g_bufinit_jm, CONSTRUCTOR, "()V" },
		{ JMETHOD, &g_buf_append_char_jm, "append",
			"(C)Ljava/lang/StringBuilder;" },
		{ JMETHOD, &g_buf_append_int_jm, "append",
			"(I)Ljava/lang/StringBuilder;" },
		{ JMETHOD, &g_buf_append_long_jm, "append",
			"(J)Ljava/lang/StringBuilder;" },
		{ JMETHOD, &g_buf_append_str_jm, "append",
			"(Ljava/lang/String;)Ljava/lang/StringBuilder;" },
		{ JMETHOD, &g_buf_append_obj_jm, "append",
			"(Ljava/lang/Object;)Ljava/lang/StringBuilder;" },
		{ JMETHOD, &g_buflen_jm, "length", "()I" },
		{ JMETHOD, &g_bufsetlen_jm, "setLength", "(I)V" },

		/* java.lang.Object */
		{ JCLASS,  &g_object_jc, "java/lang/Object" },
		{ JMETHOD, &g_tostring_jm, "toString",
			"()Ljava/lang/String;" },
		{ JMETHOD, &g_equals_jm, "equals",
			"(Ljava/lang/Object;)Z" },

		/* java.lang.Enum */
		{ JCLASS,  &g_enum_jc, "java/lang/Enum" },
		{ JMETHOD, &g_enumname_jm, "name",
			"()Ljava/lang/String;" },

		/* List */
		{ JCLASS, &g_list_jc, "java/util/List" },
		{ JMETHOD, &g_listclear_jm, "clear", "()V" },
		{ JMETHOD, &g_listadd_jm, "add", "(Ljava/lang/Object;)Z" },
		{ JMETHOD, &g_listget_jm, "get", "(I)Ljava/lang/Object;" },
		{ JMETHOD, &g_listsize_jm, "size", "()I" },

		{ DTJ_TYPE_END }
	};

	status = dtj_cache_jni_classes(jenv, table);
	if (status == DTJ_OK) {
		g_dtj_load_common = B_TRUE;
	}
	return (status);
}

static int
/* ARGSUSED */
dtj_java_class_cmp(const void * v1, const void * v2, void *arg)
{
	const dtj_java_class_t *c1 = v1;
	const dtj_java_class_t *c2 = v2;
	return (strcmp(c1->djc_name, c2->djc_name));
}

static int
/* ARGSUSED */
dtj_java_method_cmp(const void *v1, const void *v2, void *arg)
{
	int cmp;
	const dtj_java_method_t *m1 = v1;
	const dtj_java_method_t *m2 = v2;
	cmp = strcmp(m1->djm_name, m2->djm_name);
	if (cmp == 0) {
		cmp = strcmp(m1->djm_signature, m2->djm_signature);
	}
	return (cmp);
}

static int
/* ARGSUSED */
dtj_java_field_cmp(const void *v1, const void *v2, void *arg)
{
	const dtj_java_field_t *f1 = v1;
	const dtj_java_field_t *f2 = v2;
	return (strcmp(f1->djf_name, f2->djf_name));
}

static dtj_java_class_t *
dtj_java_class_create(JNIEnv *jenv, jclass *jc, char *name,
    uu_list_pool_t *classpool, uu_list_pool_t *methodpool,
    uu_list_pool_t *fieldpool)
{
	dtj_java_class_t *c = uu_zalloc(sizeof (dtj_java_class_t));
	if (c) {
		uu_list_node_init(c, &c->djc_node, classpool);
		c->djc_ptr = jc;
		c->djc_name = name;
		c->djc_methods = uu_list_create(methodpool, NULL,
		    (g_dtj_util_debug ? UU_LIST_DEBUG : 0));
		if (!c->djc_methods) {
			dtj_throw_out_of_memory(jenv,
			    "Failed method list creation");
			uu_list_node_fini(c, &c->djc_node, classpool);
			free(c);
			c = NULL;
		}
		c->djc_fields = uu_list_create(fieldpool, NULL,
		    (g_dtj_util_debug ? UU_LIST_DEBUG : 0));
		if (!c->djc_fields) {
			dtj_throw_out_of_memory(jenv,
			    "Failed field list creation");
			uu_list_destroy(c->djc_methods);
			c->djc_methods = NULL;
			uu_list_node_fini(c, &c->djc_node, classpool);
			free(c);
			c = NULL;
		}
	} else {
		dtj_throw_out_of_memory(jenv,
		    "Failed to allocate class description");
	}
	return (c);
}

static dtj_java_method_t *
dtj_java_method_create(JNIEnv *jenv, jmethodID *jm, char *name, char *signature,
    uu_list_pool_t *methodpool)
{
	dtj_java_method_t *m = uu_zalloc(sizeof (dtj_java_method_t));
	if (m) {
		uu_list_node_init(m, &m->djm_node, methodpool);
		m->djm_ptr = jm;
		m->djm_name = name;
		m->djm_signature = signature;
		m->djm_static = B_FALSE;
	} else {
		dtj_throw_out_of_memory(jenv,
		    "Failed to allocate method description");
	}
	return (m);
}

static dtj_java_method_t *
dtj_java_static_method_create(JNIEnv *jenv, jmethodID *jm, char *name,
    char *signature, uu_list_pool_t *methodpool)
{
	dtj_java_method_t *m = dtj_java_method_create(jenv, jm, name, signature,
	    methodpool);
	if (m) {
		m->djm_static = B_TRUE;
	}
	return (m);
}

static dtj_java_field_t *
dtj_java_field_create(JNIEnv *jenv, jfieldID *jf, char *name, char *type,
    uu_list_pool_t *fieldpool)
{
	dtj_java_field_t *f = uu_zalloc(sizeof (dtj_java_field_t));
	if (f) {
		uu_list_node_init(f, &f->djf_node, fieldpool);
		f->djf_ptr = jf;
		f->djf_name = name;
		f->djf_type = type;
		f->djf_static = B_FALSE;
	} else {
		dtj_throw_out_of_memory(jenv,
		    "Failed to allocate field description");
	}
	return (f);
}

static dtj_java_field_t *
dtj_java_static_field_create(JNIEnv *jenv, jfieldID *jf, char *name, char *type,
    uu_list_pool_t *fieldpool)
{
	dtj_java_field_t *f = dtj_java_field_create(jenv, jf, name, type,
	    fieldpool);
	if (f) {
		f->djf_static = B_TRUE;
	}
	return (f);
}

static void
/* ARGSUSED */
dtj_java_class_destroy(void *v, void *arg)
{
	if (v) {
		dtj_java_class_t *c = v;
		c->djc_ptr = NULL;  /* do not free user-defined storage */
		c->djc_name = NULL; /* string literal */
		dtj_list_destroy(c->djc_methods, dtj_java_method_destroy, NULL);
		dtj_list_destroy(c->djc_fields, dtj_java_field_destroy, NULL);
		c->djc_methods = NULL;
		c->djc_fields = NULL;
		uu_free(v);
	}
}

static void
/* ARGSUSED */
dtj_java_method_destroy(void *v, void *arg)
{
	if (v) {
		dtj_java_method_t *m = v;
		m->djm_ptr = NULL;	/* do not free user-defined space */
		m->djm_name = NULL;	/* string literal */
		m->djm_signature = NULL;	/* string literal */
		uu_free(v);
	}
}

static void
/* ARGSUSED */
dtj_java_field_destroy(void *v, void *arg)
{
	if (v) {
		dtj_java_field_t *f = v;
		f->djf_ptr = NULL;  /* do not free user-defined space */
		f->djf_name = NULL; /* string literal */
		f->djf_type = NULL; /* string literal */
		uu_free(f);
	}
}

dtj_status_t
dtj_cache_jni_classes(JNIEnv *jenv, const dtj_table_entry_t *table)
{
	dtj_java_class_t *class;
	uu_list_pool_t *classpool;
	uu_list_pool_t *methodpool;
	uu_list_pool_t *fieldpool;
	uu_list_t *classes;
	uu_list_walk_t *itr;
	jclass jc;
	jclass gjc;
	dtj_status_t status;

	classpool = uu_list_pool_create("classpool",
	    sizeof (dtj_java_class_t),
	    offsetof(dtj_java_class_t, djc_node), dtj_java_class_cmp,
	    (g_dtj_util_debug ? UU_LIST_POOL_DEBUG : 0));
	if (!classpool) {
		dtj_throw_out_of_memory(jenv, "failed class pool creation");
		return (DTJ_ERR);
	}
	methodpool = uu_list_pool_create("methodpool",
	    sizeof (dtj_java_method_t),
	    offsetof(dtj_java_method_t, djm_node), dtj_java_method_cmp,
	    (g_dtj_util_debug ? UU_LIST_POOL_DEBUG : 0));
	if (!methodpool) {
		dtj_throw_out_of_memory(jenv, "failed method pool creation");
		return (DTJ_ERR);
	}
	fieldpool = uu_list_pool_create("fieldpool",
	    sizeof (dtj_java_field_t),
	    offsetof(dtj_java_field_t, djf_node), dtj_java_field_cmp,
	    (g_dtj_util_debug ? UU_LIST_POOL_DEBUG : 0));
	if (!fieldpool) {
		dtj_throw_out_of_memory(jenv, "failed field pool creation");
		return (DTJ_ERR);
	}

	classes = uu_list_create(classpool, NULL,
	    (g_dtj_util_debug ? UU_LIST_DEBUG : 0));
	if (!classes) {
		dtj_throw_out_of_memory(jenv, "failed class list creation");
		return (DTJ_ERR);
	}

	status = dtj_get_jni_classes(jenv, classes, classpool, methodpool,
	    fieldpool, table);
	if (status != DTJ_OK) {
		/* java error pending */
		return (status);
	}

	itr = uu_list_walk_start(classes, 0);
	while ((class = uu_list_walk_next(itr)) != NULL) {
		jc = (*jenv)->FindClass(jenv, class->djc_name);
		if (!jc) {
			/* NoClassDefFoundError pending */
			return (DTJ_ERR);
		}
		gjc = (*jenv)->NewGlobalRef(jenv, jc);
		(*jenv)->DeleteLocalRef(jenv, jc);
		if (!gjc) {
			dtj_throw_out_of_memory(jenv,
			    "Failed to create global class reference");
			return (DTJ_ERR);
		}
		*(class->djc_ptr) = gjc;
		status = dtj_cache_jni_methods(jenv, class);
		if (status != DTJ_OK) {
			/* java error pending */
			return (status);
		}
		status = dtj_cache_jni_fields(jenv, class);
		if (status != DTJ_OK) {
			/* java error pending */
			return (status);
		}
	}
	uu_list_walk_end(itr);
	dtj_list_destroy(classes, dtj_java_class_destroy, NULL);
	uu_list_pool_destroy(classpool);
	uu_list_pool_destroy(methodpool);
	uu_list_pool_destroy(fieldpool);
	return (DTJ_OK);
}

/*
 * Converts JNI table entry desriptions into java_class_t descriptors.
 */
static dtj_status_t
dtj_get_jni_classes(JNIEnv *jenv, uu_list_t *classes,
    uu_list_pool_t *classpool, uu_list_pool_t *methodpool,
    uu_list_pool_t *fieldpool, const dtj_table_entry_t *table)
{
	int i;
	dtj_java_class_t *c = NULL;
	dtj_java_method_t *m;
	dtj_java_field_t *f;

	for (i = 0; table[i].djte_type != DTJ_TYPE_END; ++i) {
		/*
		 * Class not added until all of its method and field information
		 * is attached, so we defer adding a class until the next
		 * element with type JCLASS.
		 */
		switch (table[i].djte_type) {
		case JCLASS:
			if (c) {
				/* previous class */
				if (!dtj_list_add(classes, c)) {
					dtj_throw_out_of_memory(jenv,
					    "Failed to add class description");
					/*
					 * In response to an error return value,
					 * the caller will delete the class
					 * descriptions list with any
					 * descriptions created so far.
					 */
					return (DTJ_ERR);
				}
			}
			c = dtj_java_class_create(jenv,
			    (jclass *)table[i].djte_addr, table[i].djte_name,
			    classpool, methodpool, fieldpool);
			if (!c) {
				/* OutOfMemoryError pending */
				return (DTJ_ERR);
			}
			break;
		case JMETHOD:
			if (!c) {
				dtj_throw_illegal_state(jenv,
				    "method description not preceded "
				    "by class description");
				return (DTJ_ERR);
			}
			m = dtj_java_method_create(jenv,
			    (jmethodID *)table[i].djte_addr,
			    table[i].djte_name, table[i].djte_desc,
			    methodpool);
			if (!m) {
				/* OutOfMemoryError pending */
				return (DTJ_ERR);
			}
			if (!dtj_list_add(c->djc_methods, m)) {
				dtj_throw_out_of_memory(jenv,
				    "Failed to add method description");
				return (DTJ_ERR);
			}
			break;
		case JMETHOD_STATIC:
			if (!c) {
				dtj_throw_illegal_state(jenv,
				    "static method description not preceded "
				    "by class description");
				return (DTJ_ERR);
			}
			m = dtj_java_static_method_create(jenv,
			    (jmethodID *)table[i].djte_addr,
			    table[i].djte_name, table[i].djte_desc,
			    methodpool);
			if (!m) {
				/* OutOfMemoryError pending */
				return (DTJ_ERR);
			}
			if (!dtj_list_add(c->djc_methods, m)) {
				dtj_throw_out_of_memory(jenv,
				    "Failed to add static method description");
				return (DTJ_ERR);
			}
			break;
		case JFIELD:
			if (!c) {
				dtj_throw_illegal_state(jenv,
				    "field description not preceded "
				    "by class description");
				return (DTJ_ERR);
			}
			f = dtj_java_field_create(jenv,
			    (jfieldID *)table[i].djte_addr,
			    table[i].djte_name, table[i].djte_desc,
			    fieldpool);
			if (!f) {
				/* OutOfMemoryError pending */
				return (DTJ_ERR);
			}
			if (!dtj_list_add(c->djc_fields, f)) {
				dtj_throw_out_of_memory(jenv,
				    "Failed to add field description");
				return (DTJ_ERR);
			}
			break;
		case JFIELD_STATIC:
			if (!c) {
				dtj_throw_illegal_state(jenv,
				    "static field description not preceded "
				    "by class description");
				return (DTJ_ERR);
			}
			f = dtj_java_static_field_create(jenv,
			    (jfieldID *)table[i].djte_addr,
			    table[i].djte_name, table[i].djte_desc,
			    fieldpool);
			if (!f) {
				/* OutOfMemoryError pending */
				return (DTJ_ERR);
			}
			if (!dtj_list_add(c->djc_fields, f)) {
				dtj_throw_out_of_memory(jenv,
				    "Failed to add static field description");
				return (DTJ_ERR);
			}
			break;
		default:
			dtj_throw_illegal_state(jenv,
			    "Unexpected jni_type_e: %d", table[i].djte_type);
			return (DTJ_ERR);
		}
	}
	if (c) {
		/* last class */
		if (!dtj_list_add(classes, c)) {
			dtj_throw_out_of_memory(jenv,
			    "Failed to add class description");
			return (DTJ_ERR);
		}
	}

	return (DTJ_OK);
}

static dtj_status_t
dtj_cache_jni_methods(JNIEnv *jenv, dtj_java_class_t *c)
{
	dtj_java_method_t *method;
	jmethodID jm;
	uu_list_walk_t *itr;
	itr = uu_list_walk_start(c->djc_methods, 0);
	while ((method = uu_list_walk_next(itr)) != NULL) {
		if (method->djm_static) {
			jm = (*jenv)->GetStaticMethodID(jenv, *(c->djc_ptr),
			    method->djm_name, method->djm_signature);
		} else {
			jm = (*jenv)->GetMethodID(jenv, *(c->djc_ptr),
			    method->djm_name, method->djm_signature);
		}
		if (jm == 0) {
			/*
			 * The pending NoSuchMethodError gives only the
			 * method name, which is not so helpful for
			 * overloaded methods and methods such as <init>
			 * that have the same name in multiple classes.
			 * Clear the pending error and throw one that
			 * includes the class name and the method
			 * signature.
			 */
			jclass jc;
			char msg[DTJ_MSG_SIZE];
			(*jenv)->ExceptionClear(jenv);
			(void) snprintf(msg, sizeof (msg), "%s %s %s",
			    c->djc_name, method->djm_name,
			    method->djm_signature);

			jc = (*jenv)->FindClass(jenv,
			    "java/lang/NoSuchMethodError");
			(*jenv)->ThrowNew(jenv, jc, msg);
			(*jenv)->DeleteLocalRef(jenv, jc);
			return (DTJ_ERR);
		}
		*(method->djm_ptr) = jm;
	}
	uu_list_walk_end(itr);
	return (DTJ_OK);
}

static dtj_status_t
dtj_cache_jni_fields(JNIEnv *jenv, dtj_java_class_t *c)
{
	dtj_java_field_t *field;
	jfieldID jf;
	uu_list_walk_t *itr;
	itr = uu_list_walk_start(c->djc_fields, 0);
	while ((field = uu_list_walk_next(itr)) != NULL) {
		if (field->djf_static) {
			jf = (*jenv)->GetStaticFieldID(jenv, *(c->djc_ptr),
			    field->djf_name, field->djf_type);
		} else {
			jf = (*jenv)->GetFieldID(jenv, *(c->djc_ptr),
			    field->djf_name, field->djf_type);
		}
		if (jf == 0) {
			jclass jc;
			char msg[DTJ_MSG_SIZE];
			(*jenv)->ExceptionClear(jenv);
			(void) snprintf(msg, sizeof (msg),
			    "%s.%s signature: %s", c->djc_name,
			    field->djf_name, field->djf_type);

			jc = (*jenv)->FindClass(jenv,
			    "java/lang/NoSuchFieldError");
			(*jenv)->ThrowNew(jenv, jc, msg);
			(*jenv)->DeleteLocalRef(jenv, jc);
			return (DTJ_ERR);
		}
		*(field->djf_ptr) = jf;
	}
	uu_list_walk_end(itr);
	return (DTJ_OK);
}


/* Common utilities */

static void
dtj_throw(JNIEnv *jenv, jclass jc, const char *fmt, va_list *ap)
{
	char msg[DTJ_MSG_SIZE];
	(void) vsnprintf(msg, sizeof (msg), fmt, *ap);
	(*jenv)->ThrowNew(jenv, jc, msg);
}

void
dtj_throw_out_of_memory(JNIEnv *jenv, const char *fmt, ...)
{
	va_list ap;
	jclass jc;
	/*
	 * JNI documentation unclear whether NewGlobalRef() can throw
	 * OutOfMemoryError, so we'll make this function safe in case
	 * OutOfMemoryError has already been thrown
	 */
	if ((*jenv)->ExceptionCheck(jenv)) {
		return;
	}
	jc = (*jenv)->FindClass(jenv,
	    "java/lang/OutOfMemoryError");
	va_start(ap, fmt);
	dtj_throw(jenv, jc, fmt, &ap);
	(*jenv)->DeleteLocalRef(jenv, jc);
	va_end(ap);
}

void
dtj_throw_null_pointer(JNIEnv *jenv, const char *fmt, ...)
{
	va_list ap;
	jclass jc = (*jenv)->FindClass(jenv,
	    "java/lang/NullPointerException");
	va_start(ap, fmt);
	dtj_throw(jenv, jc, fmt, &ap);
	(*jenv)->DeleteLocalRef(jenv, jc);
	va_end(ap);
}

void
dtj_throw_illegal_state(JNIEnv *jenv, const char *fmt, ...)
{
	va_list ap;
	jclass jc = (*jenv)->FindClass(jenv,
	    "java/lang/IllegalStateException");
	va_start(ap, fmt);
	dtj_throw(jenv, jc, fmt, &ap);
	(*jenv)->DeleteLocalRef(jenv, jc);
	va_end(ap);
}

void
dtj_throw_illegal_argument(JNIEnv *jenv, const char *fmt, ...)
{
	va_list ap;
	jclass jc = (*jenv)->FindClass(jenv,
	    "java/lang/IllegalArgumentException");
	va_start(ap, fmt);
	dtj_throw(jenv, jc, fmt, &ap);
	(*jenv)->DeleteLocalRef(jenv, jc);
	va_end(ap);
}

void
dtj_throw_no_such_element(JNIEnv *jenv, const char *fmt, ...)
{
	va_list ap;
	jclass jc = (*jenv)->FindClass(jenv,
	    "java/util/NoSuchElementException");
	va_start(ap, fmt);
	dtj_throw(jenv, jc, fmt, &ap);
	(*jenv)->DeleteLocalRef(jenv, jc);
	va_end(ap);
}

void
dtj_throw_class_cast(JNIEnv *jenv, const char *fmt, ...)
{
	va_list ap;
	jclass jc = (*jenv)->FindClass(jenv,
	    "java/lang/ClassCastException");
	va_start(ap, fmt);
	dtj_throw(jenv, jc, fmt, &ap);
	(*jenv)->DeleteLocalRef(jenv, jc);
	va_end(ap);
}

void
dtj_throw_assertion(JNIEnv *jenv, const char *fmt, ...)
{
	va_list ap;
	jclass jc = (*jenv)->FindClass(jenv,
	    "java/lang/AssertionError");
	va_start(ap, fmt);
	dtj_throw(jenv, jc, fmt, &ap);
	(*jenv)->DeleteLocalRef(jenv, jc);
	va_end(ap);
}

void
dtj_throw_resource_limit(JNIEnv *jenv, const char *fmt, ...)
{
	va_list ap;
	jclass jc = (*jenv)->FindClass(jenv,
	    "org/opensolaris/os/dtrace/ResourceLimitException");
	va_start(ap, fmt);
	dtj_throw(jenv, jc, fmt, &ap);
	(*jenv)->DeleteLocalRef(jenv, jc);
	va_end(ap);
}

void
dtj_wrap_exception(JNIEnv *jenv, const char *file, int line)
{
	jthrowable e = NULL;
	jthrowable nx = NULL;
	jstring jfile = NULL;

	e = (*jenv)->ExceptionOccurred(jenv);
	if (!e) {
		return;
	}

	if (!g_dtj_load_common) {
		return;
	}

	(*jenv)->ExceptionClear(jenv);

	/* Unsafe to test while exception pending */
	if ((*jenv)->IsInstanceOf(jenv, e, g_nx_jc)) {
		/* Already wrapped */
		(*jenv)->Throw(jenv, e);
		(*jenv)->DeleteLocalRef(jenv, e);
		return;
	}

	jfile = dtj_NewStringNative(jenv, file);
	if ((*jenv)->ExceptionCheck(jenv)) {
		/*
		 * Only wrap the exception if possible, otherwise just throw the
		 * original exception.
		 */
		(*jenv)->ExceptionClear(jenv);
		(*jenv)->Throw(jenv, e);
		(*jenv)->DeleteLocalRef(jenv, e);
		return;
	}

	nx = (jthrowable)(*jenv)->NewObject(jenv, g_nx_jc, g_nxinit_jm,
	    jfile, line, e);
	(*jenv)->DeleteLocalRef(jenv, jfile);
	if ((*jenv)->ExceptionCheck(jenv)) {
		(*jenv)->ExceptionClear(jenv);
		(*jenv)->Throw(jenv, e);
		(*jenv)->DeleteLocalRef(jenv, e);
		return;
	}

	(*jenv)->DeleteLocalRef(jenv, e);
	(*jenv)->Throw(jenv, nx);
	(*jenv)->DeleteLocalRef(jenv, nx);
}

/*
 * Calls the given java object's toString() method and prints the value to
 * stdout.  Useful for debugging.  Guaranteed that no exception is pending when
 * this function returns.
 */
void
dtj_print_object(JNIEnv *jenv, jobject jobj)
{
	jstring jstr;
	const char *cstr;

	if (!g_dtj_load_common) {
		dtj_throw_illegal_state(jenv,
		    "dtj_load_common() has not been called");
		(*jenv)->ExceptionDescribe(jenv); /* clears the exception */
		return;
	}

	if (!jobj) {
		(void) printf("null\n");
		return;
	}

	jstr = (*jenv)->CallObjectMethod(jenv, jobj, g_tostring_jm);
	if ((*jenv)->ExceptionCheck(jenv)) {
		(*jenv)->ExceptionDescribe(jenv); /* clears the exception */
		return;
	}
	cstr = (*jenv)->GetStringUTFChars(jenv, jstr, 0);
	if (cstr) {
		(void) printf("%s\n", cstr);
	} else {
		(*jenv)->ExceptionDescribe(jenv); /* clears the exception */
		(*jenv)->DeleteLocalRef(jenv, jstr);
		return;
	}
	(*jenv)->ReleaseStringUTFChars(jenv, jstr, cstr);
	(*jenv)->DeleteLocalRef(jenv, jstr);
}

jobject
dtj_uint64(JNIEnv *jenv, uint64_t u)
{
	int64_t i = (int64_t)u;
	jobject val64;

	if (i >= 0) {
		val64 = (*jenv)->CallStaticObjectMethod(jenv, g_bigint_jc,
		    g_bigint_val_jsm, u);
	} else {
		jobject tmp;

		u ^= ((uint64_t)0x1 << 63);
		val64 = (*jenv)->CallStaticObjectMethod(jenv, g_bigint_jc,
		    g_bigint_val_jsm, u);
		tmp = val64;
		val64 = (*jenv)->CallObjectMethod(jenv, tmp,
		    g_bigint_setbit_jm, 63);
		(*jenv)->DeleteLocalRef(jenv, tmp);
	}

	return (val64);
}

jobject
dtj_int128(JNIEnv *jenv, uint64_t high, uint64_t low)
{
	jobject val128;
	jobject low64;
	jobject tmp;

	val128 = (*jenv)->CallStaticObjectMethod(jenv, g_bigint_jc,
	    g_bigint_val_jsm, high);
	tmp = val128;
	val128 = (*jenv)->CallObjectMethod(jenv, tmp, g_bigint_shl_jm, 64);
	(*jenv)->DeleteLocalRef(jenv, tmp);
	low64 = dtj_uint64(jenv, low);
	tmp = val128;
	val128 = (*jenv)->CallObjectMethod(jenv, tmp, g_bigint_or_jm, low64);
	(*jenv)->DeleteLocalRef(jenv, tmp);
	(*jenv)->DeleteLocalRef(jenv, low64);

	return (val128);
}

jstring
dtj_format_string(JNIEnv *jenv, const char *fmt, ...)
{
	va_list ap;
	char str[DTJ_MSG_SIZE];

	jstring jstr = NULL;

	va_start(ap, fmt);
	(void) vsnprintf(str, sizeof (str), fmt, ap);
	va_end(ap);

	jstr = dtj_NewStringNative(jenv, str);
	/* return NULL if OutOfMemoryError pending */
	return (jstr);
}

jstring
dtj_NewStringNative(JNIEnv *jenv, const char *str)
{
	jstring result;
	jbyteArray bytes = 0;
	int len;

	if (!g_dtj_load_common) {
		dtj_throw_illegal_state(jenv,
		    "dtj_load_common() has not been called");
		return (NULL);
	}

	len = strlen(str);

	bytes = (*jenv)->NewByteArray(jenv, len);
	if (!bytes) {
		return (NULL); /* OutOfMemoryError pending */
	}
	(*jenv)->SetByteArrayRegion(jenv, bytes, 0, len,
	    (jbyte *)str);
	if ((*jenv)->ExceptionCheck(jenv)) {
		(*jenv)->DeleteLocalRef(jenv, bytes);
		return (NULL); /* ArrayIndexOutOfBoundsException pending */
	}
	result = (*jenv)->NewObject(jenv, g_string_jc, g_strinit_bytes_jm,
	    bytes);
	(*jenv)->DeleteLocalRef(jenv, bytes);
	/* return NULL result if exception pending */
	return (result);
}

char *
dtj_GetStringNativeChars(JNIEnv *jenv, jstring jstr)
{
	jbyteArray bytes = NULL;

	jint len;
	char *result = NULL;

	if (!g_dtj_load_common) {
		dtj_throw_illegal_state(jenv,
		    "dtj_load_common() has not been called");
		return (NULL);
	}

	bytes = (*jenv)->CallObjectMethod(jenv, jstr, g_strbytes_jm);
	if ((*jenv)->ExceptionCheck(jenv)) {
		return (NULL); /* OutOfMemoryError pending */
	}
	/* Does not throw exceptions */
	len = (*jenv)->GetArrayLength(jenv, bytes);
	result = malloc(len + 1);
	if (!result) {
		(*jenv)->DeleteLocalRef(jenv, bytes);
		dtj_throw_out_of_memory(jenv,
		    "could not allocate native chars");
		return (NULL);
	}

	/* Skip check for ArrayIndexOutOfBoundsException */
	(*jenv)->GetByteArrayRegion(jenv, bytes, 0, len,
	    (jbyte *)result);
	(*jenv)->DeleteLocalRef(jenv, bytes);
	result[len] = '\0'; /* NUL-terminate */

	return (result);
}

void
/* ARGSUSED */
dtj_ReleaseStringNativeChars(JNIEnv *jenv, jstring jstr, const char *str)
{
	free((void *)str);
}

char **
dtj_get_argv(JNIEnv *jenv, jobjectArray args, int *argc)
{
	char **argv = NULL; /* return value */
	const char *str;
	int i;

	jstring jstr = NULL;

	if (!g_dtj_load_common) {
		dtj_throw_illegal_state(jenv,
		    "dtj_load_common() has not been called");
		return (NULL);
	}

	*argc = (*jenv)->GetArrayLength(jenv, args);
	/*
	 * Initialize all string pointers to NULL so that in case of an error
	 * filling in the array, free_argv() will not attempt to free the
	 * unallocated elements.  Also NULL-terminate the string array for
	 * functions that expect terminating NULL rather than rely on argc.
	 */
	argv = uu_zalloc((sizeof (char *)) * (*argc + 1));
	if (!argv) {
		dtj_throw_out_of_memory(jenv, "Failed to allocate args array");
		return (NULL);
	}

	for (i = 0; i < *argc; ++i) {
		jstr = (*jenv)->GetObjectArrayElement(jenv, args, i);
		if ((*jenv)->ExceptionCheck(jenv)) {
			dtj_free_argv(argv);
			return (NULL);
		}
		str = dtj_GetStringNativeChars(jenv, jstr);
		if ((*jenv)->ExceptionCheck(jenv)) {
			dtj_free_argv(argv);
			(*jenv)->DeleteLocalRef(jenv, jstr);
			return (NULL);
		}
		argv[i] = malloc(strlen(str) + 1);
		if (!argv[i]) {
			dtj_throw_out_of_memory(jenv, "Failed to allocate arg");
			dtj_free_argv(argv);
			dtj_ReleaseStringNativeChars(jenv, jstr, str);
			(*jenv)->DeleteLocalRef(jenv, jstr);
			return (NULL);
		}
		(void) strcpy(argv[i], str);
		dtj_ReleaseStringNativeChars(jenv, jstr, str);
		(*jenv)->DeleteLocalRef(jenv, jstr);
		jstr = NULL;
	}

	return (argv);
}

char **
dtj_make_argv(JNIEnv *jenv, jstring command, int *argc)
{
	const char *ws = "\f\n\r\t\v ";
	char **argv = NULL; /* return value */
	const char *cmd; /* native command string */
	char *s; /* writable command */
	char *tok; /* token */
	int len;

	if (!g_dtj_load_common) {
		dtj_throw_illegal_state(jenv,
		    "dtj_load_common() has not been called");
		return (NULL);
	}

	if (!command) {
		dtj_throw_null_pointer(jenv, "command is null");
		return (NULL);
	} else if ((*jenv)->GetStringLength(jenv, command) == 0) {
		dtj_throw_illegal_argument(jenv, "command is empty");
		return (NULL);
	}

	cmd = dtj_GetStringNativeChars(jenv, command);
	if ((*jenv)->ExceptionCheck(jenv)) {
		return (NULL);
	}
	len = strlen(cmd);
	s = malloc(len + 1);
	if (!s) {
		dtj_throw_out_of_memory(jenv,
		    "failed to allocate command string");
		dtj_ReleaseStringNativeChars(jenv, command, cmd);
		return (NULL);
	}
	(void) strcpy(s, cmd);
	/*
	 * Initialize all string pointers to NULL so that in case of an error
	 * filling in the array, free_argv() will not attempt to free the
	 * unallocated elements.  Also NULL-terminate the string array for
	 * functions that expect terminating NULL rather than rely on argc.
	 * Allow for maximum length resulting from single-character tokens
	 * separated by single spaces.
	 */
	argv = uu_zalloc(sizeof (char *) * (len / 2 + 1));
	if (!argv) {
		dtj_throw_out_of_memory(jenv, "failed to allocate args array");
		free(s);
		dtj_ReleaseStringNativeChars(jenv, command, cmd);
		return (NULL);
	}

	*argc = 0;
	for (tok = strtok(s, ws); tok != NULL; tok = strtok(NULL, ws)) {
		argv[*argc] = malloc(strlen(tok) + 1);
		if (!argv[*argc]) {
			dtj_throw_out_of_memory(jenv, "Failed to allocate arg");
			dtj_free_argv(argv);
			free(s);
			dtj_ReleaseStringNativeChars(jenv, command, cmd);
			return (NULL);
		}
		(void) strcpy(argv[(*argc)++], tok);
	}

	if (*argc == 0) {
		dtj_throw_illegal_argument(jenv, "command is blank");
		dtj_free_argv(argv);
		free(s);
		dtj_ReleaseStringNativeChars(jenv, command, cmd);
		return (NULL);
	}

	free(s);
	dtj_ReleaseStringNativeChars(jenv, command, cmd);
	return (argv);
}

void
dtj_free_argv(char **argv)
{
	if (argv) {
		char **s = argv;
		while (*s) {
			free((void *)*s);
			*s++ = NULL;
		}
		free((void *)argv);
	}
}


/* Wrappers for uu_list_t */

int
/* ARGSUSED */
dtj_pointer_list_entry_cmp(const void *v1, const void *v2, void *arg)
{
	const dtj_pointer_list_entry_t *p1 = v1;
	const dtj_pointer_list_entry_t *p2 = v2;

	/*
	 * It is not valid to compare pointers using the relational operators
	 * unless they point to elements in the same array.
	 */
	uint64_t x = (uintptr_t)p1->dple_ptr;
	uint64_t y = (uintptr_t)p2->dple_ptr;
	int rc;
	rc = ((x > y) ? 1 : ((x < y) ? -1 : 0));
	return (rc);
}

int
/* ARGSUSED */
dtj_string_list_entry_cmp(const void *v1, const void *v2, void *arg)
{
	const dtj_string_list_entry_t *p1 = v1;
	const dtj_string_list_entry_t *p2 = v2;
	const char *s1 = p1->dsle_value;
	const char *s2 = p2->dsle_value;
	if (s1 == NULL) {
		return (s2 == NULL ? 0 : -1);
	}
	if (s2 == NULL) {
		return (1);
	}
	return (strcmp(s1, s2));
}

static boolean_t
dtj_check_pointer_pool(void)
{
	if (g_pointer_pool == NULL) {
		g_pointer_pool = uu_list_pool_create("g_pointer_pool",
		    sizeof (dtj_pointer_list_entry_t),
		    offsetof(dtj_pointer_list_entry_t, dple_node),
		    dtj_pointer_list_entry_cmp,
		    (g_dtj_util_debug ? UU_LIST_POOL_DEBUG : 0));
		if (g_pointer_pool == NULL) {
			return (B_FALSE);
		}
	}
	return (B_TRUE);
}

uu_list_t *
dtj_pointer_list_create(void)
{
	uu_list_t *list;

	if (!dtj_check_pointer_pool()) {
		return (NULL);
	}

	list = uu_list_create(g_pointer_pool, NULL,
	    (g_dtj_util_debug ? UU_LIST_DEBUG : 0));
	return (list);
}

dtj_pointer_list_entry_t *
dtj_pointer_list_entry_create(void *p)
{
	dtj_pointer_list_entry_t *e;

	if (!dtj_check_pointer_pool()) {
		return (NULL);
	}

	e = uu_zalloc(sizeof (dtj_pointer_list_entry_t));
	if (e) {
		uu_list_node_init(e, &e->dple_node, g_pointer_pool);
		e->dple_ptr = p;
	}
	return (e);
}

static boolean_t
dtj_check_string_pool(void)
{
	if (g_string_pool == NULL) {
		g_string_pool = uu_list_pool_create("g_string_pool",
		    sizeof (dtj_string_list_entry_t),
		    offsetof(dtj_string_list_entry_t, dsle_node),
		    dtj_string_list_entry_cmp,
		    (g_dtj_util_debug ? UU_LIST_POOL_DEBUG : 0));
		if (g_string_pool == NULL) {
			return (B_FALSE);
		}
	}
	return (B_TRUE);
}

uu_list_t *
dtj_string_list_create(void)
{
	uu_list_t *list;

	if (!dtj_check_string_pool()) {
		return (NULL);
	}

	list = uu_list_create(g_string_pool, NULL,
	    (g_dtj_util_debug ? UU_LIST_DEBUG : 0));
	return (list);
}

dtj_string_list_entry_t *
dtj_string_list_entry_create(const char *s)
{
	dtj_string_list_entry_t *e;

	if (!dtj_check_string_pool()) {
		return (NULL);
	}

	e = uu_zalloc(sizeof (dtj_string_list_entry_t));
	if (e) {
		uu_list_node_init(e, &e->dsle_node, g_string_pool);
		if (s) {
			e->dsle_value = malloc(strlen(s) + 1);
			if (e->dsle_value) {
				(void) strcpy(e->dsle_value, s);
			} else {
				uu_list_node_fini(e, &e->dsle_node,
				    g_string_pool);
				uu_free(e);
				e = NULL;
			}
		}
	}
	return (e);
}

void
dtj_pointer_list_entry_destroy(void *v,
    dtj_value_destroy_f *value_destroy, void *arg)
{
	if (v) {
		dtj_pointer_list_entry_t *e = v;
		if (value_destroy) {
			value_destroy(e->dple_ptr, arg);
		}
		uu_list_node_fini(e, &e->dple_node, g_pointer_pool);
		e->dple_ptr = NULL;
		uu_free(v);
	}
}

void
/* ARGSUSED */
dtj_string_list_entry_destroy(void *v, void *arg)
{
	if (v) {
		dtj_string_list_entry_t *e = v;
		free(e->dsle_value);
		uu_list_node_fini(e, &e->dsle_node, g_string_pool);
		e->dsle_value = NULL;
		uu_free(v);
	}
}

void
dtj_list_clear(uu_list_t *list, dtj_value_destroy_f *value_destroy,
    void *arg)
{
	void *cookie; /* needed for uu_list_teardown */
	void *value;

	if (!list) {
		return;
	}

	cookie = NULL;
	if (value_destroy) {
		while ((value = uu_list_teardown(list, &cookie)) != NULL) {
			value_destroy(value, arg);
		}
	} else {
		while ((value = uu_list_teardown(list, &cookie)) != NULL) {
		}
	}
}

void
dtj_list_destroy(uu_list_t *list,
    dtj_value_destroy_f *value_destroy, void *arg)
{
	dtj_list_clear(list, value_destroy, arg);
	uu_list_destroy(list);
}

void
dtj_pointer_list_clear(uu_list_t *list,
    dtj_value_destroy_f *value_destroy, void *arg)
{
	void *cookie; /* needed for uu_list_teardown */
	dtj_pointer_list_entry_t *e;

	if (!list) {
		return;
	}

	cookie = NULL;
	while ((e = uu_list_teardown(list, &cookie)) != NULL) {
		dtj_pointer_list_entry_destroy(e, value_destroy, arg);
	}
}

void
dtj_pointer_list_destroy(uu_list_t *list,
    dtj_value_destroy_f *value_destroy, void *arg)
{
	dtj_pointer_list_clear(list, value_destroy, arg);
	uu_list_destroy(list);
}

void
dtj_string_list_clear(uu_list_t *list)
{
	dtj_list_clear(list, dtj_string_list_entry_destroy, NULL);
}

void
dtj_string_list_destroy(uu_list_t *list)
{
	dtj_list_destroy(list, dtj_string_list_entry_destroy, NULL);
}

boolean_t
dtj_list_empty(uu_list_t *list)
{
	return (uu_list_numnodes(list) == 0);
}

boolean_t
dtj_list_add(uu_list_t *list, void *value)
{
	return (uu_list_insert_before(list, NULL, value) == 0);
}

boolean_t
dtj_pointer_list_add(uu_list_t *list, void *p)
{
	dtj_pointer_list_entry_t *e = dtj_pointer_list_entry_create(p);
	if (!e) {
		return (B_FALSE);
	}
	return (dtj_list_add(list, e));
}

void *
dtj_pointer_list_walk_next(uu_list_walk_t *itr)
{
	dtj_pointer_list_entry_t *e = uu_list_walk_next(itr);
	if (!e) {
		return (DTJ_INVALID_PTR);
	}
	return (e->dple_ptr);
}

void *
dtj_pointer_list_first(uu_list_t *list)
{
	dtj_pointer_list_entry_t *e = uu_list_first(list);
	if (!e) {
		/* NULL is a valid value; use -1 for invalid */
		return (DTJ_INVALID_PTR);
	}
	return (e->dple_ptr);
}

void *
dtj_pointer_list_last(uu_list_t *list)
{
	dtj_pointer_list_entry_t *e = uu_list_last(list);
	if (!e) {
		/* NULL is a valid value; use -1 for invalid */
		return (DTJ_INVALID_PTR);
	}
	return (e->dple_ptr);
}

boolean_t
dtj_string_list_add(uu_list_t *list, const char *s)
{
	dtj_string_list_entry_t *e = dtj_string_list_entry_create(s);
	if (!e) {
		return (B_FALSE);
	}
	return (dtj_list_add(list, e));
}

const char *
dtj_string_list_walk_next(uu_list_walk_t *itr)
{
	dtj_string_list_entry_t *e = uu_list_walk_next(itr);
	if (!e) {
		return (DTJ_INVALID_STR);
	}
	return (e->dsle_value);
}

const char *
dtj_string_list_first(uu_list_t *list)
{
	dtj_string_list_entry_t *e = uu_list_first(list);
	if (!e) {
		/* NULL is a valid string value; use -1 for invalid */
		return (DTJ_INVALID_STR);
	}
	return (e->dsle_value);
}

const char *
dtj_string_list_last(uu_list_t *list)
{
	dtj_string_list_entry_t *e = uu_list_last(list);
	if (!e) {
		/* NULL is a valid string value; use -1 for invalid */
		return (DTJ_INVALID_STR);
	}
	return (e->dsle_value);
}