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