2 * SPDX-License-Identifier: BSD-2-Clause
4 * Copyright (c) 2009-2013 The FreeBSD Foundation
5 * Copyright (c) 2013-2015 Mariusz Zaborski <oshogbo@FreeBSD.org>
8 * This software was developed by Pawel Jakub Dawidek under sponsorship from
9 * the FreeBSD Foundation.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
36 #include <sys/param.h>
37 #include <sys/endian.h>
38 #include <sys/queue.h>
42 #include <sys/errno.h>
44 #include <sys/malloc.h>
45 #include <sys/systm.h>
47 #include <machine/stdarg.h>
59 #include "common_impl.h"
69 #include "nvlist_impl.h"
70 #include "nvpair_impl.h"
74 #define PJDLOG_ASSERT(...) MPASS(__VA_ARGS__)
75 #define PJDLOG_RASSERT(expr, ...) KASSERT(expr, (__VA_ARGS__))
76 #define PJDLOG_ABORT(...) panic(__VA_ARGS__)
79 #define PJDLOG_ASSERT(...) assert(__VA_ARGS__)
80 #define PJDLOG_RASSERT(expr, ...) assert(expr)
81 #define PJDLOG_ABORT(...) abort()
85 #define NVPAIR_MAGIC 0x6e7670 /* "nvp" */
92 size_t nvp_nitems; /* Used only for array types. */
94 TAILQ_ENTRY(nvpair) nvp_next;
97 #define NVPAIR_ASSERT(nvp) do { \
98 PJDLOG_ASSERT((nvp) != NULL); \
99 PJDLOG_ASSERT((nvp)->nvp_magic == NVPAIR_MAGIC); \
102 struct nvpair_header {
104 uint16_t nvph_namesize;
105 uint64_t nvph_datasize;
106 uint64_t nvph_nitems;
111 nvpair_assert(const nvpair_t *nvp __unused)
118 nvpair_allocv(const char *name, int type, uint64_t data, size_t datasize,
124 PJDLOG_ASSERT(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST);
126 namelen = strlen(name);
127 if (namelen >= NV_NAME_MAX) {
128 ERRNO_SET(ENAMETOOLONG);
132 nvp = nv_calloc(1, sizeof(*nvp) + namelen + 1);
134 nvp->nvp_name = (char *)(nvp + 1);
135 memcpy(nvp->nvp_name, name, namelen);
136 nvp->nvp_name[namelen] = '\0';
137 nvp->nvp_type = type;
138 nvp->nvp_data = data;
139 nvp->nvp_datasize = datasize;
140 nvp->nvp_nitems = nitems;
141 nvp->nvp_magic = NVPAIR_MAGIC;
148 nvpair_append(nvpair_t *nvp, const void *value, size_t valsize, size_t datasize)
150 void *olddata, *data, *valp;
153 oldlen = nvp->nvp_nitems * valsize;
154 olddata = (void *)(uintptr_t)nvp->nvp_data;
155 data = nv_realloc(olddata, oldlen + valsize);
160 valp = (unsigned char *)data + oldlen;
161 memcpy(valp, value, valsize);
163 nvp->nvp_data = (uint64_t)(uintptr_t)data;
164 nvp->nvp_datasize += datasize;
170 nvpair_nvlist(const nvpair_t *nvp)
175 return (nvp->nvp_list);
179 nvpair_next(const nvpair_t *nvp)
183 PJDLOG_ASSERT(nvp->nvp_list != NULL);
185 return (TAILQ_NEXT(nvp, nvp_next));
189 nvpair_prev(const nvpair_t *nvp)
193 PJDLOG_ASSERT(nvp->nvp_list != NULL);
195 return (TAILQ_PREV(nvp, nvl_head, nvp_next));
199 nvpair_insert(struct nvl_head *head, nvpair_t *nvp, nvlist_t *nvl)
203 PJDLOG_ASSERT(nvp->nvp_list == NULL);
204 PJDLOG_ASSERT((nvlist_flags(nvl) & NV_FLAG_NO_UNIQUE) != 0 ||
205 !nvlist_exists(nvl, nvpair_name(nvp)));
207 TAILQ_INSERT_TAIL(head, nvp, nvp_next);
212 nvpair_remove_nvlist(nvpair_t *nvp)
216 /* XXX: DECONST is bad, mkay? */
217 nvl = __DECONST(nvlist_t *, nvpair_get_nvlist(nvp));
218 PJDLOG_ASSERT(nvl != NULL);
219 nvlist_set_parent(nvl, NULL);
223 nvpair_remove_nvlist_array(nvpair_t *nvp)
228 /* XXX: DECONST is bad, mkay? */
229 nvlarray = __DECONST(nvlist_t **,
230 nvpair_get_nvlist_array(nvp, &count));
231 for (i = 0; i < count; i++) {
232 nvlist_set_array_next(nvlarray[i], NULL);
233 nvlist_set_parent(nvlarray[i], NULL);
238 nvpair_remove(struct nvl_head *head, nvpair_t *nvp,
239 const nvlist_t *nvl __unused)
243 PJDLOG_ASSERT(nvp->nvp_list == nvl);
245 if (nvpair_type(nvp) == NV_TYPE_NVLIST)
246 nvpair_remove_nvlist(nvp);
247 else if (nvpair_type(nvp) == NV_TYPE_NVLIST_ARRAY)
248 nvpair_remove_nvlist_array(nvp);
250 TAILQ_REMOVE(head, nvp, nvp_next);
251 nvp->nvp_list = NULL;
255 nvpair_clone(const nvpair_t *nvp)
264 name = nvpair_name(nvp);
266 switch (nvpair_type(nvp)) {
268 newnvp = nvpair_create_null(name);
271 newnvp = nvpair_create_bool(name, nvpair_get_bool(nvp));
274 newnvp = nvpair_create_number(name, nvpair_get_number(nvp));
277 newnvp = nvpair_create_string(name, nvpair_get_string(nvp));
280 newnvp = nvpair_create_nvlist(name, nvpair_get_nvlist(nvp));
283 data = nvpair_get_binary(nvp, &datasize);
284 newnvp = nvpair_create_binary(name, data, datasize);
286 case NV_TYPE_BOOL_ARRAY:
287 data = nvpair_get_bool_array(nvp, &datasize);
288 newnvp = nvpair_create_bool_array(name, data, datasize);
290 case NV_TYPE_NUMBER_ARRAY:
291 data = nvpair_get_number_array(nvp, &datasize);
292 newnvp = nvpair_create_number_array(name, data, datasize);
294 case NV_TYPE_STRING_ARRAY:
295 data = nvpair_get_string_array(nvp, &datasize);
296 newnvp = nvpair_create_string_array(name, data, datasize);
298 case NV_TYPE_NVLIST_ARRAY:
299 data = nvpair_get_nvlist_array(nvp, &datasize);
300 newnvp = nvpair_create_nvlist_array(name, data, datasize);
303 case NV_TYPE_DESCRIPTOR:
304 newnvp = nvpair_create_descriptor(name,
305 nvpair_get_descriptor(nvp));
307 case NV_TYPE_DESCRIPTOR_ARRAY:
308 data = nvpair_get_descriptor_array(nvp, &datasize);
309 newnvp = nvpair_create_descriptor_array(name, data, datasize);
313 PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
320 nvpair_header_size(void)
323 return (sizeof(struct nvpair_header));
327 nvpair_size(const nvpair_t *nvp)
332 return (nvp->nvp_datasize);
336 nvpair_pack_header(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
338 struct nvpair_header nvphdr;
343 nvphdr.nvph_type = nvp->nvp_type;
344 namesize = strlen(nvp->nvp_name) + 1;
345 PJDLOG_ASSERT(namesize > 0 && namesize <= UINT16_MAX);
346 nvphdr.nvph_namesize = namesize;
347 nvphdr.nvph_datasize = nvp->nvp_datasize;
348 nvphdr.nvph_nitems = nvp->nvp_nitems;
349 PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
350 memcpy(ptr, &nvphdr, sizeof(nvphdr));
351 ptr += sizeof(nvphdr);
352 *leftp -= sizeof(nvphdr);
354 PJDLOG_ASSERT(*leftp >= namesize);
355 memcpy(ptr, nvp->nvp_name, namesize);
363 nvpair_pack_null(const nvpair_t *nvp __unused, unsigned char *ptr,
364 size_t *leftp __unused)
368 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
374 nvpair_pack_bool(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
379 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
381 value = (uint8_t)nvp->nvp_data;
383 PJDLOG_ASSERT(*leftp >= sizeof(value));
384 memcpy(ptr, &value, sizeof(value));
385 ptr += sizeof(value);
386 *leftp -= sizeof(value);
392 nvpair_pack_number(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
397 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
399 value = (uint64_t)nvp->nvp_data;
401 PJDLOG_ASSERT(*leftp >= sizeof(value));
402 memcpy(ptr, &value, sizeof(value));
403 ptr += sizeof(value);
404 *leftp -= sizeof(value);
410 nvpair_pack_string(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
414 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
416 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
417 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
418 ptr += nvp->nvp_datasize;
419 *leftp -= nvp->nvp_datasize;
425 nvpair_pack_nvlist_up(unsigned char *ptr, size_t *leftp)
427 struct nvpair_header nvphdr;
429 const char *name = "";
432 nvphdr.nvph_type = NV_TYPE_NVLIST_UP;
433 nvphdr.nvph_namesize = namesize;
434 nvphdr.nvph_datasize = 0;
435 nvphdr.nvph_nitems = 0;
436 PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
437 memcpy(ptr, &nvphdr, sizeof(nvphdr));
438 ptr += sizeof(nvphdr);
439 *leftp -= sizeof(nvphdr);
441 PJDLOG_ASSERT(*leftp >= namesize);
442 memcpy(ptr, name, namesize);
450 nvpair_pack_nvlist_array_next(unsigned char *ptr, size_t *leftp)
452 struct nvpair_header nvphdr;
454 const char *name = "";
457 nvphdr.nvph_type = NV_TYPE_NVLIST_ARRAY_NEXT;
458 nvphdr.nvph_namesize = namesize;
459 nvphdr.nvph_datasize = 0;
460 nvphdr.nvph_nitems = 0;
461 PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
462 memcpy(ptr, &nvphdr, sizeof(nvphdr));
463 ptr += sizeof(nvphdr);
464 *leftp -= sizeof(nvphdr);
466 PJDLOG_ASSERT(*leftp >= namesize);
467 memcpy(ptr, name, namesize);
476 nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr, int64_t *fdidxp,
482 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
484 value = (int64_t)nvp->nvp_data;
487 * If there is a real descriptor here, we change its number
488 * to position in the array of descriptors send via control
491 PJDLOG_ASSERT(fdidxp != NULL);
497 PJDLOG_ASSERT(*leftp >= sizeof(value));
498 memcpy(ptr, &value, sizeof(value));
499 ptr += sizeof(value);
500 *leftp -= sizeof(value);
507 nvpair_pack_binary(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
511 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
513 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
514 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
515 ptr += nvp->nvp_datasize;
516 *leftp -= nvp->nvp_datasize;
522 nvpair_pack_bool_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
526 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
527 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
529 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
530 ptr += nvp->nvp_datasize;
531 *leftp -= nvp->nvp_datasize;
537 nvpair_pack_number_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
541 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
542 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
544 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
545 ptr += nvp->nvp_datasize;
546 *leftp -= nvp->nvp_datasize;
552 nvpair_pack_string_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
555 size_t size __unused, len;
556 const char * const *array;
559 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
560 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
563 array = nvpair_get_string_array(nvp, NULL);
564 PJDLOG_ASSERT(array != NULL);
566 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
567 len = strlen(array[ii]) + 1;
568 PJDLOG_ASSERT(*leftp >= len);
570 memcpy(ptr, (const void *)array[ii], len);
576 PJDLOG_ASSERT(size == nvp->nvp_datasize);
583 nvpair_pack_descriptor_array(const nvpair_t *nvp, unsigned char *ptr,
584 int64_t *fdidxp, size_t *leftp)
591 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
592 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
594 array = nvpair_get_descriptor_array(nvp, NULL);
595 PJDLOG_ASSERT(array != NULL);
597 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
598 PJDLOG_ASSERT(*leftp >= sizeof(value));
603 * If there is a real descriptor here, we change its
604 * number to position in the array of descriptors send
605 * via control message.
607 PJDLOG_ASSERT(fdidxp != NULL);
612 memcpy(ptr, &value, sizeof(value));
613 ptr += sizeof(value);
614 *leftp -= sizeof(value);
622 nvpair_init_datasize(nvpair_t *nvp)
627 if (nvp->nvp_type == NV_TYPE_NVLIST) {
628 if (nvp->nvp_data == 0) {
629 nvp->nvp_datasize = 0;
632 nvlist_size((const nvlist_t *)(intptr_t)nvp->nvp_data);
637 const unsigned char *
638 nvpair_unpack_header(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
641 struct nvpair_header nvphdr;
643 if (*leftp < sizeof(nvphdr))
646 memcpy(&nvphdr, ptr, sizeof(nvphdr));
647 ptr += sizeof(nvphdr);
648 *leftp -= sizeof(nvphdr);
650 #if NV_TYPE_FIRST > 0
651 if (nvphdr.nvph_type < NV_TYPE_FIRST)
654 if (nvphdr.nvph_type > NV_TYPE_LAST &&
655 nvphdr.nvph_type != NV_TYPE_NVLIST_UP &&
656 nvphdr.nvph_type != NV_TYPE_NVLIST_ARRAY_NEXT) {
660 #if BYTE_ORDER == BIG_ENDIAN
662 nvphdr.nvph_namesize = le16toh(nvphdr.nvph_namesize);
663 nvphdr.nvph_datasize = le64toh(nvphdr.nvph_datasize);
664 nvphdr.nvph_nitems = le64toh(nvphdr.nvph_nitems);
668 nvphdr.nvph_namesize = be16toh(nvphdr.nvph_namesize);
669 nvphdr.nvph_datasize = be64toh(nvphdr.nvph_datasize);
670 nvphdr.nvph_nitems = be64toh(nvphdr.nvph_nitems);
674 if (nvphdr.nvph_namesize > NV_NAME_MAX)
676 if (*leftp < nvphdr.nvph_namesize)
678 if (nvphdr.nvph_namesize < 1)
680 if (strnlen((const char *)ptr, nvphdr.nvph_namesize) !=
681 (size_t)(nvphdr.nvph_namesize - 1)) {
685 memcpy(nvp->nvp_name, ptr, nvphdr.nvph_namesize);
686 ptr += nvphdr.nvph_namesize;
687 *leftp -= nvphdr.nvph_namesize;
689 if (*leftp < nvphdr.nvph_datasize)
692 nvp->nvp_type = nvphdr.nvph_type;
694 nvp->nvp_datasize = nvphdr.nvph_datasize;
695 nvp->nvp_nitems = nvphdr.nvph_nitems;
703 const unsigned char *
704 nvpair_unpack_null(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
705 size_t *leftp __unused)
708 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
710 if (nvp->nvp_datasize != 0) {
718 const unsigned char *
719 nvpair_unpack_bool(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
724 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
726 if (nvp->nvp_datasize != sizeof(value)) {
730 if (*leftp < sizeof(value)) {
735 memcpy(&value, ptr, sizeof(value));
736 ptr += sizeof(value);
737 *leftp -= sizeof(value);
739 if (value != 0 && value != 1) {
744 nvp->nvp_data = (uint64_t)value;
749 const unsigned char *
750 nvpair_unpack_number(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
754 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
756 if (nvp->nvp_datasize != sizeof(uint64_t)) {
760 if (*leftp < sizeof(uint64_t)) {
766 nvp->nvp_data = be64dec(ptr);
768 nvp->nvp_data = le64dec(ptr);
770 ptr += sizeof(uint64_t);
771 *leftp -= sizeof(uint64_t);
776 const unsigned char *
777 nvpair_unpack_string(bool isbe __unused, nvpair_t *nvp,
778 const unsigned char *ptr, size_t *leftp)
781 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
783 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
788 if (strnlen((const char *)ptr, nvp->nvp_datasize) !=
789 nvp->nvp_datasize - 1) {
794 nvp->nvp_data = (uint64_t)(uintptr_t)nv_strdup((const char *)ptr);
795 if (nvp->nvp_data == 0)
798 ptr += nvp->nvp_datasize;
799 *leftp -= nvp->nvp_datasize;
804 const unsigned char *
805 nvpair_unpack_nvlist(bool isbe __unused, nvpair_t *nvp,
806 const unsigned char *ptr, size_t *leftp, size_t nfds, nvlist_t **child)
810 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
812 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
817 value = nvlist_create(0);
821 ptr = nvlist_unpack_header(value, ptr, nfds, NULL, leftp);
825 nvp->nvp_data = (uint64_t)(uintptr_t)value;
832 const unsigned char *
833 nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
834 size_t *leftp, const int *fds, size_t nfds)
838 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
840 if (nvp->nvp_datasize != sizeof(idx)) {
844 if (*leftp < sizeof(idx)) {
859 if ((size_t)idx >= nfds) {
864 nvp->nvp_data = (uint64_t)fds[idx];
867 *leftp -= sizeof(idx);
873 const unsigned char *
874 nvpair_unpack_binary(bool isbe __unused, nvpair_t *nvp,
875 const unsigned char *ptr, size_t *leftp)
879 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
881 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
886 value = nv_malloc(nvp->nvp_datasize);
890 memcpy(value, ptr, nvp->nvp_datasize);
891 ptr += nvp->nvp_datasize;
892 *leftp -= nvp->nvp_datasize;
894 nvp->nvp_data = (uint64_t)(uintptr_t)value;
899 const unsigned char *
900 nvpair_unpack_bool_array(bool isbe __unused, nvpair_t *nvp,
901 const unsigned char *ptr, size_t *leftp)
907 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
909 size = sizeof(*value) * nvp->nvp_nitems;
910 if (nvp->nvp_datasize != size || *leftp < size ||
911 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
916 value = nv_malloc(size);
920 for (i = 0; i < nvp->nvp_nitems; i++) {
921 value[i] = *(const uint8_t *)ptr;
923 ptr += sizeof(*value);
924 *leftp -= sizeof(*value);
927 nvp->nvp_data = (uint64_t)(uintptr_t)value;
932 const unsigned char *
933 nvpair_unpack_number_array(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
940 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
942 size = sizeof(*value) * nvp->nvp_nitems;
943 if (nvp->nvp_datasize != size || *leftp < size ||
944 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
949 value = nv_malloc(size);
953 for (i = 0; i < nvp->nvp_nitems; i++) {
955 value[i] = be64dec(ptr);
957 value[i] = le64dec(ptr);
959 ptr += sizeof(*value);
960 *leftp -= sizeof(*value);
963 nvp->nvp_data = (uint64_t)(uintptr_t)value;
968 const unsigned char *
969 nvpair_unpack_string_array(bool isbe __unused, nvpair_t *nvp,
970 const unsigned char *ptr, size_t *leftp)
978 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
980 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0 ||
981 nvp->nvp_nitems == 0) {
986 size = nvp->nvp_datasize;
987 tmp = (const char *)ptr;
988 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
989 len = strnlen(tmp, size - 1) + 1;
1002 value = nv_malloc(sizeof(*value) * nvp->nvp_nitems);
1006 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1007 value[ii] = nv_strdup((const char *)ptr);
1008 if (value[ii] == NULL)
1010 len = strlen(value[ii]) + 1;
1014 nvp->nvp_data = (uint64_t)(uintptr_t)value;
1018 for (j = 0; j < ii; j++)
1025 const unsigned char *
1026 nvpair_unpack_descriptor_array(bool isbe, nvpair_t *nvp,
1027 const unsigned char *ptr, size_t *leftp, const int *fds, size_t nfds)
1034 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
1036 size = sizeof(idx) * nvp->nvp_nitems;
1037 if (nvp->nvp_datasize != size || *leftp < size ||
1038 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
1043 array = (int *)nv_malloc(size);
1047 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1059 if ((size_t)idx >= nfds) {
1065 array[ii] = (uint64_t)fds[idx];
1068 *leftp -= sizeof(idx);
1071 nvp->nvp_data = (uint64_t)(uintptr_t)array;
1077 const unsigned char *
1078 nvpair_unpack_nvlist_array(bool isbe __unused, nvpair_t *nvp,
1079 const unsigned char *ptr, size_t *leftp, nvlist_t **firstel)
1086 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1088 sizeup = sizeof(struct nvpair_header) * nvp->nvp_nitems;
1089 if (nvp->nvp_nitems == 0 || sizeup < nvp->nvp_nitems ||
1095 value = nv_malloc(nvp->nvp_nitems * sizeof(*value));
1099 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1100 value[ii] = nvlist_create(0);
1101 if (value[ii] == NULL)
1104 tmpnvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1105 (uint64_t)(uintptr_t)value[ii], 0, 0);
1108 nvlist_set_array_next(value[ii - 1], tmpnvp);
1111 nvlist_set_flags(value[nvp->nvp_nitems - 1], NV_FLAG_IN_ARRAY);
1113 nvp->nvp_data = (uint64_t)(uintptr_t)value;
1114 *firstel = value[0];
1119 for (j = 0; j <= ii; j++)
1120 nvlist_destroy(value[j]);
1127 const unsigned char *
1128 nvpair_unpack(bool isbe, const unsigned char *ptr, size_t *leftp,
1131 nvpair_t *nvp, *tmp;
1133 nvp = nv_calloc(1, sizeof(*nvp) + NV_NAME_MAX);
1136 nvp->nvp_name = (char *)(nvp + 1);
1138 ptr = nvpair_unpack_header(isbe, nvp, ptr, leftp);
1141 tmp = nv_realloc(nvp, sizeof(*nvp) + strlen(nvp->nvp_name) + 1);
1146 /* Update nvp_name after realloc(). */
1147 nvp->nvp_name = (char *)(nvp + 1);
1148 nvp->nvp_data = 0x00;
1149 nvp->nvp_magic = NVPAIR_MAGIC;
1158 nvpair_type(const nvpair_t *nvp)
1163 return (nvp->nvp_type);
1167 nvpair_name(const nvpair_t *nvp)
1172 return (nvp->nvp_name);
1176 nvpair_create_stringf(const char *name, const char *valuefmt, ...)
1181 va_start(valueap, valuefmt);
1182 nvp = nvpair_create_stringv(name, valuefmt, valueap);
1189 nvpair_create_stringv(const char *name, const char *valuefmt, va_list valueap)
1195 len = nv_vasprintf(&str, valuefmt, valueap);
1198 nvp = nvpair_create_string(name, str);
1204 nvpair_create_null(const char *name)
1207 return (nvpair_allocv(name, NV_TYPE_NULL, 0, 0, 0));
1211 nvpair_create_bool(const char *name, bool value)
1214 return (nvpair_allocv(name, NV_TYPE_BOOL, value ? 1 : 0,
1215 sizeof(uint8_t), 0));
1219 nvpair_create_number(const char *name, uint64_t value)
1222 return (nvpair_allocv(name, NV_TYPE_NUMBER, value, sizeof(value), 0));
1226 nvpair_create_string(const char *name, const char *value)
1232 if (value == NULL) {
1237 data = nv_strdup(value);
1240 size = strlen(value) + 1;
1242 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)data,
1251 nvpair_create_nvlist(const char *name, const nvlist_t *value)
1256 if (value == NULL) {
1261 nvl = nvlist_clone(value);
1265 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0,
1268 nvlist_destroy(nvl);
1270 nvlist_set_parent(nvl, nvp);
1277 nvpair_create_descriptor(const char *name, int value)
1281 value = fcntl(value, F_DUPFD_CLOEXEC, 0);
1285 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1286 sizeof(int64_t), 0);
1298 nvpair_create_binary(const char *name, const void *value, size_t size)
1303 if (value == NULL || size == 0) {
1308 data = nv_malloc(size);
1311 memcpy(data, value, size);
1313 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)data,
1322 nvpair_create_bool_array(const char *name, const bool *value, size_t nitems)
1328 if (value == NULL || nitems == 0) {
1333 size = sizeof(value[0]) * nitems;
1334 data = nv_malloc(size);
1338 memcpy(data, value, size);
1339 nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY, (uint64_t)(uintptr_t)data,
1351 nvpair_create_number_array(const char *name, const uint64_t *value,
1358 if (value == NULL || nitems == 0) {
1363 size = sizeof(value[0]) * nitems;
1364 data = nv_malloc(size);
1368 memcpy(data, value, size);
1369 nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
1370 (uint64_t)(uintptr_t)data, size, nitems);
1381 nvpair_create_string_array(const char *name, const char * const *value,
1386 size_t datasize, size;
1389 if (value == NULL || nitems == 0) {
1396 data = nv_malloc(sizeof(value[0]) * nitems);
1400 for (ii = 0; ii < nitems; ii++) {
1401 if (value[ii] == NULL) {
1406 size = strlen(value[ii]) + 1;
1408 data[ii] = nv_strdup(value[ii]);
1409 if (data[ii] == NULL)
1412 nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
1413 (uint64_t)(uintptr_t)data, datasize, nitems);
1418 for (; ii > 0; ii--)
1419 nv_free(data[ii - 1]);
1428 nvpair_create_nvlist_array(const char *name, const nvlist_t * const *value,
1438 if (value == NULL || nitems == 0) {
1443 nvls = nv_malloc(sizeof(value[0]) * nitems);
1447 for (ii = 0; ii < nitems; ii++) {
1448 if (value[ii] == NULL) {
1453 nvls[ii] = nvlist_clone(value[ii]);
1454 if (nvls[ii] == NULL)
1460 nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1461 (uint64_t)(uintptr_t)nvls[ii], 0, 0);
1464 nvlist_destroy(nvls[ii]);
1468 nvlist_set_array_next(nvls[ii - 1], nvp);
1471 flags = nvlist_flags(nvls[nitems - 1]) | NV_FLAG_IN_ARRAY;
1472 nvlist_set_flags(nvls[nitems - 1], flags);
1474 parent = nvpair_allocv(name, NV_TYPE_NVLIST_ARRAY,
1475 (uint64_t)(uintptr_t)nvls, 0, nitems);
1479 for (ii = 0; ii < nitems; ii++)
1480 nvlist_set_parent(nvls[ii], parent);
1486 for (; ii > 0; ii--)
1487 nvlist_destroy(nvls[ii - 1]);
1496 nvpair_create_descriptor_array(const char *name, const int *value,
1503 if (value == NULL) {
1510 fds = nv_malloc(sizeof(value[0]) * nitems);
1513 for (ii = 0; ii < nitems; ii++) {
1514 if (value[ii] == -1) {
1517 fds[ii] = fcntl(value[ii], F_DUPFD_CLOEXEC, 0);
1523 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
1524 (uint64_t)(uintptr_t)fds, sizeof(int64_t) * nitems, nitems);
1529 for (; ii > 0; ii--) {
1530 if (fds[ii - 1] != -1)
1542 nvpair_move_string(const char *name, char *value)
1546 if (value == NULL) {
1551 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
1552 strlen(value) + 1, 0);
1563 nvpair_move_nvlist(const char *name, nvlist_t *value)
1567 if (value == NULL || nvlist_get_nvpair_parent(value) != NULL) {
1572 if (nvlist_error(value) != 0) {
1573 ERRNO_SET(nvlist_error(value));
1574 nvlist_destroy(value);
1578 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value,
1581 nvlist_destroy(value);
1583 nvlist_set_parent(value, nvp);
1590 nvpair_move_descriptor(const char *name, int value)
1594 if (value < 0 || !fd_is_valid(value)) {
1599 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1600 sizeof(int64_t), 0);
1612 nvpair_move_binary(const char *name, void *value, size_t size)
1616 if (value == NULL || size == 0) {
1621 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)value,
1633 nvpair_move_bool_array(const char *name, bool *value, size_t nitems)
1637 if (value == NULL || nitems == 0) {
1642 nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY,
1643 (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
1654 nvpair_move_string_array(const char *name, char **value, size_t nitems)
1659 if (value == NULL || nitems == 0) {
1665 for (i = 0; i < nitems; i++) {
1666 if (value[i] == NULL) {
1671 size += strlen(value[i]) + 1;
1674 nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
1675 (uint64_t)(uintptr_t)value, size, nitems);
1678 for (i = 0; i < nitems; i++)
1688 nvpair_move_number_array(const char *name, uint64_t *value, size_t nitems)
1692 if (value == NULL || nitems == 0) {
1697 nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
1698 (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
1709 nvpair_move_nvlist_array(const char *name, nvlist_t **value, size_t nitems)
1715 if (value == NULL || nitems == 0) {
1720 for (ii = 0; ii < nitems; ii++) {
1721 if (value == NULL || nvlist_error(value[ii]) != 0 ||
1722 nvlist_get_pararr(value[ii], NULL) != NULL) {
1729 nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1730 (uint64_t)(uintptr_t)value[ii], 0, 0);
1733 nvlist_set_array_next(value[ii - 1], nvp);
1736 flags = nvlist_flags(value[nitems - 1]) | NV_FLAG_IN_ARRAY;
1737 nvlist_set_flags(value[nitems - 1], flags);
1739 parent = nvpair_allocv(name, NV_TYPE_NVLIST_ARRAY,
1740 (uint64_t)(uintptr_t)value, 0, nitems);
1744 for (ii = 0; ii < nitems; ii++)
1745 nvlist_set_parent(value[ii], parent);
1750 for (ii = 0; ii < nitems; ii++) {
1751 if (value[ii] != NULL &&
1752 nvlist_get_pararr(value[ii], NULL) != NULL) {
1753 nvlist_destroy(value[ii]);
1764 nvpair_move_descriptor_array(const char *name, int *value, size_t nitems)
1769 if (value == NULL || nitems == 0) {
1774 for (i = 0; i < nitems; i++) {
1775 if (value[i] != -1 && !fd_is_valid(value[i])) {
1781 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
1782 (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
1789 for (i = 0; i < nitems; i++) {
1790 if (fd_is_valid(value[i]))
1801 nvpair_get_bool(const nvpair_t *nvp)
1806 return (nvp->nvp_data == 1);
1810 nvpair_get_number(const nvpair_t *nvp)
1815 return (nvp->nvp_data);
1819 nvpair_get_string(const nvpair_t *nvp)
1823 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
1825 return ((const char *)(intptr_t)nvp->nvp_data);
1829 nvpair_get_nvlist(const nvpair_t *nvp)
1833 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
1835 return ((const nvlist_t *)(intptr_t)nvp->nvp_data);
1840 nvpair_get_descriptor(const nvpair_t *nvp)
1844 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
1846 return ((int)nvp->nvp_data);
1851 nvpair_get_binary(const nvpair_t *nvp, size_t *sizep)
1855 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
1858 *sizep = nvp->nvp_datasize;
1860 return ((const void *)(intptr_t)nvp->nvp_data);
1864 nvpair_get_bool_array(const nvpair_t *nvp, size_t *nitems)
1868 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
1871 *nitems = nvp->nvp_nitems;
1873 return ((const bool *)(intptr_t)nvp->nvp_data);
1877 nvpair_get_number_array(const nvpair_t *nvp, size_t *nitems)
1881 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
1884 *nitems = nvp->nvp_nitems;
1886 return ((const uint64_t *)(intptr_t)nvp->nvp_data);
1889 const char * const *
1890 nvpair_get_string_array(const nvpair_t *nvp, size_t *nitems)
1894 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
1897 *nitems = nvp->nvp_nitems;
1899 return ((const char * const *)(intptr_t)nvp->nvp_data);
1902 const nvlist_t * const *
1903 nvpair_get_nvlist_array(const nvpair_t *nvp, size_t *nitems)
1907 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1910 *nitems = nvp->nvp_nitems;
1912 return ((const nvlist_t * const *)((intptr_t)nvp->nvp_data));
1917 nvpair_get_descriptor_array(const nvpair_t *nvp, size_t *nitems)
1921 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
1924 *nitems = nvp->nvp_nitems;
1926 return ((const int *)(intptr_t)nvp->nvp_data);
1931 nvpair_append_bool_array(nvpair_t *nvp, const bool value)
1935 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
1936 return (nvpair_append(nvp, &value, sizeof(value), sizeof(value)));
1940 nvpair_append_number_array(nvpair_t *nvp, const uint64_t value)
1944 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
1945 return (nvpair_append(nvp, &value, sizeof(value), sizeof(value)));
1949 nvpair_append_string_array(nvpair_t *nvp, const char *value)
1954 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
1955 if (value == NULL) {
1959 str = nv_strdup(value);
1963 if (nvpair_append(nvp, &str, sizeof(str), strlen(str) + 1) == -1) {
1971 nvpair_append_nvlist_array(nvpair_t *nvp, const nvlist_t *value)
1974 nvlist_t *nvl, *prev;
1978 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1979 if (value == NULL || nvlist_error(value) != 0 ||
1980 nvlist_get_pararr(value, NULL) != NULL) {
1984 nvl = nvlist_clone(value);
1988 flags = nvlist_flags(nvl) | NV_FLAG_IN_ARRAY;
1989 nvlist_set_flags(nvl, flags);
1993 if (nvp->nvp_nitems > 0) {
1994 nvlist_t **nvls = (void *)(uintptr_t)nvp->nvp_data;
1996 prev = nvls[nvp->nvp_nitems - 1];
1997 PJDLOG_ASSERT(prev != NULL);
1999 tmpnvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
2000 (uint64_t)(uintptr_t)nvl, 0, 0);
2001 if (tmpnvp == NULL) {
2005 if (nvpair_append(nvp, &nvl, sizeof(nvl), 0) == -1) {
2009 NVPAIR_ASSERT(tmpnvp);
2010 nvlist_set_array_next(prev, tmpnvp);
2012 nvlist_set_parent(nvl, nvp);
2016 nvpair_free(tmpnvp);
2018 nvlist_destroy(nvl);
2024 nvpair_append_descriptor_array(nvpair_t *nvp, const int value)
2029 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
2030 fd = fcntl(value, F_DUPFD_CLOEXEC, 0);
2034 if (nvpair_append(nvp, &fd, sizeof(fd), sizeof(fd)) == -1) {
2043 nvpair_free(nvpair_t *nvp)
2048 PJDLOG_ASSERT(nvp->nvp_list == NULL);
2051 switch (nvp->nvp_type) {
2053 case NV_TYPE_DESCRIPTOR:
2054 close((int)nvp->nvp_data);
2056 case NV_TYPE_DESCRIPTOR_ARRAY:
2057 for (i = 0; i < nvp->nvp_nitems; i++)
2058 close(((int *)(intptr_t)nvp->nvp_data)[i]);
2059 nv_free((int *)(intptr_t)nvp->nvp_data);
2062 case NV_TYPE_NVLIST:
2063 nvlist_destroy((nvlist_t *)(intptr_t)nvp->nvp_data);
2065 case NV_TYPE_STRING:
2066 nv_free((char *)(intptr_t)nvp->nvp_data);
2068 case NV_TYPE_BINARY:
2069 nv_free((void *)(intptr_t)nvp->nvp_data);
2071 case NV_TYPE_NVLIST_ARRAY:
2072 for (i = 0; i < nvp->nvp_nitems; i++) {
2074 ((nvlist_t **)(intptr_t)nvp->nvp_data)[i]);
2076 nv_free(((nvlist_t **)(intptr_t)nvp->nvp_data));
2078 case NV_TYPE_NUMBER_ARRAY:
2079 nv_free((uint64_t *)(intptr_t)nvp->nvp_data);
2081 case NV_TYPE_BOOL_ARRAY:
2082 nv_free((bool *)(intptr_t)nvp->nvp_data);
2084 case NV_TYPE_STRING_ARRAY:
2085 for (i = 0; i < nvp->nvp_nitems; i++)
2086 nv_free(((char **)(intptr_t)nvp->nvp_data)[i]);
2087 nv_free((char **)(intptr_t)nvp->nvp_data);
2094 nvpair_free_structure(nvpair_t *nvp)
2098 PJDLOG_ASSERT(nvp->nvp_list == NULL);
2105 nvpair_type_string(int type)
2113 case NV_TYPE_NUMBER:
2115 case NV_TYPE_STRING:
2117 case NV_TYPE_NVLIST:
2119 case NV_TYPE_DESCRIPTOR:
2120 return ("DESCRIPTOR");
2121 case NV_TYPE_BINARY:
2123 case NV_TYPE_BOOL_ARRAY:
2124 return ("BOOL ARRAY");
2125 case NV_TYPE_NUMBER_ARRAY:
2126 return ("NUMBER ARRAY");
2127 case NV_TYPE_STRING_ARRAY:
2128 return ("STRING ARRAY");
2129 case NV_TYPE_NVLIST_ARRAY:
2130 return ("NVLIST ARRAY");
2131 case NV_TYPE_DESCRIPTOR_ARRAY:
2132 return ("DESCRIPTOR ARRAY");
2134 return ("<UNKNOWN>");