socsvn commit: r255351 - in soc2013/dpl: . caller caller/libnv libnv
dpl at FreeBSD.org
dpl at FreeBSD.org
Tue Jul 30 15:30:01 UTC 2013
Author: dpl
Date: Tue Jul 30 15:30:01 2013
New Revision: 255351
URL: http://svnweb.FreeBSD.org/socsvn/?view=rev&rev=255351
Log:
Putting everything nicely.
Added:
soc2013/dpl/caller/
soc2013/dpl/caller/caller.c
soc2013/dpl/caller/libnv/
soc2013/dpl/caller/libnv/Makefile
soc2013/dpl/caller/libnv/msgio.c
soc2013/dpl/caller/libnv/msgio.h
soc2013/dpl/caller/libnv/nv.h
soc2013/dpl/caller/libnv/nv_impl.h
soc2013/dpl/caller/libnv/nvlist.c
soc2013/dpl/caller/libnv/nvlist_impl.h
soc2013/dpl/caller/libnv/nvpair.c
soc2013/dpl/caller/libnv/nvpair_impl.h
soc2013/dpl/caller/nv.h
Deleted:
soc2013/dpl/caller.c
soc2013/dpl/libnv/
Added: soc2013/dpl/caller/caller.c
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ soc2013/dpl/caller/caller.c Tue Jul 30 15:30:01 2013 (r255351)
@@ -0,0 +1,137 @@
+#include <unistd.h>
+#include <poll.h>
+#include <sys/capability.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <signal.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <strings.h>
+
+
+pid_t child = 0;
+int sv[2], i;
+
+pid_t startChild();
+void waitCommand();
+void killChild();
+
+/* Toy lib */
+int sum(int a);
+int sum_(int a);
+
+int
+main()
+{
+ int ret, a = 1;
+ ret = sum(a);
+ printf("ret: %d (should be 2)\n", ret);
+
+ return 0;
+}
+
+int sum(int a)
+{
+ struct pollfd fdread[1], fdwrite[1];
+ int buf[32];
+ /* Caller overhead */
+ /* Much better if we do this in a function */
+ fdwrite[0].fd = sv[0];
+ fdwrite[0].events = POLLOUT;
+ fdwrite[0].revents = 0;
+ fdread[0].fd = sv[0];
+ fdread[0].events = POLLIN|POLLPRI;
+ fdread[0].revents = 0;
+ if( child == 0)
+ startChild();
+
+ /* Real stuff */
+ buf[0] = 1;
+ buf[1] = a;
+
+ /* Should be in a function as well */
+ /* sendAndWait() (?) */
+ while(1){
+ if(poll(fdwrite, 1, 0) > 0 ){
+ write(sv[0], buf, sizeof(buf));
+ break;
+ }
+ }
+ /* Here, the stuff gets done in child. */
+ while(1){
+ if(poll(fdread, 1, 0) > 0 ){
+ read(sv[0], buf, sizeof(buf));
+ break;
+ }
+ }
+ printf("done: %d\n", buf[0]);
+
+ return buf[0];
+}
+
+int sum_(int a)
+{
+ return ++a;
+}
+
+int startChild()
+{
+ socketpair(PF_LOCAL, SOCK_STREAM, 0, sv);
+ if( (child = fork()) == 0 ){
+ cap_rights_limit(STDOUT_FILENO, CAP_WRITE);
+ close(STDIN_FILENO);
+ close(STDERR_FILENO);
+ cap_enter();
+ waitCommand();
+ } else
+ atexit(killChild);
+
+
+ return child;
+}
+
+/* Wait for commands, and execute them */
+void
+waitCommand()
+{
+ struct pollfd fdread[1], fdwrite[1];
+ int buf[32];
+ fdread[0].fd = sv[1];
+ fdread[0].events = POLLIN|POLLPRI;
+ fdread[0].revents = 0;
+ fdwrite[0].fd = sv[1];
+ fdwrite[0].events = POLLOUT;
+ fdwrite[0].revents = 0;
+ while(1) {
+ while(1){
+ if( poll(fdread, 1, 0) > 0){
+ read(sv[1], buf, sizeof(buf));
+ break;
+ }
+ }
+
+ if( buf[0] == 1 ){
+ /* We still have to take recv nvlist */
+ int ret = sum(buf[1]);
+ printf("ret:%d\n", ret);
+ fflush(stdout);
+ bzero(&buf, sizeof(buf));
+ buf[0] = ret;
+ }
+
+ while(1) {
+ if (poll(fdwrite, 1, 0) > 0){
+ write(sv[1], buf, sizeof(buf));
+ break;
+ }
+ }
+ }
+}
+
+void
+killChild()
+{
+ kill(child, SIGKILL);
+}
\ No newline at end of file
Added: soc2013/dpl/caller/libnv/Makefile
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ soc2013/dpl/caller/libnv/Makefile Tue Jul 30 15:30:01 2013 (r255351)
@@ -0,0 +1,15 @@
+# $FreeBSD$
+
+LIB= nv
+#SHLIBDIR?= /lib
+SHLIBDIR?= .
+SHLIB_MAJOR= 0
+
+SRCS= msgio.c
+SRCS+= nvlist.c
+SRCS+= nvpair.c
+INCS= nv.h
+
+CFLAGS+=-ggdb
+
+.include <bsd.lib.mk>
Added: soc2013/dpl/caller/libnv/msgio.c
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ soc2013/dpl/caller/libnv/msgio.c Tue Jul 30 15:30:01 2013 (r255351)
@@ -0,0 +1,350 @@
+/*-
+ * 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 <sys/types.h>
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifdef HAVE_PJDLOG
+#include <pjdlog.h>
+#endif
+
+#include "msgio.h"
+
+#ifndef HAVE_PJDLOG
+#include <assert.h>
+#define PJDLOG_ASSERT(...) assert(__VA_ARGS__)
+#define PJDLOG_RASSERT(expr, ...) assert(expr)
+#define PJDLOG_ABORT(...) abort()
+#endif
+
+int
+msghdr_allocate(size_t datasize, size_t nfds, struct msghdr *msg,
+ struct iovec *iov)
+{
+ int serrno;
+
+ bzero(msg, sizeof(*msg));
+ bzero(iov, sizeof(*iov));
+
+ msg->msg_iov = iov;
+ msg->msg_iovlen = 1;
+
+ if (datasize == 0)
+ return (0);
+
+ if (nfds > 0) {
+ msg->msg_controllen = nfds * CMSG_SPACE(sizeof(int));
+ msg->msg_control = calloc(1, msg->msg_controllen);
+ if (msg->msg_control == NULL)
+ return (-1);
+ }
+
+ iov->iov_len = datasize;
+ iov->iov_base = malloc(iov->iov_len);
+ if (iov->iov_base == NULL) {
+ serrno = errno;
+ free(msg->msg_control);
+ errno = serrno;
+ return (-1);
+ }
+
+ return (0);
+}
+
+static bool
+fd_is_valid(int fd)
+{
+
+ return (fcntl(fd, F_GETFL) != -1 || errno != EBADF);
+}
+
+static int
+msghdr_add_fd(struct msghdr *msg, struct cmsghdr **cmsgp, int fd)
+{
+ struct cmsghdr *cmsg;
+
+ PJDLOG_ASSERT(fd >= 0);
+
+ if (!fd_is_valid(fd)) {
+ errno = EBADF;
+ return (-1);
+ }
+
+ cmsg = *cmsgp;
+ cmsg->cmsg_level = SOL_SOCKET;
+ cmsg->cmsg_type = SCM_RIGHTS;
+ cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
+ bcopy(&fd, CMSG_DATA(cmsg), sizeof(fd));
+ *cmsgp = CMSG_NXTHDR(msg, cmsg);
+
+ return (0);
+}
+
+int
+msghdr_fds_from_array(const int *fds, size_t nfds, struct msghdr *msg)
+{
+ struct cmsghdr *cmsg;
+ unsigned int ii;
+ int serrno;
+
+ if (nfds == 0) {
+ msg->msg_control = NULL;
+ msg->msg_controllen = 0;
+ return (0);
+ }
+
+ msg->msg_controllen = nfds * CMSG_SPACE(sizeof(int));
+ msg->msg_control = calloc(1, msg->msg_controllen);
+ if (msg->msg_control == NULL)
+ return (-1);
+
+ cmsg = CMSG_FIRSTHDR(msg);
+ for (ii = 0; ii < nfds; ii++) {
+ if (msghdr_add_fd(msg, &cmsg, fds[ii]) == -1) {
+ serrno = errno;
+ free(msg->msg_control);
+ errno = serrno;
+ return (-1);
+ }
+ }
+
+ return (0);
+}
+
+static struct cmsghdr *
+msghdr_get_fd(struct msghdr *msg, struct cmsghdr *cmsg, int *fdp)
+{
+
+ if (cmsg == NULL || cmsg->cmsg_level != SOL_SOCKET ||
+ cmsg->cmsg_type != SCM_RIGHTS) {
+ return (NULL);
+ }
+
+ bcopy(CMSG_DATA(cmsg), fdp, sizeof(*fdp));
+#ifndef MSG_CMSG_CLOEXEC
+ /*
+ * If the MSG_CMSG_CLOEXEC flag is not available we cannot set the
+ * close-on-exec flag atomically, but we still want to set it for
+ * consistency.
+ */
+ (void) fcntl(*fdp, F_SETFD, FD_CLOEXEC);
+#endif
+
+ return (CMSG_NXTHDR(msg, cmsg));
+}
+
+int *
+msghdr_fds_to_array(struct msghdr *msg, size_t nfds)
+{
+ struct cmsghdr *cmsg;
+ unsigned int ii;
+ int *fds;
+
+ fds = malloc(sizeof(fds[0]) * nfds);
+ if (fds == NULL)
+ return (NULL);
+ cmsg = CMSG_FIRSTHDR(msg);
+ for (ii = 0; ii < nfds && cmsg != NULL; ii++)
+ cmsg = msghdr_get_fd(msg, cmsg, &fds[ii]);
+ if (cmsg != NULL || ii < nfds) {
+ free(fds);
+ fds = NULL;
+ }
+
+ return (fds);
+}
+
+void
+msghdr_fds_free(struct msghdr *msg)
+{
+ struct cmsghdr *cmsg;
+ int fd;
+
+ for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL;
+ cmsg = CMSG_NXTHDR(msg, cmsg)) {
+ if (cmsg->cmsg_level == SOL_SOCKET &&
+ cmsg->cmsg_type == SCM_RIGHTS) {
+ bcopy(CMSG_DATA(cmsg), &fd, sizeof(fd));
+ close(fd);
+ }
+ }
+}
+
+static void
+fd_wait(int fd, bool doread)
+{
+ fd_set fds;
+
+ PJDLOG_ASSERT(fd >= 0);
+
+ FD_ZERO(&fds);
+ FD_SET(fd, &fds);
+ (void)select(fd + 1, doread ? &fds : NULL, doread ? NULL : &fds,
+ NULL, NULL);
+}
+
+int
+msg_peek(int sock, void *buf, size_t size)
+{
+ unsigned char *ptr;
+ ssize_t done;
+
+ PJDLOG_ASSERT(sock >= 0);
+ PJDLOG_ASSERT(size > 0);
+
+ ptr = buf;
+ do {
+ fd_wait(sock, true);
+ done = recv(sock, ptr, size, MSG_PEEK);
+ if (done == -1) {
+ if (errno == EINTR)
+ continue;
+ return (-1);
+ } else if (done == 0) {
+ errno = ENOTCONN;
+ return (-1);
+ }
+ size -= done;
+ ptr += done;
+ } while (size > 0);
+
+ return (0);
+}
+
+int
+msg_recv(int sock, struct msghdr *msg)
+{
+ int flags;
+
+ PJDLOG_ASSERT(sock >= 0);
+
+#ifdef MSG_CMSG_CLOEXEC
+ flags = MSG_CMSG_CLOEXEC;
+#else
+ flags = 0;
+#endif
+
+ for (;;) {
+ fd_wait(sock, true);
+ if (recvmsg(sock, msg, flags) == -1) {
+ if (errno == EINTR)
+ continue;
+ return (-1);
+ }
+ break;
+ }
+
+ return (0);
+}
+
+int
+msg_send(int sock, const struct msghdr *msg)
+{
+
+ PJDLOG_ASSERT(sock >= 0);
+
+ for (;;) {
+ fd_wait(sock, false);
+ if (sendmsg(sock, msg, 0) == -1) {
+ if (errno == EINTR)
+ continue;
+ return (-1);
+ }
+ break;
+ }
+
+ return (0);
+}
+
+int
+cred_send(int sock)
+{
+ struct msghdr msg;
+ struct cmsghdr *cmsg;
+ unsigned char credbuf[CMSG_SPACE(sizeof(struct cmsgcred))];
+
+ bzero(credbuf, sizeof(credbuf));
+ bzero(&msg, sizeof(msg));
+
+ msg.msg_iov = NULL;
+ msg.msg_iovlen = 0;
+ msg.msg_control = credbuf;
+ msg.msg_controllen = sizeof(credbuf);
+
+ cmsg = CMSG_FIRSTHDR(&msg);
+ cmsg->cmsg_len = CMSG_LEN(sizeof(struct cmsgcred));
+ cmsg->cmsg_level = SOL_SOCKET;
+ cmsg->cmsg_type = SCM_CREDS;
+
+ if (msg_send(sock, &msg) == -1)
+ return (-1);
+
+ return (0);
+}
+
+int
+cred_recv(int sock, struct cmsgcred *cred)
+{
+ unsigned char credbuf[CMSG_SPACE(sizeof(struct cmsgcred))];
+ struct msghdr msg;
+ struct cmsghdr *cmsg;
+
+ bzero(credbuf, sizeof(credbuf));
+ bzero(&msg, sizeof(msg));
+
+ msg.msg_iov = NULL;
+ msg.msg_iovlen = 0;
+ msg.msg_control = credbuf;
+ msg.msg_controllen = sizeof(credbuf);
+
+ if (msg_recv(sock, &msg) == -1)
+ return (-1);
+
+ cmsg = CMSG_FIRSTHDR(&msg);
+ if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct cmsgcred)) ||
+ cmsg->cmsg_level != SOL_SOCKET ||
+ cmsg->cmsg_type != SCM_CREDS) {
+ errno = EINVAL;
+ return (-1);
+ }
+ bcopy(CMSG_DATA(cmsg), cred, sizeof(*cred));
+
+ return (0);
+}
Added: soc2013/dpl/caller/libnv/msgio.h
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ soc2013/dpl/caller/libnv/msgio.h Tue Jul 30 15:30:01 2013 (r255351)
@@ -0,0 +1,53 @@
+/*-
+ * 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 _MSGIO_H_
+#define _MSGIO_H_
+
+struct cmsgcred;
+struct iovec;
+struct msghdr;
+
+int msghdr_allocate(size_t datasize, size_t nfds, struct msghdr *msg,
+ struct iovec *iov);
+
+int msghdr_fds_from_array(const int *fds, size_t nfds, struct msghdr *msg);
+int *msghdr_fds_to_array(struct msghdr *msg, size_t nfds);
+void msghdr_fds_free(struct msghdr *msg);
+
+int msg_peek(int sock, void *buf, size_t size);
+int msg_recv(int sock, struct msghdr *msg);
+int msg_send(int sock, const struct msghdr *msg);
+
+int cred_send(int sock);
+int cred_recv(int sock, struct cmsgcred *cred);
+
+#endif /* !_MSGIO_H_ */
Added: soc2013/dpl/caller/libnv/nv.h
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ soc2013/dpl/caller/libnv/nv.h Tue Jul 30 15:30:01 2013 (r255351)
@@ -0,0 +1,477 @@
+/*-
+ * 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 _NVPAIR_T_DECLARED
+#define _NVPAIR_T_DECLARED
+struct nvpair;
+
+typedef struct nvpair nvpair_t;
+#endif
+
+#ifndef _NVLIST_T_DECLARED
+#define _NVLIST_T_DECLARED
+struct nvlist;
+
+typedef struct nvlist nvlist_t;
+#endif
+
+#define NVPAIR_NAME_MAX 256
+
+#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
+#define NV_TYPE_ARRAY_BOOL 8
+#define NV_TYPE_ARRAY_NUMBER 9
+#define NV_TYPE_ARRAY_STRING 10
+#define NV_TYPE_ARRAY_NVLIST 11
+#define NV_TYPE_ARRAY_DESCRIPTOR 12
+
+/* Duplicated names are not allowed. */
+#define NV_FLAG_UNIQUE_NAME 0x01
+/* Duplicated names of the same type are not allowed. */
+#define NV_FLAG_UNIQUE_NAME_TYPE 0x02
+/*
+ * NULL values for arrays and strings as well as -1 for descriptors
+ * are allowed. Note that individual entries in nvlist array, string
+ * array or descriptor array can still be NULL/-1.
+ */
+#define NV_FLAG_NO_VALUE 0x04
+
+nvlist_t *nvlist_create(int flags);
+void nvlist_destroy(nvlist_t *nvl);
+int nvlist_error(const nvlist_t *nvl);
+
+bool nvlist_exists_type(const nvlist_t *nvl, const char *name, int type);
+bool nvlist_existsf_type(const nvlist_t *nvl, int type, const char *namefmt, ...) __printflike(3, 4);
+bool nvlist_existsv_type(const nvlist_t *nvl, int type, const char *namefmt, va_list nameap) __printflike(3, 0);
+
+int nvlist_free_type(nvlist_t *nvl, const char *name, int type);
+int nvlist_freef_type(nvlist_t *nvl, int type, const char *namefmt, ...) __printflike(3, 4);
+int nvlist_freev_type(nvlist_t *nvl, int type, const char *namefmt, va_list nameap) __printflike(3, 0);
+
+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 *out);
+
+size_t nvlist_size(const nvlist_t *nvl);
+int *nvlist_descriptors(const nvlist_t *nvl, size_t *nitemsp);
+size_t nvlist_ndescriptors(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);
+
+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);
+
+/*
+ * 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_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);
+bool nvlist_exists_array_bool(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_array_number(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_array_string(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_array_nvlist(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_array_descriptor(const nvlist_t *nvl, const char *name);
+
+bool nvlist_existsf(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+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_existsf_array_bool(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+bool nvlist_existsf_array_number(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+bool nvlist_existsf_array_string(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+bool nvlist_existsf_array_nvlist(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+bool nvlist_existsf_array_descriptor(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_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);
+bool nvlist_existsv_array_bool(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+bool nvlist_existsv_array_number(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+bool nvlist_existsv_array_string(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+bool nvlist_existsv_array_nvlist(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+bool nvlist_existsv_array_descriptor(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+
+/*
+ * 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_nvpair(nvlist_t *nvl, nvpair_t *nvp);
+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);
+void nvlist_add_array_bool(nvlist_t *nvl, const char *name, const bool *value, size_t nitems);
+void nvlist_add_array_number(nvlist_t *nvl, const char *name, const uint64_t *value, size_t nitems);
+void nvlist_add_array_string(nvlist_t *nvl, const char *name, const char * const *value, size_t nitems);
+void nvlist_add_array_nvlist(nvlist_t *nvl, const char *name, const nvlist_t * const *value, size_t nitems);
+void nvlist_add_array_descriptor(nvlist_t *nvl, const char *name, const int *value, size_t nitems);
+
+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_addf_array_bool(nvlist_t *nvl, const bool *value, size_t nitems, const char *namefmt, ...) __printflike(4, 5);
+void nvlist_addf_array_number(nvlist_t *nvl, const uint64_t *value, size_t nitems, const char *namefmt, ...) __printflike(4, 5);
+void nvlist_addf_array_string(nvlist_t *nvl, const char * const *value, size_t nitems, const char *namefmt, ...) __printflike(4, 5);
+void nvlist_addf_array_nvlist(nvlist_t *nvl, const nvlist_t * const *value, size_t nitems, const char *namefmt, ...) __printflike(4, 5);
+void nvlist_addf_array_descriptor(nvlist_t *nvl, const int *value, size_t nitems, 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_addv_array_bool(nvlist_t *nvl, const bool *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+void nvlist_addv_array_number(nvlist_t *nvl, const uint64_t *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+void nvlist_addv_array_string(nvlist_t *nvl, const char * const *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+void nvlist_addv_array_nvlist(nvlist_t *nvl, const nvlist_t * const *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+void nvlist_addv_array_descriptor(nvlist_t *nvl, const int *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+
+/*
+ * 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);
+void nvlist_move_array_bool(nvlist_t *nvl, const char *name, bool *value, size_t nitems);
+void nvlist_move_array_number(nvlist_t *nvl, const char *name, uint64_t *value, size_t nitems);
+void nvlist_move_array_string(nvlist_t *nvl, const char *name, char **value, size_t nitems);
+void nvlist_move_array_nvlist(nvlist_t *nvl, const char *name, nvlist_t **value, size_t nitems);
+void nvlist_move_array_descriptor(nvlist_t *nvl, const char *name, int *value, size_t nitems);
+
+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_movef_array_bool(nvlist_t *nvl, bool *value, size_t nitems, const char *namefmt, ...) __printflike(4, 5);
+void nvlist_movef_array_number(nvlist_t *nvl, uint64_t *value, size_t nitems, const char *namefmt, ...) __printflike(4, 5);
+void nvlist_movef_array_string(nvlist_t *nvl, char **value, size_t nitems, const char *namefmt, ...) __printflike(4, 5);
+void nvlist_movef_array_nvlist(nvlist_t *nvl, nvlist_t **value, size_t nitems, const char *namefmt, ...) __printflike(4, 5);
+void nvlist_movef_array_descriptor(nvlist_t *nvl, int *value, size_t nitems, 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);
+void nvlist_movev_array_bool(nvlist_t *nvl, bool *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+void nvlist_movev_array_number(nvlist_t *nvl, uint64_t *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+void nvlist_movev_array_string(nvlist_t *nvl, char **value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+void nvlist_movev_array_nvlist(nvlist_t *nvl, nvlist_t **value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+void nvlist_movev_array_descriptor(nvlist_t *nvl, int *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(4, 0);
+
+/*
+ * 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.
+ */
+
+nvpair_t *nvlist_get_nvpair(const nvlist_t *nvl, const char *name);
+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);
+const bool *nvlist_get_array_bool(const nvlist_t *nvl, const char *name, size_t *nitemsp);
+const uint64_t *nvlist_get_array_number(const nvlist_t *nvl, const char *name, size_t *nitemsp);
+const char * const *nvlist_get_array_string(const nvlist_t *nvl, const char *name, size_t *nitemsp);
+nvlist_t * const *nvlist_get_array_nvlist(const nvlist_t *nvl, const char *name, size_t *nitemsp);
+const int *nvlist_get_array_descriptor(const nvlist_t *nvl, const char *name, size_t *nitemsp);
+
+nvpair_t *nvlist_getf_nvpair(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+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);
+const bool *nvlist_getf_array_bool(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+const uint64_t *nvlist_getf_array_number(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+const char * const *nvlist_getf_array_string(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+nvlist_t * const *nvlist_getf_array_nvlist(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+const int *nvlist_getf_array_descriptor(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+
+nvpair_t *nvlist_getv_nvpair(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+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);
+const bool *nvlist_getv_array_bool(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+const uint64_t *nvlist_getv_array_number(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+const char * const *nvlist_getv_array_string(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+nvlist_t * const *nvlist_getv_array_nvlist(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+const int *nvlist_getv_array_descriptor(const nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+
+/*
+ * 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.
+ */
+
+nvpair_t *nvlist_take_nvpair(nvlist_t *nvl, const char *name);
+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);
+bool *nvlist_take_array_bool(nvlist_t *nvl, const char *name, size_t *nitemsp);
+uint64_t *nvlist_take_array_number(nvlist_t *nvl, const char *name, size_t *nitemsp);
+char **nvlist_take_array_string(nvlist_t *nvl, const char *name, size_t *nitemsp);
+nvlist_t **nvlist_take_array_nvlist(nvlist_t *nvl, const char *name, size_t *nitemsp);
+int *nvlist_take_array_descriptor(nvlist_t *nvl, const char *name, size_t *nitemsp);
+
+nvpair_t *nvlist_takef_nvpair(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+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_takef_array_bool(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+uint64_t *nvlist_takef_array_number(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+char **nvlist_takef_array_string(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+nvlist_t **nvlist_takef_array_nvlist(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+int *nvlist_takef_array_descriptor(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, ...) __printflike(3, 4);
+
+nvpair_t *nvlist_takev_nvpair(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+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);
+bool *nvlist_takev_array_bool(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+uint64_t *nvlist_takev_array_number(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+char **nvlist_takev_array_string(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+nvlist_t **nvlist_takev_array_nvlist(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+int *nvlist_takev_array_descriptor(nvlist_t *nvl, size_t *nitemsp, const char *namefmt, va_list nameap) __printflike(3, 0);
+
+/* Function removes the given nvpair from the nvlist. */
+void nvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *nvp);
+
+/*
+ * The nvlist_free functions removes the given name/value pair from the nvlist
+ * and frees memory associated with it.
+ */
+
+int nvlist_free(nvlist_t *nvl, const char *name);
+int nvlist_free_null(nvlist_t *nvl, const char *name);
+int nvlist_free_bool(nvlist_t *nvl, const char *name);
+int nvlist_free_number(nvlist_t *nvl, const char *name);
+int nvlist_free_string(nvlist_t *nvl, const char *name);
+int nvlist_free_nvlist(nvlist_t *nvl, const char *name);
+int nvlist_free_descriptor(nvlist_t *nvl, const char *name);
+int nvlist_free_binary(nvlist_t *nvl, const char *name);
+int nvlist_free_array_bool(nvlist_t *nvl, const char *name);
+int nvlist_free_array_number(nvlist_t *nvl, const char *name);
+int nvlist_free_array_string(nvlist_t *nvl, const char *name);
+int nvlist_free_array_nvlist(nvlist_t *nvl, const char *name);
+int nvlist_free_array_descriptor(nvlist_t *nvl, const char *name);
+
+int nvlist_freef(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_null(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_bool(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_number(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_string(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_nvlist(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_descriptor(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_binary(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_array_bool(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_array_number(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_array_string(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_array_nvlist(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+int nvlist_freef_array_descriptor(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
+
+int nvlist_freev(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_null(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_bool(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_number(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_string(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_nvlist(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_descriptor(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_binary(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_array_bool(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_array_number(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_array_string(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_array_nvlist(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+int nvlist_freev_array_descriptor(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
+
+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_create_array_bool(const char *name, const bool *value, size_t nitems);
+nvpair_t *nvpair_create_array_number(const char *name, const uint64_t *value, size_t nitems);
+nvpair_t *nvpair_create_array_string(const char *name, const char * const *value, size_t nitems);
+nvpair_t *nvpair_create_array_nvlist(const char *name, const nvlist_t * const *value, size_t nitems);
+nvpair_t *nvpair_create_array_descriptor(const char *name, const int *value, size_t nitems);
+
+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_createf_array_bool(const bool *value, size_t nitems, const char *namefmt, ...) __printflike(3, 4);
+nvpair_t *nvpair_createf_array_number(const uint64_t *value, size_t nitems, const char *namefmt, ...) __printflike(3, 4);
+nvpair_t *nvpair_createf_array_string(const char * const *value, size_t nitems, const char *namefmt, ...) __printflike(3, 4);
+nvpair_t *nvpair_createf_array_nvlist(const nvlist_t * const *value, size_t nitems, const char *namefmt, ...) __printflike(3, 4);
+nvpair_t *nvpair_createf_array_descriptor(const int *value, size_t nitems, 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_createv_array_bool(const bool *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(3, 0);
+nvpair_t *nvpair_createv_array_number(const uint64_t *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(3, 0);
+nvpair_t *nvpair_createv_array_string(const char * const *value, size_t nitems, const char *namefmt, va_list nameap) __printflike(3, 0);
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-soc-all
mailing list