Merge sync of head

14 files changed, 2011 insertions, 4180 deletions

diff --git a/lib/libnv/Makefile b/lib/libnv/Makefile
index e9371bc..8b2fc78 100644
--- a/lib/libnv/Makefile
+++ b/lib/libnv/Makefile
@@ -7,10 +7,13 @@ SHLIBDIR?= /lib
 LIB=	nv
 SHLIB_MAJOR= 0
 
-SRCS=	dnvlist.c
+.PATH: ${.CURDIR}/../../sys/kern ${.CURDIR}/../../sys/sys
+CFLAGS+=-I${.CURDIR}/../../sys -I${.CURDIR}
+
+SRCS=	subr_dnvlist.c
 SRCS+=	msgio.c
-SRCS+=	nvlist.c
-SRCS+=	nvpair.c
+SRCS+=	subr_nvlist.c
+SRCS+=	subr_nvpair.c
 
 INCS=	dnv.h
 INCS+=	nv.h
@@ -19,145 +22,66 @@ MAN+=	nv.3
 
 MLINKS+=nv.3 libnv.3 \
 	nv.3 nvlist.3
-MLINKS+=nv.3 nvlist_create.3 \
-	nv.3 nvlist_destroy.3 \
-	nv.3 nvlist_error.3 \
-	nv.3 nvlist_empty.3 \
+MLINKS+=nv.3 nvlist_add_binary.3 \
+	nv.3 nvlist_add_bool.3 \
+	nv.3 nvlist_add_descriptor.3 \
+	nv.3 nvlist_add_null.3 \
+	nv.3 nvlist_add_number.3 \
+	nv.3 nvlist_add_nvlist.3 \
+	nv.3 nvlist_add_string.3 \
+	nv.3 nvlist_add_stringf.3 \
+	nv.3 nvlist_add_stringv.3 \
 	nv.3 nvlist_clone.3 \
+	nv.3 nvlist_create.3 \
+	nv.3 nvlist_destroy.3 \
 	nv.3 nvlist_dump.3 \
-	nv.3 nvlist_fdump.3 \
-	nv.3 nvlist_size.3 \
-	nv.3 nvlist_pack.3 \
-	nv.3 nvlist_unpack.3 \
-	nv.3 nvlist_send.3 \
-	nv.3 nvlist_recv.3 \
-	nv.3 nvlist_xfer.3 \
-	nv.3 nvlist_next.3 \
+	nv.3 nvlist_empty.3 \
+	nv.3 nvlist_error.3 \
 	nv.3 nvlist_exists.3 \
-	nv.3 nvlist_exists_type.3 \
-	nv.3 nvlist_exists_null.3 \
+	nv.3 nvlist_exists_binary.3 \
 	nv.3 nvlist_exists_bool.3 \
+	nv.3 nvlist_exists_descriptor.3 \
+	nv.3 nvlist_exists_null.3 \
 	nv.3 nvlist_exists_number.3 \
-	nv.3 nvlist_exists_string.3 \
 	nv.3 nvlist_exists_nvlist.3 \
-	nv.3 nvlist_exists_descriptor.3 \
-	nv.3 nvlist_exists_binary.3 \
-	nv.3 nvlist_add_null.3 \
-	nv.3 nvlist_add_bool.3 \
-	nv.3 nvlist_add_number.3 \
-	nv.3 nvlist_add_string.3 \
-	nv.3 nvlist_add_stringf.3 \
-	nv.3 nvlist_add_stringv.3 \
-	nv.3 nvlist_add_nvlist.3 \
-	nv.3 nvlist_add_descriptor.3 \
-	nv.3 nvlist_add_binary.3 \
-	nv.3 nvlist_move_string.3 \
-	nv.3 nvlist_move_nvlist.3 \
-	nv.3 nvlist_move_descriptor.3 \
-	nv.3 nvlist_move_binary.3 \
+	nv.3 nvlist_exists_string.3 \
+	nv.3 nvlist_exists_type.3 \
+	nv.3 nvlist_fdump.3 \
+	nv.3 nvlist_flags.3 \
+	nv.3 nvlist_free.3 \
+	nv.3 nvlist_free_binary.3 \
+	nv.3 nvlist_free_bool.3 \
+	nv.3 nvlist_free_descriptor.3 \
+	nv.3 nvlist_free_null.3 \
+	nv.3 nvlist_free_number.3 \
+	nv.3 nvlist_free_nvlist.3 \
+	nv.3 nvlist_free_string.3 \
+	nv.3 nvlist_free_type.3 \
+	nv.3 nvlist_get_binary.3 \
 	nv.3 nvlist_get_bool.3 \
+	nv.3 nvlist_get_descriptor.3 \
 	nv.3 nvlist_get_number.3 \
-	nv.3 nvlist_get_string.3 \
 	nv.3 nvlist_get_nvlist.3 \
-	nv.3 nvlist_get_descriptor.3 \
-	nv.3 nvlist_get_binary.3 \
+	nv.3 nvlist_get_parent.3 \
+	nv.3 nvlist_get_string.3 \
+	nv.3 nvlist_move_binary.3 \
+	nv.3 nvlist_move_descriptor.3 \
+	nv.3 nvlist_move_nvlist.3 \
+	nv.3 nvlist_move_string.3 \
+	nv.3 nvlist_next.3 \
+	nv.3 nvlist_pack.3 \
+	nv.3 nvlist_recv.3 \
+	nv.3 nvlist_send.3 \
+	nv.3 nvlist_set_error.3 \
+	nv.3 nvlist_size.3 \
+	nv.3 nvlist_take_binary.3 \
 	nv.3 nvlist_take_bool.3 \
+	nv.3 nvlist_take_descriptor.3 \
 	nv.3 nvlist_take_number.3 \
-	nv.3 nvlist_take_string.3 \
 	nv.3 nvlist_take_nvlist.3 \
-	nv.3 nvlist_take_descriptor.3 \
-	nv.3 nvlist_take_binary.3 \
-	nv.3 nvlist_free.3 \
-	nv.3 nvlist_free_type.3 \
-	nv.3 nvlist_free_null.3 \
-	nv.3 nvlist_free_bool.3 \
-	nv.3 nvlist_free_number.3 \
-	nv.3 nvlist_free_string.3 \
-	nv.3 nvlist_free_nvlist.3 \
-	nv.3 nvlist_free_descriptor.3 \
-	nv.3 nvlist_free_binary.3
-MLINKS+=nv.3 nvlist_existsf.3 \
-	nv.3 nvlist_existsf_type.3 \
-	nv.3 nvlist_existsf_null.3 \
-	nv.3 nvlist_existsf_bool.3 \
-	nv.3 nvlist_existsf_number.3 \
-	nv.3 nvlist_existsf_string.3 \
-	nv.3 nvlist_existsf_nvlist.3 \
-	nv.3 nvlist_existsf_descriptor.3 \
-	nv.3 nvlist_existsf_binary.3 \
-	nv.3 nvlist_addf_null.3 \
-	nv.3 nvlist_addf_bool.3 \
-	nv.3 nvlist_addf_number.3 \
-	nv.3 nvlist_addf_string.3 \
-	nv.3 nvlist_addf_nvlist.3 \
-	nv.3 nvlist_addf_descriptor.3 \
-	nv.3 nvlist_addf_binary.3 \
-	nv.3 nvlist_movef_string.3 \
-	nv.3 nvlist_movef_nvlist.3 \
-	nv.3 nvlist_movef_descriptor.3 \
-	nv.3 nvlist_movef_binary.3 \
-	nv.3 nvlist_getf_bool.3 \
-	nv.3 nvlist_getf_number.3 \
-	nv.3 nvlist_getf_string.3 \
-	nv.3 nvlist_getf_nvlist.3 \
-	nv.3 nvlist_getf_descriptor.3 \
-	nv.3 nvlist_getf_binary.3 \
-	nv.3 nvlist_takef_bool.3 \
-	nv.3 nvlist_takef_number.3 \
-	nv.3 nvlist_takef_string.3 \
-	nv.3 nvlist_takef_nvlist.3 \
-	nv.3 nvlist_takef_descriptor.3 \
-	nv.3 nvlist_takef_binary.3 \
-	nv.3 nvlist_freef.3 \
-	nv.3 nvlist_freef_type.3 \
-	nv.3 nvlist_freef_null.3 \
-	nv.3 nvlist_freef_bool.3 \
-	nv.3 nvlist_freef_number.3 \
-	nv.3 nvlist_freef_string.3 \
-	nv.3 nvlist_freef_nvlist.3 \
-	nv.3 nvlist_freef_descriptor.3 \
-	nv.3 nvlist_freef_binary.3
-MLINKS+=nv.3 nvlist_existsv.3 \
-	nv.3 nvlist_existsv_type.3 \
-	nv.3 nvlist_existsv_null.3 \
-	nv.3 nvlist_existsv_bool.3 \
-	nv.3 nvlist_existsv_number.3 \
-	nv.3 nvlist_existsv_string.3 \
-	nv.3 nvlist_existsv_nvlist.3 \
-	nv.3 nvlist_existsv_descriptor.3 \
-	nv.3 nvlist_existsv_binary.3 \
-	nv.3 nvlist_addv_null.3 \
-	nv.3 nvlist_addv_bool.3 \
-	nv.3 nvlist_addv_number.3 \
-	nv.3 nvlist_addv_string.3 \
-	nv.3 nvlist_addv_nvlist.3 \
-	nv.3 nvlist_addv_descriptor.3 \
-	nv.3 nvlist_addv_binary.3 \
-	nv.3 nvlist_movev_string.3 \
-	nv.3 nvlist_movev_nvlist.3 \
-	nv.3 nvlist_movev_descriptor.3 \
-	nv.3 nvlist_movev_binary.3 \
-	nv.3 nvlist_getv_bool.3 \
-	nv.3 nvlist_getv_number.3 \
-	nv.3 nvlist_getv_string.3 \
-	nv.3 nvlist_getv_nvlist.3 \
-	nv.3 nvlist_getv_descriptor.3 \
-	nv.3 nvlist_getv_binary.3 \
-	nv.3 nvlist_takev_bool.3 \
-	nv.3 nvlist_takev_number.3 \
-	nv.3 nvlist_takev_string.3 \
-	nv.3 nvlist_takev_nvlist.3 \
-	nv.3 nvlist_takev_descriptor.3 \
-	nv.3 nvlist_takev_binary.3 \
-	nv.3 nvlist_freev.3 \
-	nv.3 nvlist_freev_type.3 \
-	nv.3 nvlist_freev_null.3 \
-	nv.3 nvlist_freev_bool.3 \
-	nv.3 nvlist_freev_number.3 \
-	nv.3 nvlist_freev_string.3 \
-	nv.3 nvlist_freev_nvlist.3 \
-	nv.3 nvlist_freev_descriptor.3 \
-	nv.3 nvlist_freev_binary.3
+	nv.3 nvlist_take_string.3 \
+	nv.3 nvlist_unpack.3 \
+	nv.3 nvlist_xfer.3
 
 WARNS?=	6
 
diff --git a/lib/libnv/dnv.h b/lib/libnv/dnv.h
deleted file mode 100644
index ac1e57c..0000000
--- a/lib/libnv/dnv.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*-
- * Copyright (c) 2013 The FreeBSD Foundation
- * All rights reserved.
- *
- * This software was developed by Pawel Jakub Dawidek under sponsorship from
- * the FreeBSD Foundation.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef	_DNV_H_
-#define	_DNV_H_
-
-#include <sys/cdefs.h>
-
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifndef	_NVLIST_T_DECLARED
-#define	_NVLIST_T_DECLARED
-struct nvlist;
-
-typedef struct nvlist nvlist_t;
-#endif
-
-/*
- * The dnvlist_get functions returns value associated with the given name.
- * If it returns a pointer, the pointer represents internal buffer and should
- * not be freed by the caller.
- * If no element of the given name and type exists, the function will return
- * provided default value.
- */
-
-bool dnvlist_get_bool(const nvlist_t *nvl, const char *name, bool defval);
-uint64_t dnvlist_get_number(const nvlist_t *nvl, const char *name, uint64_t defval);
-const char *dnvlist_get_string(const nvlist_t *nvl, const char *name, const char *defval);
-const nvlist_t *dnvlist_get_nvlist(const nvlist_t *nvl, const char *name, const nvlist_t *defval);
-int dnvlist_get_descriptor(const nvlist_t *nvl, const char *name, int defval);
-const void *dnvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep, const void *defval, size_t defsize);
-
-bool dnvlist_getf_bool(const nvlist_t *nvl, bool defval, const char *namefmt, ...) __printflike(3, 4);
-uint64_t dnvlist_getf_number(const nvlist_t *nvl, uint64_t defval, const char *namefmt, ...) __printflike(3, 4);
-const char *dnvlist_getf_string(const nvlist_t *nvl, const char *defval, const char *namefmt, ...) __printflike(3, 4);
-const nvlist_t *dnvlist_getf_nvlist(const nvlist_t *nvl, const nvlist_t *defval, const char *namefmt, ...) __printflike(3, 4);
-int dnvlist_getf_descriptor(const nvlist_t *nvl, int defval, const char *namefmt, ...) __printflike(3, 4);
-const void *dnvlist_getf_binary(const nvlist_t *nvl, size_t *sizep, const void *defval, size_t defsize, const char *namefmt, ...) __printflike(5, 6);
-
-bool dnvlist_getv_bool(const nvlist_t *nvl, bool defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-uint64_t dnvlist_getv_number(const nvlist_t *nvl, uint64_t defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-const char *dnvlist_getv_string(const nvlist_t *nvl, const char *defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-const nvlist_t *dnvlist_getv_nvlist(const nvlist_t *nvl, const nvlist_t *defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-int dnvlist_getv_descriptor(const nvlist_t *nvl, int defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-const void *dnvlist_getv_binary(const nvlist_t *nvl, size_t *sizep, const void *defval, size_t defsize, const char *namefmt, va_list nameap) __printflike(5, 0);
-
-/*
- * The dnvlist_take functions returns value associated with the given name and
- * remove corresponding nvpair.
- * If it returns a pointer, the caller has to free it.
- * If no element of the given name and type exists, the function will return
- * provided default value.
- */
-
-bool dnvlist_take_bool(nvlist_t *nvl, const char *name, bool defval);
-uint64_t dnvlist_take_number(nvlist_t *nvl, const char *name, uint64_t defval);
-char *dnvlist_take_string(nvlist_t *nvl, const char *name, char *defval);
-nvlist_t *dnvlist_take_nvlist(nvlist_t *nvl, const char *name, nvlist_t *defval);
-int dnvlist_take_descriptor(nvlist_t *nvl, const char *name, int defval);
-void *dnvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep, void *defval, size_t defsize);
-
-bool dnvlist_takef_bool(nvlist_t *nvl, bool defval, const char *namefmt, ...) __printflike(3, 4);
-uint64_t dnvlist_takef_number(nvlist_t *nvl, uint64_t defval, const char *namefmt, ...) __printflike(3, 4);
-char *dnvlist_takef_string(nvlist_t *nvl, char *defval, const char *namefmt, ...) __printflike(3, 4);
-nvlist_t *dnvlist_takef_nvlist(nvlist_t *nvl, nvlist_t *defval, const char *namefmt, ...) __printflike(3, 4);
-int dnvlist_takef_descriptor(nvlist_t *nvl, int defval, const char *namefmt, ...) __printflike(3, 4);
-void *dnvlist_takef_binary(nvlist_t *nvl, size_t *sizep, void *defval, size_t defsize, const char *namefmt, ...) __printflike(5, 6);
-
-bool dnvlist_takev_bool(nvlist_t *nvl, bool defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-uint64_t dnvlist_takev_number(nvlist_t *nvl, uint64_t defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-char *dnvlist_takev_string(nvlist_t *nvl, char *defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-nvlist_t *dnvlist_takev_nvlist(nvlist_t *nvl, nvlist_t *defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-int dnvlist_takev_descriptor(nvlist_t *nvl, int defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-void *dnvlist_takev_binary(nvlist_t *nvl, size_t *sizep, void *defval, size_t defsize, const char *namefmt, va_list nameap) __printflike(5, 0);
-
-#endif	/* !_DNV_H_ */
diff --git a/lib/libnv/dnvlist.c b/lib/libnv/dnvlist.c
deleted file mode 100644
index b758bbf..0000000
--- a/lib/libnv/dnvlist.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/*-
- * Copyright (c) 2013 The FreeBSD Foundation
- * All rights reserved.
- *
- * This software was developed by Pawel Jakub Dawidek under sponsorship from
- * the FreeBSD Foundation.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "nv.h"
-#include "nv_impl.h"
-
-#include "dnv.h"
-
-#define	DNVLIST_GET(ftype, type)					\
-ftype									\
-dnvlist_get_##type(const nvlist_t *nvl, const char *name, ftype defval)	\
-{									\
-									\
-	return (dnvlist_getf_##type(nvl, defval, "%s", name));		\
-}
-
-DNVLIST_GET(bool, bool)
-DNVLIST_GET(uint64_t, number)
-DNVLIST_GET(const char *, string)
-DNVLIST_GET(const nvlist_t *, nvlist)
-DNVLIST_GET(int, descriptor)
-
-#undef	DNVLIST_GET
-
-const void *
-dnvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep,
-    const void *defval, size_t defsize)
-{
-
-	return (dnvlist_getf_binary(nvl, sizep, defval, defsize, "%s", name));
-}
-
-#define	DNVLIST_GETF(ftype, type)					\
-ftype									\
-dnvlist_getf_##type(const nvlist_t *nvl, ftype defval,			\
-    const char *namefmt, ...)						\
-{									\
-	va_list nameap;							\
-	ftype value;							\
-									\
-	va_start(nameap, namefmt);					\
-	value = dnvlist_getv_##type(nvl, defval, namefmt, nameap);	\
-	va_end(nameap);							\
-									\
-	return (value);							\
-}
-
-DNVLIST_GETF(bool, bool)
-DNVLIST_GETF(uint64_t, number)
-DNVLIST_GETF(const char *, string)
-DNVLIST_GETF(const nvlist_t *, nvlist)
-DNVLIST_GETF(int, descriptor)
-
-#undef	DNVLIST_GETF
-
-const void *
-dnvlist_getf_binary(const nvlist_t *nvl, size_t *sizep, const void *defval,
-    size_t defsize, const char *namefmt, ...)
-{
-	va_list nameap;
-	const void *value;
-
-	va_start(nameap, namefmt);
-	value = dnvlist_getv_binary(nvl, sizep, defval, defsize, namefmt,
-	    nameap);
-	va_end(nameap);
-
-	return (value);
-}
-
-#define	DNVLIST_GETV(ftype, type)					\
-ftype									\
-dnvlist_getv_##type(const nvlist_t *nvl, ftype defval,			\
-    const char *namefmt, va_list nameap)				\
-{									\
-	va_list cnameap;						\
-	ftype value;							\
-									\
-	va_copy(cnameap, nameap);					\
-	if (nvlist_existsv_##type(nvl, namefmt, cnameap))		\
-		value = nvlist_getv_##type(nvl, namefmt, nameap);	\
-	else								\
-		value = defval;						\
-	va_end(cnameap);						\
-	return (value);							\
-}
-
-DNVLIST_GETV(bool, bool)
-DNVLIST_GETV(uint64_t, number)
-DNVLIST_GETV(const char *, string)
-DNVLIST_GETV(const nvlist_t *, nvlist)
-DNVLIST_GETV(int, descriptor)
-
-#undef	DNVLIST_GETV
-
-const void *
-dnvlist_getv_binary(const nvlist_t *nvl, size_t *sizep, const void *defval,
-    size_t defsize, const char *namefmt, va_list nameap)
-{
-	va_list cnameap;
-	const void *value;
-
-	va_copy(cnameap, nameap);
-	if (nvlist_existsv_binary(nvl, namefmt, cnameap)) {
-		value = nvlist_getv_binary(nvl, sizep, namefmt, nameap);
-	} else {
-		if (sizep != NULL)
-			*sizep = defsize;
-		value = defval;
-	}
-	va_end(cnameap);
-	return (value);
-}
-
-#define	DNVLIST_TAKE(ftype, type)					\
-ftype									\
-dnvlist_take_##type(nvlist_t *nvl, const char *name, ftype defval)	\
-{									\
-									\
-	return (dnvlist_takef_##type(nvl, defval, "%s", name));		\
-}
-
-DNVLIST_TAKE(bool, bool)
-DNVLIST_TAKE(uint64_t, number)
-DNVLIST_TAKE(char *, string)
-DNVLIST_TAKE(nvlist_t *, nvlist)
-DNVLIST_TAKE(int, descriptor)
-
-#undef	DNVLIST_TAKE
-
-void *
-dnvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep,
-    void *defval, size_t defsize)
-{
-
-	return (dnvlist_takef_binary(nvl, sizep, defval, defsize, "%s", name));
-}
-
-#define	DNVLIST_TAKEF(ftype, type)					\
-ftype									\
-dnvlist_takef_##type(nvlist_t *nvl, ftype defval,			\
-    const char *namefmt, ...)						\
-{									\
-	va_list nameap;							\
-	ftype value;							\
-									\
-	va_start(nameap, namefmt);					\
-	value = dnvlist_takev_##type(nvl, defval, namefmt, nameap);	\
-	va_end(nameap);							\
-									\
-	return (value);							\
-}
-
-DNVLIST_TAKEF(bool, bool)
-DNVLIST_TAKEF(uint64_t, number)
-DNVLIST_TAKEF(char *, string)
-DNVLIST_TAKEF(nvlist_t *, nvlist)
-DNVLIST_TAKEF(int, descriptor)
-
-#undef	DNVLIST_TAKEF
-
-void *
-dnvlist_takef_binary(nvlist_t *nvl, size_t *sizep, void *defval,
-    size_t defsize, const char *namefmt, ...)
-{
-	va_list nameap;
-	void *value;
-
-	va_start(nameap, namefmt);
-	value = dnvlist_takev_binary(nvl, sizep, defval, defsize, namefmt,
-	    nameap);
-	va_end(nameap);
-
-	return (value);
-}
-
-#define	DNVLIST_TAKEV(ftype, type)					\
-ftype									\
-dnvlist_takev_##type(nvlist_t *nvl, ftype defval, const char *namefmt,	\
-    va_list nameap)							\
-{									\
-	va_list cnameap;						\
-	ftype value;							\
-									\
-	va_copy(cnameap, nameap);					\
-	if (nvlist_existsv_##type(nvl, namefmt, cnameap))		\
-		value = nvlist_takev_##type(nvl, namefmt, nameap);	\
-	else								\
-		value = defval;						\
-	va_end(cnameap);						\
-	return (value);							\
-}
-
-DNVLIST_TAKEV(bool, bool)
-DNVLIST_TAKEV(uint64_t, number)
-DNVLIST_TAKEV(char *, string)
-DNVLIST_TAKEV(nvlist_t *, nvlist)
-DNVLIST_TAKEV(int, descriptor)
-
-#undef	DNVLIST_TAKEV
-
-void *
-dnvlist_takev_binary(nvlist_t *nvl, size_t *sizep, void *defval,
-    size_t defsize, const char *namefmt, va_list nameap)
-{
-	va_list cnameap;
-	void *value;
-
-	va_copy(cnameap, nameap);
-	if (nvlist_existsv_binary(nvl, namefmt, cnameap)) {
-		value = nvlist_takev_binary(nvl, sizep, namefmt, nameap);
-	} else {
-		if (sizep != NULL)
-			*sizep = defsize;
-		value = defval;
-	}
-	va_end(cnameap);
-	return (value);
-}
diff --git a/lib/libnv/nv.3 b/lib/libnv/nv.3
index 29ba744..58033be 100644
--- a/lib/libnv/nv.3
+++ b/lib/libnv/nv.3
@@ -28,14 +28,16 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd September 25, 2014
+.Dd May 2, 2015
 .Dt NV 3
 .Os
 .Sh NAME
 .Nm nvlist_create ,
 .Nm nvlist_destroy ,
 .Nm nvlist_error ,
+.Nm nvlist_set_error ,
 .Nm nvlist_empty ,
+.Nm nvlist_flags ,
 .Nm nvlist_exists ,
 .Nm nvlist_free ,
 .Nm nvlist_clone ,
@@ -63,8 +65,12 @@
 .Fn nvlist_destroy "nvlist_t *nvl"
 .Ft int
 .Fn nvlist_error "const nvlist_t *nvl"
+.Ft void
+.Fn nvlist_set_error "nvlist_t *nvl, int error"
 .Ft bool
 .Fn nvlist_empty "const nvlist_t *nvl"
+.Ft int
+.Fn nvlist_flags "const nvlist_t *nvl"
 .\"
 .Ft "nvlist_t *"
 .Fn nvlist_clone "const nvlist_t *nvl"
@@ -79,14 +85,14 @@
 .Ft "void *"
 .Fn nvlist_pack "const nvlist_t *nvl" "size_t *sizep"
 .Ft "nvlist_t *"
-.Fn nvlist_unpack "const void *buf" "size_t size"
+.Fn nvlist_unpack "const void *buf" "size_t size" "int flags"
 .\"
 .Ft int
 .Fn nvlist_send "int sock" "const nvlist_t *nvl"
 .Ft "nvlist_t *"
-.Fn nvlist_recv "int sock"
+.Fn nvlist_recv "int sock" "int flags"
 .Ft "nvlist_t *"
-.Fn nvlist_xfer "int sock" "nvlist_t *nvl"
+.Fn nvlist_xfer "int sock" "nvlist_t *nvl" "int flags"
 .\"
 .Ft "const char *"
 .Fn nvlist_next "const nvlist_t *nvl" "int *typep" "void **cookiep"
@@ -151,7 +157,7 @@
 .Ft "const void *"
 .Fn nvlist_get_binary "const nvlist_t *nvl" "const char *name" "size_t *sizep"
 .Ft "const nvlist_t *"
-.Fn nvlist_get_parent "const nvlist_t *nvl"
+.Fn nvlist_get_parent "const nvlist_t *nvl" "void **cookiep"
 .\"
 .Ft bool
 .Fn nvlist_take_bool "nvlist_t *nvl" "const char *name"
@@ -226,6 +232,8 @@ The following flag can be provided:
 .Bl -tag -width "NV_FLAG_IGNORE_CASE" -compact -offset indent
 .It Dv NV_FLAG_IGNORE_CASE
 Perform case-insensitive lookups of provided names.
+.It Dv NV_FLAG_NO_UNIQUE
+Names in the nvlist do not have to be unique.
 .El
 .Pp
 The
@@ -248,8 +256,17 @@ the
 error will be returned.
 .Pp
 The
+.Fn nvlist_set_error
+function sets an nvlist to be in the error state.
+Subsequent calls to
+.Fn nvlist_error
+will return the given error value.
+This function cannot be used to clear the error state from an nvlist.
+This function does nothing if the nvlist is already in the error state.
+.Pp
+The
 .Fn nvlist_empty
-functions returns
+function returns
 .Dv true
 if the given nvlist is empty and
 .Dv false
@@ -257,6 +274,12 @@ otherwise.
 The nvlist must not be in error state.
 .Pp
 The
+.Fn nvlist_flags
+function returns flags used to create the nvlist with the
+.Fn nvlist_create
+function.
+.Pp
+The
 .Fn nvlist_clone
 functions clones the given nvlist.
 The clone shares no resources with its origin.
@@ -304,6 +327,18 @@ The nvlist must not be in error state.
 The
 .Fn nvlist_unpack
 function converts the given buffer to the nvlist.
+The
+.Fa flags
+argument defines what type of the top level nvlist is expected to be.
+Flags are set up using the
+.Fn nvlist_create
+function.
+If the nvlist flags do not match the flags passed to
+.Fn nvlist_unpack ,
+the nvlist will not be returned.
+Every nested nvlist list should be checked using
+.Fn nvlist_flags
+function.
 The function returns
 .Dv NULL
 in case of an error.
@@ -322,12 +357,36 @@ The
 function receives nvlist over the socket given by the
 .Fa sock
 argument.
+The
+.Fa flags
+argument defines what type of the top level nvlist is expected to be.
+Flags are set up using the
+.Fn nvlist_create
+function.
+If the nvlist flags do not match the flags passed to
+.Fn nvlist_recv ,
+the nvlist will not be returned.
+Every nested nvlist list should be checked using
+.Fn nvlist_flags
+function.
 .Pp
 The
 .Fn nvlist_xfer
 function sends the given nvlist over the socket given by the
 .Fa sock
 argument and receives nvlist over the same socket.
+The
+.Fa flags
+argument defines what type of the top level nvlist is expected to be.
+Flags are set up using the
+.Fn nvlist_create
+function.
+If the nvlist flags do not match the flags passed to
+.Fn nvlist_xfer ,
+the nvlist will not be returned.
+Every nested nvlist list should be checked using
+.Fn nvlist_flags
+function.
 The given nvlist is always destroyed.
 .Pp
 The
@@ -538,7 +597,7 @@ const char *command;
 char *filename;
 int fd;
 
-nvl = nvlist_recv(sock);
+nvl = nvlist_recv(sock, 0);
 if (nvl == NULL)
 	err(1, "nvlist_recv() failed");
 
@@ -567,7 +626,7 @@ const char *name;
 void *cookie;
 int type;
 
-nvl = nvlist_recv(sock);
+nvl = nvlist_recv(sock, 0);
 if (nvl == NULL)
 	err(1, "nvlist_recv() failed");
 
@@ -588,6 +647,28 @@ while ((name = nvlist_next(nvl, &type, &cookie)) != NULL) {
 	printf("\\n");
 }
 .Ed
+.Pp
+Iterating over every nested nvlist:
+.Bd -literal
+nvlist_t *nvl;
+const char *name;
+void *cookie;
+int type;
+
+nvl = nvlist_recv(sock, 0);
+if (nvl == NULL)
+	err(1, "nvlist_recv() failed");
+
+cookie = NULL;
+do {
+	while ((name = nvlist_next(nvl, &type, &cookie)) != NULL) {
+		if (type == NV_TYPE_NVLIST) {
+			nvl = nvlist_get_nvlist(nvl, name);
+			cookie = NULL;
+		}
+	}
+} while ((nvl = nvlist_get_parent(nvl, &cookie)) != NULL);
+.Ed
 .Sh SEE ALSO
 .Xr close 2 ,
 .Xr dup 2 ,
diff --git a/lib/libnv/nv.h b/lib/libnv/nv.h
deleted file mode 100644
index 1b55be1..0000000
--- a/lib/libnv/nv.h
+++ /dev/null
@@ -1,275 +0,0 @@
-/*-
- * Copyright (c) 2009-2013 The FreeBSD Foundation
- * All rights reserved.
- *
- * This software was developed by Pawel Jakub Dawidek under sponsorship from
- * the FreeBSD Foundation.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef	_NV_H_
-#define	_NV_H_
-
-#include <sys/cdefs.h>
-
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#ifndef	_NVLIST_T_DECLARED
-#define	_NVLIST_T_DECLARED
-struct nvlist;
-
-typedef struct nvlist nvlist_t;
-#endif
-
-#define	NV_NAME_MAX	2048
-
-#define	NV_TYPE_NONE			0
-
-#define	NV_TYPE_NULL			1
-#define	NV_TYPE_BOOL			2
-#define	NV_TYPE_NUMBER			3
-#define	NV_TYPE_STRING			4
-#define	NV_TYPE_NVLIST			5
-#define	NV_TYPE_DESCRIPTOR		6
-#define	NV_TYPE_BINARY			7
-
-/*
- * Perform case-insensitive lookups of provided names.
- */
-#define	NV_FLAG_IGNORE_CASE		0x01
-
-nvlist_t	*nvlist_create(int flags);
-void		 nvlist_destroy(nvlist_t *nvl);
-int		 nvlist_error(const nvlist_t *nvl);
-bool		 nvlist_empty(const nvlist_t *nvl);
-
-nvlist_t *nvlist_clone(const nvlist_t *nvl);
-
-void nvlist_dump(const nvlist_t *nvl, int fd);
-void nvlist_fdump(const nvlist_t *nvl, FILE *fp);
-
-size_t		 nvlist_size(const nvlist_t *nvl);
-void		*nvlist_pack(const nvlist_t *nvl, size_t *sizep);
-nvlist_t	*nvlist_unpack(const void *buf, size_t size);
-
-int nvlist_send(int sock, const nvlist_t *nvl);
-nvlist_t *nvlist_recv(int sock);
-nvlist_t *nvlist_xfer(int sock, nvlist_t *nvl);
-
-const char *nvlist_next(const nvlist_t *nvl, int *typep, void **cookiep);
-
-const nvlist_t *nvlist_get_parent(const nvlist_t *nvl);
-
-/*
- * The nvlist_exists functions check if the given name (optionally of the given
- * type) exists on nvlist.
- */
-
-bool nvlist_exists(const nvlist_t *nvl, const char *name);
-bool nvlist_exists_type(const nvlist_t *nvl, const char *name, int type);
-
-bool nvlist_exists_null(const nvlist_t *nvl, const char *name);
-bool nvlist_exists_bool(const nvlist_t *nvl, const char *name);
-bool nvlist_exists_number(const nvlist_t *nvl, const char *name);
-bool nvlist_exists_string(const nvlist_t *nvl, const char *name);
-bool nvlist_exists_nvlist(const nvlist_t *nvl, const char *name);
-bool nvlist_exists_descriptor(const nvlist_t *nvl, const char *name);
-bool nvlist_exists_binary(const nvlist_t *nvl, const char *name);
-
-/*
- * The nvlist_add functions add the given name/value pair.
- * If a pointer is provided, nvlist_add will internally allocate memory for the
- * given data (in other words it won't consume provided buffer).
- */
-
-void nvlist_add_null(nvlist_t *nvl, const char *name);
-void nvlist_add_bool(nvlist_t *nvl, const char *name, bool value);
-void nvlist_add_number(nvlist_t *nvl, const char *name, uint64_t value);
-void nvlist_add_string(nvlist_t *nvl, const char *name, const char *value);
-void nvlist_add_stringf(nvlist_t *nvl, const char *name, const char *valuefmt, ...) __printflike(3, 4);
-void nvlist_add_stringv(nvlist_t *nvl, const char *name, const char *valuefmt, va_list valueap) __printflike(3, 0);
-void nvlist_add_nvlist(nvlist_t *nvl, const char *name, const nvlist_t *value);
-void nvlist_add_descriptor(nvlist_t *nvl, const char *name, int value);
-void nvlist_add_binary(nvlist_t *nvl, const char *name, const void *value, size_t size);
-
-/*
- * The nvlist_move functions add the given name/value pair.
- * The functions consumes provided buffer.
- */
-
-void nvlist_move_string(nvlist_t *nvl, const char *name, char *value);
-void nvlist_move_nvlist(nvlist_t *nvl, const char *name, nvlist_t *value);
-void nvlist_move_descriptor(nvlist_t *nvl, const char *name, int value);
-void nvlist_move_binary(nvlist_t *nvl, const char *name, void *value, size_t size);
-
-/*
- * The nvlist_get functions returns value associated with the given name.
- * If it returns a pointer, the pointer represents internal buffer and should
- * not be freed by the caller.
- */
-
-bool		 nvlist_get_bool(const nvlist_t *nvl, const char *name);
-uint64_t	 nvlist_get_number(const nvlist_t *nvl, const char *name);
-const char	*nvlist_get_string(const nvlist_t *nvl, const char *name);
-const nvlist_t	*nvlist_get_nvlist(const nvlist_t *nvl, const char *name);
-int		 nvlist_get_descriptor(const nvlist_t *nvl, const char *name);
-const void	*nvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep);
-
-/*
- * The nvlist_take functions returns value associated with the given name and
- * remove the given entry from the nvlist.
- * The caller is responsible for freeing received data.
- */
-
-bool		 nvlist_take_bool(nvlist_t *nvl, const char *name);
-uint64_t	 nvlist_take_number(nvlist_t *nvl, const char *name);
-char		*nvlist_take_string(nvlist_t *nvl, const char *name);
-nvlist_t	*nvlist_take_nvlist(nvlist_t *nvl, const char *name);
-int		 nvlist_take_descriptor(nvlist_t *nvl, const char *name);
-void		*nvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep);
-
-/*
- * The nvlist_free functions removes the given name/value pair from the nvlist
- * and frees memory associated with it.
- */
-
-void nvlist_free(nvlist_t *nvl, const char *name);
-void nvlist_free_type(nvlist_t *nvl, const char *name, int type);
-
-void nvlist_free_null(nvlist_t *nvl, const char *name);
-void nvlist_free_bool(nvlist_t *nvl, const char *name);
-void nvlist_free_number(nvlist_t *nvl, const char *name);
-void nvlist_free_string(nvlist_t *nvl, const char *name);
-void nvlist_free_nvlist(nvlist_t *nvl, const char *name);
-void nvlist_free_descriptor(nvlist_t *nvl, const char *name);
-void nvlist_free_binary(nvlist_t *nvl, const char *name);
-
-/*
- * Below are the same functions, but which operate on format strings and
- * variable argument lists.
- */
-
-bool nvlist_existsf(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_type(const nvlist_t *nvl, int type, const char *namefmt, ...) __printflike(3, 4);
-
-bool nvlist_existsf_null(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_bool(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_number(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_string(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_nvlist(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_descriptor(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_binary(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-
-bool nvlist_existsv(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_type(const nvlist_t *nvl, int type, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-bool nvlist_existsv_null(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_bool(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_number(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_string(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_nvlist(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_descriptor(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_binary(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-
-void nvlist_addf_null(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_addf_bool(nvlist_t *nvl, bool value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_addf_number(nvlist_t *nvl, uint64_t value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_addf_string(nvlist_t *nvl, const char *value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_addf_nvlist(nvlist_t *nvl, const nvlist_t *value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_addf_descriptor(nvlist_t *nvl, int value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_addf_binary(nvlist_t *nvl, const void *value, size_t size, const char *namefmt, ...) __printflike(4, 5);
-
-void nvlist_addv_null(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_addv_bool(nvlist_t *nvl, bool value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_addv_number(nvlist_t *nvl, uint64_t value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_addv_string(nvlist_t *nvl, const char *value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_addv_nvlist(nvlist_t *nvl, const nvlist_t *value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_addv_descriptor(nvlist_t *nvl, int value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_addv_binary(nvlist_t *nvl, const void *value, size_t size, const char *namefmt, va_list nameap) __printflike(4, 0);
-
-void nvlist_movef_string(nvlist_t *nvl, char *value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_movef_nvlist(nvlist_t *nvl, nvlist_t *value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_movef_descriptor(nvlist_t *nvl, int value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_movef_binary(nvlist_t *nvl, void *value, size_t size, const char *namefmt, ...) __printflike(4, 5);
-
-void nvlist_movev_string(nvlist_t *nvl, char *value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_movev_nvlist(nvlist_t *nvl, nvlist_t *value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_movev_descriptor(nvlist_t *nvl, int value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_movev_binary(nvlist_t *nvl, void *value, size_t size, const char *namefmt, va_list nameap) __printflike(4, 0);
-
-bool		 nvlist_getf_bool(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-uint64_t	 nvlist_getf_number(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-const char	*nvlist_getf_string(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-const nvlist_t	*nvlist_getf_nvlist(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-int		 nvlist_getf_descriptor(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-const void	*nvlist_getf_binary(const nvlist_t *nvl, size_t *sizep, const char *namefmt, ...) __printflike(3, 4);
-
-bool		 nvlist_getv_bool(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-uint64_t	 nvlist_getv_number(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-const char	*nvlist_getv_string(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-const nvlist_t	*nvlist_getv_nvlist(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-int		 nvlist_getv_descriptor(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-const void	*nvlist_getv_binary(const nvlist_t *nvl, size_t *sizep, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-bool		 nvlist_takef_bool(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-uint64_t	 nvlist_takef_number(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-char		*nvlist_takef_string(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-nvlist_t	*nvlist_takef_nvlist(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-int		 nvlist_takef_descriptor(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void		*nvlist_takef_binary(nvlist_t *nvl, size_t *sizep, const char *namefmt, ...) __printflike(3, 4);
-
-bool		 nvlist_takev_bool(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-uint64_t	 nvlist_takev_number(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-char		*nvlist_takev_string(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvlist_t	*nvlist_takev_nvlist(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-int		 nvlist_takev_descriptor(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void		*nvlist_takev_binary(nvlist_t *nvl, size_t *sizep, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-void nvlist_freef(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_type(nvlist_t *nvl, int type, const char *namefmt, ...) __printflike(3, 4);
-
-void nvlist_freef_null(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_bool(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_number(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_string(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_nvlist(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_descriptor(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_binary(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-
-void nvlist_freev(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_type(nvlist_t *nvl, int type, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-void nvlist_freev_null(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_bool(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_number(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_string(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_nvlist(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_descriptor(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_binary(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-
-#endif	/* !_NV_H_ */
diff --git a/lib/libnv/nv_impl.h b/lib/libnv/nv_impl.h
deleted file mode 100644
index 3ed45b3..0000000
--- a/lib/libnv/nv_impl.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/*-
- * Copyright (c) 2013 The FreeBSD Foundation
- * All rights reserved.
- *
- * This software was developed by Pawel Jakub Dawidek under sponsorship from
- * the FreeBSD Foundation.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef	_NV_IMPL_H_
-#define	_NV_IMPL_H_
-
-#ifndef	_NVPAIR_T_DECLARED
-#define	_NVPAIR_T_DECLARED
-struct nvpair;
-
-typedef struct nvpair nvpair_t;
-#endif
-
-#define	NV_TYPE_NVLIST_UP		255
-
-#define	NV_TYPE_FIRST		NV_TYPE_NULL
-#define	NV_TYPE_LAST		NV_TYPE_BINARY
-
-#define	NV_FLAG_BIG_ENDIAN		0x80
-
-int	*nvlist_descriptors(const nvlist_t *nvl, size_t *nitemsp);
-size_t	 nvlist_ndescriptors(const nvlist_t *nvl);
-
-nvpair_t *nvlist_first_nvpair(const nvlist_t *nvl);
-nvpair_t *nvlist_next_nvpair(const nvlist_t *nvl, const nvpair_t *nvp);
-nvpair_t *nvlist_prev_nvpair(const nvlist_t *nvl, const nvpair_t *nvp);
-
-void nvlist_add_nvpair(nvlist_t *nvl, const nvpair_t *nvp);
-
-void nvlist_move_nvpair(nvlist_t *nvl, nvpair_t *nvp);
-
-void nvlist_set_parent(nvlist_t *nvl, nvpair_t *parent);
-
-const nvpair_t *nvlist_get_nvpair(const nvlist_t *nvl, const char *name);
-
-nvpair_t *nvlist_take_nvpair(nvlist_t *nvl, const char *name);
-
-/* Function removes the given nvpair from the nvlist. */
-void nvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *nvp);
-
-void nvlist_free_nvpair(nvlist_t *nvl, nvpair_t *nvp);
-
-int nvpair_type(const nvpair_t *nvp);
-const char *nvpair_name(const nvpair_t *nvp);
-
-nvpair_t *nvpair_clone(const nvpair_t *nvp);
-
-nvpair_t *nvpair_create_null(const char *name);
-nvpair_t *nvpair_create_bool(const char *name, bool value);
-nvpair_t *nvpair_create_number(const char *name, uint64_t value);
-nvpair_t *nvpair_create_string(const char *name, const char *value);
-nvpair_t *nvpair_create_stringf(const char *name, const char *valuefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_create_stringv(const char *name, const char *valuefmt, va_list valueap) __printflike(2, 0);
-nvpair_t *nvpair_create_nvlist(const char *name, const nvlist_t *value);
-nvpair_t *nvpair_create_descriptor(const char *name, int value);
-nvpair_t *nvpair_create_binary(const char *name, const void *value, size_t size);
-
-nvpair_t *nvpair_move_string(const char *name, char *value);
-nvpair_t *nvpair_move_nvlist(const char *name, nvlist_t *value);
-nvpair_t *nvpair_move_descriptor(const char *name, int value);
-nvpair_t *nvpair_move_binary(const char *name, void *value, size_t size);
-
-bool		 nvpair_get_bool(const nvpair_t *nvp);
-uint64_t	 nvpair_get_number(const nvpair_t *nvp);
-const char	*nvpair_get_string(const nvpair_t *nvp);
-const nvlist_t	*nvpair_get_nvlist(const nvpair_t *nvp);
-int		 nvpair_get_descriptor(const nvpair_t *nvp);
-const void	*nvpair_get_binary(const nvpair_t *nvp, size_t *sizep);
-
-void nvpair_free(nvpair_t *nvp);
-
-const nvpair_t *nvlist_getf_nvpair(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-
-const nvpair_t *nvlist_getv_nvpair(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-
-nvpair_t *nvlist_takef_nvpair(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-
-nvpair_t *nvlist_takev_nvpair(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-
-nvpair_t *nvpair_createf_null(const char *namefmt, ...) __printflike(1, 2);
-nvpair_t *nvpair_createf_bool(bool value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_number(uint64_t value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_string(const char *value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_nvlist(const nvlist_t *value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_descriptor(int value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_binary(const void *value, size_t size, const char *namefmt, ...) __printflike(3, 4);
-
-nvpair_t *nvpair_createv_null(const char *namefmt, va_list nameap) __printflike(1, 0);
-nvpair_t *nvpair_createv_bool(bool value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_number(uint64_t value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_string(const char *value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_nvlist(const nvlist_t *value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_descriptor(int value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_binary(const void *value, size_t size, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-nvpair_t *nvpair_movef_string(char *value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_movef_nvlist(nvlist_t *value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_movef_descriptor(int value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_movef_binary(void *value, size_t size, const char *namefmt, ...) __printflike(3, 4);
-
-nvpair_t *nvpair_movev_string(char *value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_movev_nvlist(nvlist_t *value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_movev_descriptor(int value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_movev_binary(void *value, size_t size, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-#endif	/* !_NV_IMPL_H_ */
diff --git a/lib/libnv/nvlist.c b/lib/libnv/nvlist.c
deleted file mode 100644
index b495441..0000000
--- a/lib/libnv/nvlist.c
+++ /dev/null
@@ -1,1848 +0,0 @@
-/*-
- * Copyright (c) 2009-2013 The FreeBSD Foundation
- * All rights reserved.
- *
- * This software was developed by Pawel Jakub Dawidek under sponsorship from
- * the FreeBSD Foundation.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/param.h>
-#include <sys/endian.h>
-#include <sys/queue.h>
-#include <sys/socket.h>
-
-#include <errno.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#define	_WITH_DPRINTF
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#ifdef HAVE_PJDLOG
-#include <pjdlog.h>
-#endif
-
-#include "msgio.h"
-#include "nv.h"
-#include "nv_impl.h"
-#include "nvlist_impl.h"
-#include "nvpair_impl.h"
-
-#ifndef	HAVE_PJDLOG
-#include <assert.h>
-#define	PJDLOG_ASSERT(...)		assert(__VA_ARGS__)
-#define	PJDLOG_RASSERT(expr, ...)	assert(expr)
-#define	PJDLOG_ABORT(...)		do {				\
-	fprintf(stderr, "%s:%u: ", __FILE__, __LINE__);			\
-	fprintf(stderr, __VA_ARGS__);					\
-	fprintf(stderr, "\n");						\
-	abort();							\
-} while (0)
-#endif
-
-#define	NV_FLAG_PRIVATE_MASK	(NV_FLAG_BIG_ENDIAN)
-#define	NV_FLAG_PUBLIC_MASK	(NV_FLAG_IGNORE_CASE)
-#define	NV_FLAG_ALL_MASK	(NV_FLAG_PRIVATE_MASK | NV_FLAG_PUBLIC_MASK)
-
-#define	NVLIST_MAGIC	0x6e766c	/* "nvl" */
-struct nvlist {
-	int		 nvl_magic;
-	int		 nvl_error;
-	int		 nvl_flags;
-	nvpair_t	*nvl_parent;
-	struct nvl_head	 nvl_head;
-};
-
-#define	NVLIST_ASSERT(nvl)	do {					\
-	PJDLOG_ASSERT((nvl) != NULL);					\
-	PJDLOG_ASSERT((nvl)->nvl_magic == NVLIST_MAGIC);		\
-} while (0)
-
-#define	NVPAIR_ASSERT(nvp)	nvpair_assert(nvp)
-
-#define	NVLIST_HEADER_MAGIC	0x6c
-#define	NVLIST_HEADER_VERSION	0x00
-struct nvlist_header {
-	uint8_t		nvlh_magic;
-	uint8_t		nvlh_version;
-	uint8_t		nvlh_flags;
-	uint64_t	nvlh_descriptors;
-	uint64_t	nvlh_size;
-} __packed;
-
-nvlist_t *
-nvlist_create(int flags)
-{
-	nvlist_t *nvl;
-
-	PJDLOG_ASSERT((flags & ~(NV_FLAG_PUBLIC_MASK)) == 0);
-
-	nvl = malloc(sizeof(*nvl));
-	nvl->nvl_error = 0;
-	nvl->nvl_flags = flags;
-	nvl->nvl_parent = NULL;
-	TAILQ_INIT(&nvl->nvl_head);
-	nvl->nvl_magic = NVLIST_MAGIC;
-
-	return (nvl);
-}
-
-void
-nvlist_destroy(nvlist_t *nvl)
-{
-	nvpair_t *nvp;
-	int serrno;
-
-	if (nvl == NULL)
-		return;
-
-	serrno = errno;
-
-	NVLIST_ASSERT(nvl);
-
-	while ((nvp = nvlist_first_nvpair(nvl)) != NULL) {
-		nvlist_remove_nvpair(nvl, nvp);
-		nvpair_free(nvp);
-	}
-	nvl->nvl_magic = 0;
-	free(nvl);
-
-	errno = serrno;
-}
-
-int
-nvlist_error(const nvlist_t *nvl)
-{
-
-	if (nvl == NULL)
-		return (ENOMEM);
-
-	NVLIST_ASSERT(nvl);
-
-	return (nvl->nvl_error);
-}
-
-nvpair_t *
-nvlist_get_nvpair_parent(const nvlist_t *nvl)
-{
-
-	NVLIST_ASSERT(nvl);
-
-	return (nvl->nvl_parent);
-}
-
-const nvlist_t *
-nvlist_get_parent(const nvlist_t *nvl)
-{
-
-	NVLIST_ASSERT(nvl);
-
-	if (nvl->nvl_parent == NULL)
-		return (NULL);
-
-	return (nvpair_nvlist(nvl->nvl_parent));
-}
-
-void
-nvlist_set_parent(nvlist_t *nvl, nvpair_t *parent)
-{
-
-	NVLIST_ASSERT(nvl);
-
-	nvl->nvl_parent = parent;
-}
-
-bool
-nvlist_empty(const nvlist_t *nvl)
-{
-
-	NVLIST_ASSERT(nvl);
-	PJDLOG_ASSERT(nvl->nvl_error == 0);
-
-	return (nvlist_first_nvpair(nvl) == NULL);
-}
-
-static void
-nvlist_report_missing(int type, const char *namefmt, va_list nameap)
-{
-	char *name;
-
-	vasprintf(&name, namefmt, nameap);
-	PJDLOG_ABORT("Element '%s' of type %s doesn't exist.",
-	    name != NULL ? name : "N/A", nvpair_type_string(type));
-}
-
-static nvpair_t *
-nvlist_findv(const nvlist_t *nvl, int type, const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-	char *name;
-
-	NVLIST_ASSERT(nvl);
-	PJDLOG_ASSERT(nvl->nvl_error == 0);
-	PJDLOG_ASSERT(type == NV_TYPE_NONE ||
-	    (type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));
-
-	if (vasprintf(&name, namefmt, nameap) < 0)
-		return (NULL);
-
-	for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
-	    nvp = nvlist_next_nvpair(nvl, nvp)) {
-		if (type != NV_TYPE_NONE && nvpair_type(nvp) != type)
-			continue;
-		if ((nvl->nvl_flags & NV_FLAG_IGNORE_CASE) != 0) {
-			if (strcasecmp(nvpair_name(nvp), name) != 0)
-				continue;
-		} else {
-			if (strcmp(nvpair_name(nvp), name) != 0)
-				continue;
-		}
-		break;
-	}
-
-	free(name);
-
-	if (nvp == NULL)
-		errno = ENOENT;
-
-	return (nvp);
-}
-
-bool
-nvlist_exists_type(const nvlist_t *nvl, const char *name, int type)
-{
-
-	return (nvlist_existsf_type(nvl, type, "%s", name));
-}
-
-bool
-nvlist_existsf_type(const nvlist_t *nvl, int type, const char *namefmt, ...)
-{
-	va_list nameap;
-	bool ret;
-
-	va_start(nameap, namefmt);
-	ret = nvlist_existsv_type(nvl, type, namefmt, nameap);
-	va_end(nameap);
-
-	return (ret);
-}
-
-bool
-nvlist_existsv_type(const nvlist_t *nvl, int type, const char *namefmt,
-    va_list nameap)
-{
-
-	NVLIST_ASSERT(nvl);
-	PJDLOG_ASSERT(nvl->nvl_error == 0);
-	PJDLOG_ASSERT(type == NV_TYPE_NONE ||
-	    (type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));
-
-	return (nvlist_findv(nvl, type, namefmt, nameap) != NULL);
-}
-
-void
-nvlist_free_type(nvlist_t *nvl, const char *name, int type)
-{
-
-	nvlist_freef_type(nvl, type, "%s", name);
-}
-
-void
-nvlist_freef_type(nvlist_t *nvl, int type, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_freev_type(nvl, type, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_freev_type(nvlist_t *nvl, int type, const char *namefmt, va_list nameap)
-{
-	va_list cnameap;
-	nvpair_t *nvp;
-
-	NVLIST_ASSERT(nvl);
-	PJDLOG_ASSERT(nvl->nvl_error == 0);
-	PJDLOG_ASSERT(type == NV_TYPE_NONE ||
-	    (type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));
-
-	va_copy(cnameap, nameap);
-	nvp = nvlist_findv(nvl, type, namefmt, cnameap);
-	va_end(cnameap);
-	if (nvp != NULL)
-		nvlist_free_nvpair(nvl, nvp);
-	else
-		nvlist_report_missing(type, namefmt, nameap);
-}
-
-nvlist_t *
-nvlist_clone(const nvlist_t *nvl)
-{
-	nvlist_t *newnvl;
-	nvpair_t *nvp, *newnvp;
-
-	NVLIST_ASSERT(nvl);
-
-	if (nvl->nvl_error != 0) {
-		errno = nvl->nvl_error;
-		return (NULL);
-	}
-
-	newnvl = nvlist_create(nvl->nvl_flags & NV_FLAG_PUBLIC_MASK);
-	for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
-	    nvp = nvlist_next_nvpair(nvl, nvp)) {
-		newnvp = nvpair_clone(nvp);
-		if (newnvp == NULL)
-			break;
-		nvlist_move_nvpair(newnvl, newnvp);
-	}
-	if (nvp != NULL) {
-		nvlist_destroy(newnvl);
-		return (NULL);
-	}
-	return (newnvl);
-}
-
-static bool
-nvlist_dump_error_check(const nvlist_t *nvl, int fd, int level)
-{
-
-	if (nvlist_error(nvl) != 0) {
-		dprintf(fd, "%*serror: %d\n", level * 4, "",
-		    nvlist_error(nvl));
-		return (true);
-	}
-
-	return (false);
-}
-
-/*
- * Dump content of nvlist.
- */
-void
-nvlist_dump(const nvlist_t *nvl, int fd)
-{
-	nvpair_t *nvp;
-	int level;
-
-	level = 0;
-	if (nvlist_dump_error_check(nvl, fd, level))
-		return;
-
-	nvp = nvlist_first_nvpair(nvl);
-	while (nvp != NULL) {
-		dprintf(fd, "%*s%s (%s):", level * 4, "", nvpair_name(nvp),
-		    nvpair_type_string(nvpair_type(nvp)));
-		switch (nvpair_type(nvp)) {
-		case NV_TYPE_NULL:
-			dprintf(fd, " null\n");
-			break;
-		case NV_TYPE_BOOL:
-			dprintf(fd, " %s\n", nvpair_get_bool(nvp) ?
-			    "TRUE" : "FALSE");
-			break;
-		case NV_TYPE_NUMBER:
-			dprintf(fd, " %ju (%jd) (0x%jx)\n",
-			    (uintmax_t)nvpair_get_number(nvp),
-			    (intmax_t)nvpair_get_number(nvp),
-			    (uintmax_t)nvpair_get_number(nvp));
-			break;
-		case NV_TYPE_STRING:
-			dprintf(fd, " [%s]\n", nvpair_get_string(nvp));
-			break;
-		case NV_TYPE_NVLIST:
-			dprintf(fd, "\n");
-			nvl = nvpair_get_nvlist(nvp);
-			if (nvlist_dump_error_check(nvl, fd, level + 1)) {
-				nvl = nvlist_get_parent(nvl);
-				break;
-			}
-			level += 1;
-			nvp = nvlist_first_nvpair(nvl);
-			continue;
-		case NV_TYPE_DESCRIPTOR:
-			dprintf(fd, " %d\n", nvpair_get_descriptor(nvp));
-			break;
-		case NV_TYPE_BINARY:
-		    {
-			const unsigned char *binary;
-			unsigned int ii;
-			size_t size;
-
-			binary = nvpair_get_binary(nvp, &size);
-			dprintf(fd, " %zu ", size);
-			for (ii = 0; ii < size; ii++)
-				dprintf(fd, "%02hhx", binary[ii]);
-			dprintf(fd, "\n");
-			break;
-		    }
-		default:
-			PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
-		}
-
-		while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
-			nvp = nvlist_get_nvpair_parent(nvl);
-			if (nvp == NULL)
-				return;
-			nvl = nvlist_get_parent(nvl);
-			level --;
-		}
-	}
-}
-
-void
-nvlist_fdump(const nvlist_t *nvl, FILE *fp)
-{
-
-	fflush(fp);
-	nvlist_dump(nvl, fileno(fp));
-}
-
-/*
- * The function obtains size of the nvlist after nvlist_pack().
- */
-size_t
-nvlist_size(const nvlist_t *nvl)
-{
-	const nvpair_t *nvp;
-	size_t size;
-
-	NVLIST_ASSERT(nvl);
-	PJDLOG_ASSERT(nvl->nvl_error == 0);
-
-	size = sizeof(struct nvlist_header);
-	nvp = nvlist_first_nvpair(nvl);
-	while (nvp != NULL) {
-		size += nvpair_header_size();
-		size += strlen(nvpair_name(nvp)) + 1;
-		if (nvpair_type(nvp) == NV_TYPE_NVLIST) {
-			size += sizeof(struct nvlist_header);
-			size += nvpair_header_size() + 1;
-			nvl = nvpair_get_nvlist(nvp);
-			PJDLOG_ASSERT(nvl->nvl_error == 0);
-			nvp = nvlist_first_nvpair(nvl);
-			continue;
-		} else {
-			size += nvpair_size(nvp);
-		}
-
-		while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
-			nvp = nvlist_get_nvpair_parent(nvl);
-			if (nvp == NULL)
-				goto out;
-			nvl = nvlist_get_parent(nvl);
-		}
-	}
-
-out:
-	return (size);
-}
-
-static int *
-nvlist_xdescriptors(const nvlist_t *nvl, int *descs, int level)
-{
-	const nvpair_t *nvp;
-
-	NVLIST_ASSERT(nvl);
-	PJDLOG_ASSERT(nvl->nvl_error == 0);
-	PJDLOG_ASSERT(level < 3);
-
-	for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
-	    nvp = nvlist_next_nvpair(nvl, nvp)) {
-		switch (nvpair_type(nvp)) {
-		case NV_TYPE_DESCRIPTOR:
-			*descs = nvpair_get_descriptor(nvp);
-			descs++;
-			break;
-		case NV_TYPE_NVLIST:
-			descs = nvlist_xdescriptors(nvpair_get_nvlist(nvp),
-			    descs, level + 1);
-			break;
-		}
-	}
-
-	return (descs);
-}
-
-int *
-nvlist_descriptors(const nvlist_t *nvl, size_t *nitemsp)
-{
-	size_t nitems;
-	int *fds;
-
-	nitems = nvlist_ndescriptors(nvl);
-	fds = malloc(sizeof(fds[0]) * (nitems + 1));
-	if (fds == NULL)
-		return (NULL);
-	if (nitems > 0)
-		nvlist_xdescriptors(nvl, fds, 0);
-	fds[nitems] = -1;
-	if (nitemsp != NULL)
-		*nitemsp = nitems;
-	return (fds);
-}
-
-static size_t
-nvlist_xndescriptors(const nvlist_t *nvl, int level)
-{
-	const nvpair_t *nvp;
-	size_t ndescs;
-
-	NVLIST_ASSERT(nvl);
-	PJDLOG_ASSERT(nvl->nvl_error == 0);
-	PJDLOG_ASSERT(level < 3);
-
-	ndescs = 0;
-	for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
-	    nvp = nvlist_next_nvpair(nvl, nvp)) {
-		switch (nvpair_type(nvp)) {
-		case NV_TYPE_DESCRIPTOR:
-			ndescs++;
-			break;
-		case NV_TYPE_NVLIST:
-			ndescs += nvlist_xndescriptors(nvpair_get_nvlist(nvp),
-			    level + 1);
-			break;
-		}
-	}
-
-	return (ndescs);
-}
-
-size_t
-nvlist_ndescriptors(const nvlist_t *nvl)
-{
-
-	return (nvlist_xndescriptors(nvl, 0));
-}
-
-static unsigned char *
-nvlist_pack_header(const nvlist_t *nvl, unsigned char *ptr, size_t *leftp)
-{
-	struct nvlist_header nvlhdr;
-
-	NVLIST_ASSERT(nvl);
-
-	nvlhdr.nvlh_magic = NVLIST_HEADER_MAGIC;
-	nvlhdr.nvlh_version = NVLIST_HEADER_VERSION;
-	nvlhdr.nvlh_flags = nvl->nvl_flags;
-#if BYTE_ORDER == BIG_ENDIAN
-	nvlhdr.nvlh_flags |= NV_FLAG_BIG_ENDIAN;
-#endif
-	nvlhdr.nvlh_descriptors = nvlist_ndescriptors(nvl);
-	nvlhdr.nvlh_size = *leftp - sizeof(nvlhdr);
-	PJDLOG_ASSERT(*leftp >= sizeof(nvlhdr));
-	memcpy(ptr, &nvlhdr, sizeof(nvlhdr));
-	ptr += sizeof(nvlhdr);
-	*leftp -= sizeof(nvlhdr);
-
-	return (ptr);
-}
-
-void *
-nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
-{
-	unsigned char *buf, *ptr;
-	size_t left, size;
-	nvpair_t *nvp;
-
-	NVLIST_ASSERT(nvl);
-
-	if (nvl->nvl_error != 0) {
-		errno = nvl->nvl_error;
-		return (NULL);
-	}
-
-	size = nvlist_size(nvl);
-	buf = malloc(size);
-	if (buf == NULL)
-		return (NULL);
-
-	ptr = buf;
-	left = size;
-
-	ptr = nvlist_pack_header(nvl, ptr, &left);
-
-	nvp = nvlist_first_nvpair(nvl);
-	while (nvp != NULL) {
-		NVPAIR_ASSERT(nvp);
-
-		nvpair_init_datasize(nvp);
-		ptr = nvpair_pack_header(nvp, ptr, &left);
-		if (ptr == NULL) {
-			free(buf);
-			return (NULL);
-		}
-		switch (nvpair_type(nvp)) {
-		case NV_TYPE_NULL:
-			ptr = nvpair_pack_null(nvp, ptr, &left);
-			break;
-		case NV_TYPE_BOOL:
-			ptr = nvpair_pack_bool(nvp, ptr, &left);
-			break;
-		case NV_TYPE_NUMBER:
-			ptr = nvpair_pack_number(nvp, ptr, &left);
-			break;
-		case NV_TYPE_STRING:
-			ptr = nvpair_pack_string(nvp, ptr, &left);
-			break;
-		case NV_TYPE_NVLIST:
-			nvl = nvpair_get_nvlist(nvp);
-			nvp = nvlist_first_nvpair(nvl);
-			ptr = nvlist_pack_header(nvl, ptr, &left);
-			continue;
-		case NV_TYPE_DESCRIPTOR:
-			ptr = nvpair_pack_descriptor(nvp, ptr, fdidxp, &left);
-			break;
-		case NV_TYPE_BINARY:
-			ptr = nvpair_pack_binary(nvp, ptr, &left);
-			break;
-		default:
-			PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
-		}
-		if (ptr == NULL) {
-			free(buf);
-			return (NULL);
-		}
-		while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
-			nvp = nvlist_get_nvpair_parent(nvl);
-			if (nvp == NULL)
-				goto out;
-			ptr = nvpair_pack_nvlist_up(ptr, &left);
-			if (ptr == NULL)
-				goto out;
-			nvl = nvlist_get_parent(nvl);
-		}
-	}
-
-out:
-	if (sizep != NULL)
-		*sizep = size;
-	return (buf);
-}
-
-void *
-nvlist_pack(const nvlist_t *nvl, size_t *sizep)
-{
-
-	NVLIST_ASSERT(nvl);
-
-	if (nvl->nvl_error != 0) {
-		errno = nvl->nvl_error;
-		return (NULL);
-	}
-
-	if (nvlist_ndescriptors(nvl) > 0) {
-		errno = EOPNOTSUPP;
-		return (NULL);
-	}
-
-	return (nvlist_xpack(nvl, NULL, sizep));
-}
-
-static bool
-nvlist_check_header(struct nvlist_header *nvlhdrp)
-{
-
-	if (nvlhdrp->nvlh_magic != NVLIST_HEADER_MAGIC) {
-		errno = EINVAL;
-		return (false);
-	}
-	if ((nvlhdrp->nvlh_flags & ~NV_FLAG_ALL_MASK) != 0) {
-		errno = EINVAL;
-		return (false);
-	}
-#if BYTE_ORDER == BIG_ENDIAN
-	if ((nvlhdrp->nvlh_flags & NV_FLAG_BIG_ENDIAN) == 0) {
-		nvlhdrp->nvlh_size = le64toh(nvlhdrp->nvlh_size);
-		nvlhdrp->nvlh_descriptors = le64toh(nvlhdrp->nvlh_descriptors);
-	}
-#else
-	if ((nvlhdrp->nvlh_flags & NV_FLAG_BIG_ENDIAN) != 0) {
-		nvlhdrp->nvlh_size = be64toh(nvlhdrp->nvlh_size);
-		nvlhdrp->nvlh_descriptors = be64toh(nvlhdrp->nvlh_descriptors);
-	}
-#endif
-	return (true);
-}
-
-const unsigned char *
-nvlist_unpack_header(nvlist_t *nvl, const unsigned char *ptr, size_t nfds,
-    bool *isbep, size_t *leftp)
-{
-	struct nvlist_header nvlhdr;
-
-	if (*leftp < sizeof(nvlhdr))
-		goto failed;
-
-	memcpy(&nvlhdr, ptr, sizeof(nvlhdr));
-
-	if (!nvlist_check_header(&nvlhdr))
-		goto failed;
-
-	if (nvlhdr.nvlh_size != *leftp - sizeof(nvlhdr))
-		goto failed;
-
-	/*
-	 * nvlh_descriptors might be smaller than nfds in embedded nvlists.
-	 */
-	if (nvlhdr.nvlh_descriptors > nfds)
-		goto failed;
-
-	if ((nvlhdr.nvlh_flags & ~NV_FLAG_ALL_MASK) != 0)
-		goto failed;
-
-	nvl->nvl_flags = (nvlhdr.nvlh_flags & NV_FLAG_PUBLIC_MASK);
-
-	ptr += sizeof(nvlhdr);
-	if (isbep != NULL)
-		*isbep = (((int)nvlhdr.nvlh_flags & NV_FLAG_BIG_ENDIAN) != 0);
-	*leftp -= sizeof(nvlhdr);
-
-	return (ptr);
-failed:
-	errno = EINVAL;
-	return (NULL);
-}
-
-nvlist_t *
-nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds)
-{
-	const unsigned char *ptr;
-	nvlist_t *nvl, *retnvl, *tmpnvl;
-	nvpair_t *nvp;
-	size_t left;
-	bool isbe;
-
-	left = size;
-	ptr = buf;
-
-	tmpnvl = NULL;
-	nvl = retnvl = nvlist_create(0);
-	if (nvl == NULL)
-		goto failed;
-
-	ptr = nvlist_unpack_header(nvl, ptr, nfds, &isbe, &left);
-	if (ptr == NULL)
-		goto failed;
-
-	while (left > 0) {
-		ptr = nvpair_unpack(isbe, ptr, &left, &nvp);
-		if (ptr == NULL)
-			goto failed;
-		switch (nvpair_type(nvp)) {
-		case NV_TYPE_NULL:
-			ptr = nvpair_unpack_null(isbe, nvp, ptr, &left);
-			break;
-		case NV_TYPE_BOOL:
-			ptr = nvpair_unpack_bool(isbe, nvp, ptr, &left);
-			break;
-		case NV_TYPE_NUMBER:
-			ptr = nvpair_unpack_number(isbe, nvp, ptr, &left);
-			break;
-		case NV_TYPE_STRING:
-			ptr = nvpair_unpack_string(isbe, nvp, ptr, &left);
-			break;
-		case NV_TYPE_NVLIST:
-			ptr = nvpair_unpack_nvlist(isbe, nvp, ptr, &left, nfds,
-			    &tmpnvl);
-			nvlist_set_parent(tmpnvl, nvp);
-			break;
-		case NV_TYPE_DESCRIPTOR:
-			ptr = nvpair_unpack_descriptor(isbe, nvp, ptr, &left,
-			    fds, nfds);
-			break;
-		case NV_TYPE_BINARY:
-			ptr = nvpair_unpack_binary(isbe, nvp, ptr, &left);
-			break;
-		case NV_TYPE_NVLIST_UP:
-			if (nvl->nvl_parent == NULL)
-				goto failed;
-			nvl = nvpair_nvlist(nvl->nvl_parent);
-			continue;
-		default:
-			PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
-		}
-		if (ptr == NULL)
-			goto failed;
-		nvlist_move_nvpair(nvl, nvp);
-		if (tmpnvl != NULL) {
-			nvl = tmpnvl;
-			tmpnvl = NULL;
-		}
-	}
-
-	return (retnvl);
-failed:
-	nvlist_destroy(retnvl);
-	return (NULL);
-}
-
-nvlist_t *
-nvlist_unpack(const void *buf, size_t size)
-{
-
-	return (nvlist_xunpack(buf, size, NULL, 0));
-}
-
-int
-nvlist_send(int sock, const nvlist_t *nvl)
-{
-	size_t datasize, nfds;
-	int *fds;
-	void *data;
-	int64_t fdidx;
-	int serrno, ret;
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return (-1);
-	}
-
-	fds = nvlist_descriptors(nvl, &nfds);
-	if (fds == NULL)
-		return (-1);
-
-	ret = -1;
-	data = NULL;
-	fdidx = 0;
-
-	data = nvlist_xpack(nvl, &fdidx, &datasize);
-	if (data == NULL)
-		goto out;
-
-	if (buf_send(sock, data, datasize) == -1)
-		goto out;
-
-	if (nfds > 0) {
-		if (fd_send(sock, fds, nfds) == -1)
-			goto out;
-	}
-
-	ret = 0;
-out:
-	serrno = errno;
-	free(fds);
-	free(data);
-	errno = serrno;
-	return (ret);
-}
-
-nvlist_t *
-nvlist_recv(int sock)
-{
-	struct nvlist_header nvlhdr;
-	nvlist_t *nvl, *ret;
-	unsigned char *buf;
-	size_t nfds, size, i;
-	int serrno, *fds;
-
-	if (buf_recv(sock, &nvlhdr, sizeof(nvlhdr)) == -1)
-		return (NULL);
-
-	if (!nvlist_check_header(&nvlhdr))
-		return (NULL);
-
-	nfds = (size_t)nvlhdr.nvlh_descriptors;
-	size = sizeof(nvlhdr) + (size_t)nvlhdr.nvlh_size;
-
-	buf = malloc(size);
-	if (buf == NULL)
-		return (NULL);
-
-	memcpy(buf, &nvlhdr, sizeof(nvlhdr));
-
-	ret = NULL;
-	fds = NULL;
-
-	if (buf_recv(sock, buf + sizeof(nvlhdr), size - sizeof(nvlhdr)) == -1)
-		goto out;
-
-	if (nfds > 0) {
-		fds = malloc(nfds * sizeof(fds[0]));
-		if (fds == NULL)
-			goto out;
-		if (fd_recv(sock, fds, nfds) == -1)
-			goto out;
-	}
-
-	nvl = nvlist_xunpack(buf, size, fds, nfds);
-	if (nvl == NULL) {
-		for (i = 0; i < nfds; i++)
-			close(fds[i]);
-		goto out;
-	}
-
-	ret = nvl;
-out:
-	serrno = errno;
-	free(buf);
-	free(fds);
-	errno = serrno;
-
-	return (ret);
-}
-
-nvlist_t *
-nvlist_xfer(int sock, nvlist_t *nvl)
-{
-
-	if (nvlist_send(sock, nvl) < 0) {
-		nvlist_destroy(nvl);
-		return (NULL);
-	}
-	nvlist_destroy(nvl);
-	return (nvlist_recv(sock));
-}
-
-nvpair_t *
-nvlist_first_nvpair(const nvlist_t *nvl)
-{
-
-	NVLIST_ASSERT(nvl);
-
-	return (TAILQ_FIRST(&nvl->nvl_head));
-}
-
-nvpair_t *
-nvlist_next_nvpair(const nvlist_t *nvl, const nvpair_t *nvp)
-{
-	nvpair_t *retnvp;
-
-	NVLIST_ASSERT(nvl);
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
-
-	retnvp = nvpair_next(nvp);
-	PJDLOG_ASSERT(retnvp == NULL || nvpair_nvlist(retnvp) == nvl);
-
-	return (retnvp);
-
-}
-
-nvpair_t *
-nvlist_prev_nvpair(const nvlist_t *nvl, const nvpair_t *nvp)
-{
-	nvpair_t *retnvp;
-
-	NVLIST_ASSERT(nvl);
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
-
-	retnvp = nvpair_prev(nvp);
-	PJDLOG_ASSERT(nvpair_nvlist(retnvp) == nvl);
-
-	return (retnvp);
-}
-
-const char *
-nvlist_next(const nvlist_t *nvl, int *typep, void **cookiep)
-{
-	nvpair_t *nvp;
-
-	NVLIST_ASSERT(nvl);
-	PJDLOG_ASSERT(cookiep != NULL);
-
-	if (*cookiep == NULL)
-		nvp = nvlist_first_nvpair(nvl);
-	else
-		nvp = nvlist_next_nvpair(nvl, *cookiep);
-	if (nvp == NULL)
-		return (NULL);
-	if (typep != NULL)
-		*typep = nvpair_type(nvp);
-	*cookiep = nvp;
-	return (nvpair_name(nvp));
-}
-
-bool
-nvlist_exists(const nvlist_t *nvl, const char *name)
-{
-
-	return (nvlist_existsf(nvl, "%s", name));
-}
-
-#define	NVLIST_EXISTS(type)						\
-bool									\
-nvlist_exists_##type(const nvlist_t *nvl, const char *name)		\
-{									\
-									\
-	return (nvlist_existsf_##type(nvl, "%s", name));		\
-}
-
-NVLIST_EXISTS(null)
-NVLIST_EXISTS(bool)
-NVLIST_EXISTS(number)
-NVLIST_EXISTS(string)
-NVLIST_EXISTS(nvlist)
-NVLIST_EXISTS(descriptor)
-NVLIST_EXISTS(binary)
-
-#undef	NVLIST_EXISTS
-
-bool
-nvlist_existsf(const nvlist_t *nvl, const char *namefmt, ...)
-{
-	va_list nameap;
-	bool ret;
-
-	va_start(nameap, namefmt);
-	ret = nvlist_existsv(nvl, namefmt, nameap);
-	va_end(nameap);
-	return (ret);
-}
-
-#define	NVLIST_EXISTSF(type)						\
-bool									\
-nvlist_existsf_##type(const nvlist_t *nvl, const char *namefmt, ...)	\
-{									\
-	va_list nameap;							\
-	bool ret;							\
-									\
-	va_start(nameap, namefmt);					\
-	ret = nvlist_existsv_##type(nvl, namefmt, nameap);		\
-	va_end(nameap);							\
-	return (ret);							\
-}
-
-NVLIST_EXISTSF(null)
-NVLIST_EXISTSF(bool)
-NVLIST_EXISTSF(number)
-NVLIST_EXISTSF(string)
-NVLIST_EXISTSF(nvlist)
-NVLIST_EXISTSF(descriptor)
-NVLIST_EXISTSF(binary)
-
-#undef	NVLIST_EXISTSF
-
-bool
-nvlist_existsv(const nvlist_t *nvl, const char *namefmt, va_list nameap)
-{
-
-	return (nvlist_findv(nvl, NV_TYPE_NONE, namefmt, nameap) != NULL);
-}
-
-#define	NVLIST_EXISTSV(type, TYPE)					\
-bool									\
-nvlist_existsv_##type(const nvlist_t *nvl, const char *namefmt,		\
-    va_list nameap)							\
-{									\
-									\
-	return (nvlist_findv(nvl, NV_TYPE_##TYPE, namefmt, nameap) !=	\
-	    NULL);							\
-}
-
-NVLIST_EXISTSV(null, NULL)
-NVLIST_EXISTSV(bool, BOOL)
-NVLIST_EXISTSV(number, NUMBER)
-NVLIST_EXISTSV(string, STRING)
-NVLIST_EXISTSV(nvlist, NVLIST)
-NVLIST_EXISTSV(descriptor, DESCRIPTOR)
-NVLIST_EXISTSV(binary, BINARY)
-
-#undef	NVLIST_EXISTSV
-
-void
-nvlist_add_nvpair(nvlist_t *nvl, const nvpair_t *nvp)
-{
-	nvpair_t *newnvp;
-
-	NVPAIR_ASSERT(nvp);
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return;
-	}
-	if (nvlist_exists(nvl, nvpair_name(nvp))) {
-		nvl->nvl_error = errno = EEXIST;
-		return;
-	}
-
-	newnvp = nvpair_clone(nvp);
-	if (newnvp == NULL) {
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-		return;
-	}
-
-	nvpair_insert(&nvl->nvl_head, newnvp, nvl);
-}
-
-void
-nvlist_add_null(nvlist_t *nvl, const char *name)
-{
-
-	nvlist_addf_null(nvl, "%s", name);
-}
-
-void
-nvlist_add_bool(nvlist_t *nvl, const char *name, bool value)
-{
-
-	nvlist_addf_bool(nvl, value, "%s", name);
-}
-
-void
-nvlist_add_number(nvlist_t *nvl, const char *name, uint64_t value)
-{
-
-	nvlist_addf_number(nvl, value, "%s", name);
-}
-
-void
-nvlist_add_string(nvlist_t *nvl, const char *name, const char *value)
-{
-
-	nvlist_addf_string(nvl, value, "%s", name);
-}
-
-void
-nvlist_add_stringf(nvlist_t *nvl, const char *name, const char *valuefmt, ...)
-{
-	va_list valueap;
-
-	va_start(valueap, valuefmt);
-	nvlist_add_stringv(nvl, name, valuefmt, valueap);
-	va_end(valueap);
-}
-
-void
-nvlist_add_stringv(nvlist_t *nvl, const char *name, const char *valuefmt,
-    va_list valueap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_create_stringv(name, valuefmt, valueap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_add_nvlist(nvlist_t *nvl, const char *name, const nvlist_t *value)
-{
-
-	nvlist_addf_nvlist(nvl, value, "%s", name);
-}
-
-void
-nvlist_add_descriptor(nvlist_t *nvl, const char *name, int value)
-{
-
-	nvlist_addf_descriptor(nvl, value, "%s", name);
-}
-
-void
-nvlist_add_binary(nvlist_t *nvl, const char *name, const void *value,
-    size_t size)
-{
-
-	nvlist_addf_binary(nvl, value, size, "%s", name);
-}
-
-void
-nvlist_addf_null(nvlist_t *nvl, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_null(nvl, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_addf_bool(nvlist_t *nvl, bool value, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_bool(nvl, value, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_addf_number(nvlist_t *nvl, uint64_t value, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_number(nvl, value, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_addf_string(nvlist_t *nvl, const char *value, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_string(nvl, value, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_addf_nvlist(nvlist_t *nvl, const nvlist_t *value, const char *namefmt,
-    ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_nvlist(nvl, value, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_addf_descriptor(nvlist_t *nvl, int value, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_descriptor(nvl, value, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_addf_binary(nvlist_t *nvl, const void *value, size_t size,
-    const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_binary(nvl, value, size, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_addv_null(nvlist_t *nvl, const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_createv_null(namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_addv_bool(nvlist_t *nvl, bool value, const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_createv_bool(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_addv_number(nvlist_t *nvl, uint64_t value, const char *namefmt,
-    va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_createv_number(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_addv_string(nvlist_t *nvl, const char *value, const char *namefmt,
-    va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_createv_string(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_addv_nvlist(nvlist_t *nvl, const nvlist_t *value, const char *namefmt,
-    va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_createv_nvlist(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_addv_descriptor(nvlist_t *nvl, int value, const char *namefmt,
-    va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_createv_descriptor(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_addv_binary(nvlist_t *nvl, const void *value, size_t size,
-    const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_createv_binary(value, size, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_move_nvpair(nvlist_t *nvl, nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvpair_nvlist(nvp) == NULL);
-
-	if (nvlist_error(nvl) != 0) {
-		nvpair_free(nvp);
-		errno = nvlist_error(nvl);
-		return;
-	}
-	if (nvlist_exists(nvl, nvpair_name(nvp))) {
-		nvpair_free(nvp);
-		nvl->nvl_error = errno = EEXIST;
-		return;
-	}
-
-	nvpair_insert(&nvl->nvl_head, nvp, nvl);
-}
-
-#define	NVLIST_MOVE(vtype, type)					\
-void									\
-nvlist_move_##type(nvlist_t *nvl, const char *name, vtype value)	\
-{									\
-									\
-	nvlist_movef_##type(nvl, value, "%s", name);			\
-}
-
-NVLIST_MOVE(char *, string)
-NVLIST_MOVE(nvlist_t *, nvlist)
-NVLIST_MOVE(int, descriptor)
-
-#undef	NVLIST_MOVE
-
-void
-nvlist_move_binary(nvlist_t *nvl, const char *name, void *value, size_t size)
-{
-
-	nvlist_movef_binary(nvl, value, size, "%s", name);
-}
-
-#define	NVLIST_MOVEF(vtype, type)					\
-void									\
-nvlist_movef_##type(nvlist_t *nvl, vtype value, const char *namefmt,	\
-    ...)								\
-{									\
-	va_list nameap;							\
-									\
-	va_start(nameap, namefmt);					\
-	nvlist_movev_##type(nvl, value, namefmt, nameap);		\
-	va_end(nameap);							\
-}
-
-NVLIST_MOVEF(char *, string)
-NVLIST_MOVEF(nvlist_t *, nvlist)
-NVLIST_MOVEF(int, descriptor)
-
-#undef	NVLIST_MOVEF
-
-void
-nvlist_movef_binary(nvlist_t *nvl, void *value, size_t size,
-    const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_movev_binary(nvl, value, size, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_movev_string(nvlist_t *nvl, char *value, const char *namefmt,
-    va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		free(value);
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_movev_string(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_movev_nvlist(nvlist_t *nvl, nvlist_t *value, const char *namefmt,
-    va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		if (value != NULL && nvlist_get_nvpair_parent(value) != NULL)
-			nvlist_destroy(value);
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_movev_nvlist(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_movev_descriptor(nvlist_t *nvl, int value, const char *namefmt,
-    va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		close(value);
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_movev_descriptor(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-void
-nvlist_movev_binary(nvlist_t *nvl, void *value, size_t size,
-    const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (nvlist_error(nvl) != 0) {
-		free(value);
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_movev_binary(value, size, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-
-#define	NVLIST_GET(ftype, type)						\
-ftype									\
-nvlist_get_##type(const nvlist_t *nvl, const char *name)		\
-{									\
-									\
-	return (nvlist_getf_##type(nvl, "%s", name));			\
-}
-
-NVLIST_GET(const nvpair_t *, nvpair)
-NVLIST_GET(bool, bool)
-NVLIST_GET(uint64_t, number)
-NVLIST_GET(const char *, string)
-NVLIST_GET(const nvlist_t *, nvlist)
-NVLIST_GET(int, descriptor)
-
-#undef	NVLIST_GET
-
-const void *
-nvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep)
-{
-
-	return (nvlist_getf_binary(nvl, sizep, "%s", name));
-}
-
-#define	NVLIST_GETF(ftype, type)					\
-ftype									\
-nvlist_getf_##type(const nvlist_t *nvl, const char *namefmt, ...)	\
-{									\
-	va_list nameap;							\
-	ftype value;							\
-									\
-	va_start(nameap, namefmt);					\
-	value = nvlist_getv_##type(nvl, namefmt, nameap);		\
-	va_end(nameap);							\
-									\
-	return (value);							\
-}
-
-NVLIST_GETF(const nvpair_t *, nvpair)
-NVLIST_GETF(bool, bool)
-NVLIST_GETF(uint64_t, number)
-NVLIST_GETF(const char *, string)
-NVLIST_GETF(const nvlist_t *, nvlist)
-NVLIST_GETF(int, descriptor)
-
-#undef	NVLIST_GETF
-
-const void *
-nvlist_getf_binary(const nvlist_t *nvl, size_t *sizep, const char *namefmt, ...)
-{
-	va_list nameap;
-	const void *value;
-
-	va_start(nameap, namefmt);
-	value = nvlist_getv_binary(nvl, sizep, namefmt, nameap);
-	va_end(nameap);
-
-	return (value);
-}
-
-const nvpair_t *
-nvlist_getv_nvpair(const nvlist_t *nvl, const char *namefmt, va_list nameap)
-{
-
-	return (nvlist_findv(nvl, NV_TYPE_NONE, namefmt, nameap));
-}
-
-#define	NVLIST_GETV(ftype, type, TYPE)					\
-ftype									\
-nvlist_getv_##type(const nvlist_t *nvl, const char *namefmt,		\
-    va_list nameap)							\
-{									\
-	va_list cnameap;						\
-	const nvpair_t *nvp;						\
-									\
-	va_copy(cnameap, nameap);					\
-	nvp = nvlist_findv(nvl, NV_TYPE_##TYPE, namefmt, cnameap);	\
-	va_end(cnameap);						\
-	if (nvp == NULL)						\
-		nvlist_report_missing(NV_TYPE_##TYPE, namefmt, nameap);	\
-	return (nvpair_get_##type(nvp));				\
-}
-
-NVLIST_GETV(bool, bool, BOOL)
-NVLIST_GETV(uint64_t, number, NUMBER)
-NVLIST_GETV(const char *, string, STRING)
-NVLIST_GETV(const nvlist_t *, nvlist, NVLIST)
-NVLIST_GETV(int, descriptor, DESCRIPTOR)
-
-#undef	NVLIST_GETV
-
-const void *
-nvlist_getv_binary(const nvlist_t *nvl, size_t *sizep, const char *namefmt,
-    va_list nameap)
-{
-	va_list cnameap;
-	const nvpair_t *nvp;
-
-	va_copy(cnameap, nameap);
-	nvp = nvlist_findv(nvl, NV_TYPE_BINARY, namefmt, cnameap);
-	va_end(cnameap);
-	if (nvp == NULL)
-		nvlist_report_missing(NV_TYPE_BINARY, namefmt, nameap);
-
-	return (nvpair_get_binary(nvp, sizep));
-}
-
-#define	NVLIST_TAKE(ftype, type)					\
-ftype									\
-nvlist_take_##type(nvlist_t *nvl, const char *name)			\
-{									\
-									\
-	return (nvlist_takef_##type(nvl, "%s", name));			\
-}
-
-NVLIST_TAKE(nvpair_t *, nvpair)
-NVLIST_TAKE(bool, bool)
-NVLIST_TAKE(uint64_t, number)
-NVLIST_TAKE(char *, string)
-NVLIST_TAKE(nvlist_t *, nvlist)
-NVLIST_TAKE(int, descriptor)
-
-#undef	NVLIST_TAKE
-
-void *
-nvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep)
-{
-
-	return (nvlist_takef_binary(nvl, sizep, "%s", name));
-}
-
-#define	NVLIST_TAKEF(ftype, type)					\
-ftype									\
-nvlist_takef_##type(nvlist_t *nvl, const char *namefmt, ...)		\
-{									\
-	va_list nameap;							\
-	ftype value;							\
-									\
-	va_start(nameap, namefmt);					\
-	value = nvlist_takev_##type(nvl, namefmt, nameap);		\
-	va_end(nameap);							\
-									\
-	return (value);							\
-}
-
-NVLIST_TAKEF(nvpair_t *, nvpair)
-NVLIST_TAKEF(bool, bool)
-NVLIST_TAKEF(uint64_t, number)
-NVLIST_TAKEF(char *, string)
-NVLIST_TAKEF(nvlist_t *, nvlist)
-NVLIST_TAKEF(int, descriptor)
-
-#undef	NVLIST_TAKEF
-
-void *
-nvlist_takef_binary(nvlist_t *nvl, size_t *sizep, const char *namefmt, ...)
-{
-	va_list nameap;
-	void *value;
-
-	va_start(nameap, namefmt);
-	value = nvlist_takev_binary(nvl, sizep, namefmt, nameap);
-	va_end(nameap);
-
-	return (value);
-}
-
-nvpair_t *
-nvlist_takev_nvpair(nvlist_t *nvl, const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-
-	nvp = nvlist_findv(nvl, NV_TYPE_NONE, namefmt, nameap);
-	if (nvp != NULL)
-		nvlist_remove_nvpair(nvl, nvp);
-	return (nvp);
-}
-
-#define	NVLIST_TAKEV(ftype, type, TYPE)					\
-ftype									\
-nvlist_takev_##type(nvlist_t *nvl, const char *namefmt, va_list nameap)	\
-{									\
-	va_list cnameap;						\
-	nvpair_t *nvp;							\
-	ftype value;							\
-									\
-	va_copy(cnameap, nameap);					\
-	nvp = nvlist_findv(nvl, NV_TYPE_##TYPE, namefmt, cnameap);	\
-	va_end(cnameap);						\
-	if (nvp == NULL)						\
-		nvlist_report_missing(NV_TYPE_##TYPE, namefmt, nameap);	\
-	value = (ftype)(intptr_t)nvpair_get_##type(nvp);		\
-	nvlist_remove_nvpair(nvl, nvp);					\
-	nvpair_free_structure(nvp);					\
-	return (value);							\
-}
-
-NVLIST_TAKEV(bool, bool, BOOL)
-NVLIST_TAKEV(uint64_t, number, NUMBER)
-NVLIST_TAKEV(char *, string, STRING)
-NVLIST_TAKEV(nvlist_t *, nvlist, NVLIST)
-NVLIST_TAKEV(int, descriptor, DESCRIPTOR)
-
-#undef	NVLIST_TAKEV
-
-void *
-nvlist_takev_binary(nvlist_t *nvl, size_t *sizep, const char *namefmt,
-    va_list nameap)
-{
-	va_list cnameap;
-	nvpair_t *nvp;
-	void *value;
-
-	va_copy(cnameap, nameap);
-	nvp = nvlist_findv(nvl, NV_TYPE_BINARY, namefmt, cnameap);
-	va_end(cnameap);
-	if (nvp == NULL)
-		nvlist_report_missing(NV_TYPE_BINARY, namefmt, nameap);
-
-	value = (void *)(intptr_t)nvpair_get_binary(nvp, sizep);
-	nvlist_remove_nvpair(nvl, nvp);
-	nvpair_free_structure(nvp);
-	return (value);
-}
-
-void
-nvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *nvp)
-{
-
-	NVLIST_ASSERT(nvl);
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
-
-	nvpair_remove(&nvl->nvl_head, nvp, nvl);
-}
-
-void
-nvlist_free(nvlist_t *nvl, const char *name)
-{
-
-	nvlist_freef(nvl, "%s", name);
-}
-
-#define	NVLIST_FREE(type)						\
-void									\
-nvlist_free_##type(nvlist_t *nvl, const char *name)			\
-{									\
-									\
-	nvlist_freef_##type(nvl, "%s", name);				\
-}
-
-NVLIST_FREE(null)
-NVLIST_FREE(bool)
-NVLIST_FREE(number)
-NVLIST_FREE(string)
-NVLIST_FREE(nvlist)
-NVLIST_FREE(descriptor)
-NVLIST_FREE(binary)
-
-#undef	NVLIST_FREE
-
-void
-nvlist_freef(nvlist_t *nvl, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_freev(nvl, namefmt, nameap);
-	va_end(nameap);
-}
-
-#define	NVLIST_FREEF(type)						\
-void									\
-nvlist_freef_##type(nvlist_t *nvl, const char *namefmt, ...)		\
-{									\
-	va_list nameap;							\
-									\
-	va_start(nameap, namefmt);					\
-	nvlist_freev_##type(nvl, namefmt, nameap);			\
-	va_end(nameap);							\
-}
-
-NVLIST_FREEF(null)
-NVLIST_FREEF(bool)
-NVLIST_FREEF(number)
-NVLIST_FREEF(string)
-NVLIST_FREEF(nvlist)
-NVLIST_FREEF(descriptor)
-NVLIST_FREEF(binary)
-
-#undef	NVLIST_FREEF
-
-void
-nvlist_freev(nvlist_t *nvl, const char *namefmt, va_list nameap)
-{
-
-	nvlist_freev_type(nvl, NV_TYPE_NONE, namefmt, nameap);
-}
-
-#define	NVLIST_FREEV(type, TYPE)					\
-void									\
-nvlist_freev_##type(nvlist_t *nvl, const char *namefmt, va_list nameap)	\
-{									\
-									\
-	nvlist_freev_type(nvl, NV_TYPE_##TYPE, namefmt, nameap);	\
-}
-
-NVLIST_FREEV(null, NULL)
-NVLIST_FREEV(bool, BOOL)
-NVLIST_FREEV(number, NUMBER)
-NVLIST_FREEV(string, STRING)
-NVLIST_FREEV(nvlist, NVLIST)
-NVLIST_FREEV(descriptor, DESCRIPTOR)
-NVLIST_FREEV(binary, BINARY)
-#undef	NVLIST_FREEV
-
-void
-nvlist_free_nvpair(nvlist_t *nvl, nvpair_t *nvp)
-{
-
-	NVLIST_ASSERT(nvl);
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
-
-	nvlist_remove_nvpair(nvl, nvp);
-	nvpair_free(nvp);
-}
diff --git a/lib/libnv/nvlist_impl.h b/lib/libnv/nvlist_impl.h
deleted file mode 100644
index ef32dea..0000000
--- a/lib/libnv/nvlist_impl.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*-
- * Copyright (c) 2013 The FreeBSD Foundation
- * All rights reserved.
- *
- * This software was developed by Pawel Jakub Dawidek under sponsorship from
- * the FreeBSD Foundation.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef	_NVLIST_IMPL_H_
-#define	_NVLIST_IMPL_H_
-
-#include <stdint.h>
-
-#include "nv.h"
-
-void *nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep);
-nvlist_t *nvlist_xunpack(const void *buf, size_t size, const int *fds,
-    size_t nfds);
-
-nvpair_t *nvlist_get_nvpair_parent(const nvlist_t *nvl);
-const unsigned char *nvlist_unpack_header(nvlist_t *nvl,
-    const unsigned char *ptr, size_t nfds, bool *isbep, size_t *leftp);
-
-#endif	/* !_NVLIST_IMPL_H_ */
diff --git a/lib/libnv/nvpair.c b/lib/libnv/nvpair.c
deleted file mode 100644
index 4f0bd72..0000000
--- a/lib/libnv/nvpair.c
+++ /dev/null
@@ -1,1282 +0,0 @@
-/*-
- * Copyright (c) 2009-2013 The FreeBSD Foundation
- * All rights reserved.
- *
- * This software was developed by Pawel Jakub Dawidek under sponsorship from
- * the FreeBSD Foundation.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/param.h>
-#include <sys/endian.h>
-#include <sys/queue.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#ifdef HAVE_PJDLOG
-#include <pjdlog.h>
-#endif
-
-#include "common_impl.h"
-#include "nv.h"
-#include "nv_impl.h"
-#include "nvlist_impl.h"
-#include "nvpair_impl.h"
-
-#ifndef	HAVE_PJDLOG
-#include <assert.h>
-#define	PJDLOG_ASSERT(...)		assert(__VA_ARGS__)
-#define	PJDLOG_RASSERT(expr, ...)	assert(expr)
-#define	PJDLOG_ABORT(...)		abort()
-#endif
-
-#define	NVPAIR_MAGIC	0x6e7670	/* "nvp" */
-struct nvpair {
-	int		 nvp_magic;
-	char		*nvp_name;
-	int		 nvp_type;
-	uint64_t	 nvp_data;
-	size_t		 nvp_datasize;
-	nvlist_t	*nvp_list;
-	TAILQ_ENTRY(nvpair) nvp_next;
-};
-
-#define	NVPAIR_ASSERT(nvp)	do {					\
-	PJDLOG_ASSERT((nvp) != NULL);					\
-	PJDLOG_ASSERT((nvp)->nvp_magic == NVPAIR_MAGIC);		\
-} while (0)
-
-struct nvpair_header {
-	uint8_t		nvph_type;
-	uint16_t	nvph_namesize;
-	uint64_t	nvph_datasize;
-} __packed;
-
-
-void
-nvpair_assert(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-}
-
-nvlist_t *
-nvpair_nvlist(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-
-	return (nvp->nvp_list);
-}
-
-nvpair_t *
-nvpair_next(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_list != NULL);
-
-	return (TAILQ_NEXT(nvp, nvp_next));
-}
-
-nvpair_t *
-nvpair_prev(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_list != NULL);
-
-	return (TAILQ_PREV(nvp, nvl_head, nvp_next));
-}
-
-void
-nvpair_insert(struct nvl_head *head, nvpair_t *nvp, nvlist_t *nvl)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_list == NULL);
-	PJDLOG_ASSERT(!nvlist_exists(nvl, nvpair_name(nvp)));
-
-	TAILQ_INSERT_TAIL(head, nvp, nvp_next);
-	nvp->nvp_list = nvl;
-}
-
-static void
-nvpair_remove_nvlist(nvpair_t *nvp)
-{
-	nvlist_t *nvl;
-
-	/* XXX: DECONST is bad, mkay? */
-	nvl = __DECONST(nvlist_t *, nvpair_get_nvlist(nvp));
-	PJDLOG_ASSERT(nvl != NULL);
-	nvlist_set_parent(nvl, NULL);
-}
-
-void
-nvpair_remove(struct nvl_head *head, nvpair_t *nvp, const nvlist_t *nvl)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_list == nvl);
-
-	if (nvpair_type(nvp) == NV_TYPE_NVLIST)
-		nvpair_remove_nvlist(nvp);
-
-	TAILQ_REMOVE(head, nvp, nvp_next);
-	nvp->nvp_list = NULL;
-}
-
-nvpair_t *
-nvpair_clone(const nvpair_t *nvp)
-{
-	nvpair_t *newnvp;
-	const char *name;
-	const void *data;
-	size_t datasize;
-
-	NVPAIR_ASSERT(nvp);
-
-	name = nvpair_name(nvp);
-
-	switch (nvpair_type(nvp)) {
-	case NV_TYPE_NULL:
-		newnvp = nvpair_create_null(name);
-		break;
-	case NV_TYPE_BOOL:
-		newnvp = nvpair_create_bool(name, nvpair_get_bool(nvp));
-		break;
-	case NV_TYPE_NUMBER:
-		newnvp = nvpair_create_number(name, nvpair_get_number(nvp));
-		break;
-	case NV_TYPE_STRING:
-		newnvp = nvpair_create_string(name, nvpair_get_string(nvp));
-		break;
-	case NV_TYPE_NVLIST:
-		newnvp = nvpair_create_nvlist(name, nvpair_get_nvlist(nvp));
-		break;
-	case NV_TYPE_DESCRIPTOR:
-		newnvp = nvpair_create_descriptor(name,
-		    nvpair_get_descriptor(nvp));
-		break;
-	case NV_TYPE_BINARY:
-		data = nvpair_get_binary(nvp, &datasize);
-		newnvp = nvpair_create_binary(name, data, datasize);
-		break;
-	default:
-		PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
-	}
-
-	return (newnvp);
-}
-
-size_t
-nvpair_header_size(void)
-{
-
-	return (sizeof(struct nvpair_header));
-}
-
-size_t
-nvpair_size(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-
-	return (nvp->nvp_datasize);
-}
-
-unsigned char *
-nvpair_pack_header(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
-{
-	struct nvpair_header nvphdr;
-	size_t namesize;
-
-	NVPAIR_ASSERT(nvp);
-
-	nvphdr.nvph_type = nvp->nvp_type;
-	namesize = strlen(nvp->nvp_name) + 1;
-	PJDLOG_ASSERT(namesize > 0 && namesize <= UINT16_MAX);
-	nvphdr.nvph_namesize = namesize;
-	nvphdr.nvph_datasize = nvp->nvp_datasize;
-	PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
-	memcpy(ptr, &nvphdr, sizeof(nvphdr));
-	ptr += sizeof(nvphdr);
-	*leftp -= sizeof(nvphdr);
-
-	PJDLOG_ASSERT(*leftp >= namesize);
-	memcpy(ptr, nvp->nvp_name, namesize);
-	ptr += namesize;
-	*leftp -= namesize;
-
-	return (ptr);
-}
-
-unsigned char *
-nvpair_pack_null(const nvpair_t *nvp, unsigned char *ptr,
-    size_t *leftp __unused)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
-
-	return (ptr);
-}
-
-unsigned char *
-nvpair_pack_bool(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
-{
-	uint8_t value;
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
-
-	value = (uint8_t)nvp->nvp_data;
-
-	PJDLOG_ASSERT(*leftp >= sizeof(value));
-	memcpy(ptr, &value, sizeof(value));
-	ptr += sizeof(value);
-	*leftp -= sizeof(value);
-
-	return (ptr);
-}
-
-unsigned char *
-nvpair_pack_number(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
-{
-	uint64_t value;
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
-
-	value = (uint64_t)nvp->nvp_data;
-
-	PJDLOG_ASSERT(*leftp >= sizeof(value));
-	memcpy(ptr, &value, sizeof(value));
-	ptr += sizeof(value);
-	*leftp -= sizeof(value);
-
-	return (ptr);
-}
-
-unsigned char *
-nvpair_pack_string(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
-
-	PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
-	memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
-	ptr += nvp->nvp_datasize;
-	*leftp -= nvp->nvp_datasize;
-
-	return (ptr);
-}
-
-unsigned char *
-nvpair_pack_nvlist_up(unsigned char *ptr, size_t *leftp)
-{
-	struct nvpair_header nvphdr;
-	size_t namesize;
-	const char *name = "";
-
-	namesize = 1;
-	nvphdr.nvph_type = NV_TYPE_NVLIST_UP;
-	nvphdr.nvph_namesize = namesize;
-	nvphdr.nvph_datasize = 0;
-	PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
-	memcpy(ptr, &nvphdr, sizeof(nvphdr));
-	ptr += sizeof(nvphdr);
-	*leftp -= sizeof(nvphdr);
-
-	PJDLOG_ASSERT(*leftp >= namesize);
-	memcpy(ptr, name, namesize);
-	ptr += namesize;
-	*leftp -= namesize;
-
-	return (ptr);
-}
-
-unsigned char *
-nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr, int64_t *fdidxp,
-    size_t *leftp)
-{
-	int64_t value;
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
-
-	value = (int64_t)nvp->nvp_data;
-	if (value != -1) {
-		/*
-		 * If there is a real descriptor here, we change its number
-		 * to position in the array of descriptors send via control
-		 * message.
-		 */
-		PJDLOG_ASSERT(fdidxp != NULL);
-
-		value = *fdidxp;
-		(*fdidxp)++;
-	}
-
-	PJDLOG_ASSERT(*leftp >= sizeof(value));
-	memcpy(ptr, &value, sizeof(value));
-	ptr += sizeof(value);
-	*leftp -= sizeof(value);
-
-	return (ptr);
-}
-
-unsigned char *
-nvpair_pack_binary(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
-
-	PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
-	memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
-	ptr += nvp->nvp_datasize;
-	*leftp -= nvp->nvp_datasize;
-
-	return (ptr);
-}
-
-void
-nvpair_init_datasize(nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-
-	if (nvp->nvp_type == NV_TYPE_NVLIST) {
-		if (nvp->nvp_data == 0) {
-			nvp->nvp_datasize = 0;
-		} else {
-			nvp->nvp_datasize =
-			    nvlist_size((const nvlist_t *)(intptr_t)nvp->nvp_data);
-		}
-	}
-}
-
-const unsigned char *
-nvpair_unpack_header(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
-    size_t *leftp)
-{
-	struct nvpair_header nvphdr;
-
-	if (*leftp < sizeof(nvphdr))
-		goto failed;
-
-	memcpy(&nvphdr, ptr, sizeof(nvphdr));
-	ptr += sizeof(nvphdr);
-	*leftp -= sizeof(nvphdr);
-
-#if NV_TYPE_FIRST > 0
-	if (nvphdr.nvph_type < NV_TYPE_FIRST)
-		goto failed;
-#endif
-	if (nvphdr.nvph_type > NV_TYPE_LAST &&
-	    nvphdr.nvph_type != NV_TYPE_NVLIST_UP) {
-		goto failed;
-	}
-
-#if BYTE_ORDER == BIG_ENDIAN
-	if (!isbe) {
-		nvphdr.nvph_namesize = le16toh(nvphdr.nvph_namesize);
-		nvphdr.nvph_datasize = le64toh(nvphdr.nvph_datasize);
-	}
-#else
-	if (isbe) {
-		nvphdr.nvph_namesize = be16toh(nvphdr.nvph_namesize);
-		nvphdr.nvph_datasize = be64toh(nvphdr.nvph_datasize);
-	}
-#endif
-
-	if (nvphdr.nvph_namesize > NV_NAME_MAX)
-		goto failed;
-	if (*leftp < nvphdr.nvph_namesize)
-		goto failed;
-	if (nvphdr.nvph_namesize < 1)
-		goto failed;
-	if (strnlen((const char *)ptr, nvphdr.nvph_namesize) !=
-	    (size_t)(nvphdr.nvph_namesize - 1)) {
-		goto failed;
-	}
-
-	memcpy(nvp->nvp_name, ptr, nvphdr.nvph_namesize);
-	ptr += nvphdr.nvph_namesize;
-	*leftp -= nvphdr.nvph_namesize;
-
-	if (*leftp < nvphdr.nvph_datasize)
-		goto failed;
-
-	nvp->nvp_type = nvphdr.nvph_type;
-	nvp->nvp_data = 0;
-	nvp->nvp_datasize = nvphdr.nvph_datasize;
-
-	return (ptr);
-failed:
-	errno = EINVAL;
-	return (NULL);
-}
-
-const unsigned char *
-nvpair_unpack_null(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
-    size_t *leftp __unused)
-{
-
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
-
-	if (nvp->nvp_datasize != 0) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	return (ptr);
-}
-
-const unsigned char *
-nvpair_unpack_bool(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
-    size_t *leftp)
-{
-	uint8_t value;
-
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
-
-	if (nvp->nvp_datasize != sizeof(value)) {
-		errno = EINVAL;
-		return (NULL);
-	}
-	if (*leftp < sizeof(value)) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	memcpy(&value, ptr, sizeof(value));
-	ptr += sizeof(value);
-	*leftp -= sizeof(value);
-
-	if (value != 0 && value != 1) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	nvp->nvp_data = (uint64_t)value;
-
-	return (ptr);
-}
-
-const unsigned char *
-nvpair_unpack_number(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
-     size_t *leftp)
-{
-
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
-
-	if (nvp->nvp_datasize != sizeof(uint64_t)) {
-		errno = EINVAL;
-		return (NULL);
-	}
-	if (*leftp < sizeof(uint64_t)) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	if (isbe)
-		nvp->nvp_data = be64dec(ptr);
-	else
-		nvp->nvp_data = le64dec(ptr);
-	ptr += sizeof(uint64_t);
-	*leftp -= sizeof(uint64_t);
-
-	return (ptr);
-}
-
-const unsigned char *
-nvpair_unpack_string(bool isbe __unused, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp)
-{
-
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
-
-	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	if (strnlen((const char *)ptr, nvp->nvp_datasize) !=
-	    nvp->nvp_datasize - 1) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	nvp->nvp_data = (uint64_t)(uintptr_t)strdup((const char *)ptr);
-	if (nvp->nvp_data == 0)
-		return (NULL);
-
-	ptr += nvp->nvp_datasize;
-	*leftp -= nvp->nvp_datasize;
-
-	return (ptr);
-}
-
-const unsigned char *
-nvpair_unpack_nvlist(bool isbe __unused, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp, size_t nfds, nvlist_t **child)
-{
-	nvlist_t *value;
-
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
-
-	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	value = nvlist_create(0);
-	if (value == NULL)
-		return (NULL);
-
-	ptr = nvlist_unpack_header(value, ptr, nfds, NULL, leftp);
-	if (ptr == NULL)
-		return (NULL);
-
-	nvp->nvp_data = (uint64_t)(uintptr_t)value;
-	*child = value;
-
-	return (ptr);
-}
-
-const unsigned char *
-nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
-    size_t *leftp, const int *fds, size_t nfds)
-{
-	int64_t idx;
-
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
-
-	if (nvp->nvp_datasize != sizeof(idx)) {
-		errno = EINVAL;
-		return (NULL);
-	}
-	if (*leftp < sizeof(idx)) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	if (isbe)
-		idx = be64dec(ptr);
-	else
-		idx = le64dec(ptr);
-
-	if (idx < 0) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	if ((size_t)idx >= nfds) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	nvp->nvp_data = (uint64_t)fds[idx];
-
-	ptr += sizeof(idx);
-	*leftp -= sizeof(idx);
-
-	return (ptr);
-}
-
-const unsigned char *
-nvpair_unpack_binary(bool isbe __unused, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp)
-{
-	void *value;
-
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
-
-	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	value = malloc(nvp->nvp_datasize);
-	if (value == NULL)
-		return (NULL);
-
-	memcpy(value, ptr, nvp->nvp_datasize);
-	ptr += nvp->nvp_datasize;
-	*leftp -= nvp->nvp_datasize;
-
-	nvp->nvp_data = (uint64_t)(uintptr_t)value;
-
-	return (ptr);
-}
-
-const unsigned char *
-nvpair_unpack(bool isbe, const unsigned char *ptr, size_t *leftp,
-    nvpair_t **nvpp)
-{
-	nvpair_t *nvp, *tmp;
-
-	nvp = calloc(1, sizeof(*nvp) + NV_NAME_MAX);
-	if (nvp == NULL)
-		return (NULL);
-	nvp->nvp_name = (char *)(nvp + 1);
-
-	ptr = nvpair_unpack_header(isbe, nvp, ptr, leftp);
-	if (ptr == NULL)
-		goto failed;
-	tmp = realloc(nvp, sizeof(*nvp) + strlen(nvp->nvp_name) + 1);
-	if (tmp == NULL)
-		goto failed;
-	nvp = tmp;
-
-	/* Update nvp_name after realloc(). */
-	nvp->nvp_name = (char *)(nvp + 1);
-	nvp->nvp_data = 0x00;
-	nvp->nvp_magic = NVPAIR_MAGIC;
-	*nvpp = nvp;
-	return (ptr);
-failed:
-	free(nvp);
-	return (NULL);
-}
-
-int
-nvpair_type(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-
-	return (nvp->nvp_type);
-}
-
-const char *
-nvpair_name(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-
-	return (nvp->nvp_name);
-}
-
-static nvpair_t *
-nvpair_allocv(int type, uint64_t data, size_t datasize, const char *namefmt,
-    va_list nameap)
-{
-	nvpair_t *nvp;
-	char *name;
-	int namelen;
-
-	PJDLOG_ASSERT(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST);
-
-	namelen = vasprintf(&name, namefmt, nameap);
-	if (namelen < 0)
-		return (NULL);
-
-	PJDLOG_ASSERT(namelen > 0);
-	if (namelen >= NV_NAME_MAX) {
-		free(name);
-		errno = ENAMETOOLONG;
-		return (NULL);
-	}
-
-	nvp = calloc(1, sizeof(*nvp) + namelen + 1);
-	if (nvp != NULL) {
-		nvp->nvp_name = (char *)(nvp + 1);
-		memcpy(nvp->nvp_name, name, namelen + 1);
-		nvp->nvp_type = type;
-		nvp->nvp_data = data;
-		nvp->nvp_datasize = datasize;
-		nvp->nvp_magic = NVPAIR_MAGIC;
-	}
-	free(name);
-
-	return (nvp);
-};
-
-nvpair_t *
-nvpair_create_null(const char *name)
-{
-
-	return (nvpair_createf_null("%s", name));
-}
-
-nvpair_t *
-nvpair_create_bool(const char *name, bool value)
-{
-
-	return (nvpair_createf_bool(value, "%s", name));
-}
-
-nvpair_t *
-nvpair_create_number(const char *name, uint64_t value)
-{
-
-	return (nvpair_createf_number(value, "%s", name));
-}
-
-nvpair_t *
-nvpair_create_string(const char *name, const char *value)
-{
-
-	return (nvpair_createf_string(value, "%s", name));
-}
-
-nvpair_t *
-nvpair_create_stringf(const char *name, const char *valuefmt, ...)
-{
-	va_list valueap;
-	nvpair_t *nvp;
-
-	va_start(valueap, valuefmt);
-	nvp = nvpair_create_stringv(name, valuefmt, valueap);
-	va_end(valueap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_create_stringv(const char *name, const char *valuefmt, va_list valueap)
-{
-	nvpair_t *nvp;
-	char *str;
-	int len;
-
-	len = vasprintf(&str, valuefmt, valueap);
-	if (len < 0)
-		return (NULL);
-	nvp = nvpair_create_string(name, str);
-	if (nvp == NULL)
-		free(str);
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_create_nvlist(const char *name, const nvlist_t *value)
-{
-
-	return (nvpair_createf_nvlist(value, "%s", name));
-}
-
-nvpair_t *
-nvpair_create_descriptor(const char *name, int value)
-{
-
-	return (nvpair_createf_descriptor(value, "%s", name));
-}
-
-nvpair_t *
-nvpair_create_binary(const char *name, const void *value, size_t size)
-{
-
-	return (nvpair_createf_binary(value, size, "%s", name));
-}
-
-nvpair_t *
-nvpair_createf_null(const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_null(namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createf_bool(bool value, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_bool(value, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createf_number(uint64_t value, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_number(value, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createf_string(const char *value, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_string(value, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createf_nvlist(const nvlist_t *value, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_nvlist(value, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createf_descriptor(int value, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_descriptor(value, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createf_binary(const void *value, size_t size, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_binary(value, size, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createv_null(const char *namefmt, va_list nameap)
-{
-
-	return (nvpair_allocv(NV_TYPE_NULL, 0, 0, namefmt, nameap));
-}
-
-nvpair_t *
-nvpair_createv_bool(bool value, const char *namefmt, va_list nameap)
-{
-
-	return (nvpair_allocv(NV_TYPE_BOOL, value ? 1 : 0, sizeof(uint8_t),
-	    namefmt, nameap));
-}
-
-nvpair_t *
-nvpair_createv_number(uint64_t value, const char *namefmt, va_list nameap)
-{
-
-	return (nvpair_allocv(NV_TYPE_NUMBER, value, sizeof(value), namefmt,
-	    nameap));
-}
-
-nvpair_t *
-nvpair_createv_string(const char *value, const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-	size_t size;
-	char *data;
-
-	if (value == NULL) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	data = strdup(value);
-	if (data == NULL)
-		return (NULL);
-	size = strlen(value) + 1;
-
-	nvp = nvpair_allocv(NV_TYPE_STRING, (uint64_t)(uintptr_t)data, size,
-	    namefmt, nameap);
-	if (nvp == NULL)
-		free(data);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createv_nvlist(const nvlist_t *value, const char *namefmt,
-    va_list nameap)
-{
-	nvlist_t *nvl;
-	nvpair_t *nvp;
-
-	if (value == NULL) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	nvl = nvlist_clone(value);
-	if (nvl == NULL)
-		return (NULL);
-
-	nvp = nvpair_allocv(NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0,
-	    namefmt, nameap);
-	if (nvp == NULL)
-		nvlist_destroy(nvl);
-	else
-		nvlist_set_parent(nvl, nvp);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createv_descriptor(int value, const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (value < 0 || !fd_is_valid(value)) {
-		errno = EBADF;
-		return (NULL);
-	}
-
-	value = fcntl(value, F_DUPFD_CLOEXEC, 0);
-	if (value < 0)
-		return (NULL);
-
-	nvp = nvpair_allocv(NV_TYPE_DESCRIPTOR, (uint64_t)value,
-	    sizeof(int64_t), namefmt, nameap);
-	if (nvp == NULL)
-		close(value);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_createv_binary(const void *value, size_t size, const char *namefmt,
-    va_list nameap)
-{
-	nvpair_t *nvp;
-	void *data;
-
-	if (value == NULL || size == 0) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	data = malloc(size);
-	if (data == NULL)
-		return (NULL);
-	memcpy(data, value, size);
-
-	nvp = nvpair_allocv(NV_TYPE_BINARY, (uint64_t)(uintptr_t)data, size,
-	    namefmt, nameap);
-	if (nvp == NULL)
-		free(data);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_move_string(const char *name, char *value)
-{
-
-	return (nvpair_movef_string(value, "%s", name));
-}
-
-nvpair_t *
-nvpair_move_nvlist(const char *name, nvlist_t *value)
-{
-
-	return (nvpair_movef_nvlist(value, "%s", name));
-}
-
-nvpair_t *
-nvpair_move_descriptor(const char *name, int value)
-{
-
-	return (nvpair_movef_descriptor(value, "%s", name));
-}
-
-nvpair_t *
-nvpair_move_binary(const char *name, void *value, size_t size)
-{
-
-	return (nvpair_movef_binary(value, size, "%s", name));
-}
-
-nvpair_t *
-nvpair_movef_string(char *value, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_movev_string(value, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_movef_nvlist(nvlist_t *value, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_movev_nvlist(value, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_movef_descriptor(int value, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_movev_descriptor(value, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_movef_binary(void *value, size_t size, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
-
-	va_start(nameap, namefmt);
-	nvp = nvpair_movev_binary(value, size, namefmt, nameap);
-	va_end(nameap);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_movev_string(char *value, const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (value == NULL) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	nvp = nvpair_allocv(NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
-	    strlen(value) + 1, namefmt, nameap);
-	if (nvp == NULL)
-		free(value);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_movev_nvlist(nvlist_t *value, const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
-
-	if (value == NULL || nvlist_get_nvpair_parent(value) != NULL) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	nvp = nvpair_allocv(NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value, 0,
-	    namefmt, nameap);
-	if (nvp == NULL)
-		nvlist_destroy(value);
-	else
-		nvlist_set_parent(value, nvp);
-
-	return (nvp);
-}
-
-nvpair_t *
-nvpair_movev_descriptor(int value, const char *namefmt, va_list nameap)
-{
-
-	if (value < 0 || !fd_is_valid(value)) {
-		errno = EBADF;
-		return (NULL);
-	}
-
-	return (nvpair_allocv(NV_TYPE_DESCRIPTOR, (uint64_t)value,
-	    sizeof(int64_t), namefmt, nameap));
-}
-
-nvpair_t *
-nvpair_movev_binary(void *value, size_t size, const char *namefmt,
-    va_list nameap)
-{
-
-	if (value == NULL || size == 0) {
-		errno = EINVAL;
-		return (NULL);
-	}
-
-	return (nvpair_allocv(NV_TYPE_BINARY, (uint64_t)(uintptr_t)value, size,
-	    namefmt, nameap));
-}
-
-bool
-nvpair_get_bool(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-
-	return (nvp->nvp_data == 1);
-}
-
-uint64_t
-nvpair_get_number(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-
-	return (nvp->nvp_data);
-}
-
-const char *
-nvpair_get_string(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
-
-	return ((const char *)(intptr_t)nvp->nvp_data);
-}
-
-const nvlist_t *
-nvpair_get_nvlist(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
-
-	return ((const nvlist_t *)(intptr_t)nvp->nvp_data);
-}
-
-int
-nvpair_get_descriptor(const nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
-
-	return ((int)nvp->nvp_data);
-}
-
-const void *
-nvpair_get_binary(const nvpair_t *nvp, size_t *sizep)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
-
-	if (sizep != NULL)
-		*sizep = nvp->nvp_datasize;
-	return ((const void *)(intptr_t)nvp->nvp_data);
-}
-
-void
-nvpair_free(nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_list == NULL);
-
-	nvp->nvp_magic = 0;
-	switch (nvp->nvp_type) {
-	case NV_TYPE_DESCRIPTOR:
-		close((int)nvp->nvp_data);
-		break;
-	case NV_TYPE_NVLIST:
-		nvlist_destroy((nvlist_t *)(intptr_t)nvp->nvp_data);
-		break;
-	case NV_TYPE_STRING:
-		free((char *)(intptr_t)nvp->nvp_data);
-		break;
-	case NV_TYPE_BINARY:
-		free((void *)(intptr_t)nvp->nvp_data);
-		break;
-	}
-	free(nvp);
-}
-
-void
-nvpair_free_structure(nvpair_t *nvp)
-{
-
-	NVPAIR_ASSERT(nvp);
-	PJDLOG_ASSERT(nvp->nvp_list == NULL);
-
-	nvp->nvp_magic = 0;
-	free(nvp);
-}
-
-const char *
-nvpair_type_string(int type)
-{
-
-	switch (type) {
-	case NV_TYPE_NULL:
-		return ("NULL");
-	case NV_TYPE_BOOL:
-		return ("BOOL");
-	case NV_TYPE_NUMBER:
-		return ("NUMBER");
-	case NV_TYPE_STRING:
-		return ("STRING");
-	case NV_TYPE_NVLIST:
-		return ("NVLIST");
-	case NV_TYPE_DESCRIPTOR:
-		return ("DESCRIPTOR");
-	case NV_TYPE_BINARY:
-		return ("BINARY");
-	default:
-		return ("<UNKNOWN>");
-	}
-}
diff --git a/lib/libnv/nvpair_impl.h b/lib/libnv/nvpair_impl.h
deleted file mode 100644
index a72000b..0000000
--- a/lib/libnv/nvpair_impl.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*-
- * Copyright (c) 2009-2013 The FreeBSD Foundation
- * All rights reserved.
- *
- * This software was developed by Pawel Jakub Dawidek under sponsorship from
- * the FreeBSD Foundation.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef	_NVPAIR_IMPL_H_
-#define	_NVPAIR_IMPL_H_
-
-#include <sys/queue.h>
-
-#include <stdint.h>
-
-#include "nv.h"
-
-TAILQ_HEAD(nvl_head, nvpair);
-
-void nvpair_assert(const nvpair_t *nvp);
-nvlist_t *nvpair_nvlist(const nvpair_t *nvp);
-nvpair_t *nvpair_next(const nvpair_t *nvp);
-nvpair_t *nvpair_prev(const nvpair_t *nvp);
-void nvpair_insert(struct nvl_head *head, nvpair_t *nvp, nvlist_t *nvl);
-void nvpair_remove(struct nvl_head *head, nvpair_t *nvp, const nvlist_t *nvl);
-size_t nvpair_header_size(void);
-size_t nvpair_size(const nvpair_t *nvp);
-const unsigned char *nvpair_unpack(bool isbe, const unsigned char *ptr,
-    size_t *leftp, nvpair_t **nvpp);
-void nvpair_free_structure(nvpair_t *nvp);
-void nvpair_init_datasize(nvpair_t *nvp);
-const char *nvpair_type_string(int type);
-
-/* Pack functions. */
-unsigned char *nvpair_pack_header(const nvpair_t *nvp, unsigned char *ptr,
-    size_t *leftp);
-unsigned char *nvpair_pack_null(const nvpair_t *nvp, unsigned char *ptr,
-    size_t *leftp);
-unsigned char *nvpair_pack_bool(const nvpair_t *nvp, unsigned char *ptr,
-    size_t *leftp);
-unsigned char *nvpair_pack_number(const nvpair_t *nvp, unsigned char *ptr,
-    size_t *leftp);
-unsigned char *nvpair_pack_string(const nvpair_t *nvp, unsigned char *ptr,
-    size_t *leftp);
-unsigned char *nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr,
-    int64_t *fdidxp, size_t *leftp);
-unsigned char *nvpair_pack_binary(const nvpair_t *nvp, unsigned char *ptr,
-    size_t *leftp);
-unsigned char *nvpair_pack_nvlist_up(unsigned char *ptr, size_t *leftp);
-
-/* Unpack data functions. */
-const unsigned char *nvpair_unpack_header(bool isbe, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp);
-const unsigned char *nvpair_unpack_null(bool isbe, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp);
-const unsigned char *nvpair_unpack_bool(bool isbe, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp);
-const unsigned char *nvpair_unpack_number(bool isbe, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp);
-const unsigned char *nvpair_unpack_string(bool isbe, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp);
-const unsigned char *nvpair_unpack_nvlist(bool isbe, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp, size_t nvlist, nvlist_t **child);
-const unsigned char *nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp, const int *fds, size_t nfds);
-const unsigned char *nvpair_unpack_binary(bool isbe, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp);
-
-#endif	/* !_NVPAIR_IMPL_H_ */
diff --git a/lib/libnv/tests/Makefile b/lib/libnv/tests/Makefile
index df10549..7fc8d91 100644
--- a/lib/libnv/tests/Makefile
+++ b/lib/libnv/tests/Makefile
@@ -2,6 +2,10 @@
 
 TESTSDIR=	${TESTSBASE}/lib/libnv
 
+ATF_TESTS_CXX=	\
+	dnv_tests \
+	nv_tests \
+
 TAP_TESTS_C+=	nvlist_add_test
 TAP_TESTS_C+=	nvlist_exists_test
 TAP_TESTS_C+=	nvlist_free_test
@@ -9,9 +13,8 @@ TAP_TESTS_C+=	nvlist_get_test
 TAP_TESTS_C+=	nvlist_move_test
 TAP_TESTS_C+=	nvlist_send_recv_test
 
-DPADD+=		${LIBNV}
-LDADD+=		-lnv
+LIBADD+=	nv
 
-WARNS?=		6
+WARNS?=		3
 
 .include <bsd.test.mk>
diff --git a/lib/libnv/tests/dnv_tests.cc b/lib/libnv/tests/dnv_tests.cc
new file mode 100644
index 0000000..2f92d9d
--- /dev/null
+++ b/lib/libnv/tests/dnv_tests.cc
@@ -0,0 +1,567 @@
+/*-
+ * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <atf-c++.hpp>
+#include <dnv.h>
+#include <nv.h>
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_bool__present);
+ATF_TEST_CASE_BODY(dnvlist_get_bool__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	bool value;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = true;
+	nvlist_add_bool(nvl, key, value);
+
+	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, key, false), value);
+	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, "name", false), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_bool__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_bool__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	key = "123";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, key, false), false);
+	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, "123", true), true);
+
+	nvlist_add_bool(nvl, key, true);
+
+	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, "otherkey", true), true);
+	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, "12c", false), false);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_number__present);
+ATF_TEST_CASE_BODY(dnvlist_get_number__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	uint64_t value;
+
+	nvl = nvlist_create(0);
+
+	key = "key";
+	value = 48952;
+	nvlist_add_number(nvl, key, value);
+
+	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, key, 19), value);
+	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, "key", 65), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_number__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_number__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	key = "123";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, key, 5), 5);
+	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, "1234", 5), 5);
+
+	nvlist_add_number(nvl, key, 24841);
+
+	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, "1234", 5641), 5641);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_string__present);
+ATF_TEST_CASE_BODY(dnvlist_get_string__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	const char *value, *actual_value;
+
+	nvl = nvlist_create(0);
+
+	key = "string";
+	value = "fjdojfdi";
+	nvlist_add_string(nvl, key, value);
+
+	ATF_REQUIRE_EQ(strcmp(dnvlist_get_string(nvl, key, "g"), value), 0);
+
+	actual_value = dnvlist_get_string(nvl, key, "rs");
+	ATF_REQUIRE_EQ(strcmp(actual_value, value), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_string__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_string__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+	const char *actual_value;
+
+	key = "123";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(strcmp(dnvlist_get_string(nvl, key, "bar"), "bar"), 0);
+
+	actual_value = dnvlist_get_string(nvl, key, "d");
+	ATF_REQUIRE_EQ(strcmp(actual_value, "d"), 0);
+
+	nvlist_add_string(nvl, key, "cxhweh");
+
+	ATF_REQUIRE_EQ(strcmp(dnvlist_get_string(nvl, "hthth", "fd"), "fd"), 0);
+	actual_value = dnvlist_get_string(nvl, "5", "5");
+	ATF_REQUIRE_EQ(strcmp("5", "5"), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_nvlist__present);
+ATF_TEST_CASE_BODY(dnvlist_get_nvlist__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	nvlist_t *value;
+	const nvlist_t *actual_value;
+
+	nvl = nvlist_create(0);
+
+	key = "nvlist";
+	value = nvlist_create(0);
+	nvlist_move_nvlist(nvl, key, value);
+
+	actual_value = dnvlist_get_nvlist(nvl, key, NULL);
+	ATF_REQUIRE(actual_value != NULL);
+	ATF_REQUIRE(nvlist_empty(actual_value));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_nvlist__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_nvlist__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+	nvlist_t *dummy;
+
+	key = "123";
+	nvl = nvlist_create(0);
+	dummy = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_get_nvlist(nvl, key, dummy), dummy);
+
+	nvlist_move_nvlist(nvl, key, nvlist_create(0));
+	ATF_REQUIRE_EQ(dnvlist_get_nvlist(nvl, "456", dummy), dummy);
+	ATF_REQUIRE_EQ(dnvlist_get_nvlist(nvl, "gh", dummy), dummy);
+
+	nvlist_destroy(nvl);
+}
+
+static void
+set_const_binary_value(const void *&value, size_t &size, const char *str)
+{
+
+	value = str;
+	size = strlen(str) + 1; /* +1 to include '\0' */
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_binary__present);
+ATF_TEST_CASE_BODY(dnvlist_get_binary__present)
+{
+	nvlist_t *nvl;
+	const char *k;
+	const void *value, *actual_value;
+	size_t value_size, actual_size;
+
+	nvl = nvlist_create(0);
+
+	k = "binary";
+	set_const_binary_value(value, value_size, "fjdojfdi");
+	nvlist_add_binary(nvl, k, value, value_size);
+
+	actual_value = dnvlist_get_binary(nvl, k, &actual_size, "g", 1);
+	ATF_REQUIRE_EQ(value_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, value, actual_size), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_binary__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_binary__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+	const void *default_value, *actual_value;
+	size_t default_size, actual_size;
+
+	key = "123";
+	nvl = nvlist_create(0);
+
+	set_const_binary_value(default_value, default_size, "bar");
+	actual_value = dnvlist_get_binary(nvl, key, &actual_size, default_value,
+	    default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
+
+	set_const_binary_value(default_value, default_size, "atf");
+	actual_value = dnvlist_get_binary(nvl, key, &actual_size, default_value,
+	    default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
+
+	nvlist_add_binary(nvl, key, "test", 4);
+
+	set_const_binary_value(default_value, default_size, "bthrg");
+	actual_value = dnvlist_get_binary(nvl, "k", &actual_size, default_value,
+	    default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
+
+	set_const_binary_value(default_value, default_size,
+	     "rrhgrythtyrtgbrhgrtdsvdfbtjlkul");
+	actual_value = dnvlist_get_binary(nvl, "s", &actual_size, default_value,
+	    default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_bool__present);
+ATF_TEST_CASE_BODY(dnvlist_take_bool__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	bool value;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = true;
+	nvlist_add_bool(nvl, key, value);
+
+	ATF_REQUIRE_EQ(dnvlist_take_bool(nvl, key, false), value);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_bool__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_bool__empty)
+{
+	nvlist_t *nvl;
+
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_take_bool(nvl, "123", false), false);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_bool__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_bool__default_value)
+{
+	nvlist_t *nvl;
+
+	nvl = nvlist_create(0);
+	nvlist_add_bool(nvl, "key", true);
+
+	ATF_REQUIRE_EQ(dnvlist_take_bool(nvl, "otherkey", true), true);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_number__present);
+ATF_TEST_CASE_BODY(dnvlist_take_number__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	uint64_t value;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = 194154;
+	nvlist_add_number(nvl, key, value);
+
+	ATF_REQUIRE_EQ(dnvlist_take_number(nvl, key, 2), value);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_number__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_number__empty)
+{
+	nvlist_t *nvl;
+
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_take_number(nvl, "123", 126484), 126484);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_number__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_number__default_value)
+{
+	nvlist_t *nvl;
+
+	nvl = nvlist_create(0);
+	nvlist_add_number(nvl, "key", 12);
+
+	ATF_REQUIRE_EQ(dnvlist_take_number(nvl, "otherkey", 13), 13);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_string__present);
+ATF_TEST_CASE_BODY(dnvlist_take_string__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	const char *value;
+	char *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = "wrowm";
+	default_val = strdup("default");
+	nvlist_add_string(nvl, key, value);
+
+	actual_val = dnvlist_take_string(nvl, key, default_val);
+	ATF_REQUIRE_EQ(strcmp(actual_val, value), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	free(actual_val);
+	free(default_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_string__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_string__empty)
+{
+	nvlist_t *nvl;
+	char *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+	default_val = strdup("");
+
+	actual_val = dnvlist_take_string(nvl, "123", default_val);
+	ATF_REQUIRE_EQ(strcmp(actual_val, default_val), 0);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_string__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_string__default_value)
+{
+	nvlist_t *nvl;
+	char *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+	nvlist_add_string(nvl, "key", "foobar");
+	default_val = strdup("other");
+
+	actual_val = dnvlist_take_string(nvl, "otherkey", default_val);
+	ATF_REQUIRE_EQ(strcmp(actual_val, default_val), 0);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_nvlist__present);
+ATF_TEST_CASE_BODY(dnvlist_take_nvlist__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	nvlist_t *value, *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = nvlist_create(0);
+	default_val = nvlist_create(0);
+	nvlist_move_nvlist(nvl, key, value);
+
+	actual_val = dnvlist_take_nvlist(nvl, key, default_val);
+	ATF_REQUIRE_EQ(actual_val, value);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	free(actual_val);
+	free(default_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_nvlist__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_nvlist__empty)
+{
+	nvlist_t *nvl, *actual_val;
+
+	nvl = nvlist_create(0);
+
+	actual_val = dnvlist_take_nvlist(nvl, "123", NULL);
+	ATF_REQUIRE_EQ(actual_val, static_cast<nvlist_t *>(NULL));
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_nvlist__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_nvlist__default_value)
+{
+	nvlist_t *nvl;
+	nvlist_t *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+	nvlist_move_nvlist(nvl, "key", nvlist_create(0));
+	default_val = nvlist_create(0);
+
+	actual_val = dnvlist_take_nvlist(nvl, "otherkey", default_val);
+	ATF_REQUIRE_EQ(actual_val, default_val);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+static void
+set_binary_value(void *&value, size_t &size, const char *str)
+{
+
+	value = strdup(str);
+	size = strlen(str) + 1; /* +1 to include '\0' */
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_binary__present);
+ATF_TEST_CASE_BODY(dnvlist_take_binary__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	void *value, *default_val, *actual_val;
+	size_t value_size, default_size, actual_size;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	set_binary_value(value, value_size, "fkdojvmo908");
+	set_binary_value(default_val, default_size, "16546");
+	nvlist_add_binary(nvl, key, value, value_size);
+
+	actual_val = dnvlist_take_binary(nvl, key, &actual_size, default_val,
+	    default_size);
+	ATF_REQUIRE_EQ(value_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_val, value, value_size), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	free(actual_val);
+	free(default_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_binary__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_binary__empty)
+{
+	nvlist_t *nvl;
+	void *default_val, *actual_val;
+	size_t default_size, actual_size;
+
+	nvl = nvlist_create(0);
+	set_binary_value(default_val, default_size, "\xa8\x89\x49\xff\xe2\x08");
+
+	actual_val = dnvlist_take_binary(nvl, "123", &actual_size, default_val,
+	    default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_val, default_val, actual_size), 0);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_binary__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_binary__default_value)
+{
+	nvlist_t *nvl;
+	void *default_val, *actual_val;
+	size_t default_size, actual_size;
+
+	nvl = nvlist_create(0);
+	nvlist_add_binary(nvl, "key", "foobar", 6);
+	set_binary_value(default_val, default_size, "vbhag");
+
+	actual_val = dnvlist_take_binary(nvl, "otherkey", &actual_size,
+	    default_val, default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_val, default_val, default_size), 0);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_INIT_TEST_CASES(tp)
+{
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_bool__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_bool__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_number__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_number__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_string__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_string__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_nvlist__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_nvlist__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_binary__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_binary__default_value);
+
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_bool__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_bool__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_bool__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_number__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_number__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_number__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_string__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_string__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_string__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_nvlist__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_nvlist__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_nvlist__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_binary__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_binary__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_binary__default_value);
+}
diff --git a/lib/libnv/tests/nv_tests.cc b/lib/libnv/tests/nv_tests.cc
new file mode 100644
index 0000000..d779190
--- /dev/null
+++ b/lib/libnv/tests/nv_tests.cc
@@ -0,0 +1,1275 @@
+/*-
+ * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <atf-c++.hpp>
+#include <nv.h>
+
+#include <errno.h>
+#include <limits>
+#include <set>
+#include <sstream>
+#include <string>
+
+/*
+ * Test that a newly created nvlist has no errors, and is empty.
+ */
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
+ATF_TEST_CASE_BODY(nvlist_create__is_empty)
+{
+	nvlist_t *nvl;
+	int type;
+	void *it;
+
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+
+	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	it = NULL;
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), static_cast<const char *>(NULL));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "key";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(nvl, key);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_exists_null(nvl, key));
+	ATF_REQUIRE(nvlist_exists_null(nvl, "key"));
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "name";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_bool(nvl, key, true);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_exists(nvl, "name"));
+	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
+	ATF_REQUIRE(nvlist_exists_bool(nvl, "name"));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	uint64_t value;
+	int type;
+
+	key = "foo123";
+	value = 71965;
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_number(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_exists(nvl, "foo123"));
+	ATF_REQUIRE(nvlist_exists_number(nvl, key));
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	const char *value;
+	int type;
+
+	key = "test";
+	value = "fgjdkgjdk";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_string(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_exists(nvl, "test"));
+	ATF_REQUIRE(nvlist_exists_string(nvl, key));
+	ATF_REQUIRE(nvlist_exists_string(nvl, "test"));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key, *subkey;
+	nvlist_t *sublist;
+	const nvlist_t *value;
+	int type;
+
+	key = "test";
+	subkey = "subkey";
+	sublist = nvlist_create(0);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(sublist, subkey);
+	nvlist_add_nvlist(nvl, key, sublist);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_exists(nvl, "test"));
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, "test"));
+
+	value = nvlist_get_nvlist(nvl, key);
+	ATF_REQUIRE(nvlist_exists_null(value, subkey));
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(sublist != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
+
+	nvlist_destroy(sublist);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__child_with_error);
+ATF_TEST_CASE_BODY(nvlist_add_nvlist__child_with_error)
+{
+	nvlist_t *nvl, *parent;
+
+	nvl = nvlist_create(0);
+	parent = nvlist_create(0);
+
+	nvlist_set_error(nvl, EBADF);
+	nvlist_add_nvlist(parent, "test", nvl);
+	ATF_REQUIRE_EQ(nvlist_error(parent), EBADF);
+
+	nvlist_destroy(nvl);
+	nvlist_destroy(parent);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	void *value;
+	const void *ret_value;
+	size_t value_size, ret_size;
+	int type;
+
+	key = "binary";
+	value_size = 13;
+	value = malloc(value_size);
+	memset(value, 0xa5, value_size);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_binary(nvl, key, value, value_size);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_exists(nvl, "binary"));
+	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
+	ATF_REQUIRE(nvlist_exists_binary(nvl, "binary"));
+
+	ret_value = nvlist_get_binary(nvl, key, &ret_size);
+	ATF_REQUIRE_EQ(value_size, ret_size);
+	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(value != ret_value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
+
+	nvlist_destroy(nvl);
+	free(value);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist)
+{
+	nvlist_t *nvl, *clone;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	clone = nvlist_clone(nvl);
+	ATF_REQUIRE(clone != NULL);
+	ATF_REQUIRE(clone != nvl);
+	ATF_REQUIRE(nvlist_empty(clone));
+
+	nvlist_destroy(clone);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist)
+{
+	nvlist_t *nvl, *clone;
+	const char *key;
+	void *it;
+	uint64_t value;
+	int type;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	value = 684874;
+	nvlist_add_number(nvl, key, value);
+
+	clone = nvlist_clone(nvl);
+	ATF_REQUIRE(clone != NULL);
+	ATF_REQUIRE(clone != nvl);
+	ATF_REQUIRE(nvlist_exists_number(clone, key));
+	ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), static_cast<const char *>(NULL));
+
+	nvlist_destroy(clone);
+	nvlist_destroy(nvl);
+}
+
+static const char * const test_subnvlist_key = "nvlist";
+
+static const char * const test_string_key = "string";
+static const char * const test_string_val = "59525";
+
+static nvlist_t*
+create_test_nvlist(void)
+{
+	nvlist_t *nvl, *sublist;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	sublist = nvlist_create(0);
+	ATF_REQUIRE(sublist != NULL);
+
+	nvlist_add_string(sublist, test_string_key, test_string_val);
+	nvlist_move_nvlist(nvl, test_subnvlist_key, sublist);
+
+	return (nvl);
+}
+
+static void
+verify_test_nvlist(const nvlist_t *nvl)
+{
+	void *it;
+	const nvlist_t *value;
+	int type;
+
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key));
+
+	value = nvlist_get_nvlist(nvl, test_subnvlist_key);
+
+	ATF_REQUIRE(nvlist_exists_string(value, test_string_key));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0);
+	ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val);
+
+	/* Iterate over both nvlists; ensure that each has only the one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it),
+	    test_string_key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), static_cast<const char *>(NULL));
+
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it),
+	    test_subnvlist_key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), static_cast<const char *>(NULL));
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist)
+{
+	nvlist_t *nvl, *clone;
+
+	nvl = create_test_nvlist();
+	clone = nvlist_clone(nvl);
+
+	ATF_REQUIRE(clone != NULL);
+	ATF_REQUIRE(clone != nvl);
+	verify_test_nvlist(clone);
+
+	nvlist_destroy(clone);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__error_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__error_nvlist)
+{
+	nvlist_t *nvl, *clone;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	nvlist_set_error(nvl, ENOMEM);
+
+	clone = nvlist_clone(nvl);
+	ATF_REQUIRE(clone == NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist);
+ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist)
+{
+	nvlist_t *nvl, *unpacked;
+	void *packed;
+	size_t packed_size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	packed = nvlist_pack(nvl, &packed_size);
+	ATF_REQUIRE(packed != NULL);
+
+	unpacked = nvlist_unpack(packed, packed_size, 0);
+	ATF_REQUIRE(unpacked != NULL);
+	ATF_REQUIRE(unpacked != nvl);
+	ATF_REQUIRE(nvlist_empty(unpacked));
+
+	nvlist_destroy(unpacked);
+	nvlist_destroy(nvl);
+	free(packed);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__flags_nvlist);
+ATF_TEST_CASE_BODY(nvlist_unpack__flags_nvlist)
+{
+	nvlist_t *nvl, *unpacked;
+	void *packed;
+	size_t packed_size;
+
+	nvl = nvlist_create(NV_FLAG_NO_UNIQUE);
+	ATF_REQUIRE(nvl != NULL);
+
+	nvlist_add_bool(nvl, "name", true);
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists_bool(nvl, "name"));
+
+	packed = nvlist_pack(nvl, &packed_size);
+	ATF_REQUIRE(packed != NULL);
+
+	unpacked = nvlist_unpack(packed, packed_size, 0);
+	ATF_REQUIRE(unpacked == NULL);
+
+	unpacked = nvlist_unpack(packed, packed_size, NV_FLAG_IGNORE_CASE);
+	ATF_REQUIRE(unpacked == NULL);
+
+	unpacked = nvlist_unpack(packed, packed_size, NV_FLAG_NO_UNIQUE);
+	ATF_REQUIRE(unpacked != NULL);
+	ATF_REQUIRE(unpacked != nvl);
+	ATF_REQUIRE(!nvlist_empty(unpacked));
+	ATF_REQUIRE(nvlist_exists_bool(unpacked, "name"));
+
+	nvlist_destroy(unpacked);
+	nvlist_destroy(nvl);
+	free(packed);
+}
+
+static void
+verify_null(const nvlist_t *nvl, int type)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
+}
+
+static void
+verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value);
+}
+
+static void
+verify_string(const nvlist_t *nvl, const char *name, int type,
+    const char * value)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0);
+}
+
+static void
+verify_nvlist(const nvlist_t *nvl, const char *name, int type)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	verify_test_nvlist(nvlist_get_nvlist(nvl, name));
+}
+
+static void
+verify_binary(const nvlist_t *nvl, const char *name, int type,
+    const void * value, size_t size)
+{
+	const void *actual_value;
+	size_t actual_size;
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
+	actual_value = nvlist_get_binary(nvl, name, &actual_size);
+	ATF_REQUIRE_EQ(size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values);
+ATF_TEST_CASE_BODY(nvlist_pack__multiple_values)
+{
+	std::ostringstream msg;
+	std::set<std::string> keys_seen;
+	nvlist_t *nvl, *unpacked, *nvvalue;
+	const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name;
+	int numvalue;
+	const char * strvalue;
+	void *binvalue, *packed, *it;
+	size_t binsize, packed_size;
+	int type;
+
+	nvl = nvlist_create(0);
+
+	nullkey = "null";
+	nvlist_add_null(nvl, nullkey);
+
+	numkey = "number";
+	numvalue = 939853984;
+	nvlist_add_number(nvl, numkey, numvalue);
+
+	strkey = "string";
+	strvalue = "jfieutijf";
+	nvlist_add_string(nvl, strkey, strvalue);
+
+	nvkey = "nvlist";
+	nvvalue = create_test_nvlist();
+	nvlist_move_nvlist(nvl, nvkey, nvvalue);
+
+	binkey = "binary";
+	binsize = 4;
+	binvalue = malloc(binsize);
+	memset(binvalue, 'b', binsize);
+	nvlist_move_binary(nvl, binkey, binvalue, binsize);
+
+	packed = nvlist_pack(nvl, &packed_size);
+	ATF_REQUIRE(packed != NULL);
+
+	unpacked = nvlist_unpack(packed, packed_size, 0);
+	ATF_REQUIRE(unpacked != 0);
+
+	it = NULL;
+	while ((name = nvlist_next(unpacked, &type, &it)) != NULL) {
+		/* Ensure that we see every key only once. */
+		ATF_REQUIRE_EQ(keys_seen.count(name), 0);
+
+		if (strcmp(name, nullkey) == 0)
+			verify_null(unpacked, type);
+		else if (strcmp(name, numkey) == 0)
+			verify_number(unpacked, name, type, numvalue);
+		else if (strcmp(name, strkey) == 0)
+			verify_string(unpacked, name, type, strvalue);
+		else if (strcmp(name, nvkey) == 0)
+			verify_nvlist(unpacked, name, type);
+		else if (strcmp(name, binkey) == 0)
+			verify_binary(unpacked, name, type, binvalue, binsize);
+		else {
+			msg << "Unexpected key :'" << name << "'";
+			ATF_FAIL(msg.str().c_str());
+		}
+
+		keys_seen.insert(name);
+	}
+
+	/* Ensure that we saw every key. */
+	ATF_REQUIRE_EQ(keys_seen.size(), 5);
+
+	nvlist_destroy(nvl);
+	nvlist_destroy(unpacked);
+	free(packed);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__error_nvlist);
+ATF_TEST_CASE_BODY(nvlist_pack__error_nvlist)
+{
+	nvlist_t *nvl;
+	void *packed;
+	size_t size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	nvlist_set_error(nvl, ENOMEM);
+
+	packed = nvlist_pack(nvl, &size);
+	ATF_REQUIRE(packed == NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key);
+ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key)
+{
+	nvlist_t *nvl, *unpacked;
+	const char *key1, *key2;
+	void *packed, *keypos;
+	size_t size, keylen;
+
+	nvl = nvlist_create(0);
+
+	key1 = "key1";
+	keylen = strlen(key1);
+	nvlist_add_number(nvl, key1, 5);
+
+	key2 = "key2";
+	ATF_REQUIRE_EQ(keylen, strlen(key2));
+	nvlist_add_number(nvl, key2, 10);
+
+	packed = nvlist_pack(nvl, &size);
+
+	/*
+	 * Mangle the packed nvlist by replacing key1 with key2, creating a
+	 * packed nvlist with a duplicate key.
+	 */
+	keypos = memmem(packed, size, key1, keylen);
+	ATF_REQUIRE(keypos != NULL);
+	memcpy(keypos, key2, keylen);
+
+	unpacked = nvlist_unpack(packed, size, 0);
+	ATF_REQUIRE(nvlist_error(unpacked) != 0);
+
+	free(packed);
+	nvlist_destroy(nvl);
+	nvlist_destroy(unpacked);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert);
+ATF_TEST_CASE_BODY(nvlist_move_string__single_insert)
+{
+	nvlist_t *nvl;
+	const char *key;
+	char *value;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	value = strdup("testval");
+	ATF_REQUIRE(value != NULL);
+
+	nvlist_move_string(nvl, key, value);
+	ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child);
+ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child)
+{
+	nvlist_t *parent;
+
+	parent = nvlist_create(0);
+
+	nvlist_move_nvlist(parent, "test", NULL);
+
+	ATF_REQUIRE(nvlist_error(parent) != 0);
+
+	nvlist_destroy(parent);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__child_with_error);
+ATF_TEST_CASE_BODY(nvlist_move_nvlist__child_with_error)
+{
+	nvlist_t *nvl, *parent;
+
+	nvl = nvlist_create(0);
+	parent = nvlist_create(0);
+
+	nvlist_set_error(nvl, EBADF);
+	nvlist_move_nvlist(parent, "test", nvl);
+	ATF_REQUIRE_EQ(nvlist_error(parent), EBADF);
+
+	nvlist_destroy(parent);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert);
+ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert)
+{
+	nvlist_t *nvl;
+	const char *key;
+	nvlist_t *value;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	value = nvlist_create(0);
+	ATF_REQUIRE(value != NULL);
+
+	nvlist_move_nvlist(nvl, key, value);
+	ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert);
+ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert)
+{
+	nvlist_t *nvl;
+	const char *key;
+	void *value;
+	size_t size, actual_size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	size = 73;
+	value = malloc(size);
+	ATF_REQUIRE(value != NULL);
+
+	nvlist_move_binary(nvl, key, value, size);
+	ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value);
+	ATF_REQUIRE_EQ(size, actual_size);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	bool testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "boolkey";
+	testval = false;
+	nvlist_add_bool(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	bool testval, otherval1;
+	nvlist_t *otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "boolkey";
+	testval = true;
+	nvlist_add_bool(nvl, testkey, testval);
+
+	otherkey1 = "key1";
+	otherval1 = false;
+	nvlist_add_bool(nvl, otherkey1, otherval1);
+
+	otherkey2 = "key2";
+	otherval2 = create_test_nvlist();
+	nvlist_move_nvlist(nvl, otherkey2, otherval2);
+
+	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
+
+	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1);
+
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2));
+	verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_number__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	uint64_t testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testval = std::numeric_limits<uint64_t>::max();
+	nvlist_add_number(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	uint64_t testval, otherval1;
+	const char *otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	otherkey1 = "key1";
+	otherval1 = 5;
+	nvlist_add_number(nvl, otherkey1, otherval1);
+
+	testkey = "numkey";
+	testval = 1654;
+	nvlist_add_number(nvl, testkey, testval);
+
+	otherkey2 = "key2";
+	otherval2 = "string";
+	nvlist_add_string(nvl, otherkey2, otherval2);
+
+	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
+
+	ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1));
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1);
+
+	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_string__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	const char *testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testval = "nvlist";
+	nvlist_add_string(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	const char *testval, *otherval1;
+	bool otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	otherkey1 = "key1";
+	otherval1 = "fjdifjdk";
+	nvlist_add_string(nvl, otherkey1, otherval1);
+
+	otherkey2 = "key2";
+	otherval2 = true;
+	nvlist_add_bool(nvl, otherkey2, otherval2);
+
+	testkey = "strkey";
+	testval = "1654";
+	nvlist_add_string(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
+
+	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0);
+
+	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	nvlist_t *testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testval = create_test_nvlist();
+	nvlist_move_nvlist(nvl, testkey, testval);
+
+	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	nvlist_t *testval, *otherval1;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "strkey";
+	testval = create_test_nvlist();
+	nvlist_move_nvlist(nvl, testkey, testval);
+
+	otherkey1 = "key1";
+	otherval1 = nvlist_create(0);
+	nvlist_move_nvlist(nvl, otherkey1, otherval1);
+
+	otherkey2 = "key2";
+	nvlist_add_null(nvl, otherkey2);
+
+	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
+
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1));
+	ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1)));
+
+	ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	void *testval;
+	const void *actual_val;
+	size_t testsize, actual_size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testsize = 457;
+	testval = malloc(testsize);
+	memset(testval, '5', testsize);
+	nvlist_move_binary(nvl, testkey, testval, testsize);
+
+	actual_val = nvlist_take_binary(nvl, testkey, &actual_size);
+	ATF_REQUIRE_EQ(testsize, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	const void *actual_value;
+	char testval[] = "gjiertj";
+	char otherval1[] = "fdreg";
+	size_t testsize, othersize, actual_size;
+	bool otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	otherkey1 = "key1";
+	othersize = sizeof(otherval1);
+	nvlist_add_binary(nvl, otherkey1, otherval1, othersize);
+
+	otherkey2 = "key2";
+	otherval2 = true;
+	nvlist_add_bool(nvl, otherkey2, otherval2);
+
+	testkey = "strkey";
+	testsize = sizeof(testval);
+	nvlist_add_binary(nvl, testkey, testval, testsize);
+
+	actual_value = nvlist_take_binary(nvl, testkey, &actual_size);
+	ATF_REQUIRE_EQ(testsize, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0);
+
+	ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1));
+	actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size);
+	ATF_REQUIRE_EQ(othersize, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0);
+
+	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null);
+ATF_TEST_CASE_BODY(nvlist_free__single_null)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_null(nvl, key);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool);
+ATF_TEST_CASE_BODY(nvlist_free__single_bool)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_bool(nvl, key, true);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number);
+ATF_TEST_CASE_BODY(nvlist_free__single_number)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_number(nvl, key, 584);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string);
+ATF_TEST_CASE_BODY(nvlist_free__single_string)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_string(nvl, key, "gjkfkjd");
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist);
+ATF_TEST_CASE_BODY(nvlist_free__single_nvlist)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_nvlist(nvl, key, nvlist_create(0));
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary);
+ATF_TEST_CASE_BODY(nvlist_free__single_binary)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_binary(nvl, key, "jgjgfd", 6);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null);
+ATF_TEST_CASE_BODY(nvlist_free_null__single_null)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_null(nvl, key);
+
+	nvlist_free_null(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool);
+ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_bool(nvl, key, true);
+
+	nvlist_free_bool(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number);
+ATF_TEST_CASE_BODY(nvlist_free_number__single_number)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_number(nvl, key, 584);
+
+	nvlist_free_number(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string);
+ATF_TEST_CASE_BODY(nvlist_free_string__single_string)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_string(nvl, key, "gjkfkjd");
+
+	nvlist_free_string(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist);
+ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_nvlist(nvl, key, nvlist_create(0));
+
+	nvlist_free_nvlist(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary);
+ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_binary(nvl, key, "jgjgfd", 6);
+
+	nvlist_free_binary(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_INIT_TEST_CASES(tp)
+{
+	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__child_with_error);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__error_nvlist);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values);
+	ATF_ADD_TEST_CASE(tp, nvlist_pack__error_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key);
+	ATF_ADD_TEST_CASE(tp, nvlist_unpack__flags_nvlist);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__child_with_error);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_null);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_number);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_string);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary);
+}
diff --git a/lib/libnv/tests/nvlist_send_recv_test.c b/lib/libnv/tests/nvlist_send_recv_test.c
index c751bf7..50222fb 100644
--- a/lib/libnv/tests/nvlist_send_recv_test.c
+++ b/lib/libnv/tests/nvlist_send_recv_test.c
@@ -58,8 +58,10 @@ static void
 child(int sock)
 {
 	nvlist_t *nvl;
+	nvlist_t *empty;
 
 	nvl = nvlist_create(0);
+	empty = nvlist_create(0);
 
 	nvlist_add_bool(nvl, "nvlist/bool/true", true);
 	nvlist_add_bool(nvl, "nvlist/bool/false", false);
@@ -75,6 +77,7 @@ child(int sock)
 	nvlist_add_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO", STDERR_FILENO);
 	nvlist_add_binary(nvl, "nvlist/binary/x", "x", 1);
 	nvlist_add_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz"));
+	nvlist_move_nvlist(nvl, "nvlist/nvlist/empty", empty);
 	nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
 
 	nvlist_send(sock, nvl);
@@ -86,13 +89,13 @@ static void
 parent(int sock)
 {
 	nvlist_t *nvl;
-	const nvlist_t *cnvl;
+	const nvlist_t *cnvl, *empty;
 	const char *name, *cname;
 	void *cookie, *ccookie;
 	int type, ctype;
 	size_t size;
 
-	nvl = nvlist_recv(sock);
+	nvl = nvlist_recv(sock, 0);
 	CHECK(nvlist_error(nvl) == 0);
 	if (nvlist_error(nvl) != 0)
 		err(1, "nvlist_recv() failed");
@@ -190,6 +193,13 @@ parent(int sock)
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_NVLIST);
+	CHECK(strcmp(name, "nvlist/nvlist/empty") == 0);
+	cnvl = nvlist_get_nvlist(nvl, name);
+	CHECK(nvlist_empty(cnvl));
+
+	name = nvlist_next(nvl, &type, &cookie);
+	CHECK(name != NULL);
+	CHECK(type == NV_TYPE_NVLIST);
 	CHECK(strcmp(name, "nvlist/nvlist") == 0);
 	cnvl = nvlist_get_nvlist(nvl, name);
 
@@ -284,6 +294,13 @@ parent(int sock)
 	CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
+	CHECK(cname != NULL);
+	CHECK(ctype == NV_TYPE_NVLIST);
+	CHECK(strcmp(cname, "nvlist/nvlist/empty") == 0);
+	empty = nvlist_get_nvlist(cnvl, cname);
+	CHECK(nvlist_empty(empty));
+
+	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname == NULL);
 
 	name = nvlist_next(nvl, &type, &cookie);
@@ -296,7 +313,7 @@ main(void)
 	int status, socks[2];
 	pid_t pid;
 
-	printf("1..126\n");
+	printf("1..134\n");
 	fflush(stdout);
 
 	if (socketpair(PF_UNIX, SOCK_STREAM, 0, socks) < 0)