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 5001–6000 of 6,031

                        userdata = va_arg(ap, void*);
 
                        if (current->n_suppress == 0) {
                                if (cb) {
                                        r = cb(&add_more, n, userdata);
                                        if (r < 0)
                                                goto finish;
                                }
 
                                if (add_more) {
                                        r = sd_json_variant_new_string(&add, n);
                                        if (r < 0)
                                                goto finish;
                                }
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_BASE64_NON_EMPTY:
                case _JSON_BUILD_PAIR_BASE32HEX_NON_EMPTY:
                case _JSON_BUILD_PAIR_HEX_NON_EMPTY:
                case _JSON_BUILD_PAIR_OCTESCAPE_NON_EMPTY: {
                        const void *p;
                        size_t sz;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char*);
                        p = va_arg(ap, const void *);
                        sz = va_arg(ap, size_t);
 
                        if (sz > 0 && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = command == _JSON_BUILD_PAIR_BASE64_NON_EMPTY    ? sd_json_variant_new_base64(&add_more, p, sz) :
                                    command == _JSON_BUILD_PAIR_BASE32HEX_NON_EMPTY ? sd_json_variant_new_base32hex(&add_more, p, sz) :
                                    command == _JSON_BUILD_PAIR_HEX_NON_EMPTY       ? sd_json_variant_new_hex(&add_more, p, sz) :
                                                                                      sd_json_variant_new_octescape(&add_more, p, sz);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
 
                case _JSON_BUILD_PAIR_TRISTATE_NON_NULL: {
                        int tristate;
                        const char *n;
 
                        if (current->expect != EXPECT_OBJECT_KEY) {
                                r = -EINVAL;
                                goto finish;
                        }
 
                        n = va_arg(ap, const char*);
                        tristate = va_arg(ap, int);
 
                        if (tristate >= 0 && current->n_suppress == 0) {
                                r = sd_json_variant_new_string(&add, n);
                                if (r < 0)
                                        goto finish;
 
                                r = sd_json_variant_new_boolean(&add_more, tristate);
                                if (r < 0)
                                        goto finish;
                        }
 
                        n_subtract = 2; /* we generated two items */
 
                        current->expect = EXPECT_OBJECT_KEY;
                        break;
                }
                }
 
                /* If variants were generated, add them to our current variant, but only if we are not supposed to suppress additions */
                if (add && current->n_suppress == 0) {
                        if (!GREEDY_REALLOC(current->elements, current->n_elements + 1 + !!add_more)) {
                                r = -ENOMEM;
                                goto finish;
                        }
 
                        current->elements[current->n_elements++] = TAKE_PTR(add);
                        if (add_more)
                                current->elements[current->n_elements++] = TAKE_PTR(add_more);
                }
 
                /* If we are supposed to suppress items, let's subtract how many items where generated from
                 * that counter. Except if the counter is SIZE_MAX, i.e. we shall suppress an infinite number
                 * of elements on this stack level */
                if (current->n_suppress != SIZE_MAX) {
                        if (current->n_suppress <= n_subtract) /* Saturated */
                                current->n_suppress = 0;
                        else
                                current->n_suppress -= n_subtract;
                }
        }
 
done:
        assert(n_stack == 1);
        assert(stack[0].n_elements == 1);
 
        *ret = sd_json_variant_ref(stack[0].elements[0]);
        r = 0;
 
finish:
        FOREACH_ARRAY(i, stack, n_stack)
                json_stack_release(i);
 
        free(stack);
 
        return r;
}
 
_public_ int sd_json_build(sd_json_variant **ret, ...) {
        va_list ap;
        int r;
 
        va_start(ap, ret);
        r = sd_json_buildv(ret, ap);
        va_end(ap);
 
        return r;
}
 
int json_log_internal(
                sd_json_variant *variant,
                int level,
                int error,
                const char *file,
                int line,
                const char *func,
                const char *format, ...) {
 
        PROTECT_ERRNO;
 
        unsigned source_line, source_column;
        char buffer[LINE_MAX];
        const char *source;
        va_list ap;
        int r;
 
        errno = ERRNO_VALUE(error);
 
        va_start(ap, format);
        (void) vsnprintf(buffer, sizeof buffer, format, ap);
        va_end(ap);
 
        if (variant) {
                r = sd_json_variant_get_source(variant, &source, &source_line, &source_column);
                if (r < 0)
                        return r;
        } else {
                source = NULL;
                source_line = 0;
                source_column = 0;
        }
 
        if (source && source_line > 0 && source_column > 0)
                return log_struct_internal(
                                level,
                                error,
                                file, line, func,
                                LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
                                LOG_ITEM("CONFIG_FILE=%s", source),
                                LOG_ITEM("CONFIG_LINE=%u", source_line),
                                LOG_ITEM("CONFIG_COLUMN=%u", source_column),
                                LOG_MESSAGE("%s:%u:%u: %s", source, source_line, source_column, buffer),
                                NULL);
        else if (source_line > 0 && source_column > 0)
                return log_struct_internal(
                                level,
                                error,
                                file, line, func,
                                LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
                                LOG_ITEM("CONFIG_LINE=%u", source_line),
                                LOG_ITEM("CONFIG_COLUMN=%u", source_column),
                                LOG_MESSAGE("(string):%u:%u: %s", source_line, source_column, buffer),
                                NULL);
        else
                return log_struct_internal(
                                level,
                                error,
                                file, line, func,
                                LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
                                LOG_MESSAGE("%s", buffer),
                                NULL);
}
 
static void* dispatch_userdata(const sd_json_dispatch_field *p, void *userdata) {
 
        /* When the userdata pointer is passed in as NULL, then we'll just use the offset as a literal
         * address, and convert it to a pointer.  Note that might as well just add the offset to the NULL
         * pointer, but UndefinedBehaviourSanitizer doesn't like pointer arithmetics based on NULL pointers,
         * hence we code this explicitly here. */
 
        if (userdata)
                return (uint8_t*) userdata + p->offset;
 
        return SIZE_TO_PTR(p->offset);
}
 
_public_ int sd_json_dispatch_full(
                sd_json_variant *v,
                const sd_json_dispatch_field table[],
                sd_json_dispatch_callback_t bad,
                sd_json_dispatch_flags_t flags,
                void *userdata,
                const char **reterr_bad_field) {
        size_t m;
        int r, done = 0;
        bool *found;
 
        /* Consider a NULL pointer equivalent to an empty object */
        if (!v)
                v = JSON_VARIANT_MAGIC_EMPTY_OBJECT;
 
        if (!sd_json_variant_is_object(v)) {
                json_log(v, flags, 0, "JSON variant is not an object.");
 
                if (flags & SD_JSON_PERMISSIVE)
                        return 0;
 
                if (reterr_bad_field)
                        *reterr_bad_field = NULL;
 
                return -EINVAL;
        }
 
        m = 0;
        for (const sd_json_dispatch_field *p = table; p && p->name; p++)
                m++;
 
        found = newa0(bool, m);
 
        size_t n = sd_json_variant_elements(v);
        for (size_t i = 0; i < n; i += 2) {
                sd_json_variant *key, *value;
                const sd_json_dispatch_field *p;
 
                assert_se(key = sd_json_variant_by_index(v, i));
                assert_se(value = sd_json_variant_by_index(v, i+1));
 
                for (p = table; p && p->name; p++)
                        if (p->name == POINTER_MAX ||
                            streq_ptr(sd_json_variant_string(key), p->name))
                                break;
 
                if (p && p->name) { /* Found a matching entry! 🙂 */
                        sd_json_dispatch_flags_t merged_flags;
 
                        merged_flags = flags | p->flags;
 
                        /* If an explicit type is specified, verify it matches */
                        if (p->type != _SD_JSON_VARIANT_TYPE_INVALID &&
                            !sd_json_variant_has_type(value, p->type) &&
                            !(FLAGS_SET(merged_flags, SD_JSON_NULLABLE) && sd_json_variant_is_null(value))) {
 
                                json_log(value, merged_flags, 0,
                                         "Object field '%s' has wrong type %s, expected %s.", sd_json_variant_string(key),
                                         sd_json_variant_type_to_string(sd_json_variant_type(value)), sd_json_variant_type_to_string(p->type));
 
                                if (merged_flags & SD_JSON_PERMISSIVE)
                                        continue;
 
                                if (reterr_bad_field)
                                        *reterr_bad_field = p->name;
 
                                return -EINVAL;
                        }
 
                        /* If the SD_JSON_REFUSE_NULL flag is specified, insist the field is not "null". Note
                         * that this provides overlapping functionality with the type check above. */
                        if (FLAGS_SET(merged_flags, SD_JSON_REFUSE_NULL) && sd_json_variant_is_null(value)) {
 
                                json_log(value, merged_flags, 0,
                                         "Object field '%s' may not be null.", sd_json_variant_string(key));
 
                                if (merged_flags & SD_JSON_PERMISSIVE)
                                        continue;
 
                                if (reterr_bad_field)
                                        *reterr_bad_field = p->name;
 
                                return -EINVAL;
                        }
 
                        if (found[p-table]) {
                                json_log(value, merged_flags, 0, "Duplicate object field '%s'.", sd_json_variant_string(key));
 
                                if (merged_flags & SD_JSON_PERMISSIVE)
                                        continue;
 
                                if (reterr_bad_field)
                                        *reterr_bad_field = p->name;
 
                                return -ENOTUNIQ;
                        }
 
                        found[p-table] = true;
 
                        if (p->callback) {
                                r = p->callback(sd_json_variant_string(key), value, merged_flags, dispatch_userdata(p, userdata));
                                if (r < 0) {
                                        if (merged_flags & SD_JSON_PERMISSIVE)
                                                continue;
 
                                        if (reterr_bad_field)
                                                *reterr_bad_field = sd_json_variant_string(key);
 
                                        return r;
                                }
                        }
 
                        done++;
 
                } else { /* Didn't find a matching entry! ☹️ */
 
                        if (bad) {
                                r = bad(sd_json_variant_string(key), value, flags, userdata);
                                if (r < 0) {
                                        if (flags & SD_JSON_PERMISSIVE)
                                                continue;
 
                                        if (reterr_bad_field)
                                                *reterr_bad_field = sd_json_variant_string(key);
 
                                        return r;
                                } else
                                        done++;
 
                        } else {
                                if (flags & SD_JSON_ALLOW_EXTENSIONS)
                                        continue;
 
                                json_log(value, flags, 0, "Unexpected object field '%s'.", sd_json_variant_string(key));
                                if (flags & SD_JSON_PERMISSIVE)
                                        continue;
 
                                if (reterr_bad_field)
                                        *reterr_bad_field = sd_json_variant_string(key);
 
                                return -EADDRNOTAVAIL;
                        }
                }
        }
 
        for (const sd_json_dispatch_field *p = table; p && p->name; p++) {
                sd_json_dispatch_flags_t merged_flags = p->flags | flags;
 
                if ((p->flags & SD_JSON_MANDATORY) && !found[p-table]) {
                        json_log(v, merged_flags, 0, "Missing object field '%s'.", p->name);
 
                        if ((merged_flags & SD_JSON_PERMISSIVE))
                                continue;
 
                        if (reterr_bad_field)
                                *reterr_bad_field = p->name;
 
                        return -ENXIO;
                }
        }
 
        return done;
}
 
_public_ int sd_json_dispatch(
                sd_json_variant *v,
                const sd_json_dispatch_field table[],
                sd_json_dispatch_flags_t flags,
                void *userdata) {
 
        return sd_json_dispatch_full(v, table, NULL, flags, userdata, NULL);
}
 
_public_ int sd_json_dispatch_stdbool(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        bool *b = userdata;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *b = false;
                return 0;
        }
 
        if (!sd_json_variant_is_boolean(variant))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a boolean.", strna(name));
 
        *b = sd_json_variant_boolean(variant);
        return 0;
}
 
_public_ int sd_json_dispatch_intbool(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        int *b = userdata;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *b = false;
                return 0;
        }
 
        if (!sd_json_variant_is_boolean(variant))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a boolean.", strna(name));
 
        *b = sd_json_variant_boolean(variant);
        return 0;
}
 
_public_ int sd_json_dispatch_tristate(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        int *b = userdata;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *b = -1;
                return 0;
        }
 
        if (!sd_json_variant_is_boolean(variant))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a boolean.", strna(name));
 
        *b = sd_json_variant_boolean(variant);
        return 0;
}
 
_public_ int sd_json_dispatch_int64(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        int64_t *i = userdata;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *i = -1;
                return 0;
        }
 
        /* Also accept numbers formatted as string, to increase compatibility with less capable JSON
         * implementations that cannot do 64bit integers. */
        if (sd_json_variant_is_string(variant) && safe_atoi64(sd_json_variant_string(variant), i) >= 0)
                return 0;
 
        if (!sd_json_variant_is_integer(variant))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer, nor one formatted as decimal string.", strna(name));
 
        *i = sd_json_variant_integer(variant);
        return 0;
}
 
_public_ int sd_json_dispatch_uint64(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        uint64_t *u = userdata;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *u = UINT64_MAX;
                return 0;
        }
 
        /* Since 64bit values (in particular unsigned ones) in JSON are problematic, let's also accept them
         * formatted as strings. If this is not desired make sure to set the .type field in
         * sd_json_dispatch_field to SD_JSON_UNSIGNED rather than _SD_JSON_VARIANT_TYPE_INVALID, so that
         * json_dispatch() already filters out the non-matching type. */
 
        if (sd_json_variant_is_string(variant) && safe_atou64(sd_json_variant_string(variant), u) >= 0)
                return 0;
 
        if (!sd_json_variant_is_unsigned(variant))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an unsigned integer, nor one formatted as decimal string.", strna(name));
 
        *u = sd_json_variant_unsigned(variant);
        return 0;
}
 
_public_ int sd_json_dispatch_uint32(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        uint32_t *u = userdata;
        uint64_t u64;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *u = UINT32_MAX;
                return 0;
        }
 
        r = sd_json_dispatch_uint64(name, variant, flags, &u64);
        if (r < 0)
                return r;
 
        if (u64 > UINT32_MAX)
                return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "JSON field '%s' out of bounds.", strna(name));
 
        *u = (uint32_t) u64;
        return 0;
}
 
/* We define sd_json_dispatch_uint() as alias for json_dispatch_uint32(), let's make sure this is safe */
assert_cc(sizeof(uint32_t) == sizeof(unsigned));
 
_public_ int sd_json_dispatch_int32(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        int32_t *i = userdata;
        int64_t i64;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *i = -1;
                return 0;
        }
 
        r = sd_json_dispatch_int64(name, variant, flags, &i64);
        if (r < 0)
                return r;
 
        if (i64 < INT32_MIN || i64 > INT32_MAX)
                return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "JSON field '%s' out of bounds.", strna(name));
 
        *i = (int32_t) i64;
        return 0;
}
 
/* We define sd_json_dispatch_int() as alias for json_dispatch_int32(), let's make sure this is safe */
assert_cc(sizeof(int32_t) == sizeof(int));
 
_public_ int sd_json_dispatch_int16(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        int16_t *i = userdata;
        int64_t i64;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *i = -1;
                return 0;
        }
 
        r = sd_json_dispatch_int64(name, variant, flags, &i64);
        if (r < 0)
                return r;
 
        if (i64 < INT16_MIN || i64 > INT16_MAX)
                return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "JSON field '%s' out of bounds.", strna(name));
 
        *i = (int16_t) i64;
        return 0;
}
 
_public_ int sd_json_dispatch_uint16(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        uint16_t *u = userdata;
        uint64_t u64;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *u = UINT16_MAX;
                return 0;
        }
 
        r = sd_json_dispatch_uint64(name, variant, flags, &u64);
        if (r < 0)
                return r;
 
        if (u64 > UINT16_MAX)
                return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "JSON field '%s' out of bounds.", strna(name));
 
        *u = (uint16_t) u64;
        return 0;
}
 
_public_ int sd_json_dispatch_int8(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        int8_t *i = userdata;
        int64_t i64;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *i = -1;
                return 0;
        }
 
        r = sd_json_dispatch_int64(name, variant, flags, &i64);
        if (r < 0)
                return r;
 
        if (i64 < INT8_MIN || i64 > INT8_MAX)
                return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "JSON field '%s' out of bounds.", strna(name));
 
        *i = (int8_t) i64;
        return 0;
}
 
_public_ int sd_json_dispatch_uint8(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        uint8_t *u = userdata;
        uint64_t u64;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *u = UINT8_MAX;
                return 0;
        }
 
        r = sd_json_dispatch_uint64(name, variant, flags, &u64);
        if (r < 0)
                return r;
 
        if (u64 > UINT8_MAX)
                return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "JSON field '%s' out of bounds.", strna(name));
 
        *u = (uint8_t) u64;
        return 0;
}
 
_public_ int sd_json_dispatch_double(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        double *d = userdata;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *d = NAN;
                return 0;
        }
 
        /* Note, this will take care of parsing NaN, -Infinity, Infinity for us */
        if (sd_json_variant_is_string(variant) && safe_atod(sd_json_variant_string(variant), d) >= 0)
                return 0;
 
        if (!sd_json_variant_is_real(variant))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a floating point value, nor one formatted as string.", strna(name));
 
        *d = sd_json_variant_real(variant);
        return 0;
}
 
_public_ int sd_json_dispatch_string(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        char **s = userdata;
        const char *n;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *s = mfree(*s);
                return 0;
        }
 
        r = sd_json_dispatch_const_string(name, variant, flags, &n);
        if (r < 0)
                return r;
 
        r = free_and_strdup(s, n);
        if (r < 0)
                return json_log(variant, flags, r, "Failed to allocate string: %m");
 
        return 0;
}
 
_public_ int sd_json_dispatch_const_string(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        const char **s = userdata;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *s = NULL;
                return 0;
        }
 
        if (!sd_json_variant_is_string(variant))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
 
        if ((flags & SD_JSON_STRICT) && !string_is_safe(sd_json_variant_string(variant), STRING_ALLOW_EMPTY|STRING_ALLOW_GLOBS))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' contains unsafe characters, refusing.", strna(name));
 
        *s = sd_json_variant_string(variant);
        return 0;
}
 
_public_ int sd_json_dispatch_strv(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        _cleanup_strv_free_ char **l = NULL;
        char ***s = userdata;
        sd_json_variant *e;
        size_t n = 0;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *s = strv_free(*s);
                return 0;
        }
 
        /* Let's be flexible here: accept a single string in place of a single-item array */
        if (sd_json_variant_is_string(variant)) {
                if ((flags & SD_JSON_STRICT) && !string_is_safe(sd_json_variant_string(variant), STRING_ALLOW_EMPTY|STRING_ALLOW_GLOBS))
                        return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' contains unsafe characters, refusing.", strna(name));
 
                l = strv_new(sd_json_variant_string(variant));
                if (!l)
                        return log_oom();
 
                strv_free_and_replace(*s, l);
                return 0;
        }
 
        if (!sd_json_variant_is_array(variant))
                return json_log(variant, SYNTHETIC_ERRNO(EINVAL), flags, "JSON field '%s' is not an array.", strna(name));
 
        JSON_VARIANT_ARRAY_FOREACH(e, variant) {
                if (!sd_json_variant_is_string(e))
                        return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not a string.");
 
                if ((flags & SD_JSON_STRICT) && !string_is_safe(sd_json_variant_string(e), STRING_ALLOW_EMPTY|STRING_ALLOW_GLOBS))
                        return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' contains unsafe characters, refusing.", strna(name));
 
                r = strv_extend_with_size(&l, &n, sd_json_variant_string(e));
                if (r < 0)
                        return json_log(e, flags, r, "Failed to append array element: %m");
        }
 
        strv_free_and_replace(*s, l);
        return 0;
}
 
_public_ int sd_json_dispatch_variant(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        sd_json_variant **p = userdata;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        /* Takes a reference */
        JSON_VARIANT_REPLACE(*p, sd_json_variant_ref(variant));
        return 0;
}
 
_public_ int sd_json_dispatch_variant_noref(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        sd_json_variant **p = userdata;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        /* Doesn't take a reference */
        *p = variant;
        return 0;
}
 
_public_ int sd_json_dispatch_uid_gid(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        uid_t *uid = userdata;
        uint32_t k;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        assert_cc(sizeof(uid_t) == sizeof(uint32_t));
        assert_cc(sizeof(gid_t) == sizeof(uint32_t));
 
        DISABLE_WARNING_TYPE_LIMITS;
        assert_cc((UID_INVALID < (uid_t) 0) == (GID_INVALID < (gid_t) 0));
        REENABLE_WARNING;
 
        if (sd_json_variant_is_null(variant)) {
                *uid = UID_INVALID;
                return 0;
        }
 
        r = sd_json_dispatch_uint32(name, variant, flags, &k);
        if (r < 0)
                return r;
        if (!uid_is_valid(k))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid UID/GID.", strna(name));
 
        *uid = k;
        return 0;
}
 
_public_ int sd_json_dispatch_id128(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        sd_id128_t *uuid = userdata;
        int r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *uuid = SD_ID128_NULL;
                return 0;
        }
 
        if (!sd_json_variant_is_string(variant))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
 
        r = sd_id128_from_string(sd_json_variant_string(variant), uuid);
        if (r < 0)
                return json_log(variant, flags, r, "JSON field '%s' is not a valid UID.", strna(name));
 
        return 0;
}
 
_public_ int sd_json_dispatch_signal(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        int *signo = userdata, r;
 
        assert_return(variant, -EINVAL);
        assert_return(userdata, -EINVAL);
 
        if (sd_json_variant_is_null(variant)) {
                *signo = SIGNO_INVALID;
                return 0;
        }
 
        int k;
        if (sd_json_variant_is_string(variant)) {
                k = signal_from_string(sd_json_variant_string(variant));
                if (k < 0)
                        return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid signal.", strna(name));
        } else {
                r = sd_json_dispatch_int(name, variant, flags, &k);
                if (r < 0)
                        return r;
 
                if (!SIGNAL_VALID(k))
                        return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid signal.", strna(name));
        }
 
        *signo = k;
        return 0;
}
 
_public_ int sd_json_dispatch_unsupported(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not allowed in this object.", strna(name));
}
 
static int json_cmp_strings(const void *x, const void *y) {
        sd_json_variant *const *a = x, *const *b = y;
 
        if (!sd_json_variant_is_string(*a) || !sd_json_variant_is_string(*b))
                return CMP(*a, *b);
 
        return strcmp(sd_json_variant_string(*a), sd_json_variant_string(*b));
}
 
_public_ int sd_json_variant_sort(sd_json_variant **v) {
        _cleanup_free_ sd_json_variant **a = NULL;
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *n = NULL;
        size_t m;
        int r;
 
        assert_return(v, -EINVAL);
 
        if (sd_json_variant_is_sorted(*v))
                return 0;
 
        if (!sd_json_variant_is_object(*v))
                return -EMEDIUMTYPE;
 
        /* Sorts they key/value pairs in an object variant */
 
        m = sd_json_variant_elements(*v);
        a = new(sd_json_variant*, m);
        if (!a)
                return -ENOMEM;
 
        for (size_t i = 0; i < m; i++)
                a[i] = sd_json_variant_by_index(*v, i);
 
        qsort(a, m/2, sizeof(sd_json_variant*)*2, json_cmp_strings);
 
        r = sd_json_variant_new_object(&n, a, m);
        if (r < 0)
                return r;
 
        json_variant_propagate_sensitive(*v, n);
 
        if (!n->sorted) /* Check if this worked. This will fail if there are multiple identical keys used. */
                return -ENOTUNIQ;
 
        json_variant_unref_and_replace(*v, n);
 
        return 1;
}
 
_public_ int sd_json_variant_normalize(sd_json_variant **v) {
        _cleanup_free_ sd_json_variant **a = NULL;
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *n = NULL;
        size_t i, m;
        int r;
 
        assert_return(v, -EINVAL);
 
        if (sd_json_variant_is_normalized(*v))
                return 0;
 
        if (!sd_json_variant_is_object(*v) && !sd_json_variant_is_array(*v))
                return -EMEDIUMTYPE;
 
        /* Sorts the key/value pairs in an object variant anywhere down the tree in the specified variant */
 
        m = sd_json_variant_elements(*v);
        a = new(sd_json_variant*, m);
        if (!a)
                return -ENOMEM;
 
        for (i = 0; i < m; ) {
                a[i] = sd_json_variant_ref(sd_json_variant_by_index(*v, i));
                i++;
 
                r = sd_json_variant_normalize(&a[i-1]);
                if (r < 0)
                        goto finish;
        }
 
        qsort(a, m/2, sizeof(sd_json_variant*)*2, json_cmp_strings);
 
        if (sd_json_variant_is_object(*v))
                r = sd_json_variant_new_object(&n, a, m);
        else {
                assert(sd_json_variant_is_array(*v));
                r = sd_json_variant_new_array(&n, a, m);
        }
        if (r < 0)
                goto finish;
 
        json_variant_propagate_sensitive(*v, n);
 
        if (!n->normalized) { /* Let's see if normalization worked. It will fail if there are multiple
                               * identical keys used in the same object anywhere, or if there are floating
                               * point numbers used (see below) */
                r = -ENOTUNIQ;
                goto finish;
        }
 
        json_variant_unref_and_replace(*v, n);
 
        r = 1;
 
finish:
        for (size_t j = 0; j < i; j++)
                sd_json_variant_unref(a[j]);
 
        return r;
}
 
_public_ int sd_json_variant_is_normalized(sd_json_variant *v) {
        /* For now, let's consider anything containing numbers not expressible as integers as non-normalized.
         * That's because we cannot sensibly compare them due to accuracy issues, nor even store them if they
         * are too large. */
        if (sd_json_variant_is_real(v) && !sd_json_variant_is_integer(v) && !sd_json_variant_is_unsigned(v))
                return false;
 
        /* The concept only applies to variants that include other variants, i.e. objects and arrays. All
         * others are normalized anyway. */
        if (!sd_json_variant_is_object(v) && !sd_json_variant_is_array(v))
                return true;
 
        /* Empty objects/arrays don't include any other variant, hence are always normalized too */
        if (sd_json_variant_elements(v) == 0)
                return true;
 
        return v->normalized; /* For everything else there's an explicit boolean we maintain */
}
 
_public_ int sd_json_variant_is_sorted(sd_json_variant *v) {
 
        /* Returns true if all key/value pairs of an object are properly sorted. Note that this only applies
         * to objects, not arrays. */
 
        if (!sd_json_variant_is_object(v))
                return true;
        if (sd_json_variant_elements(v) <= 1)
                return true;