HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-json/sd-json.c

216,944 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: dea16611a22e2975d723e14e171d670c48aede44

Lines 4001–5000 of 6,031

                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _SD_JSON_BUILD_BASE64:
                case _SD_JSON_BUILD_BASE32HEX:
                case _SD_JSON_BUILD_HEX:
                case _SD_JSON_BUILD_OCTESCAPE: {
                        const void *p;
                        size_t n;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        p = va_arg(ap, const void *);
                        n = va_arg(ap, size_t);
 
                        if (current->n_suppress == 0) {
                                r = command == _SD_JSON_BUILD_BASE64    ? sd_json_variant_new_base64(&add, p, n) :
                                    command == _SD_JSON_BUILD_BASE32HEX ? sd_json_variant_new_base32hex(&add, p, n) :
                                    command == _SD_JSON_BUILD_HEX       ? sd_json_variant_new_hex(&add, p, n) :
                                                                          sd_json_variant_new_octescape(&add, p, n);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _JSON_BUILD_IOVEC_BASE64:
                case _JSON_BUILD_IOVEC_HEX: {
                        const struct iovec *iov;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        iov = va_arg(ap, const struct iovec*);
 
                        if (current->n_suppress == 0) {
                                if (iov)
                                        r = command == _JSON_BUILD_IOVEC_BASE64 ? sd_json_variant_new_base64(&add, iov->iov_base, iov->iov_len) :
                                                                                  sd_json_variant_new_hex(&add, iov->iov_base, iov->iov_len);
                                else
                                        r = sd_json_variant_new_string(&add, "");
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _SD_JSON_BUILD_ID128:
                case _SD_JSON_BUILD_UUID: {
                        const sd_id128_t *id;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        assert_se(id = va_arg(ap, sd_id128_t*));
 
                        if (current->n_suppress == 0) {
                                r = command == _SD_JSON_BUILD_ID128 ?
                                        sd_json_variant_new_id128(&add, *id) :
                                        sd_json_variant_new_uuid(&add, *id);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _SD_JSON_BUILD_BYTE_ARRAY: {
                        const void *array;
                        size_t n;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        array = va_arg(ap, const void*);
                        n = va_arg(ap, size_t);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_array_bytes(&add, array, n);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _JSON_BUILD_HW_ADDR: {
                        const struct hw_addr_data *hw_addr;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        assert_se(hw_addr = va_arg(ap, struct hw_addr_data*));
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_array_bytes(&add, hw_addr->bytes, hw_addr->length);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _JSON_BUILD_STRING_SET: {
                        Set *set;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        set = va_arg(ap, Set*);
 
                        if (current->n_suppress == 0) {
                                _cleanup_free_ char **sorted = NULL;
 
                                r = set_dump_sorted(set, (void ***) &sorted, NULL);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_array_strv(&add, sorted);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _JSON_BUILD_STRING_ORDERED_SET: {
                        OrderedSet *set;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        set = va_arg(ap, OrderedSet*);
 
                        if (current->n_suppress == 0) {
                                _cleanup_free_ char **sv = NULL;
 
                                sv = ordered_set_get_strv(set);
                                if (!sv) {
                                        r = -ENOMEM;
                                        goto finish;
                                }
 
                                r = sd_json_variant_new_array_strv(&add, sv);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _JSON_BUILD_DUAL_TIMESTAMP: {
                        dual_timestamp *ts;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        ts = va_arg(ap, dual_timestamp*);
 
                        if (current->n_suppress == 0) {
                                if (dual_timestamp_is_set(ts)) {
                                        r = sd_json_buildo(
                                                        &add,
                                                        SD_JSON_BUILD_PAIR_UNSIGNED("realtime", ts->realtime),
                                                        SD_JSON_BUILD_PAIR_UNSIGNED("monotonic", ts->monotonic));
                                        if (r < 0)
                                                goto finish;
                                } else
                                        add = JSON_VARIANT_MAGIC_NULL;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _JSON_BUILD_RATELIMIT: {
                        const RateLimit *rl;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        rl = va_arg(ap, const RateLimit*);
 
                        if (current->n_suppress == 0) {
                                if (ratelimit_configured(rl)) {
                                        r = sd_json_buildo(
                                                        &add,
                                                        SD_JSON_BUILD_PAIR_UNSIGNED("intervalUSec", rl->interval),
                                                        SD_JSON_BUILD_PAIR_UNSIGNED("burst", rl->burst));
                                        if (r < 0)
                                                goto finish;
                                } else
                                        add = JSON_VARIANT_MAGIC_NULL;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _JSON_BUILD_PIDREF: {
                        PidRef *pidref;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        pidref = va_arg(ap, PidRef*);
 
                        if (current->n_suppress == 0) {
                                r = json_variant_new_pidref(&add, pidref);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _JSON_BUILD_DEVNUM: {
                        dev_t devnum;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        devnum = va_arg(ap, dev_t);
 
                        if (current->n_suppress == 0) {
                                r = json_variant_new_devnum(&add, devnum);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _JSON_BUILD_TRISTATE: {
                        int tristate;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        tristate = va_arg(ap, int);
 
                        if (current->n_suppress == 0) {
                                if (tristate >= 0) {
                                        r = sd_json_variant_new_boolean(&add, tristate);
                                        if (r < 0)
                                                goto finish;
                                } else
                                        add = JSON_VARIANT_MAGIC_NULL;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _SD_JSON_BUILD_CALLBACK: {
                        sd_json_build_callback_t cb;
                        void *userdata;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        cb = va_arg(ap, sd_json_build_callback_t);
                        userdata = va_arg(ap, void *);
 
                        if (current->n_suppress == 0) {
                                if (cb) {
                                        r = cb(&add, name, userdata);
                                        if (r < 0)
                                                goto finish;
                                }
 
                                if (!add)
                                        add = JSON_VARIANT_MAGIC_NULL;
 
                                name = NULL;
                        }
 
                        n_subtract = 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        break;
                }
 
                case _SD_JSON_BUILD_OBJECT_BEGIN:
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (!GREEDY_REALLOC(stack, n_stack+1)) {
                                r = -ENOMEM;
                                goto finish;
                        }
                        current = stack + n_stack - 1;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_KEY;
                        else
                                assert(current->expect == EXPECT_ARRAY_ELEMENT);
 
                        stack[n_stack++] = (JsonStack) {
                                .expect = EXPECT_OBJECT_KEY,
                                .n_suppress = current->n_suppress != 0 ? SIZE_MAX : 0, /* If we shall suppress the
                                                                                        * new object, then we should
                                                                                        * also suppress all object
                                                                                        * members. */
                        };
 
                        break;
 
                case _SD_JSON_BUILD_OBJECT_END:
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        assert(n_stack > 1);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_object(&add, current->elements, current->n_elements);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        json_stack_release(current);
                        n_stack--, current--;
 
                        break;
 
                case _SD_JSON_BUILD_PAIR: {
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        name = va_arg(ap, const char *);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, name);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1;
 
                        current->expect = EXPECT_OBJECT_VALUE;
                        break;
                }
 
                case _SD_JSON_BUILD_PAIR_CONDITION: {
                        bool b;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        b = va_arg(ap, int);
                        name = va_arg(ap, const char *);
 
                        if (b && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, name);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 1; /* we generated one item */
 
                        if (!b && current->n_suppress != SIZE_MAX)
                                current->n_suppress += 2; /* Suppress this one and the next item */
 
                        current->expect = EXPECT_OBJECT_VALUE;
                        break;
                }
 
                case _JSON_BUILD_PAIR_INTEGER_NON_ZERO:
                case _JSON_BUILD_PAIR_INTEGER_NON_NEGATIVE: {
                        const char *n;
                        int64_t i;
                        bool include;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char*);
                        i = va_arg(ap, int64_t);
 
                        if (command == _JSON_BUILD_PAIR_INTEGER_NON_ZERO)
                                include = i != 0;
                        else if (command == _JSON_BUILD_PAIR_INTEGER_NON_NEGATIVE)
                                include = i >= 0;
                        else
                                assert_not_reached();
 
                        if (include && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_integer(&add_more, i);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_UNSIGNED_NON_ZERO:
                case _JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL: {
                        const char *n;
                        uint64_t u, eq;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        u = va_arg(ap, uint64_t);
                        eq = command == _JSON_BUILD_PAIR_UNSIGNED_NON_ZERO ? 0 : va_arg(ap, uint64_t);
 
                        if (u != eq && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_unsigned(&add_more, u);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_FINITE_USEC_NON_ZERO:
                case _JSON_BUILD_PAIR_FINITE_USEC: {
                        const char *n;
                        usec_t u;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        u = va_arg(ap, usec_t);
 
                        if (u != USEC_INFINITY &&
                            (command != _JSON_BUILD_PAIR_FINITE_USEC_NON_ZERO || u > 0) &&
                            current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_unsigned(&add_more, u);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_STRING_NON_EMPTY:
                case _JSON_BUILD_PAIR_STRING_NON_EMPTY_UNDERSCORIFY: {
                        const char *n, *s;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        s = va_arg(ap, const char *);
 
                        if (!isempty(s) && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                if (command == _JSON_BUILD_PAIR_STRING_NON_EMPTY_UNDERSCORIFY) {
                                        _cleanup_free_ char *c = strdup(s);
                                        if (!c) {
                                                r = -ENOMEM;
                                                goto finish;
                                        }
 
                                        r = sd_json_variant_new_string(&add_more, json_underscorify(c));
                                } else
                                        r = sd_json_variant_new_string(&add_more, s);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_STRV_NON_EMPTY:
                case _JSON_BUILD_PAIR_STRV_ENV_PAIR_NON_EMPTY: {
                        const char *n;
                        char **l;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        l = va_arg(ap, char **);
 
                        if (!strv_isempty(l) && current->n_suppress == 0) {
                                _cleanup_strv_free_ char **el = NULL;
 
                                if (command == _JSON_BUILD_PAIR_STRV_ENV_PAIR_NON_EMPTY) {
                                        r = strv_env_get_merged(l, &el);
                                        if (r < 0)
                                                goto finish;
                                }
 
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_array_strv(&add_more, el ?: l);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_VARIANT_NON_NULL: {
                        sd_json_variant *v;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        v = va_arg(ap, sd_json_variant *);
 
                        if (v && !sd_json_variant_is_null(v) && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                add_more = sd_json_variant_ref(v);
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_VARIANT_NON_EMPTY: {
                        sd_json_variant *v;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        v = va_arg(ap, sd_json_variant *);
 
                        if (v && !sd_json_variant_is_blank_object(v) && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                add_more = sd_json_variant_ref(v);
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_BYTE_ARRAY_NON_EMPTY: {
                        const void *array;
                        size_t sz;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        array = va_arg(ap, const void*);
                        sz = va_arg(ap, size_t);
 
                        if (sz > 0 && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_array_bytes(&add_more, array, sz);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_IN_ADDR_NON_NULL:
                case _JSON_BUILD_PAIR_IN_ADDR_WITH_STRING_NON_NULL:
                case _JSON_BUILD_PAIR_IN_ADDR_WITH_STRING: {
                        const union in_addr_union *a;
                        const char *n;
                        int f;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        f = va_arg(ap, int);
                        a = va_arg(ap, const union in_addr_union *);
 
                        if (current->n_suppress == 0 &&
                            ((a && in_addr_is_set(f, a)) ||
                             command == _JSON_BUILD_PAIR_IN_ADDR_WITH_STRING)) {
 
                                if (!a)
                                        a = &IN_ADDR_NULL;
 
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_array_bytes(&add_more, a->bytes, FAMILY_ADDRESS_SIZE_SAFE(f));
                                if (r < 0)
                                        goto finish;
 
                                if (IN_SET(command, _JSON_BUILD_PAIR_IN_ADDR_WITH_STRING, _JSON_BUILD_PAIR_IN_ADDR_WITH_STRING_NON_NULL)) {
                                        _cleanup_free_ char *string_key_name = NULL;
                                        _cleanup_(sd_json_variant_unrefp) sd_json_variant *string_key = NULL, *string_value = NULL;
 
                                        string_key_name = strjoin(n, "String");
                                        if (!string_key_name) {
                                                r = -ENOMEM;
                                                goto finish;
                                        }
 
                                        r = sd_json_variant_new_string(&string_key, string_key_name);
                                        if (r < 0)
                                                goto finish;
 
                                        r = sd_json_variant_new_string(&string_value, IN_ADDR_TO_STRING(f, a));
                                        if (r < 0)
                                                goto finish;
 
                                        if (!GREEDY_REALLOC(current->elements, current->n_elements + 2)) {
                                                r = -ENOMEM;
                                                goto finish;
                                        }
 
                                        current->elements[current->n_elements++] = TAKE_PTR(string_key);
                                        current->elements[current->n_elements++] = TAKE_PTR(string_value);
                                }
                        }
 
                        n_subtract = command == _JSON_BUILD_PAIR_IN_ADDR_NON_NULL ? 2 : 4;
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_ETHER_ADDR_NON_NULL: {
                        const struct ether_addr *a;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        a = va_arg(ap, const struct ether_addr *);
 
                        if (a && !ether_addr_is_null(a) && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_array_bytes(&add_more, a->ether_addr_octet, sizeof(struct ether_addr));
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_HW_ADDR_NON_NULL: {
                        const struct hw_addr_data *a;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char *);
                        a = va_arg(ap, const struct hw_addr_data *);
 
                        if (a && !hw_addr_is_null(a) && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_array_bytes(&add_more, a->bytes, a->length);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_DUAL_TIMESTAMP_NON_NULL: {
                        const dual_timestamp *ts;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char*);
                        ts = va_arg(ap, const dual_timestamp*);
 
                        if (ts && dual_timestamp_is_set(ts) && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_buildo(&add_more,
                                                SD_JSON_BUILD_PAIR_UNSIGNED("realtime", ts->realtime),
                                                SD_JSON_BUILD_PAIR_UNSIGNED("monotonic", ts->monotonic));
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_RATELIMIT_ENABLED: {
                        const RateLimit *rl;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char*);
                        rl = va_arg(ap, const RateLimit*);
 
                        if (rl && ratelimit_configured(rl) && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_buildo(&add_more,
                                                SD_JSON_BUILD_PAIR_UNSIGNED("intervalUSec", rl->interval),
                                                SD_JSON_BUILD_PAIR_UNSIGNED("burst", rl->burst));
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_PIDREF_NON_NULL: {
                        PidRef *p;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char*);
                        p = va_arg(ap, PidRef*);
 
                        if (pidref_is_set(p) && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = json_variant_new_pidref(&add_more, p);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_CALLBACK_NON_NULL: {
                        sd_json_build_callback_t cb;
                        void *userdata;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char*);
                        cb = va_arg(ap, sd_json_build_callback_t);