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 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;