Differential D1879 Diff 4039 head/lib/libnv/nvlist.c

Changeset View

Standalone View

head/lib/libnv/nvlist.c

Show First 20 Lines • Show All 202 Lines • ▼ Show 20 Lines	nvlist_empty(const nvlist_t *nvl)

NVLIST_ASSERT(nvl);		NVLIST_ASSERT(nvl);
PJDLOG_ASSERT(nvl->nvl_error == 0);		PJDLOG_ASSERT(nvl->nvl_error == 0);

return (nvlist_first_nvpair(nvl) == NULL);		return (nvlist_first_nvpair(nvl) == NULL);
}		}

static void		static void
nvlist_report_missing(int type, const char *namefmt, va_list nameap)		nvlist_report_missing(int type, const char *name)
{		{
char *name;

vasprintf(&name, namefmt, nameap);
PJDLOG_ABORT("Element '%s' of type %s doesn't exist.",		PJDLOG_ABORT("Element '%s' of type %s doesn't exist.",
name != NULL ? name : "N/A", nvpair_type_string(type));		name, nvpair_type_string(type));
}		}

static nvpair_t *		static nvpair_t *
nvlist_findv(const nvlist_t nvl, int type, const char namefmt, va_list nameap)		nvlist_find(const nvlist_t nvl, int type, const char name)
{		{
nvpair_t *nvp;		nvpair_t *nvp;
char *name;

NVLIST_ASSERT(nvl);		NVLIST_ASSERT(nvl);
PJDLOG_ASSERT(nvl->nvl_error == 0);		PJDLOG_ASSERT(nvl->nvl_error == 0);
PJDLOG_ASSERT(type == NV_TYPE_NONE \|\|		PJDLOG_ASSERT(type == NV_TYPE_NONE \|\|
(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));		(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));

if (vasprintf(&name, namefmt, nameap) < 0)
return (NULL);

for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;		for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
nvp = nvlist_next_nvpair(nvl, nvp)) {		nvp = nvlist_next_nvpair(nvl, nvp)) {
if (type != NV_TYPE_NONE && nvpair_type(nvp) != type)		if (type != NV_TYPE_NONE && nvpair_type(nvp) != type)
continue;		continue;
if ((nvl->nvl_flags & NV_FLAG_IGNORE_CASE) != 0) {		if ((nvl->nvl_flags & NV_FLAG_IGNORE_CASE) != 0) {
if (strcasecmp(nvpair_name(nvp), name) != 0)		if (strcasecmp(nvpair_name(nvp), name) != 0)
continue;		continue;
} else {		} else {
if (strcmp(nvpair_name(nvp), name) != 0)		if (strcmp(nvpair_name(nvp), name) != 0)
continue;		continue;
}		}
break;		break;
}		}

free(name);

if (nvp == NULL)		if (nvp == NULL)
errno = ENOENT;		errno = ENOENT;

return (nvp);		return (nvp);
}		}

bool		bool
nvlist_exists_type(const nvlist_t nvl, const char name, int type)		nvlist_exists_type(const nvlist_t nvl, const char name, int type)
{		{

return (nvlist_existsf_type(nvl, type, "%s", name));		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_find(nvl, type, name) != NULL);
}		}

bool		bool
nvlist_existsf_type(const nvlist_t nvl, int type, const char namefmt, ...)		nvlist_existsf_type(const nvlist_t nvl, int type, const char namefmt, ...)
{		{
va_list nameap;		va_list nameap;
bool ret;		bool ret;

va_start(nameap, namefmt);		va_start(nameap, namefmt);
ret = nvlist_existsv_type(nvl, type, namefmt, nameap);		ret = nvlist_existsv_type(nvl, type, namefmt, nameap);
va_end(nameap);		va_end(nameap);

return (ret);		return (ret);
}		}

bool		bool
nvlist_existsv_type(const nvlist_t nvl, int type, const char namefmt,		nvlist_existsv_type(const nvlist_t nvl, int type, const char namefmt,
va_list nameap)		va_list nameap)
{		{
		char *name;
		bool exists;

NVLIST_ASSERT(nvl);		vasprintf(&name, namefmt, nameap);
PJDLOG_ASSERT(nvl->nvl_error == 0);		if (name == NULL)
PJDLOG_ASSERT(type == NV_TYPE_NONE \|\|		return (false);
(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));

return (nvlist_findv(nvl, type, namefmt, nameap) != NULL);		exists = nvlist_exists_type(nvl, name, type);
		free(name);
		return (exists);
}		}

void		void
nvlist_free_type(nvlist_t nvl, const char name, int type)		nvlist_free_type(nvlist_t nvl, const char name, int type)
{		{
		nvpair_t *nvp;

nvlist_freef_type(nvl, type, "%s", name);		NVLIST_ASSERT(nvl);
		PJDLOG_ASSERT(nvl->nvl_error == 0);
		PJDLOG_ASSERT(type == NV_TYPE_NONE \|\|
		(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));

		nvp = nvlist_find(nvl, type, name);
		if (nvp != NULL)
		nvlist_free_nvpair(nvl, nvp);
		else
		nvlist_report_missing(type, name);
}		}

void		void
nvlist_freef_type(nvlist_t nvl, int type, const char namefmt, ...)		nvlist_freef_type(nvlist_t nvl, int type, const char namefmt, ...)
{		{
va_list nameap;		va_list nameap;

va_start(nameap, namefmt);		va_start(nameap, namefmt);
nvlist_freev_type(nvl, type, namefmt, nameap);		nvlist_freev_type(nvl, type, namefmt, nameap);
va_end(nameap);		va_end(nameap);
}		}

void		void
nvlist_freev_type(nvlist_t nvl, int type, const char namefmt, va_list nameap)		nvlist_freev_type(nvlist_t nvl, int type, const char namefmt, va_list nameap)
{		{
va_list cnameap;		char *name;
nvpair_t *nvp;

NVLIST_ASSERT(nvl);		vasprintf(&name, namefmt, nameap);
PJDLOG_ASSERT(nvl->nvl_error == 0);		if (name == NULL)
PJDLOG_ASSERT(type == NV_TYPE_NONE \|\|		nvlist_report_missing(type, "<unknown>");
(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));		nvlist_free_type(nvl, name, type);
		free(name);
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_t *
nvlist_clone(const nvlist_t *nvl)		nvlist_clone(const nvlist_t *nvl)
{		{
nvlist_t *newnvl;		nvlist_t *newnvl;
nvpair_t nvp, newnvp;		nvpair_t nvp, newnvp;

▲ Show 20 Lines • Show All 694 Lines • ▼ Show 20 Lines	nvlist_next(const nvlist_t nvl, int typep, void **cookiep)
*cookiep = nvp;		*cookiep = nvp;
return (nvpair_name(nvp));		return (nvpair_name(nvp));
}		}

bool		bool
nvlist_exists(const nvlist_t nvl, const char name)		nvlist_exists(const nvlist_t nvl, const char name)
{		{

return (nvlist_existsf(nvl, "%s", name));		return (nvlist_find(nvl, NV_TYPE_NONE, name) != NULL);
}		}

#define NVLIST_EXISTS(type) \		#define NVLIST_EXISTS(type, TYPE) \
bool \		bool \
nvlist_exists_##type(const nvlist_t nvl, const char name) \		nvlist_exists_##type(const nvlist_t nvl, const char name) \
{ \		{ \
\		\
return (nvlist_existsf_##type(nvl, "%s", name)); \		return (nvlist_find(nvl, NV_TYPE_##TYPE, name) != NULL); \
}		}

NVLIST_EXISTS(null)		NVLIST_EXISTS(null, NULL)
NVLIST_EXISTS(bool)		NVLIST_EXISTS(bool, BOOL)
NVLIST_EXISTS(number)		NVLIST_EXISTS(number, NUMBER)
NVLIST_EXISTS(string)		NVLIST_EXISTS(string, STRING)
NVLIST_EXISTS(nvlist)		NVLIST_EXISTS(nvlist, NVLIST)
NVLIST_EXISTS(descriptor)		NVLIST_EXISTS(descriptor, DESCRIPTOR)
NVLIST_EXISTS(binary)		NVLIST_EXISTS(binary, BINARY)

#undef NVLIST_EXISTS		#undef NVLIST_EXISTS

bool		bool
nvlist_existsf(const nvlist_t nvl, const char namefmt, ...)		nvlist_existsf(const nvlist_t nvl, const char namefmt, ...)
{		{
va_list nameap;		va_list nameap;
bool ret;		bool ret;
Show All 25 Lines
NVLIST_EXISTSF(descriptor)		NVLIST_EXISTSF(descriptor)
NVLIST_EXISTSF(binary)		NVLIST_EXISTSF(binary)

#undef NVLIST_EXISTSF		#undef NVLIST_EXISTSF

bool		bool
nvlist_existsv(const nvlist_t nvl, const char namefmt, va_list nameap)		nvlist_existsv(const nvlist_t nvl, const char namefmt, va_list nameap)
{		{
		char *name;
		bool exists;

return (nvlist_findv(nvl, NV_TYPE_NONE, namefmt, nameap) != NULL);		vasprintf(&name, namefmt, nameap);
		if (name == NULL)
		return (false);

		exists = nvlist_exists(nvl, name);
		free(name);
		return (exists);
}		}

#define NVLIST_EXISTSV(type, TYPE) \		#define NVLIST_EXISTSV(type) \
bool \		bool \
nvlist_existsv_##type(const nvlist_t nvl, const char namefmt, \		nvlist_existsv_##type(const nvlist_t nvl, const char namefmt, \
va_list nameap) \		va_list nameap) \
{ \		{ \
		char *name; \
		bool exists; \
\		\
return (nvlist_findv(nvl, NV_TYPE_##TYPE, namefmt, nameap) != \		vasprintf(&name, namefmt, nameap); \
NULL); \		if (name == NULL) \
		return (false); \
		exists = nvlist_exists_##type(nvl, name); \
		free(name); \
		return (exists); \
}		}

NVLIST_EXISTSV(null, NULL)		NVLIST_EXISTSV(null)
NVLIST_EXISTSV(bool, BOOL)		NVLIST_EXISTSV(bool)
NVLIST_EXISTSV(number, NUMBER)		NVLIST_EXISTSV(number)
NVLIST_EXISTSV(string, STRING)		NVLIST_EXISTSV(string)
NVLIST_EXISTSV(nvlist, NVLIST)		NVLIST_EXISTSV(nvlist)
NVLIST_EXISTSV(descriptor, DESCRIPTOR)		NVLIST_EXISTSV(descriptor)
NVLIST_EXISTSV(binary, BINARY)		NVLIST_EXISTSV(binary)

#undef NVLIST_EXISTSV		#undef NVLIST_EXISTSV

void		void
nvlist_add_nvpair(nvlist_t nvl, const nvpair_t nvp)		nvlist_add_nvpair(nvlist_t nvl, const nvpair_t nvp)
{		{
nvpair_t *newnvp;		nvpair_t *newnvp;

▲ Show 20 Lines • Show All 434 Lines • ▼ Show 20 Lines	nvlist_movev_binary(nvlist_t nvl, void value, size_t size,

nvp = nvpair_movev_binary(value, size, namefmt, nameap);		nvp = nvpair_movev_binary(value, size, namefmt, nameap);
if (nvp == NULL)		if (nvp == NULL)
nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
else		else
nvlist_move_nvpair(nvl, nvp);		nvlist_move_nvpair(nvl, nvp);
}		}

#define NVLIST_GET(ftype, type) \		const nvpair_t *
		nvlist_get_nvpair(const nvlist_t nvl, const char name)
		{

		return (nvlist_find(nvl, NV_TYPE_NONE, name));
		}

		#define NVLIST_GET(ftype, type, TYPE) \
ftype \		ftype \
nvlist_get_##type(const nvlist_t nvl, const char name) \		nvlist_get_##type(const nvlist_t nvl, const char name) \
{ \		{ \
		const nvpair_t *nvp; \
\		\
return (nvlist_getf_##type(nvl, "%s", name)); \		nvp = nvlist_find(nvl, NV_TYPE_##TYPE, name); \
		if (nvp == NULL) \
		nvlist_report_missing(NV_TYPE_##TYPE, name); \
		return (nvpair_get_##type(nvp)); \
}		}

NVLIST_GET(const nvpair_t *, nvpair)		NVLIST_GET(bool, bool, BOOL)
NVLIST_GET(bool, bool)		NVLIST_GET(uint64_t, number, NUMBER)
NVLIST_GET(uint64_t, number)		NVLIST_GET(const char *, string, STRING)
NVLIST_GET(const char *, string)		NVLIST_GET(const nvlist_t *, nvlist, NVLIST)
NVLIST_GET(const nvlist_t *, nvlist)		NVLIST_GET(int, descriptor, DESCRIPTOR)
NVLIST_GET(int, descriptor)

#undef NVLIST_GET		#undef NVLIST_GET

const void *		const void *
nvlist_get_binary(const nvlist_t nvl, const char name, size_t *sizep)		nvlist_get_binary(const nvlist_t nvl, const char name, size_t *sizep)
{		{
		nvpair_t *nvp;

return (nvlist_getf_binary(nvl, sizep, "%s", name));		nvp = nvlist_find(nvl, NV_TYPE_BINARY, name);
		if (nvp == NULL)
		nvlist_report_missing(NV_TYPE_BINARY, name);

		return (nvpair_get_binary(nvp, sizep));
}		}

#define NVLIST_GETF(ftype, type) \		#define NVLIST_GETF(ftype, type) \
ftype \		ftype \
nvlist_getf_##type(const nvlist_t nvl, const char namefmt, ...) \		nvlist_getf_##type(const nvlist_t nvl, const char namefmt, ...) \
{ \		{ \
va_list nameap; \		va_list nameap; \
ftype value; \		ftype value; \
\		\
va_start(nameap, namefmt); \		va_start(nameap, namefmt); \
value = nvlist_getv_##type(nvl, namefmt, nameap); \		value = nvlist_getv_##type(nvl, namefmt, nameap); \
va_end(nameap); \		va_end(nameap); \
\		\
return (value); \		return (value); \
}		}

NVLIST_GETF(const nvpair_t *, nvpair)
NVLIST_GETF(bool, bool)		NVLIST_GETF(bool, bool)
NVLIST_GETF(uint64_t, number)		NVLIST_GETF(uint64_t, number)
NVLIST_GETF(const char *, string)		NVLIST_GETF(const char *, string)
NVLIST_GETF(const nvlist_t *, nvlist)		NVLIST_GETF(const nvlist_t *, nvlist)
NVLIST_GETF(int, descriptor)		NVLIST_GETF(int, descriptor)

#undef NVLIST_GETF		#undef NVLIST_GETF

const void *		const void *
nvlist_getf_binary(const nvlist_t nvl, size_t sizep, const char *namefmt, ...)		nvlist_getf_binary(const nvlist_t nvl, size_t sizep, const char *namefmt, ...)
{		{
va_list nameap;		va_list nameap;
const void *value;		const void *value;

va_start(nameap, namefmt);		va_start(nameap, namefmt);
value = nvlist_getv_binary(nvl, sizep, namefmt, nameap);		value = nvlist_getv_binary(nvl, sizep, namefmt, nameap);
va_end(nameap);		va_end(nameap);

return (value);		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) \		#define NVLIST_GETV(ftype, type, TYPE) \
ftype \		ftype \
nvlist_getv_##type(const nvlist_t nvl, const char namefmt, \		nvlist_getv_##type(const nvlist_t nvl, const char namefmt, \
va_list nameap) \		va_list nameap) \
{ \		{ \
va_list cnameap; \		char *name; \
const nvpair_t *nvp; \		ftype value; \
\		\
va_copy(cnameap, nameap); \		vasprintf(&name, namefmt, nameap); \
nvp = nvlist_findv(nvl, NV_TYPE_##TYPE, namefmt, cnameap); \		if (name == NULL) \
va_end(cnameap); \		nvlist_report_missing(NV_TYPE_##TYPE, "<unknown>"); \
if (nvp == NULL) \		value = nvlist_get_##type(nvl, name); \
nvlist_report_missing(NV_TYPE_##TYPE, namefmt, nameap); \		free(name); \
return (nvpair_get_##type(nvp)); \		\
		return (value); \
}		}

NVLIST_GETV(bool, bool, BOOL)		NVLIST_GETV(bool, bool, BOOL)
NVLIST_GETV(uint64_t, number, NUMBER)		NVLIST_GETV(uint64_t, number, NUMBER)
NVLIST_GETV(const char *, string, STRING)		NVLIST_GETV(const char *, string, STRING)
NVLIST_GETV(const nvlist_t *, nvlist, NVLIST)		NVLIST_GETV(const nvlist_t *, nvlist, NVLIST)
NVLIST_GETV(int, descriptor, DESCRIPTOR)		NVLIST_GETV(int, descriptor, DESCRIPTOR)

#undef NVLIST_GETV		#undef NVLIST_GETV

const void *		const void *
nvlist_getv_binary(const nvlist_t nvl, size_t sizep, const char *namefmt,		nvlist_getv_binary(const nvlist_t nvl, size_t sizep, const char *namefmt,
va_list nameap)		va_list nameap)
{		{
va_list cnameap;		char *name;
const nvpair_t *nvp;		const void *binary;

va_copy(cnameap, nameap);		vasprintf(&name, namefmt, nameap);
nvp = nvlist_findv(nvl, NV_TYPE_BINARY, namefmt, cnameap);		if (name == NULL)
va_end(cnameap);		nvlist_report_missing(NV_TYPE_BINARY, "<unknown>");
if (nvp == NULL)
nvlist_report_missing(NV_TYPE_BINARY, namefmt, nameap);

return (nvpair_get_binary(nvp, sizep));		binary = nvlist_get_binary(nvl, name, sizep);
		free(name);
		return (binary);
}		}

#define NVLIST_TAKE(ftype, type) \		#define NVLIST_TAKE(ftype, type, TYPE) \
ftype \		ftype \
nvlist_take_##type(nvlist_t nvl, const char name) \		nvlist_take_##type(nvlist_t nvl, const char name) \
{ \		{ \
		nvpair_t *nvp; \
		ftype value; \
\		\
return (nvlist_takef_##type(nvl, "%s", name)); \		nvp = nvlist_find(nvl, NV_TYPE_##TYPE, name); \
		if (nvp == NULL) \
		nvlist_report_missing(NV_TYPE_##TYPE, name); \
		value = (ftype)(intptr_t)nvpair_get_##type(nvp); \
		nvlist_remove_nvpair(nvl, nvp); \
		nvpair_free_structure(nvp); \
		return (value); \
}		}

NVLIST_TAKE(nvpair_t *, nvpair)		NVLIST_TAKE(bool, bool, BOOL)
NVLIST_TAKE(bool, bool)		NVLIST_TAKE(uint64_t, number, NUMBER)
NVLIST_TAKE(uint64_t, number)		NVLIST_TAKE(char *, string, STRING)
NVLIST_TAKE(char *, string)		NVLIST_TAKE(nvlist_t *, nvlist, NVLIST)
NVLIST_TAKE(nvlist_t *, nvlist)		NVLIST_TAKE(int, descriptor, DESCRIPTOR)
NVLIST_TAKE(int, descriptor)

#undef NVLIST_TAKE		#undef NVLIST_TAKE

void *		void *
nvlist_take_binary(nvlist_t nvl, const char name, size_t *sizep)		nvlist_take_binary(nvlist_t nvl, const char name, size_t *sizep)
{		{
		nvpair_t *nvp;
		void *value;

return (nvlist_takef_binary(nvl, sizep, "%s", name));		nvp = nvlist_find(nvl, NV_TYPE_BINARY, name);
		if (nvp == NULL)
		nvlist_report_missing(NV_TYPE_BINARY, name);

		value = (void *)(intptr_t)nvpair_get_binary(nvp, sizep);
		nvlist_remove_nvpair(nvl, nvp);
		nvpair_free_structure(nvp);
		return (value);
}		}

#define NVLIST_TAKEF(ftype, type) \		#define NVLIST_TAKEF(ftype, type) \
ftype \		ftype \
nvlist_takef_##type(nvlist_t nvl, const char namefmt, ...) \		nvlist_takef_##type(nvlist_t nvl, const char namefmt, ...) \
{ \		{ \
va_list nameap; \		va_list nameap; \
ftype value; \		ftype value; \
\		\
va_start(nameap, namefmt); \		va_start(nameap, namefmt); \
value = nvlist_takev_##type(nvl, namefmt, nameap); \		value = nvlist_takev_##type(nvl, namefmt, nameap); \
va_end(nameap); \		va_end(nameap); \
\		\
return (value); \		return (value); \
}		}

NVLIST_TAKEF(nvpair_t *, nvpair)
NVLIST_TAKEF(bool, bool)		NVLIST_TAKEF(bool, bool)
NVLIST_TAKEF(uint64_t, number)		NVLIST_TAKEF(uint64_t, number)
NVLIST_TAKEF(char *, string)		NVLIST_TAKEF(char *, string)
NVLIST_TAKEF(nvlist_t *, nvlist)		NVLIST_TAKEF(nvlist_t *, nvlist)
NVLIST_TAKEF(int, descriptor)		NVLIST_TAKEF(int, descriptor)

#undef NVLIST_TAKEF		#undef NVLIST_TAKEF

void *		void *
nvlist_takef_binary(nvlist_t nvl, size_t sizep, const char *namefmt, ...)		nvlist_takef_binary(nvlist_t nvl, size_t sizep, const char *namefmt, ...)
{		{
va_list nameap;		va_list nameap;
void *value;		void *value;

va_start(nameap, namefmt);		va_start(nameap, namefmt);
value = nvlist_takev_binary(nvl, sizep, namefmt, nameap);		value = nvlist_takev_binary(nvl, sizep, namefmt, nameap);
va_end(nameap);		va_end(nameap);

return (value);		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) \		#define NVLIST_TAKEV(ftype, type, TYPE) \
ftype \		ftype \
nvlist_takev_##type(nvlist_t nvl, const char namefmt, va_list nameap) \		nvlist_takev_##type(nvlist_t nvl, const char namefmt, va_list nameap) \
{ \		{ \
va_list cnameap; \		char *name; \
nvpair_t *nvp; \
ftype value; \		ftype value; \
\		\
va_copy(cnameap, nameap); \		vasprintf(&name, namefmt, nameap); \
nvp = nvlist_findv(nvl, NV_TYPE_##TYPE, namefmt, cnameap); \		if (name == NULL) \
va_end(cnameap); \		nvlist_report_missing(NV_TYPE_##TYPE, "<unknown>"); \
if (nvp == NULL) \		value = nvlist_take_##type(nvl, name); \
nvlist_report_missing(NV_TYPE_##TYPE, namefmt, nameap); \		free(name); \
value = (ftype)(intptr_t)nvpair_get_##type(nvp); \
nvlist_remove_nvpair(nvl, nvp); \
nvpair_free_structure(nvp); \
return (value); \		return (value); \
}		}

NVLIST_TAKEV(bool, bool, BOOL)		NVLIST_TAKEV(bool, bool, BOOL)
NVLIST_TAKEV(uint64_t, number, NUMBER)		NVLIST_TAKEV(uint64_t, number, NUMBER)
NVLIST_TAKEV(char *, string, STRING)		NVLIST_TAKEV(char *, string, STRING)
NVLIST_TAKEV(nvlist_t *, nvlist, NVLIST)		NVLIST_TAKEV(nvlist_t *, nvlist, NVLIST)
NVLIST_TAKEV(int, descriptor, DESCRIPTOR)		NVLIST_TAKEV(int, descriptor, DESCRIPTOR)

#undef NVLIST_TAKEV		#undef NVLIST_TAKEV

void *		void *
nvlist_takev_binary(nvlist_t nvl, size_t sizep, const char *namefmt,		nvlist_takev_binary(nvlist_t nvl, size_t sizep, const char *namefmt,
va_list nameap)		va_list nameap)
{		{
va_list cnameap;		char *name;
nvpair_t *nvp;		void *binary;
void *value;

va_copy(cnameap, nameap);		vasprintf(&name, namefmt, nameap);
nvp = nvlist_findv(nvl, NV_TYPE_BINARY, namefmt, cnameap);		if (name == NULL)
va_end(cnameap);		nvlist_report_missing(NV_TYPE_BINARY, "<unknown>");
if (nvp == NULL)
nvlist_report_missing(NV_TYPE_BINARY, namefmt, nameap);

value = (void *)(intptr_t)nvpair_get_binary(nvp, sizep);		binary = nvlist_take_binary(nvl, name, sizep);
nvlist_remove_nvpair(nvl, nvp);		free(name);
nvpair_free_structure(nvp);		return (binary);
return (value);
}		}

void		void
nvlist_remove_nvpair(nvlist_t nvl, nvpair_t nvp)		nvlist_remove_nvpair(nvlist_t nvl, nvpair_t nvp)
{		{

NVLIST_ASSERT(nvl);		NVLIST_ASSERT(nvl);
NVPAIR_ASSERT(nvp);		NVPAIR_ASSERT(nvp);
PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);		PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);

nvpair_remove(&nvl->nvl_head, nvp, nvl);		nvpair_remove(&nvl->nvl_head, nvp, nvl);
}		}

void		void
nvlist_free(nvlist_t nvl, const char name)		nvlist_free(nvlist_t nvl, const char name)
{		{

nvlist_freef(nvl, "%s", name);		nvlist_free_type(nvl, name, NV_TYPE_NONE);
}		}

#define NVLIST_FREE(type) \		#define NVLIST_FREE(type, TYPE) \
void \		void \
nvlist_free_##type(nvlist_t nvl, const char name) \		nvlist_free_##type(nvlist_t nvl, const char name) \
{ \		{ \
\		\
nvlist_freef_##type(nvl, "%s", name); \		nvlist_free_type(nvl, name, NV_TYPE_##TYPE); \
}		}

NVLIST_FREE(null)		NVLIST_FREE(null, NULL)
NVLIST_FREE(bool)		NVLIST_FREE(bool, BOOL)
NVLIST_FREE(number)		NVLIST_FREE(number, NUMBER)
NVLIST_FREE(string)		NVLIST_FREE(string, STRING)
NVLIST_FREE(nvlist)		NVLIST_FREE(nvlist, NVLIST)
NVLIST_FREE(descriptor)		NVLIST_FREE(descriptor, DESCRIPTOR)
NVLIST_FREE(binary)		NVLIST_FREE(binary, BINARY)

#undef NVLIST_FREE		#undef NVLIST_FREE

void		void
nvlist_freef(nvlist_t nvl, const char namefmt, ...)		nvlist_freef(nvlist_t nvl, const char namefmt, ...)
{		{
va_list nameap;		va_list nameap;

Show All 29 Lines	nvlist_freev(nvlist_t nvl, const char namefmt, va_list nameap)

nvlist_freev_type(nvl, NV_TYPE_NONE, namefmt, nameap);		nvlist_freev_type(nvl, NV_TYPE_NONE, namefmt, nameap);
}		}

#define NVLIST_FREEV(type, TYPE) \		#define NVLIST_FREEV(type, TYPE) \
void \		void \
nvlist_freev_##type(nvlist_t nvl, const char namefmt, va_list nameap) \		nvlist_freev_##type(nvlist_t nvl, const char namefmt, va_list nameap) \
{ \		{ \
		char *name; \
\		\
nvlist_freev_type(nvl, NV_TYPE_##TYPE, namefmt, nameap); \		vasprintf(&name, namefmt, nameap); \
		if (name == NULL) \
		nvlist_report_missing(NV_TYPE_##TYPE, "<unknown>"); \
		nvlist_free_##type(nvl, name); \
		free(name); \
}		}

NVLIST_FREEV(null, NULL)		NVLIST_FREEV(null, NULL)
NVLIST_FREEV(bool, BOOL)		NVLIST_FREEV(bool, BOOL)
NVLIST_FREEV(number, NUMBER)		NVLIST_FREEV(number, NUMBER)
NVLIST_FREEV(string, STRING)		NVLIST_FREEV(string, STRING)
NVLIST_FREEV(nvlist, NVLIST)		NVLIST_FREEV(nvlist, NVLIST)
NVLIST_FREEV(descriptor, DESCRIPTOR)		NVLIST_FREEV(descriptor, DESCRIPTOR)
Show All 14 Lines