HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-json/sd-json.c
Git blob: dea16611a22e2975d723e14e171d670c48aede44
Lines 1001–2000 of 6,031
v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED ||
v == JSON_VARIANT_MAGIC_ZERO_REAL)
return 0;
if (!json_variant_is_regular(v))
goto mismatch;
if (v->is_reference)
return sd_json_variant_unsigned(v->reference);
switch (v->type) {
case SD_JSON_VARIANT_INTEGER:
if (v->value.integer >= 0)
return (uint64_t) v->value.integer;
log_debug("Signed integer %" PRIi64 " requested as unsigned integer and out of range, returning 0.", v->value.integer);
return 0;
case SD_JSON_VARIANT_UNSIGNED:
return v->value.unsig;
case SD_JSON_VARIANT_REAL: {
uint64_t converted;
converted = (uint64_t) v->value.real;
if (fp_equal((double) converted, v->value.real))
return converted;
log_debug("Real %g requested as unsigned integer, and cannot be converted losslessly, returning 0.", v->value.real);
return 0;
}
default:
;
}
mismatch:
log_debug("Non-integer JSON variant requested as unsigned, returning 0.");
return 0;
}
_public_ double sd_json_variant_real(sd_json_variant *v) {
if (!v)
return 0.0;
if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED ||
v == JSON_VARIANT_MAGIC_ZERO_REAL)
return 0.0;
if (!json_variant_is_regular(v))
goto mismatch;
if (v->is_reference)
return sd_json_variant_real(v->reference);
switch (v->type) {
case SD_JSON_VARIANT_REAL:
return v->value.real;
case SD_JSON_VARIANT_INTEGER: {
double converted = (double) v->value.integer;
if ((int64_t) converted == v->value.integer)
return converted;
log_debug("Signed integer %" PRIi64 " requested as real, and cannot be converted losslessly, returning 0.", v->value.integer);
return 0.0;
}
case SD_JSON_VARIANT_UNSIGNED: {
double converted = (double) v->value.unsig;
if ((uint64_t) converted == v->value.unsig)
return converted;
log_debug("Unsigned integer %" PRIu64 " requested as real, and cannot be converted losslessly, returning 0.", v->value.unsig);
return 0.0;
}
default:
;
}
mismatch:
log_debug("Non-integer JSON variant requested as integer, returning 0.");
return 0.0;
}
_public_ int sd_json_variant_is_negative(sd_json_variant *v) {
if (!v)
goto mismatch;
if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED ||
v == JSON_VARIANT_MAGIC_ZERO_REAL)
return false;
if (!json_variant_is_regular(v))
goto mismatch;
if (v->is_reference)
return sd_json_variant_is_negative(v->reference);
/* This function is useful as checking whether numbers are negative is pretty complex since we have three types
* of numbers. And some JSON code (OCI for example) uses negative numbers to mark "not defined" numeric
* values. */
switch (v->type) {
case SD_JSON_VARIANT_REAL:
return v->value.real < 0;
case SD_JSON_VARIANT_INTEGER:
return v->value.integer < 0;
case SD_JSON_VARIANT_UNSIGNED:
return false;
default:
;
}
mismatch:
log_debug("Non-integer JSON variant tested for negativity, returning false.");
return false;
}
_public_ int sd_json_variant_is_blank_object(sd_json_variant *v) {
/* Returns true if the specified object is null or empty */
return !v ||
sd_json_variant_is_null(v) ||
(sd_json_variant_is_object(v) && sd_json_variant_elements(v) == 0);
}
_public_ int sd_json_variant_is_blank_array(sd_json_variant *v) {
return !v ||
sd_json_variant_is_null(v) ||
(sd_json_variant_is_array(v) && sd_json_variant_elements(v) == 0);
}
_public_ sd_json_variant_type_t sd_json_variant_type(sd_json_variant *v) {
if (!v)
return _SD_JSON_VARIANT_TYPE_INVALID;
if (json_variant_is_const_string(v))
return SD_JSON_VARIANT_STRING;
if (v == JSON_VARIANT_MAGIC_TRUE || v == JSON_VARIANT_MAGIC_FALSE)
return SD_JSON_VARIANT_BOOLEAN;
if (v == JSON_VARIANT_MAGIC_NULL)
return SD_JSON_VARIANT_NULL;
if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER)
return SD_JSON_VARIANT_INTEGER;
if (v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED)
return SD_JSON_VARIANT_UNSIGNED;
if (v == JSON_VARIANT_MAGIC_ZERO_REAL)
return SD_JSON_VARIANT_REAL;
if (v == JSON_VARIANT_MAGIC_EMPTY_STRING)
return SD_JSON_VARIANT_STRING;
if (v == JSON_VARIANT_MAGIC_EMPTY_ARRAY)
return SD_JSON_VARIANT_ARRAY;
if (v == JSON_VARIANT_MAGIC_EMPTY_OBJECT)
return SD_JSON_VARIANT_OBJECT;
return v->type;
}
_function_no_sanitize_float_cast_overflow_
_public_ int sd_json_variant_has_type(sd_json_variant *v, sd_json_variant_type_t type) {
sd_json_variant_type_t rt;
/* Note: we turn off ubsan float cast overflow detection for this function, since it would complain
* about our float casts but we do them explicitly to detect conversion errors. */
v = json_variant_dereference(v);
if (!v)
return false;
rt = sd_json_variant_type(v);
if (rt == type)
return true;
/* If it's a const string, then it only can be a string, and if it is not, it's not */
if (json_variant_is_const_string(v))
return false;
/* All three magic zeroes qualify as integer, unsigned and as real */
if ((v == JSON_VARIANT_MAGIC_ZERO_INTEGER || v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED || v == JSON_VARIANT_MAGIC_ZERO_REAL) &&
IN_SET(type, SD_JSON_VARIANT_INTEGER, SD_JSON_VARIANT_UNSIGNED, SD_JSON_VARIANT_REAL, SD_JSON_VARIANT_NUMBER))
return true;
/* All other magic variant types are only equal to themselves */
if (json_variant_is_magic(v))
return false;
/* Handle the "number" pseudo type */
if (type == SD_JSON_VARIANT_NUMBER)
return IN_SET(rt, SD_JSON_VARIANT_INTEGER, SD_JSON_VARIANT_UNSIGNED, SD_JSON_VARIANT_REAL);
/* Integer conversions are OK in many cases */
if (rt == SD_JSON_VARIANT_INTEGER && type == SD_JSON_VARIANT_UNSIGNED)
return v->value.integer >= 0;
if (rt == SD_JSON_VARIANT_UNSIGNED && type == SD_JSON_VARIANT_INTEGER)
return v->value.unsig <= INT64_MAX;
/* Any integer that can be converted lossley to a real and back may also be considered a real */
if (rt == SD_JSON_VARIANT_INTEGER && type == SD_JSON_VARIANT_REAL)
return (int64_t) (double) v->value.integer == v->value.integer;
if (rt == SD_JSON_VARIANT_UNSIGNED && type == SD_JSON_VARIANT_REAL)
return (uint64_t) (double) v->value.unsig == v->value.unsig;
/* Any real that can be converted losslessly to an integer and back may also be considered an integer */
if (rt == SD_JSON_VARIANT_REAL && type == SD_JSON_VARIANT_INTEGER)
return fp_equal((double) (int64_t) v->value.real, v->value.real);
if (rt == SD_JSON_VARIANT_REAL && type == SD_JSON_VARIANT_UNSIGNED)
return fp_equal((double) (uint64_t) v->value.real, v->value.real);
return false;
}
_public_ int sd_json_variant_is_string(sd_json_variant *v) {
return sd_json_variant_has_type(v, SD_JSON_VARIANT_STRING);
}
_public_ int sd_json_variant_is_integer(sd_json_variant *v) {
return sd_json_variant_has_type(v, SD_JSON_VARIANT_INTEGER);
}
_public_ int sd_json_variant_is_unsigned(sd_json_variant *v) {
return sd_json_variant_has_type(v, SD_JSON_VARIANT_UNSIGNED);
}
_public_ int sd_json_variant_is_real(sd_json_variant *v) {
return sd_json_variant_has_type(v, SD_JSON_VARIANT_REAL);
}
_public_ int sd_json_variant_is_number(sd_json_variant *v) {
return sd_json_variant_has_type(v, SD_JSON_VARIANT_NUMBER);
}
_public_ int sd_json_variant_is_boolean(sd_json_variant *v) {
return sd_json_variant_has_type(v, SD_JSON_VARIANT_BOOLEAN);
}
_public_ int sd_json_variant_is_array(sd_json_variant *v) {
return sd_json_variant_has_type(v, SD_JSON_VARIANT_ARRAY);
}
_public_ int sd_json_variant_is_object(sd_json_variant *v) {
return sd_json_variant_has_type(v, SD_JSON_VARIANT_OBJECT);
}
_public_ int sd_json_variant_is_null(sd_json_variant *v) {
return sd_json_variant_has_type(v, SD_JSON_VARIANT_NULL);
}
_public_ size_t sd_json_variant_elements(sd_json_variant *v) {
if (!v)
return 0;
if (v == JSON_VARIANT_MAGIC_EMPTY_ARRAY ||
v == JSON_VARIANT_MAGIC_EMPTY_OBJECT)
return 0;
if (!json_variant_is_regular(v))
goto mismatch;
if (!IN_SET(v->type, SD_JSON_VARIANT_ARRAY, SD_JSON_VARIANT_OBJECT))
goto mismatch;
if (v->is_reference)
return sd_json_variant_elements(v->reference);
return v->n_elements;
mismatch:
log_debug("Number of elements in non-array/non-object JSON variant requested, returning 0.");
return 0;
}
_public_ sd_json_variant *sd_json_variant_by_index(sd_json_variant *v, size_t index) {
if (!v)
return NULL;
if (v == JSON_VARIANT_MAGIC_EMPTY_ARRAY ||
v == JSON_VARIANT_MAGIC_EMPTY_OBJECT)
return NULL;
if (!json_variant_is_regular(v))
goto mismatch;
if (!IN_SET(v->type, SD_JSON_VARIANT_ARRAY, SD_JSON_VARIANT_OBJECT))
goto mismatch;
if (v->is_reference)
return sd_json_variant_by_index(v->reference, index);
if (index >= v->n_elements)
return NULL;
return json_variant_conservative_formalize(v + 1 + index);
mismatch:
log_debug("Element in non-array/non-object JSON variant requested by index, returning NULL.");
return NULL;
}
_public_ sd_json_variant *sd_json_variant_by_key_full(sd_json_variant *v, const char *key, sd_json_variant **ret_key) {
if (!v)
goto not_found;
if (!key)
goto not_found;
if (v == JSON_VARIANT_MAGIC_EMPTY_OBJECT)
goto not_found;
if (!json_variant_is_regular(v))
goto mismatch;
if (v->type != SD_JSON_VARIANT_OBJECT)
goto mismatch;
if (v->is_reference)
return sd_json_variant_by_key(v->reference, key);
if (v->sorted) {
size_t a = 0, b = v->n_elements/2;
/* If the variant is sorted we can use bisection to find the entry we need in O(log(n)) time */
while (b > a) {
sd_json_variant *p;
const char *f;
size_t i;
int c;
i = (a + b) / 2;
p = json_variant_dereference(v + 1 + i*2);
assert_se(f = sd_json_variant_string(p));
c = strcmp(key, f);
if (c == 0) {
if (ret_key)
*ret_key = json_variant_conservative_formalize(v + 1 + i*2);
return json_variant_conservative_formalize(v + 1 + i*2 + 1);
} else if (c < 0)
b = i;
else
a = i + 1;
}
goto not_found;
}
/* The variant is not sorted, hence search for the field linearly */
for (size_t i = 0; i < v->n_elements; i += 2) {
sd_json_variant *p;
p = json_variant_dereference(v + 1 + i);
if (!sd_json_variant_has_type(p, SD_JSON_VARIANT_STRING))
continue;
if (streq(sd_json_variant_string(p), key)) {
if (ret_key)
*ret_key = json_variant_conservative_formalize(v + 1 + i);
return json_variant_conservative_formalize(v + 1 + i + 1);
}
}
not_found:
if (ret_key)
*ret_key = NULL;
return NULL;
mismatch:
log_debug("Element in non-object JSON variant requested by key, returning NULL.");
if (ret_key)
*ret_key = NULL;
return NULL;
}
_public_ sd_json_variant *sd_json_variant_by_key(sd_json_variant *v, const char *key) {
return sd_json_variant_by_key_full(v, key, NULL);
}
_public_ int sd_json_variant_equal(sd_json_variant *a, sd_json_variant *b) {
sd_json_variant_type_t t;
a = json_variant_formalize(a);
b = json_variant_formalize(b);
if (a == b)
return true;
t = sd_json_variant_type(a);
if (!sd_json_variant_has_type(b, t))
return false;
switch (t) {
case SD_JSON_VARIANT_STRING:
return streq(sd_json_variant_string(a), sd_json_variant_string(b));
case SD_JSON_VARIANT_INTEGER:
return sd_json_variant_integer(a) == sd_json_variant_integer(b);
case SD_JSON_VARIANT_UNSIGNED:
return sd_json_variant_unsigned(a) == sd_json_variant_unsigned(b);
case SD_JSON_VARIANT_REAL:
return fp_equal(sd_json_variant_real(a), sd_json_variant_real(b));
case SD_JSON_VARIANT_BOOLEAN:
return sd_json_variant_boolean(a) == sd_json_variant_boolean(b);
case SD_JSON_VARIANT_NULL:
return true;
case SD_JSON_VARIANT_ARRAY: {
size_t n = sd_json_variant_elements(a);
if (n != sd_json_variant_elements(b))
return false;
for (size_t i = 0; i < n; i++)
if (!sd_json_variant_equal(sd_json_variant_by_index(a, i), sd_json_variant_by_index(b, i)))
return false;
return true;
}
case SD_JSON_VARIANT_OBJECT: {
size_t n = sd_json_variant_elements(a);
if (n != sd_json_variant_elements(b))
return false;
/* Iterate through all keys in 'a' */
for (size_t i = 0; i < n; i += 2) {
bool found = false;
/* Match them against all keys in 'b' */
for (size_t j = 0; j < n; j += 2) {
sd_json_variant *key_b;
key_b = sd_json_variant_by_index(b, j);
/* During the first iteration unmark everything */
if (i == 0)
key_b->is_marked = false;
else if (key_b->is_marked) /* In later iterations if we already marked something, don't bother with it again */
continue;
if (found)
continue;
if (sd_json_variant_equal(sd_json_variant_by_index(a, i), key_b) &&
sd_json_variant_equal(sd_json_variant_by_index(a, i+1), sd_json_variant_by_index(b, j+1))) {
/* Key and values match! */
key_b->is_marked = found = true;
/* In the first iteration we continue the inner loop since we want to mark
* everything, otherwise exit the loop quickly after we found what we were
* looking for. */
if (i != 0)
break;
}
}
if (!found)
return false;
}
return true;
}
default:
assert_not_reached();
}
}
_public_ void sd_json_variant_sensitive(sd_json_variant *v) {
if (!v)
return;
/* Marks a variant as "sensitive", so that it is erased from memory when it is destroyed. This is a
* one-way operation: as soon as it is marked this way it remains marked this way until it's
* destroyed. A magic variant is never sensitive though, even when asked, since it's too
* basic. Similar, const string variant are never sensitive either, after all they are included in
* the source code as they are, which is not suitable for inclusion of secrets.
*
* Note that this flag has a recursive effect: when we destroy an object or array we'll propagate the
* flag to all contained variants. And if those are then destroyed this is propagated further down,
* and so on. */
v = json_variant_formalize(v);
if (!json_variant_is_regular(v))
return;
v->sensitive = true;
}
_public_ int sd_json_variant_is_sensitive(sd_json_variant *v) {
v = json_variant_formalize(v);
if (!json_variant_is_regular(v))
return false;
return v->sensitive;
}
_public_ int sd_json_variant_is_sensitive_recursive(sd_json_variant *v) {
if (!v)
return false;
if (sd_json_variant_is_sensitive(v))
return true;
if (!json_variant_is_regular(v))
return false;
if (v->recursive_sensitive) /* Already checked this before */
return true;
if (!IN_SET(v->type, SD_JSON_VARIANT_ARRAY, SD_JSON_VARIANT_OBJECT))
return false;
if (v->is_reference) {
if (!sd_json_variant_is_sensitive_recursive(v->reference))
return false;
return (v->recursive_sensitive = true);
}
for (size_t i = 0; i < sd_json_variant_elements(v); i++)
if (sd_json_variant_is_sensitive_recursive(sd_json_variant_by_index(v, i)))
return (v->recursive_sensitive = true);
/* Note: we only cache the result here in case true, since we allow all elements down the tree to
* have their sensitive flag toggled later on (but never off) */
return false;
}
static void json_variant_propagate_sensitive(sd_json_variant *from, sd_json_variant *to) {
if (sd_json_variant_is_sensitive(from))
sd_json_variant_sensitive(to);
}
_public_ int sd_json_variant_get_source(sd_json_variant *v, const char **ret_source, unsigned *ret_line, unsigned *ret_column) {
assert_return(v, -EINVAL);
if (ret_source)
*ret_source = json_variant_is_regular(v) && v->source ? v->source->name : NULL;
if (ret_line)
*ret_line = json_variant_is_regular(v) ? v->line : 0;
if (ret_column)
*ret_column = json_variant_is_regular(v) ? v->column : 0;
return 0;
}
static int print_source(FILE *f, sd_json_variant *v, sd_json_format_flags_t flags, bool whitespace) {
size_t w, k;
if (!FLAGS_SET(flags, SD_JSON_FORMAT_SOURCE|SD_JSON_FORMAT_PRETTY))
return 0;
if (!json_variant_is_regular(v))
return 0;
if (!v->source && v->line == 0 && v->column == 0)
return 0;
/* The max width we need to format the line numbers for this source file */
w = (v->source && v->source->max_line > 0) ?
DECIMAL_STR_WIDTH(v->source->max_line) :
DECIMAL_STR_MAX(unsigned)-1;
k = (v->source && v->source->max_column > 0) ?
DECIMAL_STR_WIDTH(v->source->max_column) :
DECIMAL_STR_MAX(unsigned) -1;
if (whitespace) {
size_t n = 1 + (v->source ? strlen(v->source->name) : 0) +
((v->source && (v->line > 0 || v->column > 0)) ? 1 : 0) +
(v->line > 0 ? w : 0) +
(((v->source || v->line > 0) && v->column > 0) ? 1 : 0) +
(v->column > 0 ? k : 0) +
2;
for (size_t i = 0; i < n; i++)
fputc(' ', f);
} else {
fputc('[', f);
if (v->source)
fputs(v->source->name, f);
if (v->source && (v->line > 0 || v->column > 0))
fputc(':', f);
if (v->line > 0)
fprintf(f, "%*u", (int) w, v->line);
if ((v->source || v->line > 0) || v->column > 0)
fputc(':', f);
if (v->column > 0)
fprintf(f, "%*u", (int) k, v->column);
fputc(']', f);
fputc(' ', f);
}
return 0;
}
static void json_format_string(FILE *f, const char *q, sd_json_format_flags_t flags) {
assert(q);
fputc('"', f);
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ansi_green(), f);
for (; *q; q++)
switch (*q) {
case '"':
fputs("\\\"", f);
break;
case '\\':
fputs("\\\\", f);
break;
case '\b':
fputs("\\b", f);
break;
case '\f':
fputs("\\f", f);
break;
case '\n':
fputs("\\n", f);
break;
case '\r':
fputs("\\r", f);
break;
case '\t':
fputs("\\t", f);
break;
default:
if ((signed char) *q >= 0 && *q < ' ')
fprintf(f, "\\u%04x", (unsigned) *q);
else
fputc(*q, f);
}
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
fputc('"', f);
}
static int json_format(FILE *f, sd_json_variant *v, sd_json_format_flags_t flags, const char *prefix) {
int r;
assert(f);
assert(v);
if (FLAGS_SET(flags, SD_JSON_FORMAT_CENSOR_SENSITIVE) && sd_json_variant_is_sensitive(v)) {
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ansi_red(), f);
fputs("\"<sensitive data>\"", f);
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
return 0;
}
switch (sd_json_variant_type(v)) {
case SD_JSON_VARIANT_REAL: {
locale_t loc, old_loc;
loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
if (loc == (locale_t) 0)
return -errno;
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ansi_highlight_blue(), f);
old_loc = uselocale(loc);
fprintf(f, "%.*e", DECIMAL_DIG, sd_json_variant_real(v));
uselocale(old_loc);
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
freelocale(loc);
break;
}
case SD_JSON_VARIANT_INTEGER:
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ansi_highlight_blue(), f);
fprintf(f, "%" PRIdMAX, sd_json_variant_integer(v));
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
break;
case SD_JSON_VARIANT_UNSIGNED:
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ansi_highlight_blue(), f);
fprintf(f, "%" PRIuMAX, sd_json_variant_unsigned(v));
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
break;
case SD_JSON_VARIANT_BOOLEAN:
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_HIGHLIGHT, f);
if (sd_json_variant_boolean(v))
fputs("true", f);
else
fputs("false", f);
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
break;
case SD_JSON_VARIANT_NULL:
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_HIGHLIGHT, f);
fputs("null", f);
if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
break;
case SD_JSON_VARIANT_STRING:
json_format_string(f, sd_json_variant_string(v), flags);
break;
case SD_JSON_VARIANT_ARRAY: {
size_t n = sd_json_variant_elements(v);
if (n == 0)
fputs("[]", f);
else {
_cleanup_free_ char *joined = NULL;
const char *prefix2;
if (flags & SD_JSON_FORMAT_PRETTY) {
joined = strjoin(strempty(prefix), "\t");
if (!joined)
return -ENOMEM;
prefix2 = joined;
fputs("[\n", f);
} else {
prefix2 = strempty(prefix);
fputc('[', f);
}
for (size_t i = 0; i < n; i++) {
sd_json_variant *e;
assert_se(e = sd_json_variant_by_index(v, i));
if (i > 0) {
if (flags & SD_JSON_FORMAT_PRETTY)
fputs(",\n", f);
else
fputc(',', f);
}
if (flags & SD_JSON_FORMAT_PRETTY) {
print_source(f, e, flags, false);
fputs(prefix2, f);
}
r = json_format(f, e, flags, prefix2);
if (r < 0)
return r;
}
if (flags & SD_JSON_FORMAT_PRETTY) {
fputc('\n', f);
print_source(f, v, flags, true);
fputs(strempty(prefix), f);
}
fputc(']', f);
}
break;
}
case SD_JSON_VARIANT_OBJECT: {
size_t n = sd_json_variant_elements(v);
if (n == 0)
fputs("{}", f);
else {
_cleanup_free_ char *joined = NULL;
const char *prefix2;
if (flags & SD_JSON_FORMAT_PRETTY) {
joined = strjoin(strempty(prefix), "\t");
if (!joined)
return -ENOMEM;
prefix2 = joined;
fputs("{\n", f);
} else {
prefix2 = strempty(prefix);
fputc('{', f);
}
for (size_t i = 0; i < n; i += 2) {
sd_json_variant *e;
e = sd_json_variant_by_index(v, i);
if (i > 0) {
if (flags & SD_JSON_FORMAT_PRETTY)
fputs(",\n", f);
else
fputc(',', f);
}
if (flags & SD_JSON_FORMAT_PRETTY) {
print_source(f, e, flags, false);
fputs(prefix2, f);
}
r = json_format(f, e, flags, prefix2);
if (r < 0)
return r;
fputs(flags & SD_JSON_FORMAT_PRETTY ? " : " : ":", f);
r = json_format(f, sd_json_variant_by_index(v, i+1), flags, prefix2);
if (r < 0)
return r;
}
if (flags & SD_JSON_FORMAT_PRETTY) {
fputc('\n', f);
print_source(f, v, flags, true);
fputs(strempty(prefix), f);
}
fputc('}', f);
}
break;
}
default:
assert_not_reached();
}
return 0;
}
_public_ int sd_json_variant_format(sd_json_variant *v, sd_json_format_flags_t flags, char **ret) {
_cleanup_(memstream_done) MemStream m = {};
size_t sz;
FILE *f;
int r;
/* Returns the length of the generated string (without the terminating NUL),
* or negative on error. */
assert_return(ret, -EINVAL);
if (!sd_json_format_enabled(flags))
return -ENOEXEC;
f = memstream_init(&m);
if (!f)
return -ENOMEM;
r = sd_json_variant_dump(v, flags, f, NULL);
if (r < 0)
return r;
r = memstream_finalize(&m, ret, &sz);
if (r < 0)
return r;
return sz;
}
_public_ int sd_json_variant_dump(sd_json_variant *v, sd_json_format_flags_t flags, FILE *f, const char *prefix) {
if (!v) {
if (flags & SD_JSON_FORMAT_EMPTY_ARRAY)
v = JSON_VARIANT_MAGIC_EMPTY_ARRAY;
else if (flags & SD_JSON_FORMAT_EMPTY_OBJECT)
v = JSON_VARIANT_MAGIC_EMPTY_OBJECT;
else
return 0;
}
if (!f)
f = stdout;
print_source(f, v, flags, false);
if (((flags & (SD_JSON_FORMAT_COLOR_AUTO|SD_JSON_FORMAT_COLOR)) == SD_JSON_FORMAT_COLOR_AUTO) && colors_enabled())
flags |= SD_JSON_FORMAT_COLOR;
if (((flags & (SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_PRETTY)) == SD_JSON_FORMAT_PRETTY_AUTO))
flags |= on_tty() ? SD_JSON_FORMAT_PRETTY : SD_JSON_FORMAT_NEWLINE;
if (flags & SD_JSON_FORMAT_SSE)
fputs("data: ", f);
if (flags & SD_JSON_FORMAT_SEQ)
fputc('\x1e', f); /* ASCII Record Separator */
json_format(f, v, flags, prefix);
if (flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_SEQ|SD_JSON_FORMAT_SSE|SD_JSON_FORMAT_NEWLINE))
fputc('\n', f);
if (flags & SD_JSON_FORMAT_SSE)
fputc('\n', f); /* In case of SSE add a second newline */
if (flags & SD_JSON_FORMAT_FLUSH)
return fflush_and_check(f);
return 0;
}
_public_ int sd_json_variant_filter(sd_json_variant **v, char **to_remove) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
_cleanup_free_ sd_json_variant **array = NULL;
size_t n = 0, k = 0;
int r;
assert_return(v, -EINVAL);
if (sd_json_variant_is_blank_object(*v))
return 0;
if (!sd_json_variant_is_object(*v))
return -EINVAL;
if (strv_isempty(to_remove))
return 0;
for (size_t i = 0, m = sd_json_variant_elements(*v); i < m; i += 2) {
sd_json_variant *p;
p = sd_json_variant_by_index(*v, i);
if (!sd_json_variant_has_type(p, SD_JSON_VARIANT_STRING))
return -EINVAL;
if (strv_contains(to_remove, sd_json_variant_string(p))) {
if (!array) {
/* Silence static analyzers */
assert(m >= 2);
array = new(sd_json_variant*, m - 2);
if (!array)
return -ENOMEM;
for (k = 0; k < i; k++)
array[k] = sd_json_variant_by_index(*v, k);
}
n++;
} else if (array) {
array[k++] = p;
array[k++] = sd_json_variant_by_index(*v, i + 1);
}
}
if (n == 0)
return 0;
r = sd_json_variant_new_object(&w, array, k);
if (r < 0)
return r;
json_variant_propagate_sensitive(*v, w);
json_variant_unref_and_replace(*v, w);
return (int) n;
}
_public_ int sd_json_variant_set_field(sd_json_variant **v, const char *field, sd_json_variant *value) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *field_variant = NULL, *w = NULL;
_cleanup_free_ sd_json_variant **array = NULL;
size_t k = 0;
int r;
assert_return(v, -EINVAL);
assert_return(field, -EINVAL);
if (sd_json_variant_is_blank_object(*v)) {
array = new(sd_json_variant*, 2);
if (!array)
return -ENOMEM;
} else {
if (!sd_json_variant_is_object(*v))
return -EINVAL;