HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-json/sd-json.c
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;