Lines Matching refs:value
171 nvpair_append(nvpair_t *nvp, const void *value, size_t valsize, size_t datasize)
184 memcpy(valp, value, valsize);
398 uint8_t value;
403 value = (uint8_t)nvp->nvp_data;
405 PJDLOG_ASSERT(*leftp >= sizeof(value));
406 memcpy(ptr, &value, sizeof(value));
407 ptr += sizeof(value);
408 *leftp -= sizeof(value);
416 uint64_t value;
421 value = (uint64_t)nvp->nvp_data;
423 PJDLOG_ASSERT(*leftp >= sizeof(value));
424 memcpy(ptr, &value, sizeof(value));
425 ptr += sizeof(value);
426 *leftp -= sizeof(value);
501 int64_t value;
506 value = (int64_t)nvp->nvp_data;
507 if (value != -1) {
515 value = *fdidxp;
519 PJDLOG_ASSERT(*leftp >= sizeof(value));
520 memcpy(ptr, &value, sizeof(value));
521 ptr += sizeof(value);
522 *leftp -= sizeof(value);
608 int64_t value;
620 PJDLOG_ASSERT(*leftp >= sizeof(value));
622 value = array[ii];
623 if (value != -1) {
631 value = *fdidxp;
634 memcpy(ptr, &value, sizeof(value));
635 ptr += sizeof(value);
636 *leftp -= sizeof(value);
742 uint8_t value;
746 if (nvp->nvp_datasize != sizeof(value)) {
750 if (*leftp < sizeof(value)) {
755 memcpy(&value, ptr, sizeof(value));
756 ptr += sizeof(value);
757 *leftp -= sizeof(value);
759 if (value != 0 && value != 1) {
764 nvp->nvp_data = (uint64_t)value;
828 nvlist_t *value;
837 value = nvlist_create(0);
838 if (value == NULL)
841 ptr = nvlist_unpack_header(value, ptr, nfds, NULL, leftp);
845 nvp->nvp_data = (uint64_t)(uintptr_t)value;
846 *child = value;
897 void *value;
906 value = nv_malloc(nvp->nvp_datasize);
907 if (value == NULL)
910 memcpy(value, ptr, nvp->nvp_datasize);
914 nvp->nvp_data = (uint64_t)(uintptr_t)value;
923 uint8_t *value;
929 size = sizeof(*value) * nvp->nvp_nitems;
936 value = nv_malloc(size);
937 if (value == NULL)
941 value[i] = *(const uint8_t *)ptr;
943 ptr += sizeof(*value);
944 *leftp -= sizeof(*value);
947 nvp->nvp_data = (uint64_t)(uintptr_t)value;
956 uint64_t *value;
962 size = sizeof(*value) * nvp->nvp_nitems;
969 value = nv_malloc(size);
970 if (value == NULL)
975 value[i] = be64dec(ptr);
977 value[i] = le64dec(ptr);
979 ptr += sizeof(*value);
980 *leftp -= sizeof(*value);
983 nvp->nvp_data = (uint64_t)(uintptr_t)value;
995 char **value;
1026 value = nv_calloc(nvp->nvp_nitems, sizeof(*value));
1027 if (value == NULL)
1031 value[ii] = nv_strdup((const char *)ptr);
1032 if (value[ii] == NULL)
1034 len = strlen(value[ii]) + 1;
1038 nvp->nvp_data = (uint64_t)(uintptr_t)value;
1043 nv_free(value[j]);
1044 nv_free(value);
1105 nvlist_t **value;
1119 value = nv_calloc(nvp->nvp_nitems, sizeof(*value));
1120 if (value == NULL)
1124 value[ii] = nvlist_create(0);
1125 if (value[ii] == NULL)
1129 (uint64_t)(uintptr_t)value[ii], 0, 0);
1132 nvlist_set_array_next(value[ii - 1], tmpnvp);
1135 nvlist_set_flags(value[nvp->nvp_nitems - 1], NV_FLAG_IN_ARRAY);
1137 nvp->nvp_data = (uint64_t)(uintptr_t)value;
1138 *firstel = value[0];
1144 nvlist_destroy(value[j]);
1145 nv_free(value);
1237 nvpair_create_bool(const char *name, bool value)
1240 return (nvpair_allocv(name, NV_TYPE_BOOL, value ? 1 : 0,
1245 nvpair_create_number(const char *name, uint64_t value)
1248 return (nvpair_allocv(name, NV_TYPE_NUMBER, value, sizeof(value), 0));
1252 nvpair_create_string(const char *name, const char *value)
1258 if (value == NULL) {
1263 data = nv_strdup(value);
1266 size = strlen(value) + 1;
1277 nvpair_create_nvlist(const char *name, const nvlist_t *value)
1282 if (value == NULL) {
1287 nvl = nvlist_clone(value);
1303 nvpair_create_descriptor(const char *name, int value)
1307 if (value < 0 || !fd_is_valid(value)) {
1312 value = fcntl(value, F_DUPFD_CLOEXEC, 0);
1313 if (value < 0)
1316 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1320 close(value);
1329 nvpair_create_binary(const char *name, const void *value, size_t size)
1334 if (value == NULL || size == 0) {
1342 memcpy(data, value, size);
1353 nvpair_create_bool_array(const char *name, const bool *value, size_t nitems)
1359 if (value == NULL || nitems == 0) {
1364 data = nv_calloc(nitems, sizeof(value[0]));
1367 size = sizeof(value[0]) * nitems;
1369 memcpy(data, value, size);
1382 nvpair_create_number_array(const char *name, const uint64_t *value,
1389 if (value == NULL || nitems == 0) {
1394 data = nv_calloc(nitems, sizeof(value[0]));
1397 size = sizeof(value[0]) * nitems;
1399 memcpy(data, value, size);
1412 nvpair_create_string_array(const char *name, const char * const *value,
1420 if (value == NULL || nitems == 0) {
1427 data = nv_calloc(nitems, sizeof(value[0]));
1432 if (value[ii] == NULL) {
1437 size = strlen(value[ii]) + 1;
1439 data[ii] = nv_strdup(value[ii]);
1459 nvpair_create_nvlist_array(const char *name, const nvlist_t * const *value,
1469 if (value == NULL || nitems == 0) {
1474 nvls = nv_calloc(nitems, sizeof(value[0]));
1479 if (value[ii] == NULL) {
1484 nvls[ii] = nvlist_clone(value[ii]);
1527 nvpair_create_descriptor_array(const char *name, const int *value,
1534 if (value == NULL) {
1541 fds = nv_calloc(nitems, sizeof(value[0]));
1545 if (value[ii] == -1) {
1548 if (!fd_is_valid(value[ii])) {
1553 fds[ii] = fcntl(value[ii], F_DUPFD_CLOEXEC, 0);
1578 nvpair_move_string(const char *name, char *value)
1582 if (value == NULL) {
1587 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
1588 strlen(value) + 1, 0);
1591 nv_free(value);
1599 nvpair_move_nvlist(const char *name, nvlist_t *value)
1603 if (value == NULL || nvlist_get_nvpair_parent(value) != NULL) {
1608 if (nvlist_error(value) != 0) {
1609 ERRNO_SET(nvlist_error(value));
1610 nvlist_destroy(value);
1614 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value,
1617 nvlist_destroy(value);
1619 nvlist_set_parent(value, nvp);
1626 nvpair_move_descriptor(const char *name, int value)
1630 if (value < 0 || !fd_is_valid(value)) {
1635 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1639 close(value);
1648 nvpair_move_binary(const char *name, void *value, size_t size)
1652 if (value == NULL || size == 0) {
1657 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)value,
1661 nv_free(value);
1669 nvpair_move_bool_array(const char *name, bool *value, size_t nitems)
1673 if (value == NULL || nitems == 0) {
1679 (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
1682 nv_free(value);
1690 nvpair_move_string_array(const char *name, char **value, size_t nitems)
1695 if (value == NULL || nitems == 0) {
1702 if (value[i] == NULL) {
1707 size += strlen(value[i]) + 1;
1711 (uint64_t)(uintptr_t)value, size, nitems);
1715 nv_free(value[i]);
1716 nv_free(value);
1724 nvpair_move_number_array(const char *name, uint64_t *value, size_t nitems)
1728 if (value == NULL || nitems == 0) {
1734 (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
1737 nv_free(value);
1745 nvpair_move_nvlist_array(const char *name, nvlist_t **value, size_t nitems)
1751 if (value == NULL || nitems == 0) {
1757 if (value == NULL || nvlist_error(value[ii]) != 0 ||
1758 nvlist_get_pararr(value[ii], NULL) != NULL) {
1766 (uint64_t)(uintptr_t)value[ii], 0, 0);
1769 nvlist_set_array_next(value[ii - 1], nvp);
1772 flags = nvlist_flags(value[nitems - 1]) | NV_FLAG_IN_ARRAY;
1773 nvlist_set_flags(value[nitems - 1], flags);
1776 (uint64_t)(uintptr_t)value, 0, nitems);
1781 nvlist_set_parent(value[ii], parent);
1787 if (value[ii] != NULL &&
1788 nvlist_get_pararr(value[ii], NULL) != NULL) {
1789 nvlist_destroy(value[ii]);
1792 nv_free(value);
1800 nvpair_move_descriptor_array(const char *name, int *value, size_t nitems)
1805 if (value == NULL || nitems == 0) {
1811 if (value[i] != -1 && !fd_is_valid(value[i])) {
1818 (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
1826 if (fd_is_valid(value[i]))
1827 close(value[i]);
1829 nv_free(value);
1967 nvpair_append_bool_array(nvpair_t *nvp, const bool value)
1972 return (nvpair_append(nvp, &value, sizeof(value), sizeof(value)));
1976 nvpair_append_number_array(nvpair_t *nvp, const uint64_t value)
1981 return (nvpair_append(nvp, &value, sizeof(value), sizeof(value)));
1985 nvpair_append_string_array(nvpair_t *nvp, const char *value)
1991 if (value == NULL) {
1995 str = nv_strdup(value);
2007 nvpair_append_nvlist_array(nvpair_t *nvp, const nvlist_t *value)
2015 if (value == NULL || nvlist_error(value) != 0 ||
2016 nvlist_get_pararr(value, NULL) != NULL) {
2020 nvl = nvlist_clone(value);
2060 nvpair_append_descriptor_array(nvpair_t *nvp, const int value)
2066 if (value < 0 || !fd_is_valid(value)) {
2070 fd = fcntl(value, F_DUPFD_CLOEXEC, 0);