Deleted Added
sdiff udiff text old ( 285139 ) new ( 286796 )
full compact
nvpair.c (285139) nvpair.c (286796)
1/*-
2 * Copyright (c) 2009-2013 The FreeBSD Foundation
1/*-
2 * Copyright (c) 2009-2013 The FreeBSD Foundation
3 * Copyright (c) 2013-2015 Mariusz Zaborski <oshogbo@FreeBSD.org>
3 * All rights reserved.
4 *
5 * This software was developed by Pawel Jakub Dawidek under sponsorship from
6 * the FreeBSD Foundation.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:

--- 12 unchanged lines hidden (view full) ---

23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#include <sys/cdefs.h>
4 * All rights reserved.
5 *
6 * This software was developed by Pawel Jakub Dawidek under sponsorship from
7 * the FreeBSD Foundation.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:

--- 12 unchanged lines hidden (view full) ---

24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31#include <sys/cdefs.h>
31__FBSDID("$FreeBSD: head/sys/contrib/libnv/nvpair.c 285139 2015-07-04 16:33:37Z oshogbo $");
32__FBSDID("$FreeBSD: head/sys/contrib/libnv/nvpair.c 286796 2015-08-15 06:34:49Z oshogbo $");
32
33#include <sys/param.h>
34#include <sys/endian.h>
35#include <sys/queue.h>
36
37#ifdef _KERNEL
38
39#include <sys/errno.h>

--- 41 unchanged lines hidden (view full) ---

81
82#define NVPAIR_MAGIC 0x6e7670 /* "nvp" */
83struct nvpair {
84 int nvp_magic;
85 char *nvp_name;
86 int nvp_type;
87 uint64_t nvp_data;
88 size_t nvp_datasize;
33
34#include <sys/param.h>
35#include <sys/endian.h>
36#include <sys/queue.h>
37
38#ifdef _KERNEL
39
40#include <sys/errno.h>

--- 41 unchanged lines hidden (view full) ---

82
83#define NVPAIR_MAGIC 0x6e7670 /* "nvp" */
84struct nvpair {
85 int nvp_magic;
86 char *nvp_name;
87 int nvp_type;
88 uint64_t nvp_data;
89 size_t nvp_datasize;
90 size_t nvp_nitems; /* Used only for array types. */
89 nvlist_t *nvp_list;
90 TAILQ_ENTRY(nvpair) nvp_next;
91};
92
93#define NVPAIR_ASSERT(nvp) do { \
94 PJDLOG_ASSERT((nvp) != NULL); \
95 PJDLOG_ASSERT((nvp)->nvp_magic == NVPAIR_MAGIC); \
96} while (0)
97
98struct nvpair_header {
99 uint8_t nvph_type;
100 uint16_t nvph_namesize;
101 uint64_t nvph_datasize;
91 nvlist_t *nvp_list;
92 TAILQ_ENTRY(nvpair) nvp_next;
93};
94
95#define NVPAIR_ASSERT(nvp) do { \
96 PJDLOG_ASSERT((nvp) != NULL); \
97 PJDLOG_ASSERT((nvp)->nvp_magic == NVPAIR_MAGIC); \
98} while (0)
99
100struct nvpair_header {
101 uint8_t nvph_type;
102 uint16_t nvph_namesize;
103 uint64_t nvph_datasize;
104 uint64_t nvph_nitems;
102} __packed;
103
104
105void
106nvpair_assert(const nvpair_t *nvp)
107{
108
109 NVPAIR_ASSERT(nvp);
110}
111
105} __packed;
106
107
108void
109nvpair_assert(const nvpair_t *nvp)
110{
111
112 NVPAIR_ASSERT(nvp);
113}
114
115static nvpair_t *
116nvpair_allocv(const char *name, int type, uint64_t data, size_t datasize,
117 size_t nitems)
118{
119 nvpair_t *nvp;
120 size_t namelen;
121
122 PJDLOG_ASSERT(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST);
123
124 namelen = strlen(name);
125 if (namelen >= NV_NAME_MAX) {
126 ERRNO_SET(ENAMETOOLONG);
127 return (NULL);
128 }
129
130 nvp = nv_calloc(1, sizeof(*nvp) + namelen + 1);
131 if (nvp != NULL) {
132 nvp->nvp_name = (char *)(nvp + 1);
133 memcpy(nvp->nvp_name, name, namelen);
134 nvp->nvp_name[namelen] = '\0';
135 nvp->nvp_type = type;
136 nvp->nvp_data = data;
137 nvp->nvp_datasize = datasize;
138 nvp->nvp_nitems = nitems;
139 nvp->nvp_magic = NVPAIR_MAGIC;
140 }
141
142 return (nvp);
143}
144
112nvlist_t *
113nvpair_nvlist(const nvpair_t *nvp)
114{
115
116 NVPAIR_ASSERT(nvp);
117
118 return (nvp->nvp_list);
119}

--- 37 unchanged lines hidden (view full) ---

157 nvlist_t *nvl;
158
159 /* XXX: DECONST is bad, mkay? */
160 nvl = __DECONST(nvlist_t *, nvpair_get_nvlist(nvp));
161 PJDLOG_ASSERT(nvl != NULL);
162 nvlist_set_parent(nvl, NULL);
163}
164
145nvlist_t *
146nvpair_nvlist(const nvpair_t *nvp)
147{
148
149 NVPAIR_ASSERT(nvp);
150
151 return (nvp->nvp_list);
152}

--- 37 unchanged lines hidden (view full) ---

190 nvlist_t *nvl;
191
192 /* XXX: DECONST is bad, mkay? */
193 nvl = __DECONST(nvlist_t *, nvpair_get_nvlist(nvp));
194 PJDLOG_ASSERT(nvl != NULL);
195 nvlist_set_parent(nvl, NULL);
196}
197
198static void
199nvpair_remove_nvlist_array(nvpair_t *nvp)
200{
201 nvlist_t **nvlarray;
202 size_t count, i;
203
204 /* XXX: DECONST is bad, mkay? */
205 nvlarray = __DECONST(nvlist_t **,
206 nvpair_get_nvlist_array(nvp, &count));
207 for (i = 0; i < count; i++)
208 nvlist_set_array_next(nvlarray[i], NULL);
209}
210
165void
166nvpair_remove(struct nvl_head *head, nvpair_t *nvp, const nvlist_t *nvl)
167{
168
169 NVPAIR_ASSERT(nvp);
170 PJDLOG_ASSERT(nvp->nvp_list == nvl);
171
172 if (nvpair_type(nvp) == NV_TYPE_NVLIST)
173 nvpair_remove_nvlist(nvp);
211void
212nvpair_remove(struct nvl_head *head, nvpair_t *nvp, const nvlist_t *nvl)
213{
214
215 NVPAIR_ASSERT(nvp);
216 PJDLOG_ASSERT(nvp->nvp_list == nvl);
217
218 if (nvpair_type(nvp) == NV_TYPE_NVLIST)
219 nvpair_remove_nvlist(nvp);
220 else if (nvpair_type(nvp) == NV_TYPE_NVLIST_ARRAY)
221 nvpair_remove_nvlist_array(nvp);
174
175 TAILQ_REMOVE(head, nvp, nvp_next);
176 nvp->nvp_list = NULL;
177}
178
179nvpair_t *
180nvpair_clone(const nvpair_t *nvp)
181{

--- 17 unchanged lines hidden (view full) ---

199 newnvp = nvpair_create_number(name, nvpair_get_number(nvp));
200 break;
201 case NV_TYPE_STRING:
202 newnvp = nvpair_create_string(name, nvpair_get_string(nvp));
203 break;
204 case NV_TYPE_NVLIST:
205 newnvp = nvpair_create_nvlist(name, nvpair_get_nvlist(nvp));
206 break;
222
223 TAILQ_REMOVE(head, nvp, nvp_next);
224 nvp->nvp_list = NULL;
225}
226
227nvpair_t *
228nvpair_clone(const nvpair_t *nvp)
229{

--- 17 unchanged lines hidden (view full) ---

247 newnvp = nvpair_create_number(name, nvpair_get_number(nvp));
248 break;
249 case NV_TYPE_STRING:
250 newnvp = nvpair_create_string(name, nvpair_get_string(nvp));
251 break;
252 case NV_TYPE_NVLIST:
253 newnvp = nvpair_create_nvlist(name, nvpair_get_nvlist(nvp));
254 break;
255 case NV_TYPE_BINARY:
256 data = nvpair_get_binary(nvp, &datasize);
257 newnvp = nvpair_create_binary(name, data, datasize);
258 break;
259 case NV_TYPE_BOOL_ARRAY:
260 data = nvpair_get_bool_array(nvp, &datasize);
261 newnvp = nvpair_create_bool_array(name, data, datasize);
262 break;
263 case NV_TYPE_NUMBER_ARRAY:
264 data = nvpair_get_number_array(nvp, &datasize);
265 newnvp = nvpair_create_number_array(name, data, datasize);
266 break;
267 case NV_TYPE_STRING_ARRAY:
268 data = nvpair_get_string_array(nvp, &datasize);
269 newnvp = nvpair_create_string_array(name, data, datasize);
270 break;
271 case NV_TYPE_NVLIST_ARRAY:
272 data = nvpair_get_nvlist_array(nvp, &datasize);
273 newnvp = nvpair_create_nvlist_array(name, data, datasize);
274 break;
207#ifndef _KERNEL
208 case NV_TYPE_DESCRIPTOR:
209 newnvp = nvpair_create_descriptor(name,
210 nvpair_get_descriptor(nvp));
211 break;
275#ifndef _KERNEL
276 case NV_TYPE_DESCRIPTOR:
277 newnvp = nvpair_create_descriptor(name,
278 nvpair_get_descriptor(nvp));
279 break;
212#endif
213 case NV_TYPE_BINARY:
214 data = nvpair_get_binary(nvp, &datasize);
215 newnvp = nvpair_create_binary(name, data, datasize);
280 case NV_TYPE_DESCRIPTOR_ARRAY:
281 data = nvpair_get_descriptor_array(nvp, &datasize);
282 newnvp = nvpair_create_descriptor_array(name, data, datasize);
216 break;
283 break;
284#endif
217 default:
218 PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
219 }
220
221 return (newnvp);
222}
223
224size_t

--- 20 unchanged lines hidden (view full) ---

245
246 NVPAIR_ASSERT(nvp);
247
248 nvphdr.nvph_type = nvp->nvp_type;
249 namesize = strlen(nvp->nvp_name) + 1;
250 PJDLOG_ASSERT(namesize > 0 && namesize <= UINT16_MAX);
251 nvphdr.nvph_namesize = namesize;
252 nvphdr.nvph_datasize = nvp->nvp_datasize;
285 default:
286 PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
287 }
288
289 return (newnvp);
290}
291
292size_t

--- 20 unchanged lines hidden (view full) ---

313
314 NVPAIR_ASSERT(nvp);
315
316 nvphdr.nvph_type = nvp->nvp_type;
317 namesize = strlen(nvp->nvp_name) + 1;
318 PJDLOG_ASSERT(namesize > 0 && namesize <= UINT16_MAX);
319 nvphdr.nvph_namesize = namesize;
320 nvphdr.nvph_datasize = nvp->nvp_datasize;
321 nvphdr.nvph_nitems = nvp->nvp_nitems;
253 PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
254 memcpy(ptr, &nvphdr, sizeof(nvphdr));
255 ptr += sizeof(nvphdr);
256 *leftp -= sizeof(nvphdr);
257
258 PJDLOG_ASSERT(*leftp >= namesize);
259 memcpy(ptr, nvp->nvp_name, namesize);
260 ptr += namesize;

--- 70 unchanged lines hidden (view full) ---

331 struct nvpair_header nvphdr;
332 size_t namesize;
333 const char *name = "";
334
335 namesize = 1;
336 nvphdr.nvph_type = NV_TYPE_NVLIST_UP;
337 nvphdr.nvph_namesize = namesize;
338 nvphdr.nvph_datasize = 0;
322 PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
323 memcpy(ptr, &nvphdr, sizeof(nvphdr));
324 ptr += sizeof(nvphdr);
325 *leftp -= sizeof(nvphdr);
326
327 PJDLOG_ASSERT(*leftp >= namesize);
328 memcpy(ptr, nvp->nvp_name, namesize);
329 ptr += namesize;

--- 70 unchanged lines hidden (view full) ---

400 struct nvpair_header nvphdr;
401 size_t namesize;
402 const char *name = "";
403
404 namesize = 1;
405 nvphdr.nvph_type = NV_TYPE_NVLIST_UP;
406 nvphdr.nvph_namesize = namesize;
407 nvphdr.nvph_datasize = 0;
408 nvphdr.nvph_nitems = 0;
339 PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
340 memcpy(ptr, &nvphdr, sizeof(nvphdr));
341 ptr += sizeof(nvphdr);
342 *leftp -= sizeof(nvphdr);
343
344 PJDLOG_ASSERT(*leftp >= namesize);
345 memcpy(ptr, name, namesize);
346 ptr += namesize;
347 *leftp -= namesize;
348
349 return (ptr);
350}
351
409 PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
410 memcpy(ptr, &nvphdr, sizeof(nvphdr));
411 ptr += sizeof(nvphdr);
412 *leftp -= sizeof(nvphdr);
413
414 PJDLOG_ASSERT(*leftp >= namesize);
415 memcpy(ptr, name, namesize);
416 ptr += namesize;
417 *leftp -= namesize;
418
419 return (ptr);
420}
421
422unsigned char *
423nvpair_pack_nvlist_array_next(unsigned char *ptr, size_t *leftp)
424{
425 struct nvpair_header nvphdr;
426 size_t namesize;
427 const char *name = "";
428
429 namesize = 1;
430 nvphdr.nvph_type = NV_TYPE_NVLIST_ARRAY_NEXT;
431 nvphdr.nvph_namesize = namesize;
432 nvphdr.nvph_datasize = 0;
433 nvphdr.nvph_nitems = 0;
434 PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
435 memcpy(ptr, &nvphdr, sizeof(nvphdr));
436 ptr += sizeof(nvphdr);
437 *leftp -= sizeof(nvphdr);
438
439 PJDLOG_ASSERT(*leftp >= namesize);
440 memcpy(ptr, name, namesize);
441 ptr += namesize;
442 *leftp -= namesize;
443
444 return (ptr);
445}
446
352#ifndef _KERNEL
353unsigned char *
354nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr, int64_t *fdidxp,
355 size_t *leftp)
356{
357 int64_t value;
358
359 NVPAIR_ASSERT(nvp);

--- 31 unchanged lines hidden (view full) ---

391 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
392 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
393 ptr += nvp->nvp_datasize;
394 *leftp -= nvp->nvp_datasize;
395
396 return (ptr);
397}
398
447#ifndef _KERNEL
448unsigned char *
449nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr, int64_t *fdidxp,
450 size_t *leftp)
451{
452 int64_t value;
453
454 NVPAIR_ASSERT(nvp);

--- 31 unchanged lines hidden (view full) ---

486 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
487 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
488 ptr += nvp->nvp_datasize;
489 *leftp -= nvp->nvp_datasize;
490
491 return (ptr);
492}
493
494unsigned char *
495nvpair_pack_bool_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
496{
497
498 NVPAIR_ASSERT(nvp);
499 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
500 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
501
502 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
503 ptr += nvp->nvp_datasize;
504 *leftp -= nvp->nvp_datasize;
505
506 return (ptr);
507}
508
509unsigned char *
510nvpair_pack_number_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
511{
512
513 NVPAIR_ASSERT(nvp);
514 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
515 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
516
517 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
518 ptr += nvp->nvp_datasize;
519 *leftp -= nvp->nvp_datasize;
520
521 return (ptr);
522}
523
524unsigned char *
525nvpair_pack_string_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
526{
527 unsigned int ii;
528 size_t size, len;
529 const char * const *array;
530
531 NVPAIR_ASSERT(nvp);
532 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
533 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
534
535 size = 0;
536 array = nvpair_get_string_array(nvp, NULL);
537 PJDLOG_ASSERT(array != NULL);
538
539 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
540 len = strlen(array[ii]) + 1;
541 PJDLOG_ASSERT(*leftp >= len);
542
543 memcpy(ptr, (const void *)array[ii], len);
544 size += len;
545 ptr += len;
546 *leftp -= len;
547 }
548
549 PJDLOG_ASSERT(size == nvp->nvp_datasize);
550
551 return (ptr);
552}
553
554#ifndef _KERNEL
555unsigned char *
556nvpair_pack_descriptor_array(const nvpair_t *nvp, unsigned char *ptr,
557 int64_t *fdidxp, size_t *leftp)
558{
559 int64_t value;
560 const int *array;
561 unsigned int ii;
562
563 NVPAIR_ASSERT(nvp);
564 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
565 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
566
567 array = nvpair_get_descriptor_array(nvp, NULL);
568 PJDLOG_ASSERT(array != NULL);
569
570 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
571 PJDLOG_ASSERT(*leftp >= sizeof(value));
572
573 value = array[ii];
574 if (value != -1) {
575 /*
576 * If there is a real descriptor here, we change its
577 * number to position in the array of descriptors send
578 * via control message.
579 */
580 PJDLOG_ASSERT(fdidxp != NULL);
581
582 value = *fdidxp;
583 (*fdidxp)++;
584 }
585 memcpy(ptr, &value, sizeof(value));
586 ptr += sizeof(value);
587 *leftp -= sizeof(value);
588 }
589
590 return (ptr);
591}
592#endif
593
399void
400nvpair_init_datasize(nvpair_t *nvp)
401{
402
403 NVPAIR_ASSERT(nvp);
404
405 if (nvp->nvp_type == NV_TYPE_NVLIST) {
406 if (nvp->nvp_data == 0) {

--- 18 unchanged lines hidden (view full) ---

425 ptr += sizeof(nvphdr);
426 *leftp -= sizeof(nvphdr);
427
428#if NV_TYPE_FIRST > 0
429 if (nvphdr.nvph_type < NV_TYPE_FIRST)
430 goto failed;
431#endif
432 if (nvphdr.nvph_type > NV_TYPE_LAST &&
594void
595nvpair_init_datasize(nvpair_t *nvp)
596{
597
598 NVPAIR_ASSERT(nvp);
599
600 if (nvp->nvp_type == NV_TYPE_NVLIST) {
601 if (nvp->nvp_data == 0) {

--- 18 unchanged lines hidden (view full) ---

620 ptr += sizeof(nvphdr);
621 *leftp -= sizeof(nvphdr);
622
623#if NV_TYPE_FIRST > 0
624 if (nvphdr.nvph_type < NV_TYPE_FIRST)
625 goto failed;
626#endif
627 if (nvphdr.nvph_type > NV_TYPE_LAST &&
433 nvphdr.nvph_type != NV_TYPE_NVLIST_UP) {
628 nvphdr.nvph_type != NV_TYPE_NVLIST_UP &&
629 nvphdr.nvph_type != NV_TYPE_NVLIST_ARRAY_NEXT) {
434 goto failed;
435 }
436
437#if BYTE_ORDER == BIG_ENDIAN
438 if (!isbe) {
439 nvphdr.nvph_namesize = le16toh(nvphdr.nvph_namesize);
440 nvphdr.nvph_datasize = le64toh(nvphdr.nvph_datasize);
441 }

--- 20 unchanged lines hidden (view full) ---

462 *leftp -= nvphdr.nvph_namesize;
463
464 if (*leftp < nvphdr.nvph_datasize)
465 goto failed;
466
467 nvp->nvp_type = nvphdr.nvph_type;
468 nvp->nvp_data = 0;
469 nvp->nvp_datasize = nvphdr.nvph_datasize;
630 goto failed;
631 }
632
633#if BYTE_ORDER == BIG_ENDIAN
634 if (!isbe) {
635 nvphdr.nvph_namesize = le16toh(nvphdr.nvph_namesize);
636 nvphdr.nvph_datasize = le64toh(nvphdr.nvph_datasize);
637 }

--- 20 unchanged lines hidden (view full) ---

658 *leftp -= nvphdr.nvph_namesize;
659
660 if (*leftp < nvphdr.nvph_datasize)
661 goto failed;
662
663 nvp->nvp_type = nvphdr.nvph_type;
664 nvp->nvp_data = 0;
665 nvp->nvp_datasize = nvphdr.nvph_datasize;
666 nvp->nvp_nitems = nvphdr.nvph_nitems;
470
471 return (ptr);
472failed:
473 ERRNO_SET(EINVAL);
474 return (NULL);
475}
476
477const unsigned char *

--- 57 unchanged lines hidden (view full) ---

535 ERRNO_SET(EINVAL);
536 return (NULL);
537 }
538
539 if (isbe)
540 nvp->nvp_data = be64dec(ptr);
541 else
542 nvp->nvp_data = le64dec(ptr);
667
668 return (ptr);
669failed:
670 ERRNO_SET(EINVAL);
671 return (NULL);
672}
673
674const unsigned char *

--- 57 unchanged lines hidden (view full) ---

732 ERRNO_SET(EINVAL);
733 return (NULL);
734 }
735
736 if (isbe)
737 nvp->nvp_data = be64dec(ptr);
738 else
739 nvp->nvp_data = le64dec(ptr);
740
543 ptr += sizeof(uint64_t);
544 *leftp -= sizeof(uint64_t);
545
546 return (ptr);
547}
548
549const unsigned char *
550nvpair_unpack_string(bool isbe __unused, nvpair_t *nvp,

--- 114 unchanged lines hidden (view full) ---

665 *leftp -= nvp->nvp_datasize;
666
667 nvp->nvp_data = (uint64_t)(uintptr_t)value;
668
669 return (ptr);
670}
671
672const unsigned char *
741 ptr += sizeof(uint64_t);
742 *leftp -= sizeof(uint64_t);
743
744 return (ptr);
745}
746
747const unsigned char *
748nvpair_unpack_string(bool isbe __unused, nvpair_t *nvp,

--- 114 unchanged lines hidden (view full) ---

863 *leftp -= nvp->nvp_datasize;
864
865 nvp->nvp_data = (uint64_t)(uintptr_t)value;
866
867 return (ptr);
868}
869
870const unsigned char *
871nvpair_unpack_bool_array(bool isbe __unused, nvpair_t *nvp,
872 const unsigned char *ptr, size_t *leftp)
873{
874 uint8_t *value;
875 size_t size;
876 unsigned int i;
877
878 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
879
880 size = sizeof(*value) * nvp->nvp_nitems;
881 if (nvp->nvp_datasize != size || *leftp < size ||
882 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
883 ERRNO_SET(EINVAL);
884 return (NULL);
885 }
886
887 value = nv_malloc(size);
888 if (value == NULL)
889 return (NULL);
890
891 for (i = 0; i < nvp->nvp_nitems; i++) {
892 value[i] = *(const uint8_t *)ptr;
893
894 ptr += sizeof(*value);
895 *leftp -= sizeof(*value);
896 }
897
898 nvp->nvp_data = (uint64_t)(uintptr_t)value;
899
900 return (ptr);
901}
902
903const unsigned char *
904nvpair_unpack_number_array(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
905 size_t *leftp)
906{
907 uint64_t *value;
908 size_t size;
909 unsigned int i;
910
911 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
912
913 size = sizeof(*value) * nvp->nvp_nitems;
914 if (nvp->nvp_datasize != size || *leftp < size ||
915 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
916 ERRNO_SET(EINVAL);
917 return (NULL);
918 }
919
920 value = nv_malloc(size);
921 if (value == NULL)
922 return (NULL);
923
924 for (i = 0; i < nvp->nvp_nitems; i++) {
925 if (isbe)
926 value[i] = be64dec(ptr);
927 else
928 value[i] = le64dec(ptr);
929
930 ptr += sizeof(*value);
931 *leftp -= sizeof(*value);
932 }
933
934 nvp->nvp_data = (uint64_t)(uintptr_t)value;
935
936 return (ptr);
937}
938
939const unsigned char *
940nvpair_unpack_string_array(bool isbe __unused, nvpair_t *nvp,
941 const unsigned char *ptr, size_t *leftp)
942{
943 ssize_t size;
944 size_t len;
945 const char *tmp;
946 char **value;
947 unsigned int ii, j;
948
949 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
950
951 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0 ||
952 nvp->nvp_nitems == 0) {
953 ERRNO_SET(EINVAL);
954 return (NULL);
955 }
956
957 size = nvp->nvp_datasize;
958 tmp = (const char *)ptr;
959 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
960 len = strnlen(tmp, size - 1) + 1;
961 size -= len;
962 if (size < 0) {
963 ERRNO_SET(EINVAL);
964 return (NULL);
965 }
966 tmp += len;
967 }
968 if (size != 0) {
969 ERRNO_SET(EINVAL);
970 return (NULL);
971 }
972
973 value = nv_malloc(sizeof(*value) * nvp->nvp_nitems);
974 if (value == NULL)
975 return (NULL);
976
977 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
978 value[ii] = nv_strdup((const char *)ptr);
979 if (value[ii] == NULL)
980 goto out;
981 len = strlen(value[ii]) + 1;
982 ptr += len;
983 *leftp -= len;
984 }
985 nvp->nvp_data = (uint64_t)(uintptr_t)value;
986
987 return (ptr);
988out:
989 for (j = 0; j < ii; j++)
990 nv_free(value[j]);
991 nv_free(value);
992 return (NULL);
993}
994
995#ifndef _KERNEL
996const unsigned char *
997nvpair_unpack_descriptor_array(bool isbe, nvpair_t *nvp,
998 const unsigned char *ptr, size_t *leftp, const int *fds, size_t nfds)
999{
1000 int64_t idx;
1001 size_t size;
1002 unsigned int ii;
1003 int *array;
1004
1005 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
1006
1007 size = sizeof(idx) * nvp->nvp_nitems;
1008 if (nvp->nvp_datasize != size || *leftp < size ||
1009 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
1010 ERRNO_SET(EINVAL);
1011 return (NULL);
1012 }
1013
1014 array = (int *)nv_malloc(size);
1015 if (array == NULL)
1016 return (NULL);
1017
1018 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1019 if (isbe)
1020 idx = be64dec(ptr);
1021 else
1022 idx = le64dec(ptr);
1023
1024 if (idx < 0) {
1025 ERRNO_SET(EINVAL);
1026 nv_free(array);
1027 return (NULL);
1028 }
1029
1030 if ((size_t)idx >= nfds) {
1031 ERRNO_SET(EINVAL);
1032 nv_free(array);
1033 return (NULL);
1034 }
1035
1036 array[ii] = (uint64_t)fds[idx];
1037
1038 ptr += sizeof(idx);
1039 *leftp -= sizeof(idx);
1040 }
1041
1042 nvp->nvp_data = (uint64_t)(uintptr_t)array;
1043
1044 return (ptr);
1045}
1046#endif
1047
1048const unsigned char *
1049nvpair_unpack_nvlist_array(bool isbe __unused, nvpair_t *nvp,
1050 const unsigned char *ptr, size_t *leftp, nvlist_t **firstel)
1051{
1052 nvlist_t **value;
1053 nvpair_t *tmpnvp;
1054 unsigned int ii, j;
1055 size_t sizeup;
1056
1057 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1058
1059 sizeup = sizeof(struct nvpair_header) * nvp->nvp_nitems;
1060 if (nvp->nvp_nitems == 0 || sizeup < nvp->nvp_nitems ||
1061 sizeup > *leftp) {
1062 ERRNO_SET(EINVAL);
1063 return (NULL);
1064 }
1065
1066 value = nv_malloc(nvp->nvp_nitems * sizeof(*value));
1067 if (value == NULL)
1068 return (NULL);
1069
1070 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1071 value[ii] = nvlist_create(0);
1072 if (value[ii] == NULL)
1073 goto fail;
1074 if (ii > 0) {
1075 tmpnvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1076 (uint64_t)(uintptr_t)value[ii], 0, 0);
1077 if (tmpnvp == NULL)
1078 goto fail;
1079 nvlist_set_array_next(value[ii - 1], tmpnvp);
1080 }
1081 }
1082 nvlist_set_flags(value[nvp->nvp_nitems - 1], NV_FLAG_IN_ARRAY);
1083
1084 nvp->nvp_data = (uint64_t)(uintptr_t)value;
1085 *firstel = value[0];
1086
1087 return (ptr);
1088fail:
1089 ERRNO_SAVE();
1090 for (j = 0; j < ii; j++)
1091 nvlist_destroy(value[j]);
1092 nv_free(value);
1093 ERRNO_RESTORE();
1094
1095 return (NULL);
1096}
1097
1098const unsigned char *
673nvpair_unpack(bool isbe, const unsigned char *ptr, size_t *leftp,
674 nvpair_t **nvpp)
675{
676 nvpair_t *nvp, *tmp;
677
678 nvp = nv_calloc(1, sizeof(*nvp) + NV_NAME_MAX);
679 if (nvp == NULL)
680 return (NULL);

--- 31 unchanged lines hidden (view full) ---

712nvpair_name(const nvpair_t *nvp)
713{
714
715 NVPAIR_ASSERT(nvp);
716
717 return (nvp->nvp_name);
718}
719
1099nvpair_unpack(bool isbe, const unsigned char *ptr, size_t *leftp,
1100 nvpair_t **nvpp)
1101{
1102 nvpair_t *nvp, *tmp;
1103
1104 nvp = nv_calloc(1, sizeof(*nvp) + NV_NAME_MAX);
1105 if (nvp == NULL)
1106 return (NULL);

--- 31 unchanged lines hidden (view full) ---

1138nvpair_name(const nvpair_t *nvp)
1139{
1140
1141 NVPAIR_ASSERT(nvp);
1142
1143 return (nvp->nvp_name);
1144}
1145
720static nvpair_t *
721nvpair_allocv(const char *name, int type, uint64_t data, size_t datasize)
722{
723 nvpair_t *nvp;
724 size_t namelen;
725
726 PJDLOG_ASSERT(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST);
727
728 namelen = strlen(name);
729 if (namelen >= NV_NAME_MAX) {
730 ERRNO_SET(ENAMETOOLONG);
731 return (NULL);
732 }
733
734 nvp = nv_calloc(1, sizeof(*nvp) + namelen + 1);
735 if (nvp != NULL) {
736 nvp->nvp_name = (char *)(nvp + 1);
737 memcpy(nvp->nvp_name, name, namelen);
738 nvp->nvp_name[namelen] = '\0';
739 nvp->nvp_type = type;
740 nvp->nvp_data = data;
741 nvp->nvp_datasize = datasize;
742 nvp->nvp_magic = NVPAIR_MAGIC;
743 }
744
745 return (nvp);
746}
747
748nvpair_t *
749nvpair_create_stringf(const char *name, const char *valuefmt, ...)
750{
751 va_list valueap;
752 nvpair_t *nvp;
753
754 va_start(valueap, valuefmt);
755 nvp = nvpair_create_stringv(name, valuefmt, valueap);

--- 17 unchanged lines hidden (view full) ---

773 nv_free(str);
774 return (nvp);
775}
776
777nvpair_t *
778nvpair_create_null(const char *name)
779{
780
1146nvpair_t *
1147nvpair_create_stringf(const char *name, const char *valuefmt, ...)
1148{
1149 va_list valueap;
1150 nvpair_t *nvp;
1151
1152 va_start(valueap, valuefmt);
1153 nvp = nvpair_create_stringv(name, valuefmt, valueap);

--- 17 unchanged lines hidden (view full) ---

1171 nv_free(str);
1172 return (nvp);
1173}
1174
1175nvpair_t *
1176nvpair_create_null(const char *name)
1177{
1178
781 return (nvpair_allocv(name, NV_TYPE_NULL, 0, 0));
1179 return (nvpair_allocv(name, NV_TYPE_NULL, 0, 0, 0));
782}
783
784nvpair_t *
785nvpair_create_bool(const char *name, bool value)
786{
787
788 return (nvpair_allocv(name, NV_TYPE_BOOL, value ? 1 : 0,
1180}
1181
1182nvpair_t *
1183nvpair_create_bool(const char *name, bool value)
1184{
1185
1186 return (nvpair_allocv(name, NV_TYPE_BOOL, value ? 1 : 0,
789 sizeof(uint8_t)));
1187 sizeof(uint8_t), 0));
790}
791
792nvpair_t *
793nvpair_create_number(const char *name, uint64_t value)
794{
795
1188}
1189
1190nvpair_t *
1191nvpair_create_number(const char *name, uint64_t value)
1192{
1193
796 return (nvpair_allocv(name, NV_TYPE_NUMBER, value, sizeof(value)));
1194 return (nvpair_allocv(name, NV_TYPE_NUMBER, value, sizeof(value), 0));
797}
798
799nvpair_t *
800nvpair_create_string(const char *name, const char *value)
801{
802 nvpair_t *nvp;
803 size_t size;
804 char *data;

--- 4 unchanged lines hidden (view full) ---

809 }
810
811 data = nv_strdup(value);
812 if (data == NULL)
813 return (NULL);
814 size = strlen(value) + 1;
815
816 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)data,
1195}
1196
1197nvpair_t *
1198nvpair_create_string(const char *name, const char *value)
1199{
1200 nvpair_t *nvp;
1201 size_t size;
1202 char *data;

--- 4 unchanged lines hidden (view full) ---

1207 }
1208
1209 data = nv_strdup(value);
1210 if (data == NULL)
1211 return (NULL);
1212 size = strlen(value) + 1;
1213
1214 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)data,
817 size);
1215 size, 0);
818 if (nvp == NULL)
819 nv_free(data);
820
821 return (nvp);
822}
823
824nvpair_t *
825nvpair_create_nvlist(const char *name, const nvlist_t *value)

--- 5 unchanged lines hidden (view full) ---

831 ERRNO_SET(EINVAL);
832 return (NULL);
833 }
834
835 nvl = nvlist_clone(value);
836 if (nvl == NULL)
837 return (NULL);
838
1216 if (nvp == NULL)
1217 nv_free(data);
1218
1219 return (nvp);
1220}
1221
1222nvpair_t *
1223nvpair_create_nvlist(const char *name, const nvlist_t *value)

--- 5 unchanged lines hidden (view full) ---

1229 ERRNO_SET(EINVAL);
1230 return (NULL);
1231 }
1232
1233 nvl = nvlist_clone(value);
1234 if (nvl == NULL)
1235 return (NULL);
1236
839 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0);
1237 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0,
1238 0);
840 if (nvp == NULL)
841 nvlist_destroy(nvl);
842 else
843 nvlist_set_parent(nvl, nvp);
844
845 return (nvp);
846}
847

--- 8 unchanged lines hidden (view full) ---

856 return (NULL);
857 }
858
859 value = fcntl(value, F_DUPFD_CLOEXEC, 0);
860 if (value < 0)
861 return (NULL);
862
863 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1239 if (nvp == NULL)
1240 nvlist_destroy(nvl);
1241 else
1242 nvlist_set_parent(nvl, nvp);
1243
1244 return (nvp);
1245}
1246

--- 8 unchanged lines hidden (view full) ---

1255 return (NULL);
1256 }
1257
1258 value = fcntl(value, F_DUPFD_CLOEXEC, 0);
1259 if (value < 0)
1260 return (NULL);
1261
1262 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
864 sizeof(int64_t));
1263 sizeof(int64_t), 0);
865 if (nvp == NULL) {
866 ERRNO_SAVE();
867 close(value);
868 ERRNO_RESTORE();
869 }
870
871 return (nvp);
872}

--- 11 unchanged lines hidden (view full) ---

884 }
885
886 data = nv_malloc(size);
887 if (data == NULL)
888 return (NULL);
889 memcpy(data, value, size);
890
891 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)data,
1264 if (nvp == NULL) {
1265 ERRNO_SAVE();
1266 close(value);
1267 ERRNO_RESTORE();
1268 }
1269
1270 return (nvp);
1271}

--- 11 unchanged lines hidden (view full) ---

1283 }
1284
1285 data = nv_malloc(size);
1286 if (data == NULL)
1287 return (NULL);
1288 memcpy(data, value, size);
1289
1290 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)data,
892 size);
1291 size, 0);
893 if (nvp == NULL)
894 nv_free(data);
895
896 return (nvp);
897}
898
899nvpair_t *
1292 if (nvp == NULL)
1293 nv_free(data);
1294
1295 return (nvp);
1296}
1297
1298nvpair_t *
1299nvpair_create_bool_array(const char *name, const bool *value, size_t nitems)
1300{
1301 nvpair_t *nvp;
1302 size_t size;
1303 void *data;
1304
1305 if (value == NULL || nitems == 0) {
1306 ERRNO_SET(EINVAL);
1307 return (NULL);
1308 }
1309
1310 size = sizeof(value[0]) * nitems;
1311 data = nv_malloc(size);
1312 if (data == NULL)
1313 return (NULL);
1314
1315 memcpy(data, value, size);
1316 nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY, (uint64_t)(uintptr_t)data,
1317 size, nitems);
1318 if (nvp == NULL) {
1319 ERRNO_SAVE();
1320 nv_free(data);
1321 ERRNO_RESTORE();
1322 }
1323
1324 return (nvp);
1325}
1326
1327nvpair_t *
1328nvpair_create_number_array(const char *name, const uint64_t *value,
1329 size_t nitems)
1330{
1331 nvpair_t *nvp;
1332 size_t size;
1333 void *data;
1334
1335 if (value == NULL || nitems == 0) {
1336 ERRNO_SET(EINVAL);
1337 return (NULL);
1338 }
1339
1340 size = sizeof(value[0]) * nitems;
1341 data = nv_malloc(size);
1342 if (data == NULL)
1343 return (NULL);
1344
1345 memcpy(data, value, size);
1346 nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
1347 (uint64_t)(uintptr_t)data, size, nitems);
1348 if (nvp == NULL) {
1349 ERRNO_SAVE();
1350 nv_free(data);
1351 ERRNO_RESTORE();
1352 }
1353
1354 return (nvp);
1355}
1356
1357nvpair_t *
1358nvpair_create_string_array(const char *name, const char * const *value,
1359 size_t nitems)
1360{
1361 nvpair_t *nvp;
1362 unsigned int ii;
1363 size_t datasize, size;
1364 char **data;
1365
1366 if (value == NULL || nitems == 0) {
1367 ERRNO_SET(EINVAL);
1368 return (NULL);
1369 }
1370
1371 nvp = NULL;
1372 datasize = 0;
1373 data = nv_malloc(sizeof(value[0]) * nitems);
1374 if (data == NULL)
1375 return (NULL);
1376
1377 for (ii = 0; ii < nitems; ii++) {
1378 if (value[ii] == NULL) {
1379 ERRNO_SET(EINVAL);
1380 goto fail;
1381 }
1382
1383 size = strlen(value[ii]) + 1;
1384 datasize += size;
1385 data[ii] = nv_strdup(value[ii]);
1386 if (data[ii] == NULL)
1387 goto fail;
1388 }
1389 nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
1390 (uint64_t)(uintptr_t)data, datasize, nitems);
1391
1392fail:
1393 if (nvp == NULL) {
1394 ERRNO_SAVE();
1395 for (; ii > 0; ii--)
1396 nv_free(data[ii - 1]);
1397 nv_free(data);
1398 ERRNO_RESTORE();
1399 }
1400
1401 return (nvp);
1402}
1403
1404nvpair_t *
1405nvpair_create_nvlist_array(const char *name, const nvlist_t * const *value,
1406 size_t nitems)
1407{
1408 unsigned int ii;
1409 nvlist_t **nvls;
1410 nvpair_t *nvp;
1411 int flags;
1412
1413 nvp = NULL;
1414 nvls = NULL;
1415 ii = 0;
1416
1417 if (value == NULL || nitems == 0) {
1418 ERRNO_SET(EINVAL);
1419 return (NULL);
1420 }
1421
1422 nvls = nv_malloc(sizeof(value[0]) * nitems);
1423 if (nvls == NULL)
1424 return (NULL);
1425
1426 for (ii = 0; ii < nitems; ii++) {
1427 if (value[ii] == NULL) {
1428 ERRNO_SET(EINVAL);
1429 goto fail;
1430 }
1431
1432 nvls[ii] = nvlist_clone(value[ii]);
1433 if (nvls[ii] == NULL)
1434 goto fail;
1435
1436 if (ii > 0) {
1437 nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1438 (uint64_t)(uintptr_t)nvls[ii], 0, 0);
1439 if (nvp == NULL)
1440 goto fail;
1441 nvlist_set_array_next(nvls[ii - 1], nvp);
1442 }
1443 }
1444 flags = nvlist_flags(nvls[nitems - 1]) | NV_FLAG_IN_ARRAY;
1445 nvlist_set_flags(nvls[nitems - 1], flags);
1446
1447 nvp = nvpair_allocv(name, NV_TYPE_NVLIST_ARRAY,
1448 (uint64_t)(uintptr_t)nvls, 0, nitems);
1449
1450fail:
1451 if (nvp == NULL) {
1452 ERRNO_SAVE();
1453 for (; ii > 0; ii--)
1454 nvlist_destroy(nvls[ii - 1]);
1455
1456 nv_free(nvls);
1457 ERRNO_RESTORE();
1458 } else {
1459 for (ii = 0; ii < nitems; ii++)
1460 nvlist_set_parent(nvls[ii], nvp);
1461 }
1462
1463 return (nvp);
1464}
1465
1466#ifndef _KERNEL
1467nvpair_t *
1468nvpair_create_descriptor_array(const char *name, const int *value,
1469 size_t nitems)
1470{
1471 unsigned int ii;
1472 nvpair_t *nvp;
1473 int *fds;
1474
1475 if (value == NULL) {
1476 ERRNO_SET(EINVAL);
1477 return (NULL);
1478 }
1479
1480 nvp = NULL;
1481
1482 fds = nv_malloc(sizeof(value[0]) * nitems);
1483 if (fds == NULL)
1484 return (NULL);
1485 for (ii = 0; ii < nitems; ii++) {
1486 if (value[ii] == -1) {
1487 fds[ii] = -1;
1488 } else {
1489 if (!fd_is_valid(value[ii])) {
1490 ERRNO_SET(EBADF);
1491 goto fail;
1492 }
1493
1494 fds[ii] = fcntl(value[ii], F_DUPFD_CLOEXEC, 0);
1495 if (fds[ii] == -1)
1496 goto fail;
1497 }
1498 }
1499
1500 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
1501 (uint64_t)(uintptr_t)fds, sizeof(int64_t) * nitems, nitems);
1502
1503fail:
1504 if (nvp == NULL) {
1505 ERRNO_SAVE();
1506 for (; ii > 0; ii--) {
1507 if (fds[ii - 1] != -1)
1508 close(fds[ii - 1]);
1509 }
1510 nv_free(fds);
1511 ERRNO_RESTORE();
1512 }
1513
1514 return (nvp);
1515}
1516#endif
1517
1518nvpair_t *
900nvpair_move_string(const char *name, char *value)
901{
902 nvpair_t *nvp;
903
904 if (value == NULL) {
905 ERRNO_SET(EINVAL);
906 return (NULL);
907 }
908
909 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
1519nvpair_move_string(const char *name, char *value)
1520{
1521 nvpair_t *nvp;
1522
1523 if (value == NULL) {
1524 ERRNO_SET(EINVAL);
1525 return (NULL);
1526 }
1527
1528 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
910 strlen(value) + 1);
1529 strlen(value) + 1, 0);
911 if (nvp == NULL) {
912 ERRNO_SAVE();
913 nv_free(value);
914 ERRNO_RESTORE();
915 }
916
917 return (nvp);
918}

--- 10 unchanged lines hidden (view full) ---

929
930 if (nvlist_error(value) != 0) {
931 ERRNO_SET(nvlist_error(value));
932 nvlist_destroy(value);
933 return (NULL);
934 }
935
936 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value,
1530 if (nvp == NULL) {
1531 ERRNO_SAVE();
1532 nv_free(value);
1533 ERRNO_RESTORE();
1534 }
1535
1536 return (nvp);
1537}

--- 10 unchanged lines hidden (view full) ---

1548
1549 if (nvlist_error(value) != 0) {
1550 ERRNO_SET(nvlist_error(value));
1551 nvlist_destroy(value);
1552 return (NULL);
1553 }
1554
1555 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value,
937 0);
1556 0, 0);
938 if (nvp == NULL)
939 nvlist_destroy(value);
940 else
941 nvlist_set_parent(value, nvp);
942
943 return (nvp);
944}
945

--- 4 unchanged lines hidden (view full) ---

950 nvpair_t *nvp;
951
952 if (value < 0 || !fd_is_valid(value)) {
953 ERRNO_SET(EBADF);
954 return (NULL);
955 }
956
957 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1557 if (nvp == NULL)
1558 nvlist_destroy(value);
1559 else
1560 nvlist_set_parent(value, nvp);
1561
1562 return (nvp);
1563}
1564

--- 4 unchanged lines hidden (view full) ---

1569 nvpair_t *nvp;
1570
1571 if (value < 0 || !fd_is_valid(value)) {
1572 ERRNO_SET(EBADF);
1573 return (NULL);
1574 }
1575
1576 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
958 sizeof(int64_t));
1577 sizeof(int64_t), 0);
959 if (nvp == NULL) {
960 ERRNO_SAVE();
961 close(value);
962 ERRNO_RESTORE();
963 }
964
965 return (nvp);
966}

--- 5 unchanged lines hidden (view full) ---

972 nvpair_t *nvp;
973
974 if (value == NULL || size == 0) {
975 ERRNO_SET(EINVAL);
976 return (NULL);
977 }
978
979 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)value,
1578 if (nvp == NULL) {
1579 ERRNO_SAVE();
1580 close(value);
1581 ERRNO_RESTORE();
1582 }
1583
1584 return (nvp);
1585}

--- 5 unchanged lines hidden (view full) ---

1591 nvpair_t *nvp;
1592
1593 if (value == NULL || size == 0) {
1594 ERRNO_SET(EINVAL);
1595 return (NULL);
1596 }
1597
1598 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)value,
980 size);
1599 size, 0);
981 if (nvp == NULL) {
982 ERRNO_SAVE();
983 nv_free(value);
984 ERRNO_RESTORE();
985 }
986
987 return (nvp);
988}
989
1600 if (nvp == NULL) {
1601 ERRNO_SAVE();
1602 nv_free(value);
1603 ERRNO_RESTORE();
1604 }
1605
1606 return (nvp);
1607}
1608
1609nvpair_t *
1610nvpair_move_bool_array(const char *name, bool *value, size_t nitems)
1611{
1612 nvpair_t *nvp;
1613
1614 if (value == NULL || nitems == 0) {
1615 ERRNO_SET(EINVAL);
1616 return (NULL);
1617 }
1618
1619 nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY,
1620 (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
1621 if (nvp == NULL) {
1622 ERRNO_SAVE();
1623 nv_free(value);
1624 ERRNO_RESTORE();
1625 }
1626
1627 return (nvp);
1628}
1629
1630nvpair_t *
1631nvpair_move_string_array(const char *name, char **value, size_t nitems)
1632{
1633 nvpair_t *nvp;
1634 size_t i, size;
1635
1636 if (value == NULL || nitems == 0) {
1637 ERRNO_SET(EINVAL);
1638 return (NULL);
1639 }
1640
1641 size = 0;
1642 for (i = 0; i < nitems; i++) {
1643 if (value[i] == NULL) {
1644 ERRNO_SET(EINVAL);
1645 return (NULL);
1646 }
1647
1648 size += strlen(value[i]) + 1;
1649 }
1650
1651 nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
1652 (uint64_t)(uintptr_t)value, size, nitems);
1653 if (nvp == NULL) {
1654 ERRNO_SAVE();
1655 for (i = 0; i < nitems; i++)
1656 nv_free(value[i]);
1657 nv_free(value);
1658 ERRNO_RESTORE();
1659 }
1660
1661 return (nvp);
1662}
1663
1664nvpair_t *
1665nvpair_move_number_array(const char *name, uint64_t *value, size_t nitems)
1666{
1667 nvpair_t *nvp;
1668
1669 if (value == NULL || nitems == 0) {
1670 ERRNO_SET(EINVAL);
1671 return (NULL);
1672 }
1673
1674 nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
1675 (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
1676 if (nvp == NULL) {
1677 ERRNO_SAVE();
1678 nv_free(value);
1679 ERRNO_RESTORE();
1680 }
1681
1682 return (nvp);
1683}
1684
1685nvpair_t *
1686nvpair_move_nvlist_array(const char *name, nvlist_t **value, size_t nitems)
1687{
1688 unsigned int ii;
1689 nvpair_t *nvp;
1690 int flags;
1691
1692 nvp = NULL;
1693 if (value == NULL || nitems == 0) {
1694 ERRNO_SET(EINVAL);
1695 return (NULL);
1696 }
1697
1698 for (ii = 0; ii < nitems; ii++) {
1699 if (value == NULL || nvlist_error(value[ii]) != 0 ||
1700 nvlist_get_pararr(value[ii], NULL) != NULL) {
1701 ERRNO_SET(EINVAL);
1702 goto fail;
1703 }
1704 if (ii > 0) {
1705 nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1706 (uint64_t)(uintptr_t)value[ii], 0, 0);
1707 if (nvp == NULL)
1708 goto fail;
1709 nvlist_set_array_next(value[ii - 1], nvp);
1710 }
1711 }
1712 flags = nvlist_flags(value[nitems - 1]) | NV_FLAG_IN_ARRAY;
1713 nvlist_set_flags(value[nitems - 1], flags);
1714
1715 nvp = nvpair_allocv(name, NV_TYPE_NVLIST_ARRAY,
1716 (uint64_t)(uintptr_t)value, 0, nitems);
1717fail:
1718 if (nvp == NULL) {
1719 ERRNO_SAVE();
1720 for (ii = 0; ii < nitems; ii++) {
1721 if (value[ii] != NULL &&
1722 nvlist_get_pararr(value[ii], NULL) != NULL) {
1723 nvlist_destroy(value[ii]);
1724 }
1725 nv_free(value);
1726 }
1727 ERRNO_RESTORE();
1728 } else {
1729 for (ii = 0; ii < nitems; ii++)
1730 nvlist_set_parent(value[ii], nvp);
1731 }
1732
1733 return (nvp);
1734}
1735
1736#ifndef _KERNEL
1737nvpair_t *
1738nvpair_move_descriptor_array(const char *name, int *value, size_t nitems)
1739{
1740 nvpair_t *nvp;
1741 size_t i;
1742
1743 nvp = NULL;
1744 if (value == NULL || nitems == 0) {
1745 ERRNO_SET(EINVAL);
1746 return (NULL);
1747 }
1748
1749 for (i = 0; i < nitems; i++) {
1750 if (value[i] != -1 && !fd_is_valid(value[i])) {
1751 ERRNO_SET(EBADF);
1752 goto fail;
1753 }
1754 }
1755
1756 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
1757 (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
1758
1759fail:
1760 if (nvp == NULL) {
1761 ERRNO_SAVE();
1762 for (i = 0; i < nitems; i++) {
1763 if (fd_is_valid(value[i]))
1764 close(value[i]);
1765 }
1766 nv_free(value);
1767 ERRNO_RESTORE();
1768 }
1769
1770 return (nvp);
1771}
1772#endif
1773
990bool
991nvpair_get_bool(const nvpair_t *nvp)
992{
993
994 NVPAIR_ASSERT(nvp);
995
996 return (nvp->nvp_data == 1);
997}

--- 43 unchanged lines hidden (view full) ---

1041nvpair_get_binary(const nvpair_t *nvp, size_t *sizep)
1042{
1043
1044 NVPAIR_ASSERT(nvp);
1045 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
1046
1047 if (sizep != NULL)
1048 *sizep = nvp->nvp_datasize;
1774bool
1775nvpair_get_bool(const nvpair_t *nvp)
1776{
1777
1778 NVPAIR_ASSERT(nvp);
1779
1780 return (nvp->nvp_data == 1);
1781}

--- 43 unchanged lines hidden (view full) ---

1825nvpair_get_binary(const nvpair_t *nvp, size_t *sizep)
1826{
1827
1828 NVPAIR_ASSERT(nvp);
1829 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
1830
1831 if (sizep != NULL)
1832 *sizep = nvp->nvp_datasize;
1833
1049 return ((const void *)(intptr_t)nvp->nvp_data);
1050}
1051
1834 return ((const void *)(intptr_t)nvp->nvp_data);
1835}
1836
1837const bool *
1838nvpair_get_bool_array(const nvpair_t *nvp, size_t *nitems)
1839{
1840
1841 NVPAIR_ASSERT(nvp);
1842 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
1843
1844 if (nitems != NULL)
1845 *nitems = nvp->nvp_nitems;
1846
1847 return ((const bool *)(intptr_t)nvp->nvp_data);
1848}
1849
1850const uint64_t *
1851nvpair_get_number_array(const nvpair_t *nvp, size_t *nitems)
1852{
1853
1854 NVPAIR_ASSERT(nvp);
1855 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
1856
1857 if (nitems != NULL)
1858 *nitems = nvp->nvp_nitems;
1859
1860 return ((const uint64_t *)(intptr_t)nvp->nvp_data);
1861}
1862
1863const char * const *
1864nvpair_get_string_array(const nvpair_t *nvp, size_t *nitems)
1865{
1866
1867 NVPAIR_ASSERT(nvp);
1868 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
1869
1870 if (nitems != NULL)
1871 *nitems = nvp->nvp_nitems;
1872
1873 return ((const char * const *)(intptr_t)nvp->nvp_data);
1874}
1875
1876const nvlist_t * const *
1877nvpair_get_nvlist_array(const nvpair_t *nvp, size_t *nitems)
1878{
1879
1880 NVPAIR_ASSERT(nvp);
1881 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1882
1883 if (nitems != NULL)
1884 *nitems = nvp->nvp_nitems;
1885
1886 return ((const nvlist_t * const *)((intptr_t)nvp->nvp_data));
1887}
1888
1889#ifndef _KERNEL
1890const int *
1891nvpair_get_descriptor_array(const nvpair_t *nvp, size_t *nitems)
1892{
1893
1894 NVPAIR_ASSERT(nvp);
1895 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
1896
1897 if (nitems != NULL)
1898 *nitems = nvp->nvp_nitems;
1899
1900 return ((const int *)(intptr_t)nvp->nvp_data);
1901}
1902#endif
1903
1052void
1053nvpair_free(nvpair_t *nvp)
1054{
1904void
1905nvpair_free(nvpair_t *nvp)
1906{
1907 size_t i;
1055
1056 NVPAIR_ASSERT(nvp);
1057 PJDLOG_ASSERT(nvp->nvp_list == NULL);
1058
1059 nvp->nvp_magic = 0;
1060 switch (nvp->nvp_type) {
1061#ifndef _KERNEL
1062 case NV_TYPE_DESCRIPTOR:
1063 close((int)nvp->nvp_data);
1064 break;
1908
1909 NVPAIR_ASSERT(nvp);
1910 PJDLOG_ASSERT(nvp->nvp_list == NULL);
1911
1912 nvp->nvp_magic = 0;
1913 switch (nvp->nvp_type) {
1914#ifndef _KERNEL
1915 case NV_TYPE_DESCRIPTOR:
1916 close((int)nvp->nvp_data);
1917 break;
1918 case NV_TYPE_DESCRIPTOR_ARRAY:
1919 for (i = 0; i < nvp->nvp_nitems; i++)
1920 close(((int *)(intptr_t)nvp->nvp_data)[i]);
1921 break;
1065#endif
1066 case NV_TYPE_NVLIST:
1067 nvlist_destroy((nvlist_t *)(intptr_t)nvp->nvp_data);
1068 break;
1069 case NV_TYPE_STRING:
1070 nv_free((char *)(intptr_t)nvp->nvp_data);
1071 break;
1072 case NV_TYPE_BINARY:
1073 nv_free((void *)(intptr_t)nvp->nvp_data);
1074 break;
1922#endif
1923 case NV_TYPE_NVLIST:
1924 nvlist_destroy((nvlist_t *)(intptr_t)nvp->nvp_data);
1925 break;
1926 case NV_TYPE_STRING:
1927 nv_free((char *)(intptr_t)nvp->nvp_data);
1928 break;
1929 case NV_TYPE_BINARY:
1930 nv_free((void *)(intptr_t)nvp->nvp_data);
1931 break;
1932 case NV_TYPE_NVLIST_ARRAY:
1933 for (i = 0; i < nvp->nvp_nitems; i++) {
1934 nvlist_destroy(
1935 ((nvlist_t **)(intptr_t)nvp->nvp_data)[i]);
1936 }
1937 nv_free(((nvlist_t **)(intptr_t)nvp->nvp_data));
1938 break;
1939 case NV_TYPE_NUMBER_ARRAY:
1940 nv_free((uint64_t *)(intptr_t)nvp->nvp_data);
1941 break;
1942 case NV_TYPE_BOOL_ARRAY:
1943 nv_free((bool *)(intptr_t)nvp->nvp_data);
1944 break;
1945 case NV_TYPE_STRING_ARRAY:
1946 for (i = 0; i < nvp->nvp_nitems; i++)
1947 nv_free(((char **)(intptr_t)nvp->nvp_data)[i]);
1948 break;
1075 }
1076 nv_free(nvp);
1077}
1078
1079void
1080nvpair_free_structure(nvpair_t *nvp)
1081{
1082

--- 18 unchanged lines hidden (view full) ---

1101 case NV_TYPE_STRING:
1102 return ("STRING");
1103 case NV_TYPE_NVLIST:
1104 return ("NVLIST");
1105 case NV_TYPE_DESCRIPTOR:
1106 return ("DESCRIPTOR");
1107 case NV_TYPE_BINARY:
1108 return ("BINARY");
1949 }
1950 nv_free(nvp);
1951}
1952
1953void
1954nvpair_free_structure(nvpair_t *nvp)
1955{
1956

--- 18 unchanged lines hidden (view full) ---

1975 case NV_TYPE_STRING:
1976 return ("STRING");
1977 case NV_TYPE_NVLIST:
1978 return ("NVLIST");
1979 case NV_TYPE_DESCRIPTOR:
1980 return ("DESCRIPTOR");
1981 case NV_TYPE_BINARY:
1982 return ("BINARY");
1983 case NV_TYPE_BOOL_ARRAY:
1984 return ("BOOL ARRAY");
1985 case NV_TYPE_NUMBER_ARRAY:
1986 return ("NUMBER ARRAY");
1987 case NV_TYPE_STRING_ARRAY:
1988 return ("STRING ARRAY");
1989 case NV_TYPE_NVLIST_ARRAY:
1990 return ("NVLIST ARRAY");
1991 case NV_TYPE_DESCRIPTOR_ARRAY:
1992 return ("DESCRIPTOR ARRAY");
1109 default:
1110 return ("<UNKNOWN>");
1111 }
1112}
1113
1993 default:
1994 return ("<UNKNOWN>");
1995 }
1996}
1997