sys/contrib/libnv/nvlist.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2009-2013 The FreeBSD Foundation
   5  * Copyright (c) 2013-2015 Mariusz Zaborski <oshogbo@FreeBSD.org>
   6  * All rights reserved.
   7  *
   8  * This software was developed by Pawel Jakub Dawidek under sponsorship from
   9  * the FreeBSD Foundation.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <sys/param.h>
  37 #include <sys/endian.h>
  38 #include <sys/queue.h>
  39
  40 #ifdef _KERNEL
  41
  42 #include <sys/errno.h>
  43 #include <sys/kernel.h>
  44 #include <sys/lock.h>
  45 #include <sys/malloc.h>
  46 #include <sys/systm.h>
  47
  48 #include <machine/stdarg.h>
  49
  50 #else
  51 #include <sys/socket.h>
  52
  53 #include <errno.h>
  54 #include <stdarg.h>
  55 #include <stdbool.h>
  56 #include <stdint.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <string.h>
  60 #include <unistd.h>
  61
  62 #include "msgio.h"
  63 #endif
  64
  65 #ifdef HAVE_PJDLOG
  66 #include <pjdlog.h>
  67 #endif
  68
  69 #include <sys/nv.h>
  70
  71 #include "nv_impl.h"
  72 #include "nvlist_impl.h"
  73 #include "nvpair_impl.h"
  74
  75 #ifndef HAVE_PJDLOG
  76 #ifdef _KERNEL
  77 #define PJDLOG_ASSERT(...)              MPASS(__VA_ARGS__)
  78 #define PJDLOG_RASSERT(expr, ...)       KASSERT(expr, (__VA_ARGS__))
  79 #define PJDLOG_ABORT(...)               panic(__VA_ARGS__)
  80 #else
  81 #include <assert.h>
  82 #define PJDLOG_ASSERT(...)              assert(__VA_ARGS__)
  83 #define PJDLOG_RASSERT(expr, ...)       assert(expr)
  84 #define PJDLOG_ABORT(...)               do {                            \
  85         fprintf(stderr, "%s:%u: ", __FILE__, __LINE__);                 \
  86         fprintf(stderr, __VA_ARGS__);                                   \
  87         fprintf(stderr, "\n");                                          \
  88         abort();                                                        \
  89 } while (0)
  90 #endif
  91 #endif
  92
  93 #define NV_FLAG_PRIVATE_MASK    (NV_FLAG_BIG_ENDIAN | NV_FLAG_IN_ARRAY)
  94 #define NV_FLAG_PUBLIC_MASK     (NV_FLAG_IGNORE_CASE | NV_FLAG_NO_UNIQUE)
  95 #define NV_FLAG_ALL_MASK        (NV_FLAG_PRIVATE_MASK | NV_FLAG_PUBLIC_MASK)
  96
  97 #define NVLIST_MAGIC    0x6e766c        /* "nvl" */
  98 struct nvlist {
  99         int              nvl_magic;
 100         int              nvl_error;
 101         int              nvl_flags;
 102         nvpair_t        *nvl_parent;
 103         nvpair_t        *nvl_array_next;
 104         struct nvl_head  nvl_head;
 105 };
 106
 107 #define NVLIST_ASSERT(nvl)      do {                                    \
 108         PJDLOG_ASSERT((nvl) != NULL);                                   \
 109         PJDLOG_ASSERT((nvl)->nvl_magic == NVLIST_MAGIC);                \
 110 } while (0)
 111
 112 #ifdef _KERNEL
 113 MALLOC_DEFINE(M_NVLIST, "nvlist", "kernel nvlist");
 114 #endif
 115
 116 #define NVPAIR_ASSERT(nvp)      nvpair_assert(nvp)
 117
 118 #define NVLIST_HEADER_MAGIC     0x6c
 119 #define NVLIST_HEADER_VERSION   0x00
 120 struct nvlist_header {
 121         uint8_t         nvlh_magic;
 122         uint8_t         nvlh_version;
 123         uint8_t         nvlh_flags;
 124         uint64_t        nvlh_descriptors;
 125         uint64_t        nvlh_size;
 126 } __packed;
 127
 128 nvlist_t *
 129 nvlist_create(int flags)
 130 {
 131         nvlist_t *nvl;
 132
 133         PJDLOG_ASSERT((flags & ~(NV_FLAG_PUBLIC_MASK)) == 0);
 134
 135         nvl = nv_malloc(sizeof(*nvl));
 136         if (nvl == NULL)
 137                 return (NULL);
 138         nvl->nvl_error = 0;
 139         nvl->nvl_flags = flags;
 140         nvl->nvl_parent = NULL;
 141         nvl->nvl_array_next = NULL;
 142         TAILQ_INIT(&nvl->nvl_head);
 143         nvl->nvl_magic = NVLIST_MAGIC;
 144
 145         return (nvl);
 146 }
 147
 148 void
 149 nvlist_destroy(nvlist_t *nvl)
 150 {
 151         nvpair_t *nvp;
 152
 153         if (nvl == NULL)
 154                 return;
 155
 156         ERRNO_SAVE();
 157
 158         NVLIST_ASSERT(nvl);
 159
 160         while ((nvp = nvlist_first_nvpair(nvl)) != NULL) {
 161                 nvlist_remove_nvpair(nvl, nvp);
 162                 nvpair_free(nvp);
 163         }
 164         if (nvl->nvl_array_next != NULL)
 165                 nvpair_free_structure(nvl->nvl_array_next);
 166         nvl->nvl_array_next = NULL;
 167         nvl->nvl_parent = NULL;
 168         nvl->nvl_magic = 0;
 169         nv_free(nvl);
 170
 171         ERRNO_RESTORE();
 172 }
 173
 174 void
 175 nvlist_set_error(nvlist_t *nvl, int error)
 176 {
 177
 178         PJDLOG_ASSERT(error != 0);
 179
 180         /*
 181          * Check for error != 0 so that we don't do the wrong thing if somebody
 182          * tries to abuse this API when asserts are disabled.
 183          */
 184         if (nvl != NULL && error != 0 && nvl->nvl_error == 0)
 185                 nvl->nvl_error = error;
 186 }
 187
 188 int
 189 nvlist_error(const nvlist_t *nvl)
 190 {
 191
 192         if (nvl == NULL)
 193                 return (ENOMEM);
 194
 195         NVLIST_ASSERT(nvl);
 196
 197         return (nvl->nvl_error);
 198 }
 199
 200 nvpair_t *
 201 nvlist_get_nvpair_parent(const nvlist_t *nvl)
 202 {
 203
 204         NVLIST_ASSERT(nvl);
 205
 206         return (nvl->nvl_parent);
 207 }
 208
 209 const nvlist_t *
 210 nvlist_get_parent(const nvlist_t *nvl, void **cookiep)
 211 {
 212         nvpair_t *nvp;
 213
 214         NVLIST_ASSERT(nvl);
 215
 216         nvp = nvl->nvl_parent;
 217         if (cookiep != NULL)
 218                 *cookiep = nvp;
 219         if (nvp == NULL)
 220                 return (NULL);
 221
 222         return (nvpair_nvlist(nvp));
 223 }
 224
 225 void
 226 nvlist_set_parent(nvlist_t *nvl, nvpair_t *parent)
 227 {
 228
 229         NVLIST_ASSERT(nvl);
 230
 231         nvl->nvl_parent = parent;
 232 }
 233
 234 void
 235 nvlist_set_array_next(nvlist_t *nvl, nvpair_t *ele)
 236 {
 237
 238         NVLIST_ASSERT(nvl);
 239
 240         if (ele != NULL) {
 241                 nvl->nvl_flags |= NV_FLAG_IN_ARRAY;
 242         } else {
 243                 nvl->nvl_flags &= ~NV_FLAG_IN_ARRAY;
 244                 nv_free(nvl->nvl_array_next);
 245         }
 246
 247         nvl->nvl_array_next = ele;
 248 }
 249
 250 nvpair_t *
 251 nvlist_get_array_next_nvpair(nvlist_t *nvl)
 252 {
 253
 254         NVLIST_ASSERT(nvl);
 255
 256         return (nvl->nvl_array_next);
 257 }
 258
 259 bool
 260 nvlist_in_array(const nvlist_t *nvl)
 261 {
 262
 263         NVLIST_ASSERT(nvl);
 264
 265         return ((nvl->nvl_flags & NV_FLAG_IN_ARRAY) != 0);
 266 }
 267
 268 const nvlist_t *
 269 nvlist_get_array_next(const nvlist_t *nvl)
 270 {
 271         nvpair_t *nvp;
 272
 273         NVLIST_ASSERT(nvl);
 274
 275         nvp = nvl->nvl_array_next;
 276         if (nvp == NULL)
 277                 return (NULL);
 278
 279         return (nvpair_get_nvlist(nvp));
 280 }
 281
 282 const nvlist_t *
 283 nvlist_get_pararr(const nvlist_t *nvl, void **cookiep)
 284 {
 285         const nvlist_t *ret;
 286
 287         ret = nvlist_get_array_next(nvl);
 288         if (ret != NULL) {
 289                 if (cookiep != NULL)
 290                         *cookiep = NULL;
 291                 return (ret);
 292         }
 293
 294         return (nvlist_get_parent(nvl, cookiep));
 295 }
 296
 297 bool
 298 nvlist_empty(const nvlist_t *nvl)
 299 {
 300
 301         NVLIST_ASSERT(nvl);
 302         PJDLOG_ASSERT(nvl->nvl_error == 0);
 303
 304         return (nvlist_first_nvpair(nvl) == NULL);
 305 }
 306
 307 int
 308 nvlist_flags(const nvlist_t *nvl)
 309 {
 310
 311         NVLIST_ASSERT(nvl);
 312         PJDLOG_ASSERT(nvl->nvl_error == 0);
 313
 314         return (nvl->nvl_flags & NV_FLAG_PUBLIC_MASK);
 315 }
 316
 317 void
 318 nvlist_set_flags(nvlist_t *nvl, int flags)
 319 {
 320
 321         NVLIST_ASSERT(nvl);
 322         PJDLOG_ASSERT(nvl->nvl_error == 0);
 323
 324         nvl->nvl_flags = flags;
 325 }
 326
 327 void
 328 nvlist_report_missing(int type, const char *name)
 329 {
 330
 331         PJDLOG_ABORT("Element '%s' of type %s doesn't exist.",
 332             name, nvpair_type_string(type));
 333 }
 334
 335 static nvpair_t *
 336 nvlist_find(const nvlist_t *nvl, int type, const char *name)
 337 {
 338         nvpair_t *nvp;
 339
 340         NVLIST_ASSERT(nvl);
 341         PJDLOG_ASSERT(nvl->nvl_error == 0);
 342         PJDLOG_ASSERT(type == NV_TYPE_NONE ||
 343             (type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));
 344
 345         for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
 346             nvp = nvlist_next_nvpair(nvl, nvp)) {
 347                 if (type != NV_TYPE_NONE && nvpair_type(nvp) != type)
 348                         continue;
 349                 if ((nvl->nvl_flags & NV_FLAG_IGNORE_CASE) != 0) {
 350                         if (strcasecmp(nvpair_name(nvp), name) != 0)
 351                                 continue;
 352                 } else {
 353                         if (strcmp(nvpair_name(nvp), name) != 0)
 354                                 continue;
 355                 }
 356                 break;
 357         }
 358
 359         if (nvp == NULL)
 360                 ERRNO_SET(ENOENT);
 361
 362         return (nvp);
 363 }
 364
 365 bool
 366 nvlist_exists_type(const nvlist_t *nvl, const char *name, int type)
 367 {
 368
 369         NVLIST_ASSERT(nvl);
 370         PJDLOG_ASSERT(nvl->nvl_error == 0);
 371         PJDLOG_ASSERT(type == NV_TYPE_NONE ||
 372             (type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));
 373
 374         return (nvlist_find(nvl, type, name) != NULL);
 375 }
 376
 377 void
 378 nvlist_free_type(nvlist_t *nvl, const char *name, int type)
 379 {
 380         nvpair_t *nvp;
 381
 382         NVLIST_ASSERT(nvl);
 383         PJDLOG_ASSERT(nvl->nvl_error == 0);
 384         PJDLOG_ASSERT(type == NV_TYPE_NONE ||
 385             (type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));
 386
 387         nvp = nvlist_find(nvl, type, name);
 388         if (nvp != NULL)
 389                 nvlist_free_nvpair(nvl, nvp);
 390         else
 391                 nvlist_report_missing(type, name);
 392 }
 393
 394 nvlist_t *
 395 nvlist_clone(const nvlist_t *nvl)
 396 {
 397         nvlist_t *newnvl;
 398         nvpair_t *nvp, *newnvp;
 399
 400         NVLIST_ASSERT(nvl);
 401
 402         if (nvl->nvl_error != 0) {
 403                 ERRNO_SET(nvl->nvl_error);
 404                 return (NULL);
 405         }
 406
 407         newnvl = nvlist_create(nvl->nvl_flags & NV_FLAG_PUBLIC_MASK);
 408         for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
 409             nvp = nvlist_next_nvpair(nvl, nvp)) {
 410                 newnvp = nvpair_clone(nvp);
 411                 if (newnvp == NULL)
 412                         break;
 413                 (void)nvlist_move_nvpair(newnvl, newnvp);
 414         }
 415         if (nvp != NULL) {
 416                 nvlist_destroy(newnvl);
 417                 return (NULL);
 418         }
 419         return (newnvl);
 420 }
 421
 422 #ifndef _KERNEL
 423 static bool
 424 nvlist_dump_error_check(const nvlist_t *nvl, int fd, int level)
 425 {
 426
 427         if (nvlist_error(nvl) != 0) {
 428                 dprintf(fd, "%*serror: %d\n", level * 4, "",
 429                     nvlist_error(nvl));
 430                 return (true);
 431         }
 432
 433         return (false);
 434 }
 435
 436 /*
 437  * Dump content of nvlist.
 438  */
 439 void
 440 nvlist_dump(const nvlist_t *nvl, int fd)
 441 {
 442         const nvlist_t *tmpnvl;
 443         nvpair_t *nvp, *tmpnvp;
 444         void *cookie;
 445         int level;
 446
 447         level = 0;
 448         if (nvlist_dump_error_check(nvl, fd, level))
 449                 return;
 450
 451         nvp = nvlist_first_nvpair(nvl);
 452         while (nvp != NULL) {
 453                 dprintf(fd, "%*s%s (%s):", level * 4, "", nvpair_name(nvp),
 454                     nvpair_type_string(nvpair_type(nvp)));
 455                 switch (nvpair_type(nvp)) {
 456                 case NV_TYPE_NULL:
 457                         dprintf(fd, " null\n");
 458                         break;
 459                 case NV_TYPE_BOOL:
 460                         dprintf(fd, " %s\n", nvpair_get_bool(nvp) ?
 461                             "TRUE" : "FALSE");
 462                         break;
 463                 case NV_TYPE_NUMBER:
 464                         dprintf(fd, " %ju (%jd) (0x%jx)\n",
 465                             (uintmax_t)nvpair_get_number(nvp),
 466                             (intmax_t)nvpair_get_number(nvp),
 467                             (uintmax_t)nvpair_get_number(nvp));
 468                         break;
 469                 case NV_TYPE_STRING:
 470                         dprintf(fd, " [%s]\n", nvpair_get_string(nvp));
 471                         break;
 472                 case NV_TYPE_NVLIST:
 473                         dprintf(fd, "\n");
 474                         tmpnvl = nvpair_get_nvlist(nvp);
 475                         if (nvlist_dump_error_check(tmpnvl, fd, level + 1))
 476                                 break;
 477                         tmpnvp = nvlist_first_nvpair(tmpnvl);
 478                         if (tmpnvp != NULL) {
 479                                 nvl = tmpnvl;
 480                                 nvp = tmpnvp;
 481                                 level++;
 482                                 continue;
 483                         }
 484                         break;
 485                 case NV_TYPE_DESCRIPTOR:
 486                         dprintf(fd, " %d\n", nvpair_get_descriptor(nvp));
 487                         break;
 488                 case NV_TYPE_BINARY:
 489                     {
 490                         const unsigned char *binary;
 491                         unsigned int ii;
 492                         size_t size;
 493
 494                         binary = nvpair_get_binary(nvp, &size);
 495                         dprintf(fd, " %zu ", size);
 496                         for (ii = 0; ii < size; ii++)
 497                                 dprintf(fd, "%02hhx", binary[ii]);
 498                         dprintf(fd, "\n");
 499                         break;
 500                     }
 501                 case NV_TYPE_BOOL_ARRAY:
 502                     {
 503                         const bool *value;
 504                         unsigned int ii;
 505                         size_t nitems;
 506
 507                         value = nvpair_get_bool_array(nvp, &nitems);
 508                         dprintf(fd, " [ ");
 509                         for (ii = 0; ii < nitems; ii++) {
 510                                 dprintf(fd, "%s", value[ii] ? "TRUE" : "FALSE");
 511                                 if (ii != nitems - 1)
 512                                         dprintf(fd, ", ");
 513                         }
 514                         dprintf(fd, " ]\n");
 515                         break;
 516                     }
 517                 case NV_TYPE_STRING_ARRAY:
 518                     {
 519                         const char * const *value;
 520                         unsigned int ii;
 521                         size_t nitems;
 522
 523                         value = nvpair_get_string_array(nvp, &nitems);
 524                         dprintf(fd, " [ ");
 525                         for (ii = 0; ii < nitems; ii++) {
 526                                 if (value[ii] == NULL)
 527                                         dprintf(fd, "NULL");
 528                                 else
 529                                         dprintf(fd, "\"%s\"", value[ii]);
 530                                 if (ii != nitems - 1)
 531                                         dprintf(fd, ", ");
 532                         }
 533                         dprintf(fd, " ]\n");
 534                         break;
 535                     }
 536                 case NV_TYPE_NUMBER_ARRAY:
 537                     {
 538                         const uint64_t *value;
 539                         unsigned int ii;
 540                         size_t nitems;
 541
 542                         value = nvpair_get_number_array(nvp, &nitems);
 543                         dprintf(fd, " [ ");
 544                         for (ii = 0; ii < nitems; ii++) {
 545                                 dprintf(fd, "%ju (%jd) (0x%jx)",
 546                                     value[ii], value[ii], value[ii]);
 547                                 if (ii != nitems - 1)
 548                                         dprintf(fd, ", ");
 549                         }
 550                         dprintf(fd, " ]\n");
 551                         break;
 552                     }
 553                 case NV_TYPE_DESCRIPTOR_ARRAY:
 554                     {
 555                         const int *value;
 556                         unsigned int ii;
 557                         size_t nitems;
 558
 559                         value = nvpair_get_descriptor_array(nvp, &nitems);
 560                         dprintf(fd, " [ ");
 561                         for (ii = 0; ii < nitems; ii++) {
 562                                 dprintf(fd, "%d", value[ii]);
 563                                 if (ii != nitems - 1)
 564                                         dprintf(fd, ", ");
 565                         }
 566                         dprintf(fd, " ]\n");
 567                         break;
 568                     }
 569                 case NV_TYPE_NVLIST_ARRAY:
 570                     {
 571                         const nvlist_t * const *value;
 572                         unsigned int ii;
 573                         size_t nitems;
 574
 575                         value = nvpair_get_nvlist_array(nvp, &nitems);
 576                         dprintf(fd, " %zu\n", nitems);
 577                         tmpnvl = NULL;
 578                         tmpnvp = NULL;
 579                         for (ii = 0; ii < nitems; ii++) {
 580                                 if (nvlist_dump_error_check(value[ii], fd,
 581                                     level + 1)) {
 582                                         break;
 583                                 }
 584
 585                                 if (tmpnvl == NULL) {
 586                                         tmpnvp = nvlist_first_nvpair(value[ii]);
 587                                         if (tmpnvp != NULL) {
 588                                                 tmpnvl = value[ii];
 589                                         } else {
 590                                                 dprintf(fd, "%*s,\n",
 591                                                     (level + 1) * 4, "");
 592                                         }
 593                                 }
 594                         }
 595                         if (tmpnvp != NULL) {
 596                                 nvl = tmpnvl;
 597                                 nvp = tmpnvp;
 598                                 level++;
 599                                 continue;
 600                         }
 601                         break;
 602                     }
 603                 default:
 604                         PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
 605                 }
 606
 607                 while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
 608                         do {
 609                                 cookie = NULL;
 610                                 if (nvlist_in_array(nvl))
 611                                         dprintf(fd, "%*s,\n", level * 4, "");
 612                                 nvl = nvlist_get_pararr(nvl, &cookie);
 613                                 if (nvl == NULL)
 614                                         return;
 615                                 if (nvlist_in_array(nvl) && cookie == NULL) {
 616                                         nvp = nvlist_first_nvpair(nvl);
 617                                 } else {
 618                                         nvp = cookie;
 619                                         level--;
 620                                 }
 621                         } while (nvp == NULL);
 622                         if (nvlist_in_array(nvl) && cookie == NULL)
 623                                 break;
 624                 }
 625         }
 626 }
 627
 628 void
 629 nvlist_fdump(const nvlist_t *nvl, FILE *fp)
 630 {
 631
 632         fflush(fp);
 633         nvlist_dump(nvl, fileno(fp));
 634 }
 635 #endif
 636
 637 /*
 638  * The function obtains size of the nvlist after nvlist_pack().
 639  */
 640 size_t
 641 nvlist_size(const nvlist_t *nvl)
 642 {
 643         const nvlist_t *tmpnvl;
 644         const nvlist_t * const *nvlarray;
 645         const nvpair_t *nvp, *tmpnvp;
 646         void *cookie;
 647         size_t size, nitems;
 648         unsigned int ii;
 649
 650         NVLIST_ASSERT(nvl);
 651         PJDLOG_ASSERT(nvl->nvl_error == 0);
 652
 653         size = sizeof(struct nvlist_header);
 654         nvp = nvlist_first_nvpair(nvl);
 655         while (nvp != NULL) {
 656                 size += nvpair_header_size();
 657                 size += strlen(nvpair_name(nvp)) + 1;
 658                 if (nvpair_type(nvp) == NV_TYPE_NVLIST) {
 659                         size += sizeof(struct nvlist_header);
 660                         size += nvpair_header_size() + 1;
 661                         tmpnvl = nvpair_get_nvlist(nvp);
 662                         PJDLOG_ASSERT(tmpnvl->nvl_error == 0);
 663                         tmpnvp = nvlist_first_nvpair(tmpnvl);
 664                         if (tmpnvp != NULL) {
 665                                 nvl = tmpnvl;
 666                                 nvp = tmpnvp;
 667                                 continue;
 668                         }
 669                 } else if (nvpair_type(nvp) == NV_TYPE_NVLIST_ARRAY) {
 670                         nvlarray = nvpair_get_nvlist_array(nvp, &nitems);
 671                         PJDLOG_ASSERT(nitems > 0);
 672
 673                         size += (nvpair_header_size() + 1) * nitems;
 674                         size += sizeof(struct nvlist_header) * nitems;
 675
 676                         tmpnvl = NULL;
 677                         tmpnvp = NULL;
 678                         for (ii = 0; ii < nitems; ii++) {
 679                                 PJDLOG_ASSERT(nvlarray[ii]->nvl_error == 0);
 680                                 tmpnvp = nvlist_first_nvpair(nvlarray[ii]);
 681                                 if (tmpnvp != NULL) {
 682                                         tmpnvl = nvlarray[ii];
 683                                         break;
 684                                 }
 685                         }
 686                         if (tmpnvp != NULL) {
 687                                 nvp = tmpnvp;
 688                                 nvl = tmpnvl;
 689                                 continue;
 690                         }
 691
 692                 } else {
 693                         size += nvpair_size(nvp);
 694                 }
 695
 696                 while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
 697                         do {
 698                                 cookie = NULL;
 699                                 nvl = nvlist_get_pararr(nvl, &cookie);
 700                                 if (nvl == NULL)
 701                                         goto out;
 702                                 if (nvlist_in_array(nvl) && cookie == NULL) {
 703                                         nvp = nvlist_first_nvpair(nvl);
 704                                 } else {
 705                                         nvp = cookie;
 706                                 }
 707                         } while (nvp == NULL);
 708                         if (nvlist_in_array(nvl) && cookie == NULL)
 709                                 break;
 710                 }
 711         }
 712
 713 out:
 714         return (size);
 715 }
 716
 717 #ifndef _KERNEL
 718 static int *
 719 nvlist_xdescriptors(const nvlist_t *nvl, int *descs)
 720 {
 721         void *cookie;
 722         nvpair_t *nvp;
 723         int type;
 724
 725         NVLIST_ASSERT(nvl);
 726         PJDLOG_ASSERT(nvl->nvl_error == 0);
 727
 728         cookie = NULL;
 729         do {
 730                 while (nvlist_next(nvl, &type, &cookie) != NULL) {
 731                         nvp = cookie;
 732                         switch (type) {
 733                         case NV_TYPE_DESCRIPTOR:
 734                                 *descs = nvpair_get_descriptor(nvp);
 735                                 descs++;
 736                                 break;
 737                         case NV_TYPE_DESCRIPTOR_ARRAY:
 738                             {
 739                                 const int *value;
 740                                 size_t nitems;
 741                                 unsigned int ii;
 742
 743                                 value = nvpair_get_descriptor_array(nvp,
 744                                     &nitems);
 745                                 for (ii = 0; ii < nitems; ii++) {
 746                                         *descs = value[ii];
 747                                         descs++;
 748                                 }
 749                                 break;
 750                             }
 751                         case NV_TYPE_NVLIST:
 752                                 nvl = nvpair_get_nvlist(nvp);
 753                                 cookie = NULL;
 754                                 break;
 755                         case NV_TYPE_NVLIST_ARRAY:
 756                             {
 757                                 const nvlist_t * const *value;
 758                                 size_t nitems;
 759
 760                                 value = nvpair_get_nvlist_array(nvp, &nitems);
 761                                 PJDLOG_ASSERT(value != NULL);
 762                                 PJDLOG_ASSERT(nitems > 0);
 763
 764                                 nvl = value[0];
 765                                 cookie = NULL;
 766                                 break;
 767                             }
 768                         }
 769                 }
 770         } while ((nvl = nvlist_get_pararr(nvl, &cookie)) != NULL);
 771
 772         return (descs);
 773 }
 774 #endif
 775
 776 #ifndef _KERNEL
 777 int *
 778 nvlist_descriptors(const nvlist_t *nvl, size_t *nitemsp)
 779 {
 780         size_t nitems;
 781         int *fds;
 782
 783         nitems = nvlist_ndescriptors(nvl);
 784         fds = nv_malloc(sizeof(fds[0]) * (nitems + 1));
 785         if (fds == NULL)
 786                 return (NULL);
 787         if (nitems > 0)
 788                 nvlist_xdescriptors(nvl, fds);
 789         fds[nitems] = -1;
 790         if (nitemsp != NULL)
 791                 *nitemsp = nitems;
 792         return (fds);
 793 }
 794 #endif
 795
 796 size_t
 797 nvlist_ndescriptors(const nvlist_t *nvl)
 798 {
 799 #ifndef _KERNEL
 800         void *cookie;
 801         nvpair_t *nvp;
 802         size_t ndescs;
 803         int type;
 804
 805         NVLIST_ASSERT(nvl);
 806         PJDLOG_ASSERT(nvl->nvl_error == 0);
 807
 808         ndescs = 0;
 809         cookie = NULL;
 810         do {
 811                 while (nvlist_next(nvl, &type, &cookie) != NULL) {
 812                         nvp = cookie;
 813                         switch (type) {
 814                         case NV_TYPE_DESCRIPTOR:
 815                                 ndescs++;
 816                                 break;
 817                         case NV_TYPE_NVLIST:
 818                                 nvl = nvpair_get_nvlist(nvp);
 819                                 cookie = NULL;
 820                                 break;
 821                         case NV_TYPE_NVLIST_ARRAY:
 822                             {
 823                                 const nvlist_t * const *value;
 824                                 size_t nitems;
 825
 826                                 value = nvpair_get_nvlist_array(nvp, &nitems);
 827                                 PJDLOG_ASSERT(value != NULL);
 828                                 PJDLOG_ASSERT(nitems > 0);
 829
 830                                 nvl = value[0];
 831                                 cookie = NULL;
 832                                 break;
 833                             }
 834                         case NV_TYPE_DESCRIPTOR_ARRAY:
 835                             {
 836                                 size_t nitems;
 837
 838                                 (void)nvpair_get_descriptor_array(nvp,
 839                                     &nitems);
 840                                 ndescs += nitems;
 841                                 break;
 842                             }
 843                         }
 844                 }
 845         } while ((nvl = nvlist_get_pararr(nvl, &cookie)) != NULL);
 846
 847         return (ndescs);
 848 #else
 849         return (0);
 850 #endif
 851 }
 852
 853 static unsigned char *
 854 nvlist_pack_header(const nvlist_t *nvl, unsigned char *ptr, size_t *leftp)
 855 {
 856         struct nvlist_header nvlhdr;
 857
 858         NVLIST_ASSERT(nvl);
 859
 860         nvlhdr.nvlh_magic = NVLIST_HEADER_MAGIC;
 861         nvlhdr.nvlh_version = NVLIST_HEADER_VERSION;
 862         nvlhdr.nvlh_flags = nvl->nvl_flags;
 863 #if BYTE_ORDER == BIG_ENDIAN
 864         nvlhdr.nvlh_flags |= NV_FLAG_BIG_ENDIAN;
 865 #endif
 866         nvlhdr.nvlh_descriptors = nvlist_ndescriptors(nvl);
 867         nvlhdr.nvlh_size = *leftp - sizeof(nvlhdr);
 868         PJDLOG_ASSERT(*leftp >= sizeof(nvlhdr));
 869         memcpy(ptr, &nvlhdr, sizeof(nvlhdr));
 870         ptr += sizeof(nvlhdr);
 871         *leftp -= sizeof(nvlhdr);
 872
 873         return (ptr);
 874 }
 875
 876 static void *
 877 nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
 878 {
 879         unsigned char *buf, *ptr;
 880         size_t left, size;
 881         const nvlist_t *tmpnvl;
 882         nvpair_t *nvp, *tmpnvp;
 883         void *cookie;
 884
 885         NVLIST_ASSERT(nvl);
 886
 887         if (nvl->nvl_error != 0) {
 888                 ERRNO_SET(nvl->nvl_error);
 889                 return (NULL);
 890         }
 891
 892         size = nvlist_size(nvl);
 893         buf = nv_malloc(size);
 894         if (buf == NULL)
 895                 return (NULL);
 896
 897         ptr = buf;
 898         left = size;
 899
 900         ptr = nvlist_pack_header(nvl, ptr, &left);
 901
 902         nvp = nvlist_first_nvpair(nvl);
 903         while (nvp != NULL) {
 904                 NVPAIR_ASSERT(nvp);
 905
 906                 nvpair_init_datasize(nvp);
 907                 ptr = nvpair_pack_header(nvp, ptr, &left);
 908                 if (ptr == NULL)
 909                         goto fail;
 910                 switch (nvpair_type(nvp)) {
 911                 case NV_TYPE_NULL:
 912                         ptr = nvpair_pack_null(nvp, ptr, &left);
 913                         break;
 914                 case NV_TYPE_BOOL:
 915                         ptr = nvpair_pack_bool(nvp, ptr, &left);
 916                         break;
 917                 case NV_TYPE_NUMBER:
 918                         ptr = nvpair_pack_number(nvp, ptr, &left);
 919                         break;
 920                 case NV_TYPE_STRING:
 921                         ptr = nvpair_pack_string(nvp, ptr, &left);
 922                         break;
 923                 case NV_TYPE_NVLIST:
 924                         tmpnvl = nvpair_get_nvlist(nvp);
 925                         ptr = nvlist_pack_header(tmpnvl, ptr, &left);
 926                         if (ptr == NULL)
 927                                 goto fail;
 928                         tmpnvp = nvlist_first_nvpair(tmpnvl);
 929                         if (tmpnvp != NULL) {
 930                                 nvl = tmpnvl;
 931                                 nvp = tmpnvp;
 932                                 continue;
 933                         }
 934                         ptr = nvpair_pack_nvlist_up(ptr, &left);
 935                         break;
 936 #ifndef _KERNEL
 937                 case NV_TYPE_DESCRIPTOR:
 938                         ptr = nvpair_pack_descriptor(nvp, ptr, fdidxp, &left);
 939                         break;
 940                 case NV_TYPE_DESCRIPTOR_ARRAY:
 941                         ptr = nvpair_pack_descriptor_array(nvp, ptr, fdidxp,
 942                             &left);
 943                         break;
 944 #endif
 945                 case NV_TYPE_BINARY:
 946                         ptr = nvpair_pack_binary(nvp, ptr, &left);
 947                         break;
 948                 case NV_TYPE_BOOL_ARRAY:
 949                         ptr = nvpair_pack_bool_array(nvp, ptr, &left);
 950                         break;
 951                 case NV_TYPE_NUMBER_ARRAY:
 952                         ptr = nvpair_pack_number_array(nvp, ptr, &left);
 953                         break;
 954                 case NV_TYPE_STRING_ARRAY:
 955                         ptr = nvpair_pack_string_array(nvp, ptr, &left);
 956                         break;
 957                 case NV_TYPE_NVLIST_ARRAY:
 958                     {
 959                         const nvlist_t * const * value;
 960                         size_t nitems;
 961                         unsigned int ii;
 962
 963                         tmpnvl = NULL;
 964                         value = nvpair_get_nvlist_array(nvp, &nitems);
 965                         for (ii = 0; ii < nitems; ii++) {
 966                                 ptr = nvlist_pack_header(value[ii], ptr, &left);
 967                                 if (ptr == NULL)
 968                                         goto out;
 969                                 tmpnvp = nvlist_first_nvpair(value[ii]);
 970                                 if (tmpnvp != NULL) {
 971                                         tmpnvl = value[ii];
 972                                         break;
 973                                 }
 974                                 ptr = nvpair_pack_nvlist_array_next(ptr, &left);
 975                                 if (ptr == NULL)
 976                                         goto out;
 977                         }
 978                         if (tmpnvl != NULL) {
 979                                 nvl = tmpnvl;
 980                                 nvp = tmpnvp;
 981                                 continue;
 982                         }
 983                         break;
 984                     }
 985                 default:
 986                         PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
 987                 }
 988                 if (ptr == NULL)
 989                         goto fail;
 990                 while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
 991                         do {
 992                                 cookie = NULL;
 993                                 if (nvlist_in_array(nvl)) {
 994                                         ptr = nvpair_pack_nvlist_array_next(ptr,
 995                                             &left);
 996                                         if (ptr == NULL)
 997                                                 goto fail;
 998                                 }
 999                                 nvl = nvlist_get_pararr(nvl, &cookie);
1000                                 if (nvl == NULL)
1001                                         goto out;
1002                                 if (nvlist_in_array(nvl) && cookie == NULL) {
1003                                         nvp = nvlist_first_nvpair(nvl);
1004                                         ptr = nvlist_pack_header(nvl, ptr,
1005                                             &left);
1006                                         if (ptr == NULL)
1007                                                 goto fail;
1008                                 } else if (nvpair_type((nvpair_t *)cookie) !=
1009                                     NV_TYPE_NVLIST_ARRAY) {
1010                                         ptr = nvpair_pack_nvlist_up(ptr, &left);
1011                                         if (ptr == NULL)
1012                                                 goto fail;
1013                                         nvp = cookie;
1014                                 } else {
1015                                         nvp = cookie;
1016                                 }
1017                         } while (nvp == NULL);
1018                         if (nvlist_in_array(nvl) && cookie == NULL)
1019                                 break;
1020                 }
1021         }
1022
1023 out:
1024         if (sizep != NULL)
1025                 *sizep = size;
1026         return (buf);
1027 fail:
1028         nv_free(buf);
1029         return (NULL);
1030 }
1031
1032 void *
1033 nvlist_pack(const nvlist_t *nvl, size_t *sizep)
1034 {
1035
1036         NVLIST_ASSERT(nvl);
1037
1038         if (nvl->nvl_error != 0) {
1039                 ERRNO_SET(nvl->nvl_error);
1040                 return (NULL);
1041         }
1042
1043         if (nvlist_ndescriptors(nvl) > 0) {
1044                 ERRNO_SET(EOPNOTSUPP);
1045                 return (NULL);
1046         }
1047
1048         return (nvlist_xpack(nvl, NULL, sizep));
1049 }
1050
1051 static bool
1052 nvlist_check_header(struct nvlist_header *nvlhdrp)
1053 {
1054
1055         if (nvlhdrp->nvlh_magic != NVLIST_HEADER_MAGIC) {
1056                 ERRNO_SET(EINVAL);
1057                 return (false);
1058         }
1059         if ((nvlhdrp->nvlh_flags & ~NV_FLAG_ALL_MASK) != 0) {
1060                 ERRNO_SET(EINVAL);
1061                 return (false);
1062         }
1063 #if BYTE_ORDER == BIG_ENDIAN
1064         if ((nvlhdrp->nvlh_flags & NV_FLAG_BIG_ENDIAN) == 0) {
1065                 nvlhdrp->nvlh_size = le64toh(nvlhdrp->nvlh_size);
1066                 nvlhdrp->nvlh_descriptors = le64toh(nvlhdrp->nvlh_descriptors);
1067         }
1068 #else
1069         if ((nvlhdrp->nvlh_flags & NV_FLAG_BIG_ENDIAN) != 0) {
1070                 nvlhdrp->nvlh_size = be64toh(nvlhdrp->nvlh_size);
1071                 nvlhdrp->nvlh_descriptors = be64toh(nvlhdrp->nvlh_descriptors);
1072         }
1073 #endif
1074         return (true);
1075 }
1076
1077 const unsigned char *
1078 nvlist_unpack_header(nvlist_t *nvl, const unsigned char *ptr, size_t nfds,
1079     bool *isbep, size_t *leftp)
1080 {
1081         struct nvlist_header nvlhdr;
1082         int inarrayf;
1083
1084         if (*leftp < sizeof(nvlhdr))
1085                 goto fail;
1086
1087         memcpy(&nvlhdr, ptr, sizeof(nvlhdr));
1088
1089         if (!nvlist_check_header(&nvlhdr))
1090                 goto fail;
1091
1092         if (nvlhdr.nvlh_size != *leftp - sizeof(nvlhdr))
1093                 goto fail;
1094
1095         /*
1096          * nvlh_descriptors might be smaller than nfds in embedded nvlists.
1097          */
1098         if (nvlhdr.nvlh_descriptors > nfds)
1099                 goto fail;
1100
1101         if ((nvlhdr.nvlh_flags & ~NV_FLAG_ALL_MASK) != 0)
1102                 goto fail;
1103
1104         inarrayf = (nvl->nvl_flags & NV_FLAG_IN_ARRAY);
1105         nvl->nvl_flags = (nvlhdr.nvlh_flags & NV_FLAG_PUBLIC_MASK) | inarrayf;
1106
1107         ptr += sizeof(nvlhdr);
1108         if (isbep != NULL)
1109                 *isbep = (((int)nvlhdr.nvlh_flags & NV_FLAG_BIG_ENDIAN) != 0);
1110         *leftp -= sizeof(nvlhdr);
1111
1112         return (ptr);
1113 fail:
1114         ERRNO_SET(EINVAL);
1115         return (NULL);
1116 }
1117
1118 static nvlist_t *
1119 nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds,
1120     int flags)
1121 {
1122         const unsigned char *ptr;
1123         nvlist_t *nvl, *retnvl, *tmpnvl, *array;
1124         nvpair_t *nvp;
1125         size_t left;
1126         bool isbe;
1127
1128         PJDLOG_ASSERT((flags & ~(NV_FLAG_PUBLIC_MASK)) == 0);
1129
1130         left = size;
1131         ptr = buf;
1132
1133         tmpnvl = array = NULL;
1134         nvl = retnvl = nvlist_create(0);
1135         if (nvl == NULL)
1136                 goto fail;
1137
1138         ptr = nvlist_unpack_header(nvl, ptr, nfds, &isbe, &left);
1139         if (ptr == NULL)
1140                 goto fail;
1141         if (nvl->nvl_flags != flags) {
1142                 ERRNO_SET(EILSEQ);
1143                 goto fail;
1144         }
1145
1146         while (left > 0) {
1147                 ptr = nvpair_unpack(isbe, ptr, &left, &nvp);
1148                 if (ptr == NULL)
1149                         goto fail;
1150                 switch (nvpair_type(nvp)) {
1151                 case NV_TYPE_NULL:
1152                         ptr = nvpair_unpack_null(isbe, nvp, ptr, &left);
1153                         break;
1154                 case NV_TYPE_BOOL:
1155                         ptr = nvpair_unpack_bool(isbe, nvp, ptr, &left);
1156                         break;
1157                 case NV_TYPE_NUMBER:
1158                         ptr = nvpair_unpack_number(isbe, nvp, ptr, &left);
1159                         break;
1160                 case NV_TYPE_STRING:
1161                         ptr = nvpair_unpack_string(isbe, nvp, ptr, &left);
1162                         break;
1163                 case NV_TYPE_NVLIST:
1164                         ptr = nvpair_unpack_nvlist(isbe, nvp, ptr, &left, nfds,
1165                             &tmpnvl);
1166                         if (tmpnvl == NULL || ptr == NULL)
1167                                 goto fail;
1168                         nvlist_set_parent(tmpnvl, nvp);
1169                         break;
1170 #ifndef _KERNEL
1171                 case NV_TYPE_DESCRIPTOR:
1172                         ptr = nvpair_unpack_descriptor(isbe, nvp, ptr, &left,
1173                             fds, nfds);
1174                         break;
1175                 case NV_TYPE_DESCRIPTOR_ARRAY:
1176                         ptr = nvpair_unpack_descriptor_array(isbe, nvp, ptr,
1177                             &left, fds, nfds);
1178                         break;
1179 #endif
1180                 case NV_TYPE_BINARY:
1181                         ptr = nvpair_unpack_binary(isbe, nvp, ptr, &left);
1182                         break;
1183                 case NV_TYPE_NVLIST_UP:
1184                         if (nvl->nvl_parent == NULL)
1185                                 goto fail;
1186                         nvl = nvpair_nvlist(nvl->nvl_parent);
1187                         nvpair_free_structure(nvp);
1188                         continue;
1189                 case NV_TYPE_NVLIST_ARRAY_NEXT:
1190                         if (nvl->nvl_array_next == NULL) {
1191                                 if (nvl->nvl_parent == NULL)
1192                                         goto fail;
1193                                 nvl = nvpair_nvlist(nvl->nvl_parent);
1194                         } else {
1195                                 nvl = __DECONST(nvlist_t *,
1196                                     nvlist_get_array_next(nvl));
1197                                 ptr = nvlist_unpack_header(nvl, ptr, nfds,
1198                                     &isbe, &left);
1199                                 if (ptr == NULL)
1200                                         goto fail;
1201                         }
1202                         nvpair_free_structure(nvp);
1203                         continue;
1204                 case NV_TYPE_BOOL_ARRAY:
1205                         ptr = nvpair_unpack_bool_array(isbe, nvp, ptr, &left);
1206                         break;
1207                 case NV_TYPE_NUMBER_ARRAY:
1208                         ptr = nvpair_unpack_number_array(isbe, nvp, ptr, &left);
1209                         break;
1210                 case NV_TYPE_STRING_ARRAY:
1211                         ptr = nvpair_unpack_string_array(isbe, nvp, ptr, &left);
1212                         break;
1213                 case NV_TYPE_NVLIST_ARRAY:
1214                         ptr = nvpair_unpack_nvlist_array(isbe, nvp, ptr, &left,
1215                             &array);
1216                         if (ptr == NULL)
1217                                 goto fail;
1218                         PJDLOG_ASSERT(array != NULL);
1219                         tmpnvl = array;
1220                         do {
1221                                 nvlist_set_parent(array, nvp);
1222                                 array = __DECONST(nvlist_t *,
1223                                     nvlist_get_array_next(array));
1224                         } while (array != NULL);
1225                         ptr = nvlist_unpack_header(tmpnvl, ptr, nfds, &isbe,
1226                             &left);
1227                         break;
1228                 default:
1229                         PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
1230                 }
1231                 if (ptr == NULL)
1232                         goto fail;
1233                 if (!nvlist_move_nvpair(nvl, nvp))
1234                         goto fail;
1235                 if (tmpnvl != NULL) {
1236                         nvl = tmpnvl;
1237                         tmpnvl = NULL;
1238                 }
1239         }
1240
1241         return (retnvl);
1242 fail:
1243         nvlist_destroy(retnvl);
1244         return (NULL);
1245 }
1246
1247 nvlist_t *
1248 nvlist_unpack(const void *buf, size_t size, int flags)
1249 {
1250
1251         return (nvlist_xunpack(buf, size, NULL, 0, flags));
1252 }
1253
1254 #ifndef _KERNEL
1255 int
1256 nvlist_send(int sock, const nvlist_t *nvl)
1257 {
1258         size_t datasize, nfds;
1259         int *fds;
1260         void *data;
1261         int64_t fdidx;
1262         int ret;
1263
1264         if (nvlist_error(nvl) != 0) {
1265                 ERRNO_SET(nvlist_error(nvl));
1266                 return (-1);
1267         }
1268
1269         fds = nvlist_descriptors(nvl, &nfds);
1270         if (fds == NULL)
1271                 return (-1);
1272
1273         ret = -1;
1274         fdidx = 0;
1275
1276         data = nvlist_xpack(nvl, &fdidx, &datasize);
1277         if (data == NULL)
1278                 goto out;
1279
1280         if (buf_send(sock, data, datasize) == -1)
1281                 goto out;
1282
1283         if (nfds > 0) {
1284                 if (fd_send(sock, fds, nfds) == -1)
1285                         goto out;
1286         }
1287
1288         ret = 0;
1289 out:
1290         ERRNO_SAVE();
1291         nv_free(fds);
1292         nv_free(data);
1293         ERRNO_RESTORE();
1294         return (ret);
1295 }
1296
1297 nvlist_t *
1298 nvlist_recv(int sock, int flags)
1299 {
1300         struct nvlist_header nvlhdr;
1301         nvlist_t *nvl, *ret;
1302         unsigned char *buf;
1303         size_t nfds, size, i;
1304         int *fds;
1305
1306         if (buf_recv(sock, &nvlhdr, sizeof(nvlhdr)) == -1)
1307                 return (NULL);
1308
1309         if (!nvlist_check_header(&nvlhdr))
1310                 return (NULL);
1311
1312         nfds = (size_t)nvlhdr.nvlh_descriptors;
1313         size = sizeof(nvlhdr) + (size_t)nvlhdr.nvlh_size;
1314
1315         buf = nv_malloc(size);
1316         if (buf == NULL)
1317                 return (NULL);
1318
1319         memcpy(buf, &nvlhdr, sizeof(nvlhdr));
1320
1321         ret = NULL;
1322         fds = NULL;
1323
1324         if (buf_recv(sock, buf + sizeof(nvlhdr), size - sizeof(nvlhdr)) == -1)
1325                 goto out;
1326
1327         if (nfds > 0) {
1328                 fds = nv_malloc(nfds * sizeof(fds[0]));
1329                 if (fds == NULL)
1330                         goto out;
1331                 if (fd_recv(sock, fds, nfds) == -1)
1332                         goto out;
1333         }
1334
1335         nvl = nvlist_xunpack(buf, size, fds, nfds, flags);
1336         if (nvl == NULL) {
1337                 ERRNO_SAVE();
1338                 for (i = 0; i < nfds; i++)
1339                         close(fds[i]);
1340                 ERRNO_RESTORE();
1341                 goto out;
1342         }
1343
1344         ret = nvl;
1345 out:
1346         ERRNO_SAVE();
1347         nv_free(buf);
1348         nv_free(fds);
1349         ERRNO_RESTORE();
1350
1351         return (ret);
1352 }
1353
1354 nvlist_t *
1355 nvlist_xfer(int sock, nvlist_t *nvl, int flags)
1356 {
1357
1358         if (nvlist_send(sock, nvl) < 0) {
1359                 nvlist_destroy(nvl);
1360                 return (NULL);
1361         }
1362         nvlist_destroy(nvl);
1363         return (nvlist_recv(sock, flags));
1364 }
1365 #endif
1366
1367 nvpair_t *
1368 nvlist_first_nvpair(const nvlist_t *nvl)
1369 {
1370
1371         NVLIST_ASSERT(nvl);
1372
1373         return (TAILQ_FIRST(&nvl->nvl_head));
1374 }
1375
1376 nvpair_t *
1377 nvlist_next_nvpair(const nvlist_t *nvl __unused, const nvpair_t *nvp)
1378 {
1379         nvpair_t *retnvp;
1380
1381         NVLIST_ASSERT(nvl);
1382         NVPAIR_ASSERT(nvp);
1383         PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
1384
1385         retnvp = nvpair_next(nvp);
1386         PJDLOG_ASSERT(retnvp == NULL || nvpair_nvlist(retnvp) == nvl);
1387
1388         return (retnvp);
1389
1390 }
1391
1392 nvpair_t *
1393 nvlist_prev_nvpair(const nvlist_t *nvl __unused, const nvpair_t *nvp)
1394 {
1395         nvpair_t *retnvp;
1396
1397         NVLIST_ASSERT(nvl);
1398         NVPAIR_ASSERT(nvp);
1399         PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
1400
1401         retnvp = nvpair_prev(nvp);
1402         PJDLOG_ASSERT(nvpair_nvlist(retnvp) == nvl);
1403
1404         return (retnvp);
1405 }
1406
1407 const char *
1408 nvlist_next(const nvlist_t *nvl, int *typep, void **cookiep)
1409 {
1410         nvpair_t *nvp;
1411
1412         NVLIST_ASSERT(nvl);
1413
1414         if (cookiep == NULL || *cookiep == NULL)
1415                 nvp = nvlist_first_nvpair(nvl);
1416         else
1417                 nvp = nvlist_next_nvpair(nvl, *cookiep);
1418         if (nvp == NULL)
1419                 return (NULL);
1420         if (typep != NULL)
1421                 *typep = nvpair_type(nvp);
1422         if (cookiep != NULL)
1423                 *cookiep = nvp;
1424         return (nvpair_name(nvp));
1425 }
1426
1427 bool
1428 nvlist_exists(const nvlist_t *nvl, const char *name)
1429 {
1430
1431         return (nvlist_find(nvl, NV_TYPE_NONE, name) != NULL);
1432 }
1433
1434 #define NVLIST_EXISTS(type, TYPE)                                       \
1435 bool                                                                    \
1436 nvlist_exists_##type(const nvlist_t *nvl, const char *name)             \
1437 {                                                                       \
1438                                                                         \
1439         return (nvlist_find(nvl, NV_TYPE_##TYPE, name) != NULL);        \
1440 }
1441
1442 NVLIST_EXISTS(null, NULL)
1443 NVLIST_EXISTS(bool, BOOL)
1444 NVLIST_EXISTS(number, NUMBER)
1445 NVLIST_EXISTS(string, STRING)
1446 NVLIST_EXISTS(nvlist, NVLIST)
1447 NVLIST_EXISTS(binary, BINARY)
1448 NVLIST_EXISTS(bool_array, BOOL_ARRAY)
1449 NVLIST_EXISTS(number_array, NUMBER_ARRAY)
1450 NVLIST_EXISTS(string_array, STRING_ARRAY)
1451 NVLIST_EXISTS(nvlist_array, NVLIST_ARRAY)
1452 #ifndef _KERNEL
1453 NVLIST_EXISTS(descriptor, DESCRIPTOR)
1454 NVLIST_EXISTS(descriptor_array, DESCRIPTOR_ARRAY)
1455 #endif
1456
1457 #undef  NVLIST_EXISTS
1458
1459 void
1460 nvlist_add_nvpair(nvlist_t *nvl, const nvpair_t *nvp)
1461 {
1462         nvpair_t *newnvp;
1463
1464         NVPAIR_ASSERT(nvp);
1465
1466         if (nvlist_error(nvl) != 0) {
1467                 ERRNO_SET(nvlist_error(nvl));
1468                 return;
1469         }
1470         if ((nvl->nvl_flags & NV_FLAG_NO_UNIQUE) == 0) {
1471                 if (nvlist_exists(nvl, nvpair_name(nvp))) {
1472                         nvl->nvl_error = EEXIST;
1473                         ERRNO_SET(nvlist_error(nvl));
1474                         return;
1475                 }
1476         }
1477
1478         newnvp = nvpair_clone(nvp);
1479         if (newnvp == NULL) {
1480                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1481                 ERRNO_SET(nvlist_error(nvl));
1482                 return;
1483         }
1484
1485         nvpair_insert(&nvl->nvl_head, newnvp, nvl);
1486 }
1487
1488 void
1489 nvlist_add_stringf(nvlist_t *nvl, const char *name, const char *valuefmt, ...)
1490 {
1491         va_list valueap;
1492
1493         va_start(valueap, valuefmt);
1494         nvlist_add_stringv(nvl, name, valuefmt, valueap);
1495         va_end(valueap);
1496 }
1497
1498 void
1499 nvlist_add_stringv(nvlist_t *nvl, const char *name, const char *valuefmt,
1500     va_list valueap)
1501 {
1502         nvpair_t *nvp;
1503
1504         if (nvlist_error(nvl) != 0) {
1505                 ERRNO_SET(nvlist_error(nvl));
1506                 return;
1507         }
1508
1509         nvp = nvpair_create_stringv(name, valuefmt, valueap);
1510         if (nvp == NULL) {
1511                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1512                 ERRNO_SET(nvl->nvl_error);
1513         } else {
1514                 (void)nvlist_move_nvpair(nvl, nvp);
1515         }
1516 }
1517
1518 void
1519 nvlist_add_null(nvlist_t *nvl, const char *name)
1520 {
1521         nvpair_t *nvp;
1522
1523         if (nvlist_error(nvl) != 0) {
1524                 ERRNO_SET(nvlist_error(nvl));
1525                 return;
1526         }
1527
1528         nvp = nvpair_create_null(name);
1529         if (nvp == NULL) {
1530                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1531                 ERRNO_SET(nvl->nvl_error);
1532         } else {
1533                 (void)nvlist_move_nvpair(nvl, nvp);
1534         }
1535 }
1536
1537 void
1538 nvlist_add_binary(nvlist_t *nvl, const char *name, const void *value,
1539     size_t size)
1540 {
1541         nvpair_t *nvp;
1542
1543         if (nvlist_error(nvl) != 0) {
1544                 ERRNO_SET(nvlist_error(nvl));
1545                 return;
1546         }
1547
1548         nvp = nvpair_create_binary(name, value, size);
1549         if (nvp == NULL) {
1550                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1551                 ERRNO_SET(nvl->nvl_error);
1552         } else {
1553                 (void)nvlist_move_nvpair(nvl, nvp);
1554         }
1555 }
1556
1557
1558 #define NVLIST_ADD(vtype, type)                                         \
1559 void                                                                    \
1560 nvlist_add_##type(nvlist_t *nvl, const char *name, vtype value)         \
1561 {                                                                       \
1562         nvpair_t *nvp;                                                  \
1563                                                                         \
1564         if (nvlist_error(nvl) != 0) {                                   \
1565                 ERRNO_SET(nvlist_error(nvl));                           \
1566                 return;                                                 \
1567         }                                                               \
1568                                                                         \
1569         nvp = nvpair_create_##type(name, value);                        \
1570         if (nvp == NULL) {                                              \
1571                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);              \
1572                 ERRNO_SET(nvl->nvl_error);                              \
1573         } else {                                                        \
1574                 (void)nvlist_move_nvpair(nvl, nvp);                     \
1575         }                                                               \
1576 }
1577
1578 NVLIST_ADD(bool, bool)
1579 NVLIST_ADD(uint64_t, number)
1580 NVLIST_ADD(const char *, string)
1581 NVLIST_ADD(const nvlist_t *, nvlist)
1582 #ifndef _KERNEL
1583 NVLIST_ADD(int, descriptor);
1584 #endif
1585
1586 #undef  NVLIST_ADD
1587
1588 #define NVLIST_ADD_ARRAY(vtype, type)                                   \
1589 void                                                                    \
1590 nvlist_add_##type##_array(nvlist_t *nvl, const char *name, vtype value, \
1591     size_t nitems)                                                      \
1592 {                                                                       \
1593         nvpair_t *nvp;                                                  \
1594                                                                         \
1595         if (nvlist_error(nvl) != 0) {                                   \
1596                 ERRNO_SET(nvlist_error(nvl));                           \
1597                 return;                                                 \
1598         }                                                               \
1599                                                                         \
1600         nvp = nvpair_create_##type##_array(name, value, nitems);        \
1601         if (nvp == NULL) {                                              \
1602                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);              \
1603                 ERRNO_SET(nvl->nvl_error);                              \
1604         } else {                                                        \
1605                 (void)nvlist_move_nvpair(nvl, nvp);                     \
1606         }                                                               \
1607 }
1608
1609 NVLIST_ADD_ARRAY(const bool *, bool)
1610 NVLIST_ADD_ARRAY(const uint64_t *, number)
1611 NVLIST_ADD_ARRAY(const char * const *, string)
1612 NVLIST_ADD_ARRAY(const nvlist_t * const *, nvlist)
1613 #ifndef _KERNEL
1614 NVLIST_ADD_ARRAY(const int *, descriptor)
1615 #endif
1616
1617 #undef  NVLIST_ADD_ARRAY
1618
1619 #define NVLIST_APPEND_ARRAY(vtype, type, TYPE)                          \
1620 void                                                                    \
1621 nvlist_append_##type##_array(nvlist_t *nvl, const char *name, vtype value)\
1622 {                                                                       \
1623         nvpair_t *nvp;                                                  \
1624                                                                         \
1625         if (nvlist_error(nvl) != 0) {                                   \
1626                 ERRNO_SET(nvlist_error(nvl));                           \
1627                 return;                                                 \
1628         }                                                               \
1629         nvp = nvlist_find(nvl, NV_TYPE_##TYPE##_ARRAY, name);           \
1630         if (nvp == NULL) {                                              \
1631                 nvlist_add_##type##_array(nvl, name, &value, 1);        \
1632                 return;                                                 \
1633         }                                                               \
1634         if (nvpair_append_##type##_array(nvp, value) == -1) {           \
1635                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);              \
1636                 ERRNO_SET(nvl->nvl_error);                              \
1637         }                                                               \
1638 }
1639
1640 NVLIST_APPEND_ARRAY(const bool, bool, BOOL)
1641 NVLIST_APPEND_ARRAY(const uint64_t, number, NUMBER)
1642 NVLIST_APPEND_ARRAY(const char *, string, STRING)
1643 NVLIST_APPEND_ARRAY(const nvlist_t *, nvlist, NVLIST)
1644 #ifndef _KERNEL
1645 NVLIST_APPEND_ARRAY(const int, descriptor, DESCRIPTOR)
1646 #endif
1647
1648 #undef  NVLIST_APPEND_ARRAY
1649
1650 bool
1651 nvlist_move_nvpair(nvlist_t *nvl, nvpair_t *nvp)
1652 {
1653
1654         NVPAIR_ASSERT(nvp);
1655         PJDLOG_ASSERT(nvpair_nvlist(nvp) == NULL);
1656
1657         if (nvlist_error(nvl) != 0) {
1658                 nvpair_free(nvp);
1659                 ERRNO_SET(nvlist_error(nvl));
1660                 return (false);
1661         }
1662         if ((nvl->nvl_flags & NV_FLAG_NO_UNIQUE) == 0) {
1663                 if (nvlist_exists(nvl, nvpair_name(nvp))) {
1664                         nvpair_free(nvp);
1665                         nvl->nvl_error = EEXIST;
1666                         ERRNO_SET(nvl->nvl_error);
1667                         return (false);
1668                 }
1669         }
1670
1671         nvpair_insert(&nvl->nvl_head, nvp, nvl);
1672         return (true);
1673 }
1674
1675 void
1676 nvlist_move_string(nvlist_t *nvl, const char *name, char *value)
1677 {
1678         nvpair_t *nvp;
1679
1680         if (nvlist_error(nvl) != 0) {
1681                 nv_free(value);
1682                 ERRNO_SET(nvlist_error(nvl));
1683                 return;
1684         }
1685
1686         nvp = nvpair_move_string(name, value);
1687         if (nvp == NULL) {
1688                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1689                 ERRNO_SET(nvl->nvl_error);
1690         } else {
1691                 (void)nvlist_move_nvpair(nvl, nvp);
1692         }
1693 }
1694
1695 void
1696 nvlist_move_nvlist(nvlist_t *nvl, const char *name, nvlist_t *value)
1697 {
1698         nvpair_t *nvp;
1699
1700         if (nvlist_error(nvl) != 0) {
1701                 if (value != NULL && nvlist_get_nvpair_parent(value) != NULL)
1702                         nvlist_destroy(value);
1703                 ERRNO_SET(nvlist_error(nvl));
1704                 return;
1705         }
1706
1707         nvp = nvpair_move_nvlist(name, value);
1708         if (nvp == NULL) {
1709                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1710                 ERRNO_SET(nvl->nvl_error);
1711         } else {
1712                 (void)nvlist_move_nvpair(nvl, nvp);
1713         }
1714 }
1715
1716 #ifndef _KERNEL
1717 void
1718 nvlist_move_descriptor(nvlist_t *nvl, const char *name, int value)
1719 {
1720         nvpair_t *nvp;
1721
1722         if (nvlist_error(nvl) != 0) {
1723                 close(value);
1724                 ERRNO_SET(nvlist_error(nvl));
1725                 return;
1726         }
1727
1728         nvp = nvpair_move_descriptor(name, value);
1729         if (nvp == NULL) {
1730                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1731                 ERRNO_SET(nvl->nvl_error);
1732         } else {
1733                 (void)nvlist_move_nvpair(nvl, nvp);
1734         }
1735 }
1736 #endif
1737
1738 void
1739 nvlist_move_binary(nvlist_t *nvl, const char *name, void *value, size_t size)
1740 {
1741         nvpair_t *nvp;
1742
1743         if (nvlist_error(nvl) != 0) {
1744                 nv_free(value);
1745                 ERRNO_SET(nvlist_error(nvl));
1746                 return;
1747         }
1748
1749         nvp = nvpair_move_binary(name, value, size);
1750         if (nvp == NULL) {
1751                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1752                 ERRNO_SET(nvl->nvl_error);
1753         } else {
1754                 (void)nvlist_move_nvpair(nvl, nvp);
1755         }
1756 }
1757
1758 void
1759 nvlist_move_bool_array(nvlist_t *nvl, const char *name, bool *value,
1760     size_t nitems)
1761 {
1762         nvpair_t *nvp;
1763
1764         if (nvlist_error(nvl) != 0) {
1765                 nv_free(value);
1766                 ERRNO_SET(nvlist_error(nvl));
1767                 return;
1768         }
1769
1770         nvp = nvpair_move_bool_array(name, value, nitems);
1771         if (nvp == NULL) {
1772                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1773                 ERRNO_SET(nvl->nvl_error);
1774         } else {
1775                 (void)nvlist_move_nvpair(nvl, nvp);
1776         }
1777 }
1778
1779 void
1780 nvlist_move_string_array(nvlist_t *nvl, const char *name, char **value,
1781     size_t nitems)
1782 {
1783         nvpair_t *nvp;
1784         size_t i;
1785
1786         if (nvlist_error(nvl) != 0) {
1787                 if (value != NULL) {
1788                         for (i = 0; i < nitems; i++)
1789                                 nv_free(value[i]);
1790                         nv_free(value);
1791                 }
1792                 ERRNO_SET(nvlist_error(nvl));
1793                 return;
1794         }
1795
1796         nvp = nvpair_move_string_array(name, value, nitems);
1797         if (nvp == NULL) {
1798                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1799                 ERRNO_SET(nvl->nvl_error);
1800         } else {
1801                 (void)nvlist_move_nvpair(nvl, nvp);
1802         }
1803 }
1804
1805 void
1806 nvlist_move_nvlist_array(nvlist_t *nvl, const char *name, nvlist_t **value,
1807     size_t nitems)
1808 {
1809         nvpair_t *nvp;
1810         size_t i;
1811
1812         if (nvlist_error(nvl) != 0) {
1813                 if (value != NULL) {
1814                         for (i = 0; i < nitems; i++) {
1815                                 if (nvlist_get_pararr(value[i], NULL) == NULL)
1816                                         nvlist_destroy(value[i]);
1817                         }
1818                 }
1819                 nv_free(value);
1820                 ERRNO_SET(nvlist_error(nvl));
1821                 return;
1822         }
1823
1824         nvp = nvpair_move_nvlist_array(name, value, nitems);
1825         if (nvp == NULL) {
1826                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1827                 ERRNO_SET(nvl->nvl_error);
1828         } else {
1829                 (void)nvlist_move_nvpair(nvl, nvp);
1830         }
1831 }
1832
1833 void
1834 nvlist_move_number_array(nvlist_t *nvl, const char *name, uint64_t *value,
1835     size_t nitems)
1836 {
1837         nvpair_t *nvp;
1838
1839         if (nvlist_error(nvl) != 0) {
1840                 nv_free(value);
1841                 ERRNO_SET(nvlist_error(nvl));
1842                 return;
1843         }
1844
1845         nvp = nvpair_move_number_array(name, value, nitems);
1846         if (nvp == NULL) {
1847                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1848                 ERRNO_SET(nvl->nvl_error);
1849         } else {
1850                 (void)nvlist_move_nvpair(nvl, nvp);
1851         }
1852 }
1853
1854 #ifndef _KERNEL
1855 void
1856 nvlist_move_descriptor_array(nvlist_t *nvl, const char *name, int *value,
1857     size_t nitems)
1858 {
1859         nvpair_t *nvp;
1860         size_t i;
1861
1862         if (nvlist_error(nvl) != 0) {
1863                 if (value != 0) {
1864                         for (i = 0; i < nitems; i++)
1865                                 close(value[i]);
1866                         nv_free(value);
1867                 }
1868
1869                 ERRNO_SET(nvlist_error(nvl));
1870                 return;
1871         }
1872
1873         nvp = nvpair_move_descriptor_array(name, value, nitems);
1874         if (nvp == NULL) {
1875                 nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
1876                 ERRNO_SET(nvl->nvl_error);
1877         } else {
1878                 (void)nvlist_move_nvpair(nvl, nvp);
1879         }
1880 }
1881 #endif
1882
1883 const nvpair_t *
1884 nvlist_get_nvpair(const nvlist_t *nvl, const char *name)
1885 {
1886
1887         return (nvlist_find(nvl, NV_TYPE_NONE, name));
1888 }
1889
1890 #define NVLIST_GET(ftype, type, TYPE)                                   \
1891 ftype                                                                   \
1892 nvlist_get_##type(const nvlist_t *nvl, const char *name)                \
1893 {                                                                       \
1894         const nvpair_t *nvp;                                            \
1895                                                                         \
1896         nvp = nvlist_find(nvl, NV_TYPE_##TYPE, name);                   \
1897         if (nvp == NULL)                                                \
1898                 nvlist_report_missing(NV_TYPE_##TYPE, name);            \
1899         return (nvpair_get_##type(nvp));                                \
1900 }
1901
1902 NVLIST_GET(bool, bool, BOOL)
1903 NVLIST_GET(uint64_t, number, NUMBER)
1904 NVLIST_GET(const char *, string, STRING)
1905 NVLIST_GET(const nvlist_t *, nvlist, NVLIST)
1906 #ifndef _KERNEL
1907 NVLIST_GET(int, descriptor, DESCRIPTOR)
1908 #endif
1909
1910 #undef  NVLIST_GET
1911
1912 const void *
1913 nvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep)
1914 {
1915         nvpair_t *nvp;
1916
1917         nvp = nvlist_find(nvl, NV_TYPE_BINARY, name);
1918         if (nvp == NULL)
1919                 nvlist_report_missing(NV_TYPE_BINARY, name);
1920
1921         return (nvpair_get_binary(nvp, sizep));
1922 }
1923
1924 #define NVLIST_GET_ARRAY(ftype, type, TYPE)                             \
1925 ftype                                                                   \
1926 nvlist_get_##type##_array(const nvlist_t *nvl, const char *name,        \
1927     size_t *nitems)                                                     \
1928 {                                                                       \
1929         const nvpair_t *nvp;                                            \
1930                                                                         \
1931         nvp = nvlist_find(nvl, NV_TYPE_##TYPE##_ARRAY, name);           \
1932         if (nvp == NULL)                                                \
1933                 nvlist_report_missing(NV_TYPE_##TYPE##_ARRAY, name);    \
1934         return (nvpair_get_##type##_array(nvp, nitems));                \
1935 }
1936
1937 NVLIST_GET_ARRAY(const bool *, bool, BOOL)
1938 NVLIST_GET_ARRAY(const uint64_t *, number, NUMBER)
1939 NVLIST_GET_ARRAY(const char * const *, string, STRING)
1940 NVLIST_GET_ARRAY(const nvlist_t * const *, nvlist, NVLIST)
1941 #ifndef _KERNEL
1942 NVLIST_GET_ARRAY(const int *, descriptor, DESCRIPTOR)
1943 #endif
1944
1945 #undef  NVLIST_GET_ARRAY
1946
1947 #define NVLIST_TAKE(ftype, type, TYPE)                                  \
1948 ftype                                                                   \
1949 nvlist_take_##type(nvlist_t *nvl, const char *name)                     \
1950 {                                                                       \
1951         nvpair_t *nvp;                                                  \
1952         ftype value;                                                    \
1953                                                                         \
1954         nvp = nvlist_find(nvl, NV_TYPE_##TYPE, name);                   \
1955         if (nvp == NULL)                                                \
1956                 nvlist_report_missing(NV_TYPE_##TYPE, name);            \
1957         value = (ftype)(intptr_t)nvpair_get_##type(nvp);                \
1958         nvlist_remove_nvpair(nvl, nvp);                                 \
1959         nvpair_free_structure(nvp);                                     \
1960         return (value);                                                 \
1961 }
1962
1963 NVLIST_TAKE(bool, bool, BOOL)
1964 NVLIST_TAKE(uint64_t, number, NUMBER)
1965 NVLIST_TAKE(char *, string, STRING)
1966 NVLIST_TAKE(nvlist_t *, nvlist, NVLIST)
1967 #ifndef _KERNEL
1968 NVLIST_TAKE(int, descriptor, DESCRIPTOR)
1969 #endif
1970
1971 #undef  NVLIST_TAKE
1972
1973 void *
1974 nvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep)
1975 {
1976         nvpair_t *nvp;
1977         void *value;
1978
1979         nvp = nvlist_find(nvl, NV_TYPE_BINARY, name);
1980         if (nvp == NULL)
1981                 nvlist_report_missing(NV_TYPE_BINARY, name);
1982
1983         value = (void *)(intptr_t)nvpair_get_binary(nvp, sizep);
1984         nvlist_remove_nvpair(nvl, nvp);
1985         nvpair_free_structure(nvp);
1986         return (value);
1987 }
1988
1989 #define NVLIST_TAKE_ARRAY(ftype, type, TYPE)                            \
1990 ftype                                                                   \
1991 nvlist_take_##type##_array(nvlist_t *nvl, const char *name,             \
1992     size_t *nitems)                                                     \
1993 {                                                                       \
1994         nvpair_t *nvp;                                                  \
1995         ftype value;                                                    \
1996                                                                         \
1997         nvp = nvlist_find(nvl, NV_TYPE_##TYPE##_ARRAY, name);           \
1998         if (nvp == NULL)                                                \
1999                 nvlist_report_missing(NV_TYPE_##TYPE##_ARRAY, name);    \
2000         value = (ftype)(intptr_t)nvpair_get_##type##_array(nvp, nitems);\
2001         nvlist_remove_nvpair(nvl, nvp);                                 \
2002         nvpair_free_structure(nvp);                                     \
2003         return (value);                                                 \
2004 }
2005
2006 NVLIST_TAKE_ARRAY(bool *, bool, BOOL)
2007 NVLIST_TAKE_ARRAY(uint64_t *, number, NUMBER)
2008 NVLIST_TAKE_ARRAY(char **, string, STRING)
2009 NVLIST_TAKE_ARRAY(nvlist_t **, nvlist, NVLIST)
2010 #ifndef _KERNEL
2011 NVLIST_TAKE_ARRAY(int *, descriptor, DESCRIPTOR)
2012 #endif
2013
2014 void
2015 nvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *nvp)
2016 {
2017
2018         NVLIST_ASSERT(nvl);
2019         NVPAIR_ASSERT(nvp);
2020         PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
2021
2022         nvpair_remove(&nvl->nvl_head, nvp, nvl);
2023 }
2024
2025 void
2026 nvlist_free(nvlist_t *nvl, const char *name)
2027 {
2028
2029         nvlist_free_type(nvl, name, NV_TYPE_NONE);
2030 }
2031
2032 #define NVLIST_FREE(type, TYPE)                                         \
2033 void                                                                    \
2034 nvlist_free_##type(nvlist_t *nvl, const char *name)                     \
2035 {                                                                       \
2036                                                                         \
2037         nvlist_free_type(nvl, name, NV_TYPE_##TYPE);                    \
2038 }
2039
2040 NVLIST_FREE(null, NULL)
2041 NVLIST_FREE(bool, BOOL)
2042 NVLIST_FREE(number, NUMBER)
2043 NVLIST_FREE(string, STRING)
2044 NVLIST_FREE(nvlist, NVLIST)
2045 NVLIST_FREE(binary, BINARY)
2046 NVLIST_FREE(bool_array, BOOL_ARRAY)
2047 NVLIST_FREE(number_array, NUMBER_ARRAY)
2048 NVLIST_FREE(string_array, STRING_ARRAY)
2049 NVLIST_FREE(nvlist_array, NVLIST_ARRAY)
2050 #ifndef _KERNEL
2051 NVLIST_FREE(descriptor, DESCRIPTOR)
2052 NVLIST_FREE(descriptor_array, DESCRIPTOR_ARRAY)
2053 #endif
2054
2055 #undef  NVLIST_FREE
2056
2057 void
2058 nvlist_free_nvpair(nvlist_t *nvl, nvpair_t *nvp)
2059 {
2060
2061         NVLIST_ASSERT(nvl);
2062         NVPAIR_ASSERT(nvp);
2063         PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
2064
2065         nvlist_remove_nvpair(nvl, nvp);
2066         nvpair_free(nvp);
2067 }
2068