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 3001–4000 of 6,031

        EXPECT_END,
        EXPECT_OBJECT_FIRST_KEY,
        EXPECT_OBJECT_NEXT_KEY,
        EXPECT_OBJECT_COLON,
        EXPECT_OBJECT_VALUE,
        EXPECT_OBJECT_COMMA,
        EXPECT_ARRAY_FIRST_ELEMENT,
        EXPECT_ARRAY_NEXT_ELEMENT,
        EXPECT_ARRAY_COMMA,
 
        /* And these are used by sd_json_build() */
        EXPECT_ARRAY_ELEMENT,
        EXPECT_OBJECT_KEY,
} JsonExpect;
 
typedef struct JsonStack {
        JsonExpect expect;
        sd_json_variant **elements;
        size_t n_elements;
        unsigned line_before;
        unsigned column_before;
        size_t n_suppress; /* When building: if > 0, suppress this many subsequent elements. If == SIZE_MAX, suppress all subsequent elements */
} JsonStack;
 
static void json_stack_release(JsonStack *s) {
        assert(s);
 
        CLEANUP_ARRAY(s->elements, s->n_elements, sd_json_variant_unref_many);
}
 
static int json_parse_internal(
                const char **input,
                JsonSource *source,
                sd_json_parse_flags_t flags,
                sd_json_variant **ret,
                unsigned *line,
                unsigned *column,
                bool continue_end) {
 
        size_t n_stack = 1;
        unsigned line_buffer = 0, column_buffer = 0;
        void *tokenizer_state = NULL;
        JsonStack *stack = NULL;
        const char *p;
        int r;
 
        assert_return(input, -EINVAL);
 
        p = *input;
 
        if (!GREEDY_REALLOC(stack, n_stack))
                return -ENOMEM;
 
        stack[0] = (JsonStack) {
                .expect = EXPECT_TOPLEVEL,
        };
 
        if (!line)
                line = &line_buffer;
        if (!column)
                column = &column_buffer;
 
        for (;;) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *add = NULL;
                _cleanup_free_ char *string = NULL;
                unsigned line_token, column_token;
                JsonStack *current;
                JsonValue value;
                int token;
 
                assert(n_stack > 0);
                current = stack + n_stack - 1;
 
                if (continue_end && current->expect == EXPECT_END)
                        goto done;
 
                token = json_tokenize(&p, &string, &value, &line_token, &column_token, &tokenizer_state, line, column);
                if (token < 0) {
                        r = token;
                        goto finish;
                }
 
                switch (token) {
 
                case JSON_TOKEN_END:
                        if (current->expect != EXPECT_END) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        assert(current->n_elements == 1);
                        assert(n_stack == 1);
                        goto done;
 
                case JSON_TOKEN_COLON:
 
                        if (current->expect != EXPECT_OBJECT_COLON) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        current->expect = EXPECT_OBJECT_VALUE;
                        break;
 
                case JSON_TOKEN_COMMA:
 
                        if (current->expect == EXPECT_OBJECT_COMMA)
                                current->expect = EXPECT_OBJECT_NEXT_KEY;
                        else if (current->expect == EXPECT_ARRAY_COMMA)
                                current->expect = EXPECT_ARRAY_NEXT_ELEMENT;
                        else {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        break;
 
                case JSON_TOKEN_OBJECT_OPEN:
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (n_stack == 1 && FLAGS_SET(flags, SD_JSON_PARSE_MUST_BE_ARRAY) && !FLAGS_SET(flags, SD_JSON_PARSE_MUST_BE_OBJECT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        /* n_stack includes the top level entry, hence > instead of >= */
                        if (n_stack > DEPTH_MAX) {
                                r = -ELNRNG;
                                goto finish;
                        }
 
                        if (!GREEDY_REALLOC(stack, n_stack+1)) {
                                r = -ENOMEM;
                                goto finish;
                        }
                        current = stack + n_stack - 1;
 
                        /* Prepare the expect for when we return from the child */
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_COMMA;
                        else {
                                assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
                                current->expect = EXPECT_ARRAY_COMMA;
                        }
 
                        stack[n_stack++] = (JsonStack) {
                                .expect = EXPECT_OBJECT_FIRST_KEY,
                                .line_before = line_token,
                                .column_before = column_token,
                        };
 
                        current = stack + n_stack - 1;
                        break;
 
                case JSON_TOKEN_OBJECT_CLOSE:
                        if (!IN_SET(current->expect, EXPECT_OBJECT_FIRST_KEY, EXPECT_OBJECT_COMMA)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        assert(n_stack > 1);
 
                        r = sd_json_variant_new_object(&add, current->elements, current->n_elements);
                        if (r < 0)
                                goto finish;
 
                        line_token = current->line_before;
                        column_token = current->column_before;
 
                        json_stack_release(current);
                        n_stack--, current--;
 
                        break;
 
                case JSON_TOKEN_ARRAY_OPEN:
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (n_stack == 1 && !FLAGS_SET(flags, SD_JSON_PARSE_MUST_BE_ARRAY) && FLAGS_SET(flags, SD_JSON_PARSE_MUST_BE_OBJECT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        /* n_stack includes the top level entry, hence > instead of >= */
                        if (n_stack > DEPTH_MAX) {
                                r = -ELNRNG;
                                goto finish;
                        }
 
                        if (!GREEDY_REALLOC(stack, n_stack+1)) {
                                r = -ENOMEM;
                                goto finish;
                        }
                        current = stack + n_stack - 1;
 
                        /* Prepare the expect for when we return from the child */
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_COMMA;
                        else {
                                assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
                                current->expect = EXPECT_ARRAY_COMMA;
                        }
 
                        stack[n_stack++] = (JsonStack) {
                                .expect = EXPECT_ARRAY_FIRST_ELEMENT,
                                .line_before = line_token,
                                .column_before = column_token,
                        };
 
                        break;
 
                case JSON_TOKEN_ARRAY_CLOSE:
                        if (!IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_COMMA)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        assert(n_stack > 1);
 
                        r = sd_json_variant_new_array(&add, current->elements, current->n_elements);
                        if (r < 0)
                                goto finish;
 
                        line_token = current->line_before;
                        column_token = current->column_before;
 
                        json_stack_release(current);
                        n_stack--, current--;
                        break;
 
                case JSON_TOKEN_STRING:
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_FIRST_KEY, EXPECT_OBJECT_NEXT_KEY, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (n_stack == 1 && (flags & (SD_JSON_PARSE_MUST_BE_ARRAY|SD_JSON_PARSE_MUST_BE_OBJECT)) != 0) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        r = sd_json_variant_new_string(&add, string);
                        if (r < 0)
                                goto finish;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (IN_SET(current->expect, EXPECT_OBJECT_FIRST_KEY, EXPECT_OBJECT_NEXT_KEY))
                                current->expect = EXPECT_OBJECT_COLON;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_COMMA;
                        else {
                                assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
                                current->expect = EXPECT_ARRAY_COMMA;
                        }
 
                        break;
 
                case JSON_TOKEN_REAL:
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (n_stack == 1 && (flags & (SD_JSON_PARSE_MUST_BE_ARRAY|SD_JSON_PARSE_MUST_BE_OBJECT)) != 0) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        r = sd_json_variant_new_real(&add, value.real);
                        if (r < 0)
                                goto finish;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_COMMA;
                        else {
                                assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
                                current->expect = EXPECT_ARRAY_COMMA;
                        }
 
                        break;
 
                case JSON_TOKEN_INTEGER:
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (n_stack == 1 && (flags & (SD_JSON_PARSE_MUST_BE_ARRAY|SD_JSON_PARSE_MUST_BE_OBJECT)) != 0) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        r = sd_json_variant_new_integer(&add, value.integer);
                        if (r < 0)
                                goto finish;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_COMMA;
                        else {
                                assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
                                current->expect = EXPECT_ARRAY_COMMA;
                        }
 
                        break;
 
                case JSON_TOKEN_UNSIGNED:
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (n_stack == 1 && (flags & (SD_JSON_PARSE_MUST_BE_ARRAY|SD_JSON_PARSE_MUST_BE_OBJECT)) != 0) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        r = sd_json_variant_new_unsigned(&add, value.unsig);
                        if (r < 0)
                                goto finish;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_COMMA;
                        else {
                                assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
                                current->expect = EXPECT_ARRAY_COMMA;
                        }
 
                        break;
 
                case JSON_TOKEN_BOOLEAN:
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (n_stack == 1 && (flags & (SD_JSON_PARSE_MUST_BE_ARRAY|SD_JSON_PARSE_MUST_BE_OBJECT)) != 0) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        r = sd_json_variant_new_boolean(&add, value.boolean);
                        if (r < 0)
                                goto finish;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_COMMA;
                        else {
                                assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
                                current->expect = EXPECT_ARRAY_COMMA;
                        }
 
                        break;
 
                case JSON_TOKEN_NULL:
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (n_stack == 1 && (flags & (SD_JSON_PARSE_MUST_BE_ARRAY|SD_JSON_PARSE_MUST_BE_OBJECT)) != 0) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        r = sd_json_variant_new_null(&add);
                        if (r < 0)
                                goto finish;
 
                        if (current->expect == EXPECT_TOPLEVEL)
                                current->expect = EXPECT_END;
                        else if (current->expect == EXPECT_OBJECT_VALUE)
                                current->expect = EXPECT_OBJECT_COMMA;
                        else {
                                assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
                                current->expect = EXPECT_ARRAY_COMMA;
                        }
 
                        break;
 
                default:
                        assert_not_reached();
                }
 
                if (add) {
                        /* If we are asked to make this parsed object sensitive, then let's apply this
                         * immediately after allocating each variant, so that when we abort half-way
                         * everything we already allocated that is then freed is correctly marked. */
                        if (FLAGS_SET(flags, SD_JSON_PARSE_SENSITIVE))
                                sd_json_variant_sensitive(add);
 
                        (void) json_variant_set_source(&add, source, line_token, column_token);
 
                        if (!GREEDY_REALLOC(current->elements, current->n_elements + 1)) {
                                r = -ENOMEM;
                                goto finish;
                        }
 
                        current->elements[current->n_elements++] = TAKE_PTR(add);
                }
        }
 
done:
        assert(n_stack == 1);
        assert(stack[0].n_elements == 1);
 
        if (ret)
                *ret = sd_json_variant_ref(stack[0].elements[0]);
        *input = p;
        r = 0;
 
finish:
        FOREACH_ARRAY(i, stack, n_stack)
                json_stack_release(i);
 
        free(stack);
 
        return r;
}
 
_public_ int sd_json_parse_with_source(
                const char *string,
                const char *source,
                sd_json_parse_flags_t flags,
                sd_json_variant **ret,
                unsigned *reterr_line,
                unsigned *reterr_column) {
 
        _cleanup_(json_source_unrefp) JsonSource *s = NULL;
 
        if (isempty(string))
                return -ENODATA;
 
        if (source) {
                s = json_source_new(source);
                if (!s)
                        return -ENOMEM;
        }
 
        return json_parse_internal(&string, s, flags, ret, reterr_line, reterr_column, false);
}
 
_public_ int sd_json_parse_with_source_continue(
                const char **p,
                const char *source,
                sd_json_parse_flags_t flags,
                sd_json_variant **ret,
                unsigned *reterr_line,
                unsigned *reterr_column) {
 
        _cleanup_(json_source_unrefp) JsonSource *s = NULL;
 
        if (source) {
                s = json_source_new(source);
                if (!s)
                        return -ENOMEM;
        }
 
        return json_parse_internal(p, s, flags, ret, reterr_line, reterr_column, true);
}
 
_public_ int sd_json_parse(
                const char *string,
                sd_json_parse_flags_t flags,
                sd_json_variant **ret,
                unsigned *reterr_line,
                unsigned *reterr_column) {
 
        return sd_json_parse_with_source(string, NULL, flags, ret, reterr_line, reterr_column);
}
 
_public_ int sd_json_parse_continue(
                const char **p,
                sd_json_parse_flags_t flags,
                sd_json_variant **ret,
                unsigned *reterr_line,
                unsigned *reterr_column) {
 
        return sd_json_parse_with_source_continue(p, NULL, flags, ret, reterr_line, reterr_column);
}
 
_public_ int sd_json_parse_file_at(
                FILE *f,
                int dir_fd,
                const char *path,
                sd_json_parse_flags_t flags,
                sd_json_variant **ret,
                unsigned *reterr_line,
                unsigned *reterr_column) {
 
        _cleanup_free_ char *text = NULL;
        int r;
 
        if (f) {
                if (FLAGS_SET(flags, SD_JSON_PARSE_SEEK0) && fseek(f, /* offset= */ 0, SEEK_SET) < 0)
                        return -errno;
 
                r = read_full_stream(f, &text, NULL);
        } else
                r = read_full_file_full(dir_fd, path, UINT64_MAX, SIZE_MAX, 0, NULL, &text, NULL);
        if (r < 0)
                return r;
 
        return sd_json_parse_with_source(text, path, flags, ret, reterr_line, reterr_column);
}
 
_public_ int sd_json_parse_file(
                FILE *f,
                const char *path,
                sd_json_parse_flags_t flags,
                sd_json_variant **ret,
                unsigned *reterr_line,
                unsigned *reterr_column) {
 
        return sd_json_parse_file_at(f, AT_FDCWD, path, flags, ret, reterr_line, reterr_column);
}
 
_public_ int sd_json_parse_fd(
                const char *path,
                int fd,
                sd_json_parse_flags_t flags,
                sd_json_variant **ret,
                unsigned *reterr_line,
                unsigned *reterr_column) {
 
        int r;
 
        assert_return(fd >= 0, -EBADF);
 
        _cleanup_close_ int our_fd = -EBADF;
        if (FLAGS_SET(flags, SD_JSON_PARSE_REOPEN_FD)) {
                assert_return(!FLAGS_SET(flags, SD_JSON_PARSE_DONATE_FD), -EINVAL);
 
                our_fd = fd_reopen(fd, O_RDONLY|O_CLOEXEC);
                if (our_fd < 0)
                        return our_fd;
 
                /* If we reopened the thing the file offset will be at the beginning anyway */
                flags &= ~SD_JSON_PARSE_SEEK0;
        } else if (FLAGS_SET(flags, SD_JSON_PARSE_DONATE_FD))
                our_fd = fd;
        else {
                our_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
                if (our_fd < 0)
                        return -errno;
        }
 
        _cleanup_fclose_ FILE *f = NULL;
        r = take_fdopen_unlocked(&our_fd, "r", &f);
        if (r < 0)
                return r;
 
        return sd_json_parse_file(f, path, flags, ret, reterr_line, reterr_column);
}
 
char *json_underscorify(char *p) {
        if (!p)
                return NULL;
 
        /* Replaces "-", "+" by "_", to deal with the usual enum naming rules we have. */
 
        for (char *q = p; *q; q++)
                *q = IN_SET(*q, '_', '-', '+') ? '_' : *q;
 
        return p;
}
 
char *json_dashify(char *p) {
        if (!p)
                return NULL;
 
        /* Replaces "-", "+" by "-", to (somewhat) undo what json_underscorify() does */
 
        for (char *q = p; *q; q++)
                *q = IN_SET(*q, '_', '-', '+') ? '-' : *q;
 
        return p;
}
 
_public_ int sd_json_buildv(sd_json_variant **ret, va_list ap) {
        JsonStack *stack = NULL;
        size_t n_stack = 1;
        const char *name = NULL;
        int r;
 
        assert_return(ret, -EINVAL);
 
        if (!GREEDY_REALLOC(stack, n_stack))
                return -ENOMEM;
 
        stack[0] = (JsonStack) {
                .expect = EXPECT_TOPLEVEL,
        };
 
        for (;;) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *add = NULL, *add_more = NULL;
                size_t n_subtract = 0; /* how much to subtract from current->n_suppress, i.e. how many elements would
                                        * have been added to the current variant */
                JsonStack *current;
                int command;
 
                assert(n_stack > 0);
                current = stack + n_stack - 1;
 
                if (current->expect == EXPECT_END)
                        goto done;
 
                command = va_arg(ap, int);
 
                switch (command) {
 
                case _SD_JSON_BUILD_STRING:
                case _JSON_BUILD_STRING_UNDERSCORIFY: {
                        const char *p;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        p = va_arg(ap, const char *);
 
                        if (current->n_suppress == 0) {
                                _cleanup_free_ char *c = NULL;
 
                                if (command == _JSON_BUILD_STRING_UNDERSCORIFY && p) {
                                        c = strdup(p);
                                        if (!c) {
                                                r = -ENOMEM;
                                                goto finish;
                                        }
 
                                        p = json_underscorify(c);
                                }
 
                                r = sd_json_variant_new_string(&add, p);
                                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_INTEGER: {
                        int64_t j;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        j = va_arg(ap, int64_t);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_integer(&add, j);
                                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_UNSIGNED: {
                        uint64_t j;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        j = va_arg(ap, uint64_t);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_unsigned(&add, j);
                                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_REAL: {
                        double d;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        d = va_arg(ap, double);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_real(&add, d);
                                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_BOOLEAN: {
                        bool b;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        b = va_arg(ap, int);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_boolean(&add, b);
                                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_NULL:
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_null(&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_VARIANT:
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        /* Note that we don't care for current->n_suppress here, after all the variant is already
                         * allocated anyway... */
                        add = va_arg(ap, sd_json_variant*);
                        if (!add)
                                add = JSON_VARIANT_MAGIC_NULL;
                        else
                                sd_json_variant_ref(add);
 
                        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_VARIANT_ARRAY: {
                        sd_json_variant **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, sd_json_variant**);
                        n = va_arg(ap, size_t);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_array(&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 _SD_JSON_BUILD_LITERAL: {
                        const char *l;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        l = va_arg(ap, const char *);
 
                        if (l) {
                                /* Note that we don't care for current->n_suppress here, we should generate parsing
                                 * errors even in suppressed object properties */
 
                                r = sd_json_parse(l, 0, &add, NULL, NULL);
                                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_ARRAY_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_ARRAY_ELEMENT,
                                .n_suppress = current->n_suppress != 0 ? SIZE_MAX : 0, /* if we shall suppress the
                                                                                           * new array, then we should
                                                                                           * also suppress all array
                                                                                           * members */
                        };
 
                        break;
 
                case _SD_JSON_BUILD_ARRAY_END:
                        if (current->expect != EXPECT_ARRAY_ELEMENT) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        assert(n_stack > 1);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_array(&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_STRV: {
                        char **l;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        l = va_arg(ap, char **);
 
                        if (current->n_suppress == 0) {
                                r = sd_json_variant_new_array_strv(&add, l);
                                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_STRV_ENV_PAIR: {
                        char **l;
 
                        if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        l = va_arg(ap, char **);
 
                        if (current->n_suppress == 0) {
                                _cleanup_strv_free_ char **el = NULL;
 
                                r = strv_env_get_merged(l, &el);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_array_strv(&add, el);
                                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;