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