'src/libsystemd/sd-hwdb',
'src/libsystemd/sd-id128',
'src/libsystemd/sd-journal',
+ 'src/libsystemd/sd-json',
'src/libsystemd/sd-netlink',
'src/libsystemd/sd-network',
'src/libsystemd/sd-resolve')]
libdl,
libgcrypt_cflags,
liblz4_cflags,
+ libm,
libmount,
libopenssl,
librt,
if (r < 0)
return r;
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF) && table_isempty(table))
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF) && table_isempty(table))
log_info("No file descriptors in fdstore of '%s'.", unit);
else {
r = table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, /* show_header= */true);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "analyze.h"
#include "analyze-inspect-elf.h"
#include "elf-util.h"
#include "fd-util.h"
#include "format-table.h"
#include "format-util.h"
-#include "json.h"
+#include "json-util.h"
#include "path-util.h"
#include "strv.h"
-static int analyze_elf(char **filenames, JsonFormatFlags json_flags) {
+static int analyze_elf(char **filenames, sd_json_format_flags_t json_flags) {
int r;
STRV_FOREACH(filename, filenames) {
- _cleanup_(json_variant_unrefp) JsonVariant *package_metadata = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *package_metadata = NULL;
_cleanup_(table_unrefp) Table *t = NULL;
_cleanup_free_ char *abspath = NULL;
_cleanup_close_ int fd = -EBADF;
return table_log_add_error(r);
if (package_metadata) {
- JsonVariant *module_json;
+ sd_json_variant *module_json;
const char *module_name;
JSON_VARIANT_OBJECT_FOREACH(module_name, module_json, package_metadata) {
const char *field_name;
- JsonVariant *field;
+ sd_json_variant *field;
/* The ELF type and architecture are added as top-level objects,
* since they are only parsed for the file itself, but the packaging
r = table_add_many(
t,
TABLE_FIELD, module_name,
- TABLE_STRING, json_variant_string(module_json));
+ TABLE_STRING, sd_json_variant_string(module_json));
if (r < 0)
return table_log_add_error(r);
}
JSON_VARIANT_OBJECT_FOREACH(field_name, field, module_json)
- if (json_variant_is_string(field)) {
+ if (sd_json_variant_is_string(field)) {
r = table_add_many(
t,
TABLE_FIELD, field_name,
- TABLE_STRING, json_variant_string(field));
+ TABLE_STRING, sd_json_variant_string(field));
if (r < 0)
return table_log_add_error(r);
}
}
}
- if (json_flags & JSON_FORMAT_OFF) {
+ if (json_flags & SD_JSON_FORMAT_OFF) {
r = table_print(t, NULL);
if (r < 0)
return table_log_print_error(r);
} else
- json_variant_dump(package_metadata, json_flags, stdout, NULL);
+ sd_json_variant_dump(package_metadata, json_flags, stdout, NULL);
}
return 0;
if (!table_isempty(table)) {
table_set_header(table, arg_legend);
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
- r = table_print_json(table, NULL, arg_json_format_flags | JSON_FORMAT_COLOR_AUTO);
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
+ r = table_print_json(table, NULL, arg_json_format_flags | SD_JSON_FORMAT_COLOR_AUTO);
else
r = table_print(table, NULL);
if (r < 0)
typesafe_qsort(times, n, compare_unit_start);
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF) || arg_table)
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF) || arg_table)
r = produce_plot_as_text(times, boot);
else
r = produce_plot_as_svg(times, host, boot, pretty_times);
},
};
-static JsonVariant* security_assessor_find_in_policy(const struct security_assessor *a, JsonVariant *policy, const char *name) {
- JsonVariant *item;
+static sd_json_variant* security_assessor_find_in_policy(const struct security_assessor *a, sd_json_variant *policy, const char *name) {
+ sd_json_variant *item;
assert(a);
if (!policy)
return NULL;
- if (!json_variant_is_object(policy)) {
+ if (!sd_json_variant_is_object(policy)) {
log_debug("Specified policy is not a JSON object, ignoring.");
return NULL;
}
- item = json_variant_by_key(policy, a->json_field);
+ item = sd_json_variant_by_key(policy, a->json_field);
if (!item)
return NULL;
- if (!json_variant_is_object(item)) {
+ if (!sd_json_variant_is_object(item)) {
log_debug("Item for '%s' in policy JSON object is not an object, ignoring.", a->id);
return NULL;
}
- return name ? json_variant_by_key(item, name) : item;
+ return name ? sd_json_variant_by_key(item, name) : item;
}
-static uint64_t access_weight(const struct security_assessor *a, JsonVariant *policy) {
- JsonVariant *val;
+static uint64_t access_weight(const struct security_assessor *a, sd_json_variant *policy) {
+ sd_json_variant *val;
assert(a);
val = security_assessor_find_in_policy(a, policy, "weight");
if (val) {
- if (json_variant_is_unsigned(val))
- return json_variant_unsigned(val);
+ if (sd_json_variant_is_unsigned(val))
+ return sd_json_variant_unsigned(val);
log_debug("JSON field 'weight' of policy for %s is not an unsigned integer, ignoring.", a->id);
}
return a->weight;
}
-static uint64_t access_range(const struct security_assessor *a, JsonVariant *policy) {
- JsonVariant *val;
+static uint64_t access_range(const struct security_assessor *a, sd_json_variant *policy) {
+ sd_json_variant *val;
assert(a);
val = security_assessor_find_in_policy(a, policy, "range");
if (val) {
- if (json_variant_is_unsigned(val))
- return json_variant_unsigned(val);
+ if (sd_json_variant_is_unsigned(val))
+ return sd_json_variant_unsigned(val);
log_debug("JSON field 'range' of policy for %s is not an unsigned integer, ignoring.", a->id);
}
return a->range;
}
-static const char *access_description_na(const struct security_assessor *a, JsonVariant *policy) {
- JsonVariant *val;
+static const char *access_description_na(const struct security_assessor *a, sd_json_variant *policy) {
+ sd_json_variant *val;
assert(a);
val = security_assessor_find_in_policy(a, policy, "description_na");
if (val) {
- if (json_variant_is_string(val))
- return json_variant_string(val);
+ if (sd_json_variant_is_string(val))
+ return sd_json_variant_string(val);
log_debug("JSON field 'description_na' of policy for %s is not a string, ignoring.", a->id);
}
return a->description_na;
}
-static const char *access_description_good(const struct security_assessor *a, JsonVariant *policy) {
- JsonVariant *val;
+static const char *access_description_good(const struct security_assessor *a, sd_json_variant *policy) {
+ sd_json_variant *val;
assert(a);
val = security_assessor_find_in_policy(a, policy, "description_good");
if (val) {
- if (json_variant_is_string(val))
- return json_variant_string(val);
+ if (sd_json_variant_is_string(val))
+ return sd_json_variant_string(val);
log_debug("JSON field 'description_good' of policy for %s is not a string, ignoring.", a->id);
}
return a->description_good;
}
-static const char *access_description_bad(const struct security_assessor *a, JsonVariant *policy) {
- JsonVariant *val;
+static const char *access_description_bad(const struct security_assessor *a, sd_json_variant *policy) {
+ sd_json_variant *val;
assert(a);
val = security_assessor_find_in_policy(a, policy, "description_bad");
if (val) {
- if (json_variant_is_string(val))
- return json_variant_string(val);
+ if (sd_json_variant_is_string(val))
+ return sd_json_variant_string(val);
log_debug("JSON field 'description_bad' of policy for %s is not a string, ignoring.", a->id);
}
Table *overview_table,
AnalyzeSecurityFlags flags,
unsigned threshold,
- JsonVariant *policy,
+ sd_json_variant *policy,
PagerFlags pager_flags,
- JsonFormatFlags json_format_flags) {
+ sd_json_format_flags_t json_format_flags) {
static const struct {
uint64_t exposure;
return log_error_errno(r, "Failed to update cell in table: %m");
}
- if (json_format_flags & JSON_FORMAT_OFF) {
+ if (json_format_flags & SD_JSON_FORMAT_OFF) {
r = table_hide_column_from_display(details_table, (size_t) 2);
if (r < 0)
return log_error_errno(r, "Failed to set columns to display: %m");
assert(i < ELEMENTSOF(badness_table));
- if (details_table && (json_format_flags & JSON_FORMAT_OFF)) {
+ if (details_table && (json_format_flags & SD_JSON_FORMAT_OFF)) {
_cleanup_free_ char *clickable = NULL;
const char *name;
Table *overview_table,
AnalyzeSecurityFlags flags,
unsigned threshold,
- JsonVariant *policy,
+ sd_json_variant *policy,
PagerFlags pager_flags,
- JsonFormatFlags json_format_flags) {
+ sd_json_format_flags_t json_format_flags) {
_cleanup_(security_info_freep) SecurityInfo *info = security_info_new();
if (!info)
static int offline_security_check(Unit *u,
unsigned threshold,
- JsonVariant *policy,
+ sd_json_variant *policy,
PagerFlags pager_flags,
- JsonFormatFlags json_format_flags) {
+ sd_json_format_flags_t json_format_flags) {
_cleanup_(table_unrefp) Table *overview_table = NULL;
AnalyzeSecurityFlags flags = 0;
static int offline_security_checks(
char **filenames,
- JsonVariant *policy,
+ sd_json_variant *policy,
RuntimeScope scope,
bool check_man,
bool run_generators,
const char *root,
const char *profile,
PagerFlags pager_flags,
- JsonFormatFlags json_format_flags) {
+ sd_json_format_flags_t json_format_flags) {
const ManagerTestRunFlags flags =
MANAGER_TEST_RUN_MINIMAL |
static int analyze_security(sd_bus *bus,
char **units,
- JsonVariant *policy,
+ sd_json_variant *policy,
RuntimeScope scope,
bool check_man,
bool run_generators,
unsigned threshold,
const char *root,
const char *profile,
- JsonFormatFlags json_format_flags,
+ sd_json_format_flags_t json_format_flags,
PagerFlags pager_flags,
AnalyzeSecurityFlags flags) {
int verb_security(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *policy = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *policy = NULL;
int r;
unsigned line, column;
pager_open(arg_pager_flags);
if (arg_security_policy) {
- r = json_parse_file(/*f=*/ NULL, arg_security_policy, /*flags=*/ 0, &policy, &line, &column);
+ r = sd_json_parse_file(/*f=*/ NULL, arg_security_policy, /*flags=*/ 0, &policy, &line, &column);
if (r < 0)
return log_error_errno(r, "Failed to parse '%s' at %u:%u: %m", arg_security_policy, line, column);
} else {
return r;
if (f) {
- r = json_parse_file(f, pp, /*flags=*/ 0, &policy, &line, &column);
+ r = sd_json_parse_file(f, pp, /*flags=*/ 0, &policy, &line, &column);
if (r < 0)
return log_error_errno(r, "[%s:%u:%u] Failed to parse JSON policy: %m", pp, line, column);
}
unsigned arg_iterations = 1;
usec_t arg_base_time = USEC_INFINITY;
char *arg_unit = NULL;
-JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
bool arg_quiet = false;
char *arg_profile = NULL;
bool arg_legend = true;
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Option --offline= requires one or more units to perform a security review.");
- if (arg_json_format_flags != JSON_FORMAT_OFF && !STRPTR_IN_SET(argv[optind], "security", "inspect-elf", "plot", "fdstore", "pcrs", "architectures", "capability", "exit-status"))
+ if (arg_json_format_flags != SD_JSON_FORMAT_OFF && !STRPTR_IN_SET(argv[optind], "security", "inspect-elf", "plot", "fdstore", "pcrs", "architectures", "capability", "exit-status"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Option --json= is only supported for security, inspect-elf, plot, fdstore, pcrs, architectures, capability, exit-status right now.");
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No conditions can be passed if --unit= is used.");
if ((!arg_legend && !STRPTR_IN_SET(argv[optind], "plot", "architectures")) ||
- (streq_ptr(argv[optind], "plot") && !arg_legend && !arg_table && FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)))
+ (streq_ptr(argv[optind], "plot") && !arg_legend && !arg_table && FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Option --no-legend is only supported for plot with either --table or --json=.");
if (arg_table && !streq_ptr(argv[optind], "plot"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Option --table is only supported for plot right now.");
- if (arg_table && !FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (arg_table && !FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--table and --json= are mutually exclusive.");
return 1; /* work to do */
#include <stdbool.h>
+#include "sd-json.h"
+
#include "analyze-verify-util.h"
#include "bus-util.h"
-#include "json.h"
#include "pager.h"
#include "pretty-print.h"
#include "time-util.h"
extern unsigned arg_iterations;
extern usec_t arg_base_time;
extern char *arg_unit;
-extern JsonFormatFlags arg_json_format_flags;
+extern sd_json_format_flags_t arg_json_format_flags;
extern bool arg_quiet;
extern char *arg_profile;
extern bool arg_legend;
}
}
-int vl_method_set_reboot_to_firmware(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "state", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, 0, 0 },
+int vl_method_set_reboot_to_firmware(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "state", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, 0, 0 },
{}
};
bool b;
return varlink_reply(link, NULL);
}
-int vl_method_get_reboot_to_firmware(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+int vl_method_get_reboot_to_firmware(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
int r;
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
r = efi_get_reboot_to_firmware();
if (r < 0)
return r;
- return varlink_replyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR_BOOLEAN("state", r)));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_BOOLEAN("state", r)));
}
int verb_reboot_to_firmware(int argc, char *argv[], void *userdata);
-int vl_method_set_reboot_to_firmware(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
-int vl_method_get_reboot_to_firmware(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
+int vl_method_set_reboot_to_firmware(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
+int vl_method_get_reboot_to_firmware(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
if (r < 0)
return r;
- if (config.n_entries == 0 && FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ if (config.n_entries == 0 && FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
log_info("No boot loader entries found.");
return 0;
}
return verb_list(argc, argv, userdata);
}
-int vl_method_list_boot_entries(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+int vl_method_list_boot_entries(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
_cleanup_(boot_config_free) BootConfig config = BOOT_CONFIG_NULL;
dev_t esp_devid = 0, xbootldr_devid = 0;
int r;
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
r = acquire_esp(/* unprivileged_mode= */ false,
if (r < 0)
return r;
- _cleanup_(json_variant_unrefp) JsonVariant *previous = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *previous = NULL;
for (size_t i = 0; i < config.n_entries; i++) {
if (previous) {
- r = varlink_notifyb(link, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("entry", previous)));
+ r = varlink_notifyb(link, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("entry", previous)));
if (r < 0)
return r;
- previous = json_variant_unref(previous);
+ previous = sd_json_variant_unref(previous);
}
r = boot_entry_to_json(&config, i, &previous);
return r;
}
- return varlink_replyb(link, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(previous, "entry", JSON_BUILD_VARIANT(previous))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(!!previous, "entry", SD_JSON_BUILD_VARIANT(previous))));
}
int verb_list(int argc, char *argv[], void *userdata);
int verb_unlink(int argc, char *argv[], void *userdata);
-int vl_method_list_boot_entries(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
+int vl_method_list_boot_entries(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
char *arg_install_layout = NULL;
BootEntryTokenType arg_entry_token_type = BOOT_ENTRY_TOKEN_AUTO;
char *arg_entry_token = NULL;
-JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
bool arg_arch_all = false;
char *arg_root = NULL;
char *arg_image = NULL;
#pragma once
#include "sd-id128.h"
+#include "sd-json.h"
#include "boot-entry.h"
#include "image-policy.h"
-#include "json.h"
#include "pager.h"
typedef enum InstallSource {
extern char *arg_install_layout;
extern BootEntryTokenType arg_entry_token_type;
extern char *arg_entry_token;
-extern JsonFormatFlags arg_json_format_flags;
+extern sd_json_format_flags_t arg_json_format_flags;
extern bool arg_arch_all;
extern char *arg_root;
extern char *arg_image;
#include <getopt.h>
#include <unistd.h>
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "build.h"
#include "efi-loader.h"
#include "fd-util.h"
#include "fileio.h"
#include "hexdecoct.h"
-#include "json.h"
#include "main-func.h"
#include "memstream-util.h"
#include "openssl-util.h"
#include "parse-util.h"
#include "pretty-print.h"
#include "sha256.h"
+#include "strv.h"
#include "terminal-util.h"
#include "tpm2-pcr.h"
#include "tpm2-util.h"
static char *arg_private_key_source = NULL;
static char *arg_public_key = NULL;
static char *arg_certificate = NULL;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO|JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO|SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static bool arg_current = false;
static char **arg_phase = NULL;
}
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
break;
case ARG_JSON:
}
static int verb_calculate(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
_cleanup_(pcr_state_free_all) PcrState *pcr_states = NULL;
int r;
return r;
for (size_t i = 0; i < n; i++) {
- if (arg_json_format_flags & JSON_FORMAT_OFF) {
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF) {
_cleanup_free_ char *hd = NULL;
if (i == 0) {
printf("%i:%s=%s\n", TPM2_PCR_KERNEL_BOOT, pcr_states[i].bank, hd);
} else {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
- array = json_variant_ref(json_variant_by_key(w, pcr_states[i].bank));
+ array = sd_json_variant_ref(sd_json_variant_by_key(w, pcr_states[i].bank));
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(!isempty(*phase), "phase", JSON_BUILD_STRING(*phase)),
- JSON_BUILD_PAIR("pcr", JSON_BUILD_INTEGER(TPM2_PCR_KERNEL_BOOT)),
- JSON_BUILD_PAIR("hash", JSON_BUILD_HEX(pcr_states[i].value, pcr_states[i].value_size))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(!isempty(*phase), "phase", SD_JSON_BUILD_STRING(*phase)),
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_INTEGER(TPM2_PCR_KERNEL_BOOT)),
+ SD_JSON_BUILD_PAIR("hash", SD_JSON_BUILD_HEX(pcr_states[i].value, pcr_states[i].value_size))));
if (r < 0)
return log_error_errno(r, "Failed to append JSON object to array: %m");
- r = json_variant_set_field(&w, pcr_states[i].bank, array);
+ r = sd_json_variant_set_field(&w, pcr_states[i].bank, array);
if (r < 0)
return log_error_errno(r, "Failed to add bank info to object: %m");
}
pcr_states_restore(pcr_states, n);
}
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
- if (arg_json_format_flags & (JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ if (arg_json_format_flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
pager_open(arg_pager_flags);
- json_variant_dump(w, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(w, arg_json_format_flags, stdout, NULL);
}
return 0;
}
static int verb_sign(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(pcr_state_free_all) PcrState *pcr_states = NULL;
_cleanup_(EVP_PKEY_freep) EVP_PKEY *privkey = NULL, *pubkey = NULL;
_cleanup_(X509_freep) X509 *certificate = NULL;
assert(!strv_isempty(arg_phase));
if (arg_append) {
- r = json_parse_file(NULL, arg_append, 0, &v, NULL, NULL);
+ r = sd_json_parse_file(NULL, arg_append, 0, &v, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to parse '%s': %m", arg_append);
- if (!json_variant_is_object(v))
+ if (!sd_json_variant_is_object(v))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"File '%s' is not a valid JSON object, refusing.", arg_append);
}
/* When signing we only support JSON output */
- arg_json_format_flags &= ~JSON_FORMAT_OFF;
+ arg_json_format_flags &= ~SD_JSON_FORMAT_OFF;
/* This must be done before openssl_load_key_from_token() otherwise it will get stuck */
if (arg_certificate) {
if (r < 0)
return r;
- _cleanup_(json_variant_unrefp) JsonVariant *a = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *a = NULL;
r = tpm2_make_pcr_json_array(UINT64_C(1) << TPM2_PCR_KERNEL_BOOT, &a);
if (r < 0)
return log_error_errno(r, "Failed to build JSON PCR mask array: %m");
- _cleanup_(json_variant_unrefp) JsonVariant *bv = NULL;
- r = json_build(&bv, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcrs", JSON_BUILD_VARIANT(a)), /* PCR mask */
- JSON_BUILD_PAIR("pkfp", JSON_BUILD_HEX(pubkey_fp, pubkey_fp_size)), /* SHA256 fingerprint of public key (DER) used for the signature */
- JSON_BUILD_PAIR("pol", JSON_BUILD_HEX(pcr_policy_digest.buffer, pcr_policy_digest.size)), /* TPM2 policy hash that is signed */
- JSON_BUILD_PAIR("sig", JSON_BUILD_BASE64(sig, ss)))); /* signature data */
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *bv = NULL;
+ r = sd_json_build(&bv, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcrs", SD_JSON_BUILD_VARIANT(a)), /* PCR mask */
+ SD_JSON_BUILD_PAIR("pkfp", SD_JSON_BUILD_HEX(pubkey_fp, pubkey_fp_size)), /* SHA256 fingerprint of public key (DER) used for the signature */
+ SD_JSON_BUILD_PAIR("pol", SD_JSON_BUILD_HEX(pcr_policy_digest.buffer, pcr_policy_digest.size)), /* TPM2 policy hash that is signed */
+ SD_JSON_BUILD_PAIR("sig", SD_JSON_BUILD_BASE64(sig, ss)))); /* signature data */
if (r < 0)
return log_error_errno(r, "Failed to build JSON object: %m");
- _cleanup_(json_variant_unrefp) JsonVariant *av = NULL;
- av = json_variant_ref(json_variant_by_key(v, p->bank));
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *av = NULL;
+ av = sd_json_variant_ref(sd_json_variant_by_key(v, p->bank));
- r = json_variant_append_array_nodup(&av, bv);
+ r = sd_json_variant_append_array_nodup(&av, bv);
if (r < 0)
return log_error_errno(r, "Failed to append JSON object: %m");
- r = json_variant_set_field(&v, p->bank, av);
+ r = sd_json_variant_set_field(&v, p->bank, av);
if (r < 0)
return log_error_errno(r, "Failed to add JSON field: %m");
}
pcr_states_restore(pcr_states, n);
}
- if (arg_json_format_flags & (JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ if (arg_json_format_flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
pager_open(arg_pager_flags);
- json_variant_dump(v, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, stdout, NULL);
return 0;
}
TPM2_PCR_SYSEXTS,
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
r = validate_stub();
if (r < 0)
return log_error_errno(r, "Failed to decode PCR value '%s': %m", s);
- if (arg_json_format_flags & JSON_FORMAT_OFF) {
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF) {
_cleanup_free_ char *f = NULL;
f = hexmem(h, l);
printf("%" PRIu32 ":%s=%s\n", relevant_pcrs[i], b, f);
} else {
- _cleanup_(json_variant_unrefp) JsonVariant *bv = NULL, *a = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *bv = NULL, *a = NULL;
- r = json_build(&bv,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcr", JSON_BUILD_INTEGER(relevant_pcrs[i])),
- JSON_BUILD_PAIR("hash", JSON_BUILD_HEX(h, l))
+ r = sd_json_build(&bv,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_INTEGER(relevant_pcrs[i])),
+ SD_JSON_BUILD_PAIR("hash", SD_JSON_BUILD_HEX(h, l))
)
);
if (r < 0)
return log_error_errno(r, "Failed to build JSON object: %m");
- a = json_variant_ref(json_variant_by_key(v, b));
+ a = sd_json_variant_ref(sd_json_variant_by_key(v, b));
- r = json_variant_append_array(&a, bv);
+ r = sd_json_variant_append_array(&a, bv);
if (r < 0)
return log_error_errno(r, "Failed to append PCR entry to JSON array: %m");
- r = json_variant_set_field(&v, b, a);
+ r = sd_json_variant_set_field(&v, b, a);
if (r < 0)
return log_error_errno(r, "Failed to add bank info to object: %m");
}
}
}
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
- if (arg_json_format_flags & (JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
+ if (arg_json_format_flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
pager_open(arg_pager_flags);
- json_variant_dump(v, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, stdout, NULL);
}
return 0;
#include <getopt.h>
#include "sd-bus.h"
+#include "sd-json.h"
#include "alloc-util.h"
#include "build.h"
#include "fileio.h"
#include "format-table.h"
#include "glyph-util.h"
-#include "json.h"
#include "log.h"
#include "main-func.h"
#include "memstream-util.h"
#include "verbs.h"
#include "version.h"
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static bool arg_legend = true;
static int arg_full = -1;
#define NAME_IS_ACQUIRED INT_TO_PTR(1)
#define NAME_IS_ACTIVATABLE INT_TO_PTR(2)
-static int json_transform_message(sd_bus_message *m, JsonVariant **ret);
+static int json_transform_message(sd_bus_message *m, sd_json_variant **ret);
static int acquire_bus(bool set_monitor, sd_bus **ret) {
_cleanup_(sd_bus_close_unrefp) sd_bus *bus = NULL;
}
static int message_json(sd_bus_message *m, FILE *f) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL;
char e[2];
int r;
usec_t ts;
if (ts == 0)
ts = now(CLOCK_REALTIME);
- r = json_build(&w, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("type", JSON_BUILD_STRING(bus_message_type_to_string(m->header->type))),
- JSON_BUILD_PAIR("endian", JSON_BUILD_STRING(e)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_INTEGER(m->header->flags)),
- JSON_BUILD_PAIR("version", JSON_BUILD_INTEGER(m->header->version)),
- JSON_BUILD_PAIR("cookie", JSON_BUILD_INTEGER(BUS_MESSAGE_COOKIE(m))),
- JSON_BUILD_PAIR_CONDITION(m->reply_cookie != 0, "reply_cookie", JSON_BUILD_INTEGER(m->reply_cookie)),
- JSON_BUILD_PAIR("timestamp-realtime", JSON_BUILD_UNSIGNED(ts)),
- JSON_BUILD_PAIR_CONDITION(m->sender, "sender", JSON_BUILD_STRING(m->sender)),
- JSON_BUILD_PAIR_CONDITION(m->destination, "destination", JSON_BUILD_STRING(m->destination)),
- JSON_BUILD_PAIR_CONDITION(m->path, "path", JSON_BUILD_STRING(m->path)),
- JSON_BUILD_PAIR_CONDITION(m->interface, "interface", JSON_BUILD_STRING(m->interface)),
- JSON_BUILD_PAIR_CONDITION(m->member, "member", JSON_BUILD_STRING(m->member)),
- JSON_BUILD_PAIR_CONDITION(m->monotonic != 0, "monotonic", JSON_BUILD_INTEGER(m->monotonic)),
- JSON_BUILD_PAIR_CONDITION(m->realtime != 0, "realtime", JSON_BUILD_INTEGER(m->realtime)),
- JSON_BUILD_PAIR_CONDITION(m->seqnum != 0, "seqnum", JSON_BUILD_INTEGER(m->seqnum)),
- JSON_BUILD_PAIR_CONDITION(m->error.name, "error_name", JSON_BUILD_STRING(m->error.name)),
- JSON_BUILD_PAIR("payload", JSON_BUILD_VARIANT(v))));
+ r = sd_json_build(&w, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("type", SD_JSON_BUILD_STRING(bus_message_type_to_string(m->header->type))),
+ SD_JSON_BUILD_PAIR("endian", SD_JSON_BUILD_STRING(e)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_INTEGER(m->header->flags)),
+ SD_JSON_BUILD_PAIR("version", SD_JSON_BUILD_INTEGER(m->header->version)),
+ SD_JSON_BUILD_PAIR("cookie", SD_JSON_BUILD_INTEGER(BUS_MESSAGE_COOKIE(m))),
+ SD_JSON_BUILD_PAIR_CONDITION(m->reply_cookie != 0, "reply_cookie", SD_JSON_BUILD_INTEGER(m->reply_cookie)),
+ SD_JSON_BUILD_PAIR("timestamp-realtime", SD_JSON_BUILD_UNSIGNED(ts)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!m->sender, "sender", SD_JSON_BUILD_STRING(m->sender)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!m->destination, "destination", SD_JSON_BUILD_STRING(m->destination)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!m->path, "path", SD_JSON_BUILD_STRING(m->path)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!m->interface, "interface", SD_JSON_BUILD_STRING(m->interface)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!m->member, "member", SD_JSON_BUILD_STRING(m->member)),
+ SD_JSON_BUILD_PAIR_CONDITION(m->monotonic != 0, "monotonic", SD_JSON_BUILD_INTEGER(m->monotonic)),
+ SD_JSON_BUILD_PAIR_CONDITION(m->realtime != 0, "realtime", SD_JSON_BUILD_INTEGER(m->realtime)),
+ SD_JSON_BUILD_PAIR_CONDITION(m->seqnum != 0, "seqnum", SD_JSON_BUILD_INTEGER(m->seqnum)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!m->error.name, "error_name", SD_JSON_BUILD_STRING(m->error.name)),
+ SD_JSON_BUILD_PAIR("payload", SD_JSON_BUILD_VARIANT(v))));
if (r < 0)
return log_error_errno(r, "Failed to build JSON object: %m");
- json_variant_dump(w, arg_json_format_flags, f, NULL);
+ sd_json_variant_dump(w, arg_json_format_flags, f, NULL);
return 0;
}
if (r < 0)
return log_error_errno(r, "Failed to get unique name: %m");
- if (!arg_quiet && arg_json_format_flags == JSON_FORMAT_OFF)
+ if (!arg_quiet && arg_json_format_flags == SD_JSON_FORMAT_OFF)
log_info("Monitoring bus message stream.");
(void) sd_notify(/* unset_environment=false */ false, "READY=1");
fflush(stdout);
if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected") > 0) {
- if (!arg_quiet && arg_json_format_flags == JSON_FORMAT_OFF)
+ if (!arg_quiet && arg_json_format_flags == SD_JSON_FORMAT_OFF)
log_info("Connection terminated, exiting.");
return 0;
}
}
static int verb_monitor(int argc, char **argv, void *userdata) {
- return monitor(argc, argv, (arg_json_format_flags & JSON_FORMAT_OFF) ? message_dump : message_json);
+ return monitor(argc, argv, (arg_json_format_flags & SD_JSON_FORMAT_OFF) ? message_dump : message_json);
}
static int verb_capture(int argc, char **argv, void *userdata) {
return 0;
}
-static int json_transform_one(sd_bus_message *m, JsonVariant **ret);
+static int json_transform_one(sd_bus_message *m, sd_json_variant **ret);
-static int json_transform_and_append(sd_bus_message *m, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *element = NULL;
+static int json_transform_and_append(sd_bus_message *m, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *element = NULL;
int r;
assert(m);
if (r < 0)
return r;
- return json_variant_append_array(ret, element);
+ return sd_json_variant_append_array(ret, element);
}
-static int json_transform_array_or_struct(sd_bus_message *m, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int json_transform_array_or_struct(sd_bus_message *m, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
int r;
assert(m);
}
if (!array)
- return json_variant_new_array(ret, NULL, 0);
+ return sd_json_variant_new_array(ret, NULL, 0);
*ret = TAKE_PTR(array);
return 0;
}
-static int json_transform_variant(sd_bus_message *m, const char *contents, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *value = NULL;
+static int json_transform_variant(sd_bus_message *m, const char *contents, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *value = NULL;
int r;
assert(m);
if (r < 0)
return r;
- r = json_build(ret, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("type", JSON_BUILD_STRING(contents)),
- JSON_BUILD_PAIR("data", JSON_BUILD_VARIANT(value))));
+ r = sd_json_build(ret, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("type", SD_JSON_BUILD_STRING(contents)),
+ SD_JSON_BUILD_PAIR("data", SD_JSON_BUILD_VARIANT(value))));
if (r < 0)
return log_oom();
return r;
}
-static int json_transform_dict_array(sd_bus_message *m, JsonVariant **ret) {
- JsonVariant **elements = NULL;
+static int json_transform_dict_array(sd_bus_message *m, sd_json_variant **ret) {
+ sd_json_variant **elements = NULL;
size_t n_elements = 0;
int r;
assert(m);
assert(ret);
- CLEANUP_ARRAY(elements, n_elements, json_variant_unref_many);
+ CLEANUP_ARRAY(elements, n_elements, sd_json_variant_unref_many);
for (;;) {
const char *contents;
return bus_log_parse_error(r);
}
- return json_variant_new_object(ret, elements, n_elements);
+ return sd_json_variant_new_object(ret, elements, n_elements);
}
-static int json_transform_one(sd_bus_message *m, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+static int json_transform_one(sd_bus_message *m, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
const char *contents;
char type;
int r;
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_unsigned(&v, b);
+ r = sd_json_variant_new_unsigned(&v, b);
if (r < 0)
return log_error_errno(r, "Failed to transform byte: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_boolean(&v, b);
+ r = sd_json_variant_new_boolean(&v, b);
if (r < 0)
return log_error_errno(r, "Failed to transform boolean: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_integer(&v, b);
+ r = sd_json_variant_new_integer(&v, b);
if (r < 0)
return log_error_errno(r, "Failed to transform int16: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_unsigned(&v, b);
+ r = sd_json_variant_new_unsigned(&v, b);
if (r < 0)
return log_error_errno(r, "Failed to transform uint16: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_integer(&v, b);
+ r = sd_json_variant_new_integer(&v, b);
if (r < 0)
return log_error_errno(r, "Failed to transform int32: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_unsigned(&v, b);
+ r = sd_json_variant_new_unsigned(&v, b);
if (r < 0)
return log_error_errno(r, "Failed to transform uint32: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_integer(&v, b);
+ r = sd_json_variant_new_integer(&v, b);
if (r < 0)
return log_error_errno(r, "Failed to transform int64: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_unsigned(&v, b);
+ r = sd_json_variant_new_unsigned(&v, b);
if (r < 0)
return log_error_errno(r, "Failed to transform uint64: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_real(&v, d);
+ r = sd_json_variant_new_real(&v, d);
if (r < 0)
return log_error_errno(r, "Failed to transform double: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_string(&v, s);
+ r = sd_json_variant_new_string(&v, s);
if (r < 0)
return log_error_errno(r, "Failed to transform double: %m");
if (r < 0)
return bus_log_parse_error(r);
- r = json_variant_new_null(&v);
+ r = sd_json_variant_new_null(&v);
if (r < 0)
return log_error_errno(r, "Failed to transform fd: %m");
return 0;
}
-static int json_transform_message(sd_bus_message *m, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+static int json_transform_message(sd_bus_message *m, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
const char *type;
int r;
if (r < 0)
return r;
- r = json_build(ret, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("type", JSON_BUILD_STRING(type)),
- JSON_BUILD_PAIR("data", JSON_BUILD_VARIANT(v))));
+ r = sd_json_build(ret, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("type", SD_JSON_BUILD_STRING(type)),
+ SD_JSON_BUILD_PAIR("data", SD_JSON_BUILD_VARIANT(v))));
if (r < 0)
return log_oom();
if (r == 0 && !arg_quiet) {
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
- if (arg_json_format_flags & (JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ if (arg_json_format_flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
pager_open(arg_pager_flags);
r = json_transform_message(reply, &v);
if (r < 0)
return r;
- json_variant_dump(v, arg_json_format_flags, NULL, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, NULL, NULL);
} else if (arg_verbose) {
pager_open(arg_pager_flags);
if (r < 0)
return bus_log_parse_error(r);
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
- if (arg_json_format_flags & (JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ if (arg_json_format_flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
pager_open(arg_pager_flags);
r = json_transform_variant(reply, contents, &v);
if (r < 0)
return r;
- json_variant_dump(v, arg_json_format_flags, NULL, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, NULL, NULL);
} else if (arg_verbose) {
pager_open(arg_pager_flags);
break;
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
break;
case ARG_JSON:
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "core-varlink.h"
+#include "json-util.h"
#include "mkdir-label.h"
#include "strv.h"
#include "user-util.h"
"ManagedOOMMemoryPressure",
};
-static int build_user_json(const char *user_name, uid_t uid, JsonVariant **ret) {
+static int build_user_json(const char *user_name, uid_t uid, sd_json_variant **ret) {
assert(user_name);
assert(uid_is_valid(uid));
assert(ret);
- return json_build(ret, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("record", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(user_name)),
- JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(uid)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(uid)),
- JSON_BUILD_PAIR("realName", JSON_BUILD_CONST_STRING("Dynamic User")),
- JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_CONST_STRING("/")),
- JSON_BUILD_PAIR("shell", JSON_BUILD_CONST_STRING(NOLOGIN)),
- JSON_BUILD_PAIR("locked", JSON_BUILD_BOOLEAN(true)),
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.DynamicUser")),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("dynamic"))))));
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(user_name)),
+ SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(uid)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(uid)),
+ SD_JSON_BUILD_PAIR("realName", JSON_BUILD_CONST_STRING("Dynamic User")),
+ SD_JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_CONST_STRING("/")),
+ SD_JSON_BUILD_PAIR("shell", JSON_BUILD_CONST_STRING(NOLOGIN)),
+ SD_JSON_BUILD_PAIR("locked", SD_JSON_BUILD_BOOLEAN(true)),
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.DynamicUser")),
+ SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("dynamic"))))));
}
static bool user_match_lookup_parameters(LookupParameters *p, const char *name, uid_t uid) {
return true;
}
-static int build_managed_oom_json_array_element(Unit *u, const char *property, JsonVariant **ret_v) {
+static int build_managed_oom_json_array_element(Unit *u, const char *property, sd_json_variant **ret_v) {
bool use_limit = false;
CGroupContext *c;
const char *mode;
} else
return -EINVAL;
- return json_build(ret_v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("mode", JSON_BUILD_STRING(mode)),
- JSON_BUILD_PAIR("path", JSON_BUILD_STRING(crt->cgroup_path)),
- JSON_BUILD_PAIR("property", JSON_BUILD_STRING(property)),
- JSON_BUILD_PAIR_CONDITION(use_limit, "limit", JSON_BUILD_UNSIGNED(c->moom_mem_pressure_limit))));
+ return sd_json_build(ret_v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("mode", SD_JSON_BUILD_STRING(mode)),
+ SD_JSON_BUILD_PAIR("path", SD_JSON_BUILD_STRING(crt->cgroup_path)),
+ SD_JSON_BUILD_PAIR("property", SD_JSON_BUILD_STRING(property)),
+ SD_JSON_BUILD_PAIR_CONDITION(use_limit, "limit", SD_JSON_BUILD_UNSIGNED(c->moom_mem_pressure_limit))));
}
int manager_varlink_send_managed_oom_update(Unit *u) {
- _cleanup_(json_variant_unrefp) JsonVariant *arr = NULL, *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *arr = NULL, *v = NULL;
CGroupRuntime *crt;
CGroupContext *c;
int r;
if (!c)
return 0;
- r = json_build(&arr, JSON_BUILD_EMPTY_ARRAY);
+ r = sd_json_build(&arr, SD_JSON_BUILD_EMPTY_ARRAY);
if (r < 0)
return r;
FOREACH_ELEMENT(i, managed_oom_mode_properties) {
- _cleanup_(json_variant_unrefp) JsonVariant *e = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *e = NULL;
r = build_managed_oom_json_array_element(u, *i, &e);
if (r < 0)
return r;
- r = json_variant_append_array(&arr, e);
+ r = sd_json_variant_append_array(&arr, e);
if (r < 0)
return r;
}
- r = json_build(&v, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("cgroups", JSON_BUILD_VARIANT(arr))));
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("cgroups", SD_JSON_BUILD_VARIANT(arr))));
if (r < 0)
return r;
return r;
}
-static int build_managed_oom_cgroups_json(Manager *m, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *arr = NULL;
+static int build_managed_oom_cgroups_json(Manager *m, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *arr = NULL;
int r;
assert(m);
assert(ret);
- r = json_build(&arr, JSON_BUILD_EMPTY_ARRAY);
+ r = sd_json_build(&arr, SD_JSON_BUILD_EMPTY_ARRAY);
if (r < 0)
return r;
continue;
FOREACH_ELEMENT(i, managed_oom_mode_properties) {
- _cleanup_(json_variant_unrefp) JsonVariant *e = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *e = NULL;
/* For the initial varlink call we only care about units that enabled (i.e. mode is not
* set to "auto") oomd properties. */
if (r < 0)
return r;
- r = json_variant_append_array(&arr, e);
+ r = sd_json_variant_append_array(&arr, e);
if (r < 0)
return r;
}
}
}
- r = json_build(&v, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("cgroups", JSON_BUILD_VARIANT(arr))));
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("cgroups", SD_JSON_BUILD_VARIANT(arr))));
if (r < 0)
return r;
static int vl_method_subscribe_managed_oom_cgroups(
Varlink *link,
- JsonVariant *parameters,
+ sd_json_variant *parameters,
VarlinkMethodFlags flags,
void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
Manager *m = ASSERT_PTR(userdata);
pid_t pid;
Unit *u;
if (!streq(u->id, "systemd-oomd.service"))
return varlink_error(link, VARLINK_ERROR_PERMISSION_DENIED, NULL);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
/* We only take one subscriber for this method so return an error if there's already an existing one.
}
static int manager_varlink_send_managed_oom_initial(Manager *m) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(m);
return varlink_send(m->managed_oom_varlink, "io.systemd.oom.ReportManagedOOMCGroups", v);
}
-static int vl_method_get_user_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_user_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "uid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
LookupParameters p = {
.uid = UID_INVALID,
};
if (r < 0)
return r;
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
}
r = build_user_json(d->name, uid, &v);
return varlink_reply(link, v);
}
-static int build_group_json(const char *group_name, gid_t gid, JsonVariant **ret) {
+static int build_group_json(const char *group_name, gid_t gid, sd_json_variant **ret) {
assert(group_name);
assert(gid_is_valid(gid));
assert(ret);
- return json_build(ret, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("record", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(group_name)),
- JSON_BUILD_PAIR("description", JSON_BUILD_CONST_STRING("Dynamic Group")),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(gid)),
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.DynamicUser")),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("dynamic"))))));
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(group_name)),
+ SD_JSON_BUILD_PAIR("description", JSON_BUILD_CONST_STRING("Dynamic Group")),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(gid)),
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.DynamicUser")),
+ SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("dynamic"))))));
}
static bool group_match_lookup_parameters(LookupParameters *p, const char *name, gid_t gid) {
return true;
}
-static int vl_method_get_group_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_group_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
LookupParameters p = {
.gid = GID_INVALID,
};
if (r < 0)
return r;
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
}
r = build_group_json(d->name, (gid_t) uid, &v);
return varlink_reply(link, v);
}
-static int vl_method_get_memberships(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_memberships(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), JSON_SAFE },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), SD_JSON_SAFE },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
return 1;
}
-static int vl_reply(Varlink *link, JsonVariant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
+static int vl_reply(Varlink *link, sd_json_variant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
int r;
#include "sd-daemon.h"
#include "sd-journal.h"
+#include "sd-json.h"
#include "sd-login.h"
#include "sd-messages.h"
#include "iovec-util.h"
#include "journal-importer.h"
#include "journal-send.h"
+#include "json-util.h"
#include "log.h"
#include "macro.h"
#include "main-func.h"
struct iovec_wrapper *iovw,
int input_fd) {
- _cleanup_(json_variant_unrefp) JsonVariant *json_metadata = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *json_metadata = NULL;
_cleanup_close_ int coredump_fd = -EBADF, coredump_node_fd = -EBADF;
_cleanup_free_ char *filename = NULL, *coredump_data = NULL;
_cleanup_free_ char *stacktrace = NULL;
const char *module_name;
uint64_t coredump_size = UINT64_MAX, coredump_compressed_size = UINT64_MAX;
bool truncated = false, written = false;
- JsonVariant *module_json;
+ sd_json_variant *module_json;
int r;
assert(context);
if (json_metadata) {
_cleanup_free_ char *formatted_json = NULL;
- r = json_variant_format(json_metadata, 0, &formatted_json);
+ r = sd_json_variant_format(json_metadata, 0, &formatted_json);
if (r < 0)
return log_error_errno(r, "Failed to format JSON package metadata: %m");
* let's avoid guessing the module name and skip the loop. */
if (context->meta[META_EXE])
JSON_VARIANT_OBJECT_FOREACH(module_name, module_json, json_metadata) {
- JsonVariant *t;
+ sd_json_variant *t;
/* We only add structured fields for the 'main' ELF module, and only if we can identify it. */
if (!path_equal_filename(module_name, context->meta[META_EXE]))
continue;
- t = json_variant_by_key(module_json, "name");
+ t = sd_json_variant_by_key(module_json, "name");
if (t)
- (void) iovw_put_string_field(iovw, "COREDUMP_PACKAGE_NAME=", json_variant_string(t));
+ (void) iovw_put_string_field(iovw, "COREDUMP_PACKAGE_NAME=", sd_json_variant_string(t));
- t = json_variant_by_key(module_json, "version");
+ t = sd_json_variant_by_key(module_json, "version");
if (t)
- (void) iovw_put_string_field(iovw, "COREDUMP_PACKAGE_VERSION=", json_variant_string(t));
+ (void) iovw_put_string_field(iovw, "COREDUMP_PACKAGE_VERSION=", sd_json_variant_string(t));
}
/* Optionally store the entire coredump in the journal */
#include "sd-bus.h"
#include "sd-journal.h"
+#include "sd-json.h"
#include "sd-messages.h"
#include "alloc-util.h"
#include "glob-util.h"
#include "journal-internal.h"
#include "journal-util.h"
+#include "json-util.h"
#include "log.h"
#include "macro.h"
#include "main-func.h"
static char *arg_root = NULL;
static char *arg_image = NULL;
static char **arg_file = NULL;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static int arg_legend = true;
static size_t arg_rows_max = SIZE_MAX;
/* Print out the build-id of the 'main' ELF module, by matching the JSON key
* with the 'exe' field. */
if (exe && pkgmeta_json) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
- r = json_parse(pkgmeta_json, 0, &v, NULL, NULL);
+ r = sd_json_parse(pkgmeta_json, 0, &v, NULL, NULL);
if (r < 0) {
_cleanup_free_ char *esc = cescape(pkgmeta_json);
log_warning_errno(r, "json_parse on \"%s\" failed, ignoring: %m", strnull(esc));
} else {
const char *module_name;
- JsonVariant *module_json;
+ sd_json_variant *module_json;
JSON_VARIANT_OBJECT_FOREACH(module_name, module_json, v) {
- JsonVariant *build_id;
+ sd_json_variant *build_id;
/* We only print the build-id for the 'main' ELF module */
if (!path_equal_filename(module_name, exe))
continue;
- build_id = json_variant_by_key(module_json, "buildId");
+ build_id = sd_json_variant_by_key(module_json, "buildId");
if (build_id)
- fprintf(file, " build-id: %s\n", json_variant_string(build_id));
+ fprintf(file, " build-id: %s\n", sd_json_variant_string(build_id));
break;
}
#include <getopt.h>
#include <unistd.h>
+#include "sd-json.h"
+
#include "build.h"
#include "bus-polkit.h"
#include "creds-util.h"
#include "format-table.h"
#include "hexdecoct.h"
#include "io-util.h"
-#include "json.h"
+#include "json-util.h"
#include "libmount-util.h"
#include "main-func.h"
#include "memory-util.h"
_TRANSCODE_INVALID = -EINVAL,
} TranscodeMode;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static bool arg_legend = true;
static bool arg_system = false;
return log_error_errno(SYNTHETIC_ERRNO(ENXIO), "No credentials passed. (i.e. $CREDENTIALS_DIRECTORY not set.)");
}
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF) && table_isempty(t)) {
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF) && table_isempty(t)) {
log_info("No credentials");
return 0;
}
int r;
if (arg_transcode == TRANSCODE_OFF &&
- arg_json_format_flags != JSON_FORMAT_OFF) {
+ arg_json_format_flags != SD_JSON_FORMAT_OFF) {
_cleanup_(erase_and_freep) char *suffixed = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = make_cstring(data, size, MAKE_CSTRING_REFUSE_TRAILING_NUL, &suffixed);
if (r < 0)
return log_error_errno(r, "Unable to convert binary string to C string: %m");
- r = json_parse(suffixed, JSON_PARSE_SENSITIVE, &v, NULL, NULL);
+ r = sd_json_parse(suffixed, SD_JSON_PARSE_SENSITIVE, &v, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to parse JSON: %m");
- json_variant_dump(v, arg_json_format_flags, f, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, f, NULL);
return 0;
}
return 0;
}
-static int vl_method_encrypt(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_encrypt(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "name", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(MethodEncryptParameters, name), 0 },
- { "text", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(MethodEncryptParameters, text), 0 },
- { "data", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(MethodEncryptParameters, data), 0 },
- { "timestamp", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(MethodEncryptParameters, timestamp), 0 },
- { "notAfter", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(MethodEncryptParameters, not_after), 0 },
- { "scope", JSON_VARIANT_STRING, dispatch_credential_scope, offsetof(MethodEncryptParameters, scope), 0 },
- { "uid", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uid_gid, offsetof(MethodEncryptParameters, uid), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MethodEncryptParameters, name), 0 },
+ { "text", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MethodEncryptParameters, text), 0 },
+ { "data", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(MethodEncryptParameters, data), 0 },
+ { "timestamp", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(MethodEncryptParameters, timestamp), 0 },
+ { "notAfter", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(MethodEncryptParameters, not_after), 0 },
+ { "scope", SD_JSON_VARIANT_STRING, dispatch_credential_scope, offsetof(MethodEncryptParameters, scope), 0 },
+ { "uid", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uid_gid, offsetof(MethodEncryptParameters, uid), 0 },
VARLINK_DISPATCH_POLKIT_FIELD,
{}
};
if (r < 0)
return r;
- _cleanup_(json_variant_unrefp) JsonVariant *reply = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *reply = NULL;
- r = json_build(&reply, JSON_BUILD_OBJECT(JSON_BUILD_PAIR_IOVEC_BASE64("blob", &output)));
+ r = sd_json_build(&reply, SD_JSON_BUILD_OBJECT(JSON_BUILD_PAIR_IOVEC_BASE64("blob", &output)));
if (r < 0)
return r;
/* Let's also mark the (theoretically encrypted) reply as sensitive, in case the NULL encryption scheme was used. */
- json_variant_sensitive(reply);
+ sd_json_variant_sensitive(reply);
return varlink_reply(link, reply);
}
iovec_done_erase(&p->blob);
}
-static int vl_method_decrypt(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_decrypt(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "name", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(MethodDecryptParameters, name), 0 },
- { "blob", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(MethodDecryptParameters, blob), JSON_MANDATORY },
- { "timestamp", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(MethodDecryptParameters, timestamp), 0 },
- { "scope", JSON_VARIANT_STRING, dispatch_credential_scope, offsetof(MethodDecryptParameters, scope), 0 },
- { "uid", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uid_gid, offsetof(MethodDecryptParameters, uid), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MethodDecryptParameters, name), 0 },
+ { "blob", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(MethodDecryptParameters, blob), SD_JSON_MANDATORY },
+ { "timestamp", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(MethodDecryptParameters, timestamp), 0 },
+ { "scope", SD_JSON_VARIANT_STRING, dispatch_credential_scope, offsetof(MethodDecryptParameters, scope), 0 },
+ { "uid", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uid_gid, offsetof(MethodDecryptParameters, uid), 0 },
VARLINK_DISPATCH_POLKIT_FIELD,
{}
};
if (r < 0)
return r;
- _cleanup_(json_variant_unrefp) JsonVariant *reply = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *reply = NULL;
- r = json_build(&reply, JSON_BUILD_OBJECT(JSON_BUILD_PAIR_IOVEC_BASE64("data", &output)));
+ r = sd_json_build(&reply, SD_JSON_BUILD_OBJECT(JSON_BUILD_PAIR_IOVEC_BASE64("data", &output)));
if (r < 0)
return r;
- json_variant_sensitive(reply);
+ sd_json_variant_sensitive(reply);
return varlink_reply(link, reply);
}
#include "cryptenroll-fido2.h"
#include "cryptsetup-fido2.h"
#include "hexdecoct.h"
-#include "json.h"
+#include "json-util.h"
#include "libfido2-util.h"
#include "memory-util.h"
#include "random-util.h"
_cleanup_(erase_and_freep) void *salt = NULL, *secret = NULL;
_cleanup_(erase_and_freep) char *base64_encoded = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *keyslot_as_string = NULL;
size_t cid_size, salt_size, secret_size;
_cleanup_free_ void *cid = NULL;
if (asprintf(&keyslot_as_string, "%i", keyslot) < 0)
return log_oom();
- r = json_build(&v,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-fido2")),
- JSON_BUILD_PAIR("keyslots", JSON_BUILD_ARRAY(JSON_BUILD_STRING(keyslot_as_string))),
- JSON_BUILD_PAIR("fido2-credential", JSON_BUILD_BASE64(cid, cid_size)),
- JSON_BUILD_PAIR("fido2-salt", JSON_BUILD_BASE64(salt, salt_size)),
- JSON_BUILD_PAIR("fido2-rp", JSON_BUILD_CONST_STRING("io.systemd.cryptsetup")),
- JSON_BUILD_PAIR("fido2-clientPin-required", JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_PIN))),
- JSON_BUILD_PAIR("fido2-up-required", JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_UP))),
- JSON_BUILD_PAIR("fido2-uv-required", JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_UV)))));
+ r = sd_json_build(&v,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-fido2")),
+ SD_JSON_BUILD_PAIR("keyslots", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_STRING(keyslot_as_string))),
+ SD_JSON_BUILD_PAIR("fido2-credential", SD_JSON_BUILD_BASE64(cid, cid_size)),
+ SD_JSON_BUILD_PAIR("fido2-salt", SD_JSON_BUILD_BASE64(salt, salt_size)),
+ SD_JSON_BUILD_PAIR("fido2-rp", JSON_BUILD_CONST_STRING("io.systemd.cryptsetup")),
+ SD_JSON_BUILD_PAIR("fido2-clientPin-required", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_PIN))),
+ SD_JSON_BUILD_PAIR("fido2-up-required", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_UP))),
+ SD_JSON_BUILD_PAIR("fido2-uv-required", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_UV)))));
if (r < 0)
return log_error_errno(r, "Failed to prepare FIDO2 JSON token object: %m");
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "cryptenroll-list.h"
#include "cryptenroll.h"
#include "format-table.h"
+#include "json-util.h"
#include "parse-util.h"
struct keyslot_metadata {
/* Second step, enumerate through all tokens, and update the slot table, indicating what kind of
* token they are assigned to */
for (int token = 0; token < sym_crypt_token_max(CRYPT_LUKS2); token++) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
const char *type;
- JsonVariant *w, *z;
+ sd_json_variant *w, *z;
EnrollType et;
r = cryptsetup_get_token_as_json(cd, token, NULL, &v);
continue;
}
- w = json_variant_by_key(v, "type");
- if (!w || !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "type");
+ if (!w || !sd_json_variant_is_string(w)) {
log_warning("Token JSON data lacks type field, ignoring.");
continue;
}
- et = luks2_token_type_from_string(json_variant_string(w));
+ et = luks2_token_type_from_string(sd_json_variant_string(w));
if (et < 0)
type = "other";
else
type = enroll_type_to_string(et);
- w = json_variant_by_key(v, "keyslots");
- if (!w || !json_variant_is_array(w)) {
+ w = sd_json_variant_by_key(v, "keyslots");
+ if (!w || !sd_json_variant_is_array(w)) {
log_warning("Token JSON data lacks keyslots field, ignoring.");
continue;
}
JSON_VARIANT_ARRAY_FOREACH(z, w) {
unsigned u;
- if (!json_variant_is_string(z)) {
+ if (!sd_json_variant_is_string(z)) {
log_warning("Token JSON data's keyslot field is not an array of strings, ignoring.");
continue;
}
- r = safe_atou(json_variant_string(z), &u);
+ r = safe_atou(sd_json_variant_string(z), &u);
if (r < 0) {
log_warning_errno(r, "Token JSON data's keyslot field is not an integer formatted as string, ignoring.");
continue;
#include "cryptenroll-pkcs11.h"
#include "hexdecoct.h"
-#include "json.h"
+#include "json-util.h"
#include "memory-util.h"
#include "openssl-util.h"
#include "pkcs11-util.h"
_cleanup_(erase_and_freep) void *decrypted_key = NULL;
_cleanup_(erase_and_freep) char *base64_encoded = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *keyslot_as_string = NULL, *private_uri = NULL;
size_t decrypted_key_size, saved_key_size;
_cleanup_free_ void *saved_key = NULL;
if (r < 0)
return r;
- r = json_build(&v,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-pkcs11")),
- JSON_BUILD_PAIR("keyslots", JSON_BUILD_ARRAY(JSON_BUILD_STRING(keyslot_as_string))),
- JSON_BUILD_PAIR("pkcs11-uri", JSON_BUILD_STRING(private_uri ?: uri)),
- JSON_BUILD_PAIR("pkcs11-key", JSON_BUILD_BASE64(saved_key, saved_key_size))));
+ r = sd_json_build(&v,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-pkcs11")),
+ SD_JSON_BUILD_PAIR("keyslots", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_STRING(keyslot_as_string))),
+ SD_JSON_BUILD_PAIR("pkcs11-uri", SD_JSON_BUILD_STRING(private_uri ?: uri)),
+ SD_JSON_BUILD_PAIR("pkcs11-key", SD_JSON_BUILD_BASE64(saved_key, saved_key_size))));
if (r < 0)
return log_error_errno(r, "Failed to prepare PKCS#11 JSON token object: %m");
#include "cryptenroll-recovery.h"
#include "glyph-util.h"
-#include "json.h"
+#include "json-util.h"
#include "memory-util.h"
#include "qrcode-util.h"
#include "recovery-key.h"
const void *volume_key,
size_t volume_key_size) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(erase_and_freep) char *password = NULL;
_cleanup_free_ char *keyslot_as_string = NULL;
int keyslot, r, q;
goto rollback;
}
- r = json_build(&v,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-recovery")),
- JSON_BUILD_PAIR("keyslots", JSON_BUILD_ARRAY(JSON_BUILD_STRING(keyslot_as_string)))));
+ r = sd_json_build(&v,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-recovery")),
+ SD_JSON_BUILD_PAIR("keyslots", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_STRING(keyslot_as_string)))));
if (r < 0) {
log_error_errno(r, "Failed to prepare recovery key JSON token object: %m");
goto rollback;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "ask-password-api.h"
#include "cryptenroll-tpm2.h"
#include "errno-util.h"
#include "fileio.h"
#include "hexdecoct.h"
-#include "json.h"
#include "log.h"
#include "memory-util.h"
#include "random-util.h"
return 0;
for (int token = 0; token < sym_crypt_token_max(CRYPT_LUKS2); token++) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ void *thash = NULL;
size_t thash_size = 0;
int keyslot;
- JsonVariant *w;
+ sd_json_variant *w;
r = cryptsetup_get_token_as_json(cd, token, "systemd-tpm2", &v);
if (IN_SET(r, -ENOENT, -EINVAL, -EMEDIUMTYPE))
continue;
}
- w = json_variant_by_key(v, "tpm2-policy-hash");
- if (!w || !json_variant_is_string(w))
+ w = sd_json_variant_by_key(v, "tpm2-policy-hash");
+ if (!w || !sd_json_variant_is_string(w))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"TPM2 token data lacks 'tpm2-policy-hash' field.");
- r = unhexmem(json_variant_string(w), &thash, &thash_size);
+ r = unhexmem(sd_json_variant_string(w), &thash, &thash_size);
if (r < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid base64 data in 'tpm2-policy-hash' field.");
const char *pcrlock_path,
int *ret_slot_to_wipe) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *signature_json = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *signature_json = NULL;
_cleanup_(erase_and_freep) char *base64_encoded = NULL;
_cleanup_(iovec_done) struct iovec srk = {}, blob = {}, pubkey = {};
_cleanup_(iovec_done_erase) struct iovec secret = {};
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "cryptenroll-wipe.h"
#include "cryptenroll.h"
-#include "json.h"
+#include "json-util.h"
#include "memory-util.h"
#include "parse-util.h"
#include "set.h"
/* Find all slots that are associated with a token of a type in the specified token type mask */
for (int token = 0; token < sym_crypt_token_max(CRYPT_LUKS2); token++) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- JsonVariant *w, *z;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+ sd_json_variant *w, *z;
EnrollType t;
r = cryptsetup_get_token_as_json(cd, token, NULL, &v);
continue;
}
- w = json_variant_by_key(v, "type");
- if (!w || !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "type");
+ if (!w || !sd_json_variant_is_string(w)) {
log_warning("Token JSON data lacks type field, ignoring.");
continue;
}
- t = luks2_token_type_from_string(json_variant_string(w));
+ t = luks2_token_type_from_string(sd_json_variant_string(w));
- w = json_variant_by_key(v, "keyslots");
- if (!w || !json_variant_is_array(w)) {
+ w = sd_json_variant_by_key(v, "keyslots");
+ if (!w || !sd_json_variant_is_array(w)) {
log_warning("Token JSON data lacks keyslots field, ignoring.");
continue;
}
JSON_VARIANT_ARRAY_FOREACH(z, w) {
int slot;
- if (!json_variant_is_string(z)) {
+ if (!sd_json_variant_is_string(z)) {
log_warning("Token JSON data's keyslot field is not an array of strings, ignoring.");
continue;
}
- r = safe_atoi(json_variant_string(z), &slot);
+ r = safe_atoi(sd_json_variant_string(z), &slot);
if (r < 0) {
log_warning_errno(r, "Token JSON data's keyslot filed is not an integer formatted as string, ignoring.");
continue;
* the slots sets according to the token data: add any other slots listed in the tokens we act on. */
for (int token = 0; token < sym_crypt_token_max(CRYPT_LUKS2); token++) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
bool shall_wipe = false;
- JsonVariant *w, *z;
+ sd_json_variant *w, *z;
r = cryptsetup_get_token_as_json(cd, token, NULL, &v);
if (IN_SET(r, -ENOENT, -EINVAL))
continue;
}
- w = json_variant_by_key(v, "keyslots");
- if (!w || !json_variant_is_array(w)) {
+ w = sd_json_variant_by_key(v, "keyslots");
+ if (!w || !sd_json_variant_is_array(w)) {
log_warning("Token JSON data lacks keyslots field, ignoring.");
continue;
}
JSON_VARIANT_ARRAY_FOREACH(z, w) {
int slot;
- if (!json_variant_is_string(z)) {
+ if (!sd_json_variant_is_string(z)) {
log_warning("Token JSON data's keyslot field is not an array of strings, ignoring.");
continue;
}
- r = safe_atoi(json_variant_string(z), &slot);
+ r = safe_atoi(sd_json_variant_string(z), &slot);
if (r < 0) {
log_warning_errno(r, "Token JSON data's keyslot filed is not an integer formatted as string, ignoring.");
continue;
JSON_VARIANT_ARRAY_FOREACH(z, w) {
int slot;
- if (!json_variant_is_string(z))
+ if (!sd_json_variant_is_string(z))
continue;
- if (safe_atoi(json_variant_string(z), &slot) < 0)
+ if (safe_atoi(sd_json_variant_string(z), &slot) < 0)
continue;
if (set_put(shall_wipe ? wipe_slots : keep_slots, INT_TO_PTR(slot)) < 0)
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
-
#include <p11-kit/p11-kit.h>
#include <p11-kit/uri.h>
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "ask-password-api.h"
#include "cryptsetup-pkcs11.h"
#include "fileio.h"
#include "format-util.h"
#include "hexdecoct.h"
-#include "json.h"
#include "macro.h"
#include "memory-util.h"
#include "parse-util.h"
/* Loads PKCS#11 metadata from LUKS2 JSON token headers. */
for (int token = 0; token < sym_crypt_token_max(CRYPT_LUKS2); token++) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- JsonVariant *w;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+ sd_json_variant *w;
int ks;
r = cryptsetup_get_token_as_json(cd, token, "systemd-pkcs11", &v);
assert(keyslot < 0);
keyslot = ks;
- w = json_variant_by_key(v, "pkcs11-uri");
- if (!w || !json_variant_is_string(w))
+ w = sd_json_variant_by_key(v, "pkcs11-uri");
+ if (!w || !sd_json_variant_is_string(w))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"PKCS#11 token data lacks 'pkcs11-uri' field.");
- uri = strdup(json_variant_string(w));
+ uri = strdup(sd_json_variant_string(w));
if (!uri)
return log_oom();
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"PKCS#11 token data contains invalid PKCS#11 URI.");
- w = json_variant_by_key(v, "pkcs11-key");
- if (!w || !json_variant_is_string(w))
+ w = sd_json_variant_by_key(v, "pkcs11-key");
+ if (!w || !sd_json_variant_is_string(w))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"PKCS#11 token data lacks 'pkcs11-key' field.");
assert(!key);
assert(key_size == 0);
- r = unbase64mem(json_variant_string(w), &key, &key_size);
+ r = unbase64mem(sd_json_variant_string(w), &key, &key_size);
if (r < 0)
return log_error_errno(r, "Failed to decode base64 encoded key.");
}
#include "cryptsetup-token.h"
#include "cryptsetup-token-util.h"
#include "hexdecoct.h"
-#include "json.h"
+#include "json-util.h"
#include "luks2-fido2.h"
#include "memory-util.h"
#include "version.h"
const char *json /* contains valid 'type' and 'keyslots' fields. 'type' is 'systemd-fido2' */) {
int r;
- JsonVariant *w;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ sd_json_variant *w;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
assert(json);
- r = json_parse(json, 0, &v, NULL, NULL);
+ r = sd_json_parse(json, 0, &v, NULL, NULL);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Could not parse " TOKEN_NAME " json object: %m.");
- w = json_variant_by_key(v, "fido2-credential");
- if (!w || !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "fido2-credential");
+ if (!w || !sd_json_variant_is_string(w)) {
crypt_log_debug(cd, "FIDO2 token data lacks 'fido2-credential' field.");
return 1;
}
- r = unbase64mem(json_variant_string(w), NULL, NULL);
+ r = unbase64mem(sd_json_variant_string(w), NULL, NULL);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Invalid base64 data in 'fido2-credential' field: %m");
- w = json_variant_by_key(v, "fido2-salt");
- if (!w || !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "fido2-salt");
+ if (!w || !sd_json_variant_is_string(w)) {
crypt_log_debug(cd, "FIDO2 token data lacks 'fido2-salt' field.");
return 1;
}
- r = unbase64mem(json_variant_string(w), NULL, NULL);
+ r = unbase64mem(sd_json_variant_string(w), NULL, NULL);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Failed to decode base64 encoded salt: %m.");
/* The "rp" field is optional. */
- w = json_variant_by_key(v, "fido2-rp");
- if (w && !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "fido2-rp");
+ if (w && !sd_json_variant_is_string(w)) {
crypt_log_debug(cd, "FIDO2 token data's 'fido2-rp' field is not a string.");
return 1;
}
/* The "fido2-clientPin-required" field is optional. */
- w = json_variant_by_key(v, "fido2-clientPin-required");
- if (w && !json_variant_is_boolean(w)) {
+ w = sd_json_variant_by_key(v, "fido2-clientPin-required");
+ if (w && !sd_json_variant_is_boolean(w)) {
crypt_log_debug(cd, "FIDO2 token data's 'fido2-clientPin-required' field is not a boolean.");
return 1;
}
/* The "fido2-up-required" field is optional. */
- w = json_variant_by_key(v, "fido2-up-required");
- if (w && !json_variant_is_boolean(w)) {
+ w = sd_json_variant_by_key(v, "fido2-up-required");
+ if (w && !sd_json_variant_is_boolean(w)) {
crypt_log_debug(cd, "FIDO2 token data's 'fido2-up-required' field is not a boolean.");
return 1;
}
/* The "fido2-uv-required" field is optional. */
- w = json_variant_by_key(v, "fido2-uv-required");
- if (w && !json_variant_is_boolean(w)) {
+ w = sd_json_variant_by_key(v, "fido2-uv-required");
+ if (w && !sd_json_variant_is_boolean(w)) {
crypt_log_debug(cd, "FIDO2 token data's 'fido2-uv-required' field is not a boolean.");
return 1;
}
#include <errno.h>
#include <libcryptsetup.h>
+#include "sd-json.h"
+
#include "cryptsetup-token.h"
#include "cryptsetup-token-util.h"
#include "hexdecoct.h"
-#include "json.h"
#include "luks2-pkcs11.h"
#include "memory-util.h"
#include "pkcs11-util.h"
const char *json /* contains valid 'type' and 'keyslots' fields. 'type' is 'systemd-pkcs11' */) {
int r;
- JsonVariant *w;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ sd_json_variant *w;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
- r = json_parse(json, 0, &v, NULL, NULL);
+ r = sd_json_parse(json, 0, &v, NULL, NULL);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Could not parse " TOKEN_NAME " json object: %m.");
- w = json_variant_by_key(v, "pkcs11-uri");
- if (!w || !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "pkcs11-uri");
+ if (!w || !sd_json_variant_is_string(w)) {
crypt_log_debug(cd, "PKCS#11 token data lacks 'pkcs11-uri' field.");
return 1;
}
- if (!pkcs11_uri_valid(json_variant_string(w))) {
+ if (!pkcs11_uri_valid(sd_json_variant_string(w))) {
crypt_log_debug(cd, "PKCS#11 token data contains invalid PKCS#11 URI.");
return 1;
}
- w = json_variant_by_key(v, "pkcs11-key");
- if (!w || !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "pkcs11-key");
+ if (!w || !sd_json_variant_is_string(w)) {
crypt_log_debug(cd, "PKCS#11 token data lacks 'pkcs11-key' field.");
return 1;
}
- r = unbase64mem(json_variant_string(w), NULL, NULL);
+ r = unbase64mem(sd_json_variant_string(w), NULL, NULL);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Failed to decode base64 encoded key: %m.");
#include "cryptsetup-token.h"
#include "cryptsetup-token-util.h"
#include "hexdecoct.h"
-#include "json.h"
+#include "json-util.h"
#include "luks2-tpm2.h"
#include "memory-util.h"
#include "strv.h"
_cleanup_(erase_and_freep) char *base64_encoded = NULL, *pin_string = NULL;
_cleanup_(iovec_done) struct iovec blob = {}, pubkey = {}, policy_hash = {}, salt = {}, srk = {}, pcrlock_nv = {};
_cleanup_(iovec_done_erase) struct iovec decrypted_key = {};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
uint32_t hash_pcr_mask, pubkey_pcr_mask;
systemd_tpm2_plugin_params params = {
.search_pcr_mask = UINT32_MAX
if (usrptr)
params = *(systemd_tpm2_plugin_params *)usrptr;
- r = json_parse(json, 0, &v, NULL, NULL);
+ r = sd_json_parse(json, 0, &v, NULL, NULL);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Failed to parse token JSON data: %m");
_cleanup_free_ char *hash_pcrs_str = NULL, *pubkey_pcrs_str = NULL, *blob_str = NULL, *policy_hash_str = NULL, *pubkey_str = NULL;
_cleanup_(iovec_done) struct iovec blob = {}, pubkey = {}, policy_hash = {}, salt = {}, srk = {}, pcrlock_nv = {};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
uint32_t hash_pcr_mask, pubkey_pcr_mask;
uint16_t pcr_bank, primary_alg;
TPM2Flags flags = 0;
assert(json);
- r = json_parse(json, 0, &v, NULL, NULL);
+ r = sd_json_parse(json, 0, &v, NULL, NULL);
if (r < 0)
return (void) crypt_log_debug_errno(cd, r, "Failed to parse " TOKEN_NAME " JSON object: %m");
const char *json /* contains valid 'type' and 'keyslots' fields. 'type' is 'systemd-tpm2' */) {
int r;
- JsonVariant *w, *e;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ sd_json_variant *w, *e;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
assert(json);
- r = json_parse(json, 0, &v, NULL, NULL);
+ r = sd_json_parse(json, 0, &v, NULL, NULL);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Could not parse " TOKEN_NAME " json object: %m");
- w = json_variant_by_key(v, "tpm2-pcrs");
- if (!w || !json_variant_is_array(w)) {
+ w = sd_json_variant_by_key(v, "tpm2-pcrs");
+ if (!w || !sd_json_variant_is_array(w)) {
crypt_log_debug(cd, "TPM2 token data lacks 'tpm2-pcrs' field.");
return 1;
}
JSON_VARIANT_ARRAY_FOREACH(e, w) {
uint64_t u;
- if (!json_variant_is_number(e)) {
+ if (!sd_json_variant_is_number(e)) {
crypt_log_debug(cd, "TPM2 PCR is not a number.");
return 1;
}
- u = json_variant_unsigned(e);
+ u = sd_json_variant_unsigned(e);
if (!TPM2_PCR_INDEX_VALID(u)) {
crypt_log_debug(cd, "TPM2 PCR number out of range.");
return 1;
/* The bank field is optional, since it was added in systemd 250 only. Before the bank was hardcoded
* to SHA256. */
- w = json_variant_by_key(v, "tpm2-pcr-bank");
+ w = sd_json_variant_by_key(v, "tpm2-pcr-bank");
if (w) {
/* The PCR bank field is optional */
- if (!json_variant_is_string(w)) {
+ if (!sd_json_variant_is_string(w)) {
crypt_log_debug(cd, "TPM2 PCR bank is not a string.");
return 1;
}
- if (tpm2_hash_alg_from_string(json_variant_string(w)) < 0) {
- crypt_log_debug(cd, "TPM2 PCR bank invalid or not supported: %s.", json_variant_string(w));
+ if (tpm2_hash_alg_from_string(sd_json_variant_string(w)) < 0) {
+ crypt_log_debug(cd, "TPM2 PCR bank invalid or not supported: %s.", sd_json_variant_string(w));
return 1;
}
}
/* The primary key algorithm field is optional, since it was also added in systemd 250 only. Before
* the algorithm was hardcoded to ECC. */
- w = json_variant_by_key(v, "tpm2-primary-alg");
+ w = sd_json_variant_by_key(v, "tpm2-primary-alg");
if (w) {
/* The primary key algorithm is optional */
- if (!json_variant_is_string(w)) {
+ if (!sd_json_variant_is_string(w)) {
crypt_log_debug(cd, "TPM2 primary key algorithm is not a string.");
return 1;
}
- if (tpm2_asym_alg_from_string(json_variant_string(w)) < 0) {
- crypt_log_debug(cd, "TPM2 primary key algorithm invalid or not supported: %s", json_variant_string(w));
+ if (tpm2_asym_alg_from_string(sd_json_variant_string(w)) < 0) {
+ crypt_log_debug(cd, "TPM2 primary key algorithm invalid or not supported: %s", sd_json_variant_string(w));
return 1;
}
}
- w = json_variant_by_key(v, "tpm2-blob");
- if (!w || !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "tpm2-blob");
+ if (!w || !sd_json_variant_is_string(w)) {
crypt_log_debug(cd, "TPM2 token data lacks 'tpm2-blob' field.");
return 1;
}
- r = unbase64mem(json_variant_string(w), NULL, NULL);
+ r = unbase64mem(sd_json_variant_string(w), NULL, NULL);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Invalid base64 data in 'tpm2-blob' field: %m");
- w = json_variant_by_key(v, "tpm2-policy-hash");
- if (!w || !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "tpm2-policy-hash");
+ if (!w || !sd_json_variant_is_string(w)) {
crypt_log_debug(cd, "TPM2 token data lacks 'tpm2-policy-hash' field.");
return 1;
}
- r = unhexmem(json_variant_string(w), NULL, NULL);
+ r = unhexmem(sd_json_variant_string(w), NULL, NULL);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Invalid base64 data in 'tpm2-policy-hash' field: %m");
- w = json_variant_by_key(v, "tpm2-pin");
+ w = sd_json_variant_by_key(v, "tpm2-pin");
if (w) {
- if (!json_variant_is_boolean(w)) {
+ if (!sd_json_variant_is_boolean(w)) {
crypt_log_debug(cd, "TPM2 PIN policy is not a boolean.");
return 1;
}
#include "cryptsetup-token-util.h"
#include "hexdecoct.h"
-#include "json.h"
+#include "json-util.h"
#include "luks2-fido2.h"
#include "memory-util.h"
#include "strv.h"
size_t cid_size = 0, salt_size = 0;
_cleanup_free_ char *rp = NULL;
int r;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- JsonVariant *w;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+ sd_json_variant *w;
Fido2EnrollFlags required = 0;
assert(json);
assert(ret_cid_size);
assert(ret_required);
- r = json_parse(json, 0, &v, NULL, NULL);
+ r = sd_json_parse(json, 0, &v, NULL, NULL);
if (r < 0)
return crypt_log_error_errno(cd, r, "Failed to parse JSON token data: %m");
- w = json_variant_by_key(v, "fido2-credential");
+ w = sd_json_variant_by_key(v, "fido2-credential");
if (!w)
return -EINVAL;
- r = unbase64mem(json_variant_string(w), &cid, &cid_size);
+ r = unbase64mem(sd_json_variant_string(w), &cid, &cid_size);
if (r < 0)
return crypt_log_error_errno(cd, r, "Failed to parse 'fido2-credentials' field: %m");
- w = json_variant_by_key(v, "fido2-salt");
+ w = sd_json_variant_by_key(v, "fido2-salt");
if (!w)
return -EINVAL;
- r = unbase64mem(json_variant_string(w), &salt, &salt_size);
+ r = unbase64mem(sd_json_variant_string(w), &salt, &salt_size);
if (r < 0)
return crypt_log_error_errno(cd, r, "Failed to parse 'fido2-salt' field: %m");
- w = json_variant_by_key(v, "fido2-rp");
+ w = sd_json_variant_by_key(v, "fido2-rp");
if (w) {
/* The "rp" field is optional. */
- rp = strdup(json_variant_string(w));
+ rp = strdup(sd_json_variant_string(w));
if (!rp) {
crypt_log_error(cd, "Not enough memory.");
return -ENOMEM;
}
}
- w = json_variant_by_key(v, "fido2-clientPin-required");
+ w = sd_json_variant_by_key(v, "fido2-clientPin-required");
if (w)
/* The "fido2-clientPin-required" field is optional. */
- SET_FLAG(required, FIDO2ENROLL_PIN, json_variant_boolean(w));
+ SET_FLAG(required, FIDO2ENROLL_PIN, sd_json_variant_boolean(w));
else
required |= FIDO2ENROLL_PIN_IF_NEEDED; /* compat with 248, where the field was unset */
- w = json_variant_by_key(v, "fido2-up-required");
+ w = sd_json_variant_by_key(v, "fido2-up-required");
if (w)
/* The "fido2-up-required" field is optional. */
- SET_FLAG(required, FIDO2ENROLL_UP, json_variant_boolean(w));
+ SET_FLAG(required, FIDO2ENROLL_UP, sd_json_variant_boolean(w));
else
required |= FIDO2ENROLL_UP_IF_NEEDED; /* compat with 248 */
- w = json_variant_by_key(v, "fido2-uv-required");
+ w = sd_json_variant_by_key(v, "fido2-uv-required");
if (w)
/* The "fido2-uv-required" field is optional. */
- SET_FLAG(required, FIDO2ENROLL_UV, json_variant_boolean(w));
+ SET_FLAG(required, FIDO2ENROLL_UV, sd_json_variant_boolean(w));
else
required |= FIDO2ENROLL_UV_OMIT; /* compat with 248 */
#include <p11-kit/p11-kit.h>
#include <p11-kit/uri.h>
+#include "sd-json.h"
+
#include "cryptsetup-token-util.h"
#include "escape.h"
#include "hexdecoct.h"
-#include "json.h"
#include "luks2-pkcs11.h"
#include "memory-util.h"
#include "pkcs11-util.h"
size_t key_size;
_cleanup_free_ char *uri = NULL;
_cleanup_free_ void *key = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- JsonVariant *w;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+ sd_json_variant *w;
assert(json);
assert(ret_uri);
assert(ret_encrypted_key);
assert(ret_encrypted_key_size);
- r = json_parse(json, 0, &v, NULL, NULL);
+ r = sd_json_parse(json, 0, &v, NULL, NULL);
if (r < 0)
return r;
- w = json_variant_by_key(v, "pkcs11-uri");
+ w = sd_json_variant_by_key(v, "pkcs11-uri");
if (!w)
return -EINVAL;
- uri = strdup(json_variant_string(w));
+ uri = strdup(sd_json_variant_string(w));
if (!uri)
return -ENOMEM;
- w = json_variant_by_key(v, "pkcs11-key");
+ w = sd_json_variant_by_key(v, "pkcs11-key");
if (!w)
return -EINVAL;
- r = unbase64mem(json_variant_string(w), &key, &key_size);
+ r = unbase64mem(sd_json_variant_string(w), &key, &key_size);
if (r < 0)
return crypt_log_debug_errno(cd, r, "Failed to decode base64 encoded key: %m.");
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "ask-password-api.h"
#include "env-util.h"
#include "hexdecoct.h"
-#include "json.h"
#include "log.h"
#include "luks2-tpm2.h"
#include "parse-util.h"
TPM2Flags flags,
struct iovec *ret_decrypted_key) {
- _cleanup_(json_variant_unrefp) JsonVariant *signature_json = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *signature_json = NULL;
_cleanup_free_ char *auto_device = NULL;
_cleanup_(erase_and_freep) char *b64_salted_pin = NULL;
int r;
#include <unistd.h>
#include "sd-device.h"
+#include "sd-json.h"
#include "sd-messages.h"
#include "alloc-util.h"
#include "fs-util.h"
#include "fstab-util.h"
#include "hexdecoct.h"
+#include "json-util.h"
#include "libfido2-util.h"
#include "log.h"
#include "main-func.h"
/* Iterate all LUKS2 tokens and keep track of all their slots */
for (int token = 0; token < sym_crypt_token_max(CRYPT_LUKS2); token++) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
const char *type;
- JsonVariant *w, *z;
+ sd_json_variant *w, *z;
int tk;
tk = cryptsetup_get_token_as_json(cd, token, NULL, &v);
continue;
}
- w = json_variant_by_key(v, "type");
- if (!w || !json_variant_is_string(w)) {
+ w = sd_json_variant_by_key(v, "type");
+ if (!w || !sd_json_variant_is_string(w)) {
log_warning("Token JSON data lacks type field, ignoring.");
continue;
}
- type = json_variant_string(w);
+ type = sd_json_variant_string(w);
if (STR_IN_SET(type, "systemd-recovery", "systemd-pkcs11", "systemd-fido2", "systemd-tpm2")) {
/* At least exists one recovery key */
if (streq(type, "systemd-recovery"))
passphrase_type |= PASSPHRASE_RECOVERY_KEY;
- w = json_variant_by_key(v, "keyslots");
- if (!w || !json_variant_is_array(w)) {
+ w = sd_json_variant_by_key(v, "keyslots");
+ if (!w || !sd_json_variant_is_array(w)) {
log_warning("Token JSON data lacks keyslots field, ignoring.");
continue;
}
unsigned u;
int at;
- if (!json_variant_is_string(z)) {
+ if (!sd_json_variant_is_string(z)) {
log_warning("Token JSON data's keyslot field is not an array of strings, ignoring.");
continue;
}
- at = safe_atou(json_variant_string(z), &u);
+ at = safe_atou(sd_json_variant_string(z), &u);
if (at < 0) {
log_warning_errno(at, "Token JSON data's keyslot field is not an integer formatted as string, ignoring.");
continue;
#include "format-util.h"
#include "fs-util.h"
#include "hexdecoct.h"
+#include "json-util.h"
#include "libarchive-util.h"
#include "log.h"
#include "loop-util.h"
DISSECT_IMAGE_ADD_PARTITION_DEVICES |
DISSECT_IMAGE_ALLOW_USERSPACE_VERITY;
static VeritySettings arg_verity_settings = VERITY_SETTINGS_DEFAULT;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static bool arg_legend = true;
static bool arg_rmdir = false;
LoopDevice *d,
int userns_fd) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(table_unrefp) Table *t = NULL;
_cleanup_free_ char *bn = NULL;
uint64_t size = UINT64_MAX;
if (r < 0)
return log_error_errno(r, "Failed to extract file name from image path '%s': %m", arg_image);
- if (arg_json_format_flags & (JSON_FORMAT_OFF|JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ if (arg_json_format_flags & (SD_JSON_FORMAT_OFF|SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
pager_open(arg_pager_flags);
- if (arg_json_format_flags & JSON_FORMAT_OFF) {
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF) {
printf(" File Name: %s%s%s\n",
ansi_highlight(), bn, ansi_normal());
log_warning_errno(r, "OS image is currently in use, proceeding without showing OS image metadata.");
else if (r < 0)
return log_error_errno(r, "Failed to acquire image metadata: %m");
- else if (arg_json_format_flags & JSON_FORMAT_OFF) {
+ else if (arg_json_format_flags & SD_JSON_FORMAT_OFF) {
if (m->image_name && !streq(m->image_name, bn))
printf("Image Name: %s\n", m->image_name);
Architecture a = dissected_image_architecture(m);
- r = json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(bn)),
- JSON_BUILD_PAIR_CONDITION(size != UINT64_MAX, "size", JSON_BUILD_INTEGER(size)),
- JSON_BUILD_PAIR("sectorSize", JSON_BUILD_INTEGER(m->sector_size)),
- JSON_BUILD_PAIR_CONDITION(a >= 0, "architecture", JSON_BUILD_STRING(architecture_to_string(a))),
- JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(m->image_uuid), "imageUuid", JSON_BUILD_UUID(m->image_uuid)),
- JSON_BUILD_PAIR_CONDITION(m->hostname, "hostname", JSON_BUILD_STRING(m->hostname)),
- JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(m->machine_id), "machineId", JSON_BUILD_ID128(m->machine_id)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->machine_info), "machineInfo", JSON_BUILD_STRV_ENV_PAIR(m->machine_info)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->os_release), "osRelease", JSON_BUILD_STRV_ENV_PAIR(m->os_release)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->initrd_release), "initrdRelease", JSON_BUILD_STRV_ENV_PAIR(m->initrd_release)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->sysext_release), "sysextRelease", JSON_BUILD_STRV_ENV_PAIR(m->sysext_release)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->confext_release), "confextRelease", JSON_BUILD_STRV_ENV_PAIR(m->confext_release)),
- JSON_BUILD_PAIR("useBootableUefi", JSON_BUILD_BOOLEAN(dissected_image_is_bootable_uefi(m))),
- JSON_BUILD_PAIR("useBootableContainer", JSON_BUILD_BOOLEAN(dissected_image_is_bootable_os(m))),
- JSON_BUILD_PAIR("useInitrd", JSON_BUILD_BOOLEAN(dissected_image_is_initrd(m))),
- JSON_BUILD_PAIR("usePortableService", JSON_BUILD_BOOLEAN(dissected_image_is_portable(m))),
- JSON_BUILD_PAIR("useSystemExtension", JSON_BUILD_BOOLEAN(strv_contains(sysext_scopes, "system"))),
- JSON_BUILD_PAIR("useInitRDSystemExtension", JSON_BUILD_BOOLEAN(strv_contains(sysext_scopes, "initrd"))),
- JSON_BUILD_PAIR("usePortableSystemExtension", JSON_BUILD_BOOLEAN(strv_contains(sysext_scopes, "portable"))),
- JSON_BUILD_PAIR("useConfigurationExtension", JSON_BUILD_BOOLEAN(strv_contains(confext_scopes, "system"))),
- JSON_BUILD_PAIR("useInitRDConfigurationExtension", JSON_BUILD_BOOLEAN(strv_contains(confext_scopes, "initrd"))),
- JSON_BUILD_PAIR("usePortableConfigurationExtension", JSON_BUILD_BOOLEAN(strv_contains(confext_scopes, "portable")))));
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(bn)),
+ SD_JSON_BUILD_PAIR_CONDITION(size != UINT64_MAX, "size", SD_JSON_BUILD_INTEGER(size)),
+ SD_JSON_BUILD_PAIR("sectorSize", SD_JSON_BUILD_INTEGER(m->sector_size)),
+ SD_JSON_BUILD_PAIR_CONDITION(a >= 0, "architecture", SD_JSON_BUILD_STRING(architecture_to_string(a))),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(m->image_uuid), "imageUuid", SD_JSON_BUILD_UUID(m->image_uuid)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!m->hostname, "hostname", SD_JSON_BUILD_STRING(m->hostname)),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(m->machine_id), "machineId", SD_JSON_BUILD_ID128(m->machine_id)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->machine_info), "machineInfo", JSON_BUILD_STRV_ENV_PAIR(m->machine_info)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->os_release), "osRelease", JSON_BUILD_STRV_ENV_PAIR(m->os_release)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->initrd_release), "initrdRelease", JSON_BUILD_STRV_ENV_PAIR(m->initrd_release)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->sysext_release), "sysextRelease", JSON_BUILD_STRV_ENV_PAIR(m->sysext_release)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(m->confext_release), "confextRelease", JSON_BUILD_STRV_ENV_PAIR(m->confext_release)),
+ SD_JSON_BUILD_PAIR("useBootableUefi", SD_JSON_BUILD_BOOLEAN(dissected_image_is_bootable_uefi(m))),
+ SD_JSON_BUILD_PAIR("useBootableContainer", SD_JSON_BUILD_BOOLEAN(dissected_image_is_bootable_os(m))),
+ SD_JSON_BUILD_PAIR("useInitrd", SD_JSON_BUILD_BOOLEAN(dissected_image_is_initrd(m))),
+ SD_JSON_BUILD_PAIR("usePortableService", SD_JSON_BUILD_BOOLEAN(dissected_image_is_portable(m))),
+ SD_JSON_BUILD_PAIR("useSystemExtension", SD_JSON_BUILD_BOOLEAN(strv_contains(sysext_scopes, "system"))),
+ SD_JSON_BUILD_PAIR("useInitRDSystemExtension", SD_JSON_BUILD_BOOLEAN(strv_contains(sysext_scopes, "initrd"))),
+ SD_JSON_BUILD_PAIR("usePortableSystemExtension", SD_JSON_BUILD_BOOLEAN(strv_contains(sysext_scopes, "portable"))),
+ SD_JSON_BUILD_PAIR("useConfigurationExtension", SD_JSON_BUILD_BOOLEAN(strv_contains(confext_scopes, "system"))),
+ SD_JSON_BUILD_PAIR("useInitRDConfigurationExtension", SD_JSON_BUILD_BOOLEAN(strv_contains(confext_scopes, "initrd"))),
+ SD_JSON_BUILD_PAIR("usePortableConfigurationExtension", SD_JSON_BUILD_BOOLEAN(strv_contains(confext_scopes, "portable")))));
if (r < 0)
return log_oom();
}
/* Hide the device path if this is a loopback device that is not relinquished, since that means the
* device node is not going to be useful the instant our command exits */
- if ((!d || d->created) && (arg_json_format_flags & JSON_FORMAT_OFF))
+ if ((!d || d->created) && (arg_json_format_flags & SD_JSON_FORMAT_OFF))
table_hide_column_from_display(t, 8);
for (PartitionDesignator i = 0; i < _PARTITION_DESIGNATOR_MAX; i++) {
return table_log_add_error(r);
}
- if (arg_json_format_flags & JSON_FORMAT_OFF) {
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF) {
(void) table_set_header(t, arg_legend);
r = table_print(t, NULL);
if (r < 0)
return table_log_print_error(r);
} else {
- _cleanup_(json_variant_unrefp) JsonVariant *jt = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *jt = NULL;
r = table_to_json(t, &jt);
if (r < 0)
return log_error_errno(r, "Failed to convert table to JSON: %m");
- r = json_variant_set_field(&v, "mounts", jt);
+ r = sd_json_variant_set_field(&v, "mounts", jt);
if (r < 0)
return log_oom();
- json_variant_dump(v, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, stdout, NULL);
}
return 0;
return log_error_errno(r, "Failed to discover images: %m");
}
- if ((arg_json_format_flags & JSON_FORMAT_OFF) && hashmap_isempty(images)) {
+ if ((arg_json_format_flags & SD_JSON_FORMAT_OFF) && hashmap_isempty(images)) {
log_info("No images found.");
return 0;
}
#include <string.h>
+#include "sd-json.h"
+
#include "bootspec.h"
#include "env-util.h"
#include "escape.h"
-#include "fuzz.h"
#include "fd-util.h"
-#include "json.h"
+#include "fuzz.h"
+#include "json-util.h"
+#include "strv.h"
-static int json_dispatch_config(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_config(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
BootConfig *config = ASSERT_PTR(userdata);
- const char *s = json_variant_string(variant);
+ const char *s = sd_json_variant_string(variant);
if (!s)
return -EINVAL;
return 0;
}
-static int json_dispatch_entries(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_entries(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
BootConfig *config = ASSERT_PTR(userdata);
- JsonVariant *entry;
+ sd_json_variant *entry;
JSON_VARIANT_ARRAY_FOREACH(entry, variant) {
- if (!json_variant_is_array(entry) ||
- json_variant_elements(entry) < 1)
+ if (!sd_json_variant_is_array(entry) ||
+ sd_json_variant_elements(entry) < 1)
return -EINVAL;
- JsonVariant *v;
+ sd_json_variant *v;
const char *id = NULL, *raw = NULL;
_cleanup_free_ char *data = NULL;
ssize_t len = -ENODATA;
- v = json_variant_by_index(entry, 0);
+ v = sd_json_variant_by_index(entry, 0);
if (v)
- id = json_variant_string(v);
+ id = sd_json_variant_string(v);
if (!id)
continue;
- v = json_variant_by_index(entry, 1);
+ v = sd_json_variant_by_index(entry, 1);
if (v)
- raw = json_variant_string(v);
+ raw = sd_json_variant_string(v);
if (raw)
len = cunescape(raw, UNESCAPE_RELAX | UNESCAPE_ACCEPT_NUL, &data);
if (len >= 0) {
return 0;
}
-static int json_dispatch_loader(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_loader(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
BootConfig *config = ASSERT_PTR(userdata);
_cleanup_strv_free_ char **entries = NULL;
int r;
- r = json_dispatch_strv(name, variant, flags, &entries);
+ r = sd_json_dispatch_strv(name, variant, flags, &entries);
if (r < 0)
return r;
return 0;
}
-static const JsonDispatch data_dispatch[] = {
- { "config", JSON_VARIANT_STRING, json_dispatch_config, 0, 0 },
- { "entries", JSON_VARIANT_ARRAY, json_dispatch_entries, 0, 0 },
- { "loader", JSON_VARIANT_ARRAY, json_dispatch_loader, 0, 0 },
+static const sd_json_dispatch_field data_dispatch[] = {
+ { "config", SD_JSON_VARIANT_STRING, json_dispatch_config, 0, 0 },
+ { "entries", SD_JSON_VARIANT_ARRAY, json_dispatch_entries, 0, 0 },
+ { "loader", SD_JSON_VARIANT_ARRAY, json_dispatch_loader, 0, 0 },
{}
};
assert_se(datadup = memdup_suffix0(data, size));
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- r = json_parse(datadup, 0, &v, NULL, NULL);
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+ r = sd_json_parse(datadup, 0, &v, NULL, NULL);
if (r < 0)
return 0;
- r = json_dispatch(v, data_dispatch, 0, &config);
+ r = sd_json_dispatch(v, data_dispatch, 0, &config);
if (r < 0)
return 0;
assert_se(freopen("/dev/null", "w", stdout));
}
- (void) show_boot_entries(&config, JSON_FORMAT_OFF);
- (void) show_boot_entries(&config, JSON_FORMAT_PRETTY);
+ (void) show_boot_entries(&config, SD_JSON_FORMAT_OFF);
+ (void) show_boot_entries(&config, SD_JSON_FORMAT_PRETTY);
if (orig_stdout_fd >= 0)
assert_se(freopen(FORMAT_PROC_FD_PATH(orig_stdout_fd), "w", stdout));
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "env-util.h"
#include "fd-util.h"
#include "fuzz.h"
-#include "json.h"
#include "memstream-util.h"
+#include "string-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(memstream_done) MemStream m = {};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_fclose_ FILE *f = NULL;
FILE *g = NULL;
int r;
f = data_to_file(data, size);
assert_se(f);
- r = json_parse_file(f, NULL, 0, &v, NULL, NULL);
+ r = sd_json_parse_file(f, NULL, 0, &v, NULL, NULL);
if (r < 0) {
log_debug_errno(r, "failed to parse input: %m");
return 0;
if (getenv_bool("SYSTEMD_FUZZ_OUTPUT") <= 0)
assert_se(g = memstream_init(&m));
- json_variant_dump(v, 0, g ?: stdout, NULL);
- json_variant_dump(v, JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR|JSON_FORMAT_SOURCE, g ?: stdout, NULL);
+ sd_json_variant_dump(v, 0, g ?: stdout, NULL);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_SOURCE, g ?: stdout, NULL);
- bool sorted = json_variant_is_sorted(v);
- log_debug("json_variant_is_sorted: %s", yes_no(sorted));
+ bool sorted = sd_json_variant_is_sorted(v);
+ log_debug("sd_json_variant_is_sorted: %s", yes_no(sorted));
- r = json_variant_sort(&v);
- log_debug_errno(r, "json_variant_sort: %d/%m", r);
+ r = sd_json_variant_sort(&v);
+ log_debug_errno(r, "sd_json_variant_sort: %d/%m", r);
- sorted = json_variant_is_sorted(v);
+ sorted = sd_json_variant_is_sorted(v);
log_debug("json_variant_is_sorted: %s", yes_no(sorted));
assert_se(r < 0 || sorted);
- bool normalized = json_variant_is_normalized(v);
+ bool normalized = sd_json_variant_is_normalized(v);
log_debug("json_variant_is_normalized: %s", yes_no(normalized));
- r = json_variant_normalize(&v);
+ r = sd_json_variant_normalize(&v);
log_debug_errno(r, "json_variant_normalize: %d/%m", r);
- normalized = json_variant_is_normalized(v);
+ normalized = sd_json_variant_is_normalized(v);
log_debug("json_variant_is_normalized: %s", yes_no(normalized));
assert_se(r < 0 || normalized);
- double real = json_variant_real(v);
+ double real = sd_json_variant_real(v);
log_debug("json_variant_real: %lf", real);
- bool negative = json_variant_is_negative(v);
+ bool negative = sd_json_variant_is_negative(v);
log_debug("json_variant_is_negative: %s", yes_no(negative));
- bool blank = json_variant_is_blank_object(v);
+ bool blank = sd_json_variant_is_blank_object(v);
log_debug("json_variant_is_blank_object: %s", yes_no(blank));
- blank = json_variant_is_blank_array(v);
+ blank = sd_json_variant_is_blank_array(v);
log_debug("json_variant_is_blank_array: %s", yes_no(blank));
- size_t elements = json_variant_elements(v);
+ size_t elements = sd_json_variant_elements(v);
log_debug("json_variant_elements: %zu", elements);
for (size_t i = 0; i <= elements + 2; i++)
- (void) json_variant_by_index(v, i);
+ (void) sd_json_variant_by_index(v, i);
- assert_se(json_variant_equal(v, v));
- assert_se(!json_variant_equal(v, NULL));
- assert_se(!json_variant_equal(NULL, v));
+ assert_se(sd_json_variant_equal(v, v));
+ assert_se(!sd_json_variant_equal(v, NULL));
+ assert_se(!sd_json_variant_equal(NULL, v));
- bool sensitive = json_variant_is_sensitive(v);
+ bool sensitive = sd_json_variant_is_sensitive(v);
log_debug("json_variant_is_sensitive: %s", yes_no(sensitive));
- json_variant_sensitive(v);
+ sd_json_variant_sensitive(v);
- sensitive = json_variant_is_sensitive(v);
+ sensitive = sd_json_variant_is_sensitive(v);
log_debug("json_variant_is_sensitive: %s", yes_no(sensitive));
const char *source;
unsigned line, column;
- assert_se(json_variant_get_source(v, &source, &line, &column) == 0);
+ assert_se(sd_json_variant_get_source(v, &source, &line, &column) == 0);
log_debug("json_variant_get_source: %s:%u:%u", source ?: "-", line, column);
- r = json_variant_set_field_string(&v, "a", "string-a");
+ r = sd_json_variant_set_field_string(&v, "a", "string-a");
log_debug_errno(r, "json_set_field_string: %d/%m", r);
- r = json_variant_set_field_integer(&v, "b", -12345);
+ r = sd_json_variant_set_field_integer(&v, "b", -12345);
log_debug_errno(r, "json_set_field_integer: %d/%m", r);
- r = json_variant_set_field_unsigned(&v, "c", 12345);
+ r = sd_json_variant_set_field_unsigned(&v, "c", 12345);
log_debug_errno(r, "json_set_field_unsigned: %d/%m", r);
- r = json_variant_set_field_boolean(&v, "d", false);
+ r = sd_json_variant_set_field_boolean(&v, "d", false);
log_debug_errno(r, "json_set_field_boolean: %d/%m", r);
- r = json_variant_set_field_strv(&v, "e", STRV_MAKE("e-1", "e-2", "e-3"));
+ r = sd_json_variant_set_field_strv(&v, "e", STRV_MAKE("e-1", "e-2", "e-3"));
log_debug_errno(r, "json_set_field_strv: %d/%m", r);
- r = json_variant_filter(&v, STRV_MAKE("a", "b", "c", "d", "e"));
+ r = sd_json_variant_filter(&v, STRV_MAKE("a", "b", "c", "d", "e"));
log_debug_errno(r, "json_variant_filter: %d/%m", r);
/* I assume we can merge v with itself… */
- r = json_variant_merge_object(&v, v);
+ r = sd_json_variant_merge_object(&v, v);
log_debug_errno(r, "json_variant_merge: %d/%m", r);
- r = json_variant_append_array(&v, v);
+ r = sd_json_variant_append_array(&v, v);
log_debug_errno(r, "json_variant_append_array: %d/%m", r);
return 0;
#include "fd-util.h"
#include "fuzz.h"
#include "io-util.h"
-#include "varlink-idl.h"
#include "log.h"
+#include "string-util.h"
+#include "varlink-idl.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(varlink_interface_freep) VarlinkInterface *vi = NULL;
static FILE *null = NULL;
-static int method_something(Varlink *v, JsonVariant *p, VarlinkMethodFlags flags, void *userdata) {
- json_variant_dump(p, JSON_FORMAT_NEWLINE|JSON_FORMAT_PRETTY, null, NULL);
+static int method_something(Varlink *v, sd_json_variant *p, VarlinkMethodFlags flags, void *userdata) {
+ sd_json_variant_dump(p, SD_JSON_FORMAT_NEWLINE|SD_JSON_FORMAT_PRETTY, null, NULL);
return 0;
}
-static int reply_callback(Varlink *v, JsonVariant *p, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
- json_variant_dump(p, JSON_FORMAT_NEWLINE|JSON_FORMAT_PRETTY, null, NULL);
+static int reply_callback(Varlink *v, sd_json_variant *p, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
+ sd_json_variant_dump(p, SD_JSON_FORMAT_NEWLINE|SD_JSON_FORMAT_PRETTY, null, NULL);
return 0;
}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "device-nodes.h"
#include "fstab-util.h"
#include "hibernate-resume-config.h"
-#include "json.h"
#include "os-util.h"
#include "parse-util.h"
#include "path-util.h"
int get_efi_hibernate_location(EFIHibernateLocation **ret) {
#if ENABLE_EFI
- static const JsonDispatch dispatch_table[] = {
- { "uuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(EFIHibernateLocation, uuid), JSON_MANDATORY },
- { "offset", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(EFIHibernateLocation, offset), JSON_MANDATORY },
- { "kernelVersion", JSON_VARIANT_STRING, json_dispatch_string, offsetof(EFIHibernateLocation, kernel_version), JSON_PERMISSIVE|JSON_DEBUG },
- { "osReleaseId", JSON_VARIANT_STRING, json_dispatch_string, offsetof(EFIHibernateLocation, id), JSON_PERMISSIVE|JSON_DEBUG },
- { "osReleaseImageId", JSON_VARIANT_STRING, json_dispatch_string, offsetof(EFIHibernateLocation, image_id), JSON_PERMISSIVE|JSON_DEBUG },
- { "osReleaseVersionId", JSON_VARIANT_STRING, json_dispatch_string, offsetof(EFIHibernateLocation, version_id), JSON_PERMISSIVE|JSON_DEBUG },
- { "osReleaseImageVersion", JSON_VARIANT_STRING, json_dispatch_string, offsetof(EFIHibernateLocation, image_version), JSON_PERMISSIVE|JSON_DEBUG },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "uuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(EFIHibernateLocation, uuid), SD_JSON_MANDATORY },
+ { "offset", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(EFIHibernateLocation, offset), SD_JSON_MANDATORY },
+ { "kernelVersion", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(EFIHibernateLocation, kernel_version), SD_JSON_PERMISSIVE|SD_JSON_DEBUG },
+ { "osReleaseId", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(EFIHibernateLocation, id), SD_JSON_PERMISSIVE|SD_JSON_DEBUG },
+ { "osReleaseImageId", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(EFIHibernateLocation, image_id), SD_JSON_PERMISSIVE|SD_JSON_DEBUG },
+ { "osReleaseVersionId", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(EFIHibernateLocation, version_id), SD_JSON_PERMISSIVE|SD_JSON_DEBUG },
+ { "osReleaseImageVersion", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(EFIHibernateLocation, image_version), SD_JSON_PERMISSIVE|SD_JSON_DEBUG },
{},
};
_cleanup_(efi_hibernate_location_freep) EFIHibernateLocation *e = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *location_str = NULL;
int r;
if (r < 0)
return log_error_errno(r, "Failed to get EFI variable HibernateLocation: %m");
- r = json_parse(location_str, 0, &v, NULL, NULL);
+ r = sd_json_parse(location_str, 0, &v, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to parse HibernateLocation JSON object: %m");
if (!e)
return log_oom();
- r = json_dispatch(v, dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, e);
+ r = sd_json_dispatch(v, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, e);
if (r < 0)
return r;
int bus_message_append_secret(sd_bus_message *m, UserRecord *secret) {
_cleanup_(erase_and_freep) char *formatted = NULL;
- JsonVariant *v;
+ sd_json_variant *v;
int r;
assert(m);
if (!FLAGS_SET(secret->mask, USER_RECORD_SECRET))
return sd_bus_message_append(m, "s", "{}");
- v = json_variant_by_key(secret->json, "secret");
+ v = sd_json_variant_by_key(secret->json, "secret");
if (!v)
return -EINVAL;
- r = json_variant_format(v, 0, &formatted);
+ r = sd_json_variant_format(v, 0, &formatted);
if (r < 0)
return r;
#if HAVE_LIBFIDO2
static int add_fido2_credential_id(
- JsonVariant **v,
+ sd_json_variant **v,
const void *cid,
size_t cid_size) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
_cleanup_strv_free_ char **l = NULL;
_cleanup_free_ char *escaped = NULL;
ssize_t escaped_size;
if (escaped_size < 0)
return log_error_errno(escaped_size, "Failed to base64 encode FIDO2 credential ID: %m");
- w = json_variant_ref(json_variant_by_key(*v, "fido2HmacCredential"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(*v, "fido2HmacCredential"));
if (w) {
- r = json_variant_strv(w, &l);
+ r = sd_json_variant_strv(w, &l);
if (r < 0)
return log_error_errno(r, "Failed to parse FIDO2 credential ID list: %m");
if (r < 0)
return log_oom();
- w = json_variant_unref(w);
- r = json_variant_new_array_strv(&w, l);
+ w = sd_json_variant_unref(w);
+ r = sd_json_variant_new_array_strv(&w, l);
if (r < 0)
return log_error_errno(r, "Failed to create FIDO2 credential ID JSON: %m");
- r = json_variant_set_field(v, "fido2HmacCredential", w);
+ r = sd_json_variant_set_field(v, "fido2HmacCredential", w);
if (r < 0)
return log_error_errno(r, "Failed to update FIDO2 credential ID: %m");
}
static int add_fido2_salt(
- JsonVariant **v,
+ sd_json_variant **v,
const void *cid,
size_t cid_size,
const void *fido2_salt,
size_t secret_size,
Fido2EnrollFlags lock_with) {
- _cleanup_(json_variant_unrefp) JsonVariant *l = NULL, *w = NULL, *e = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL, *w = NULL, *e = NULL;
_cleanup_(erase_and_freep) char *base64_encoded = NULL, *hashed = NULL;
ssize_t base64_encoded_size;
int r;
if (r < 0)
return log_error_errno(errno_or_else(EINVAL), "Failed to UNIX hash secret key: %m");
- r = json_build(&e, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("credential", JSON_BUILD_BASE64(cid, cid_size)),
- JSON_BUILD_PAIR("salt", JSON_BUILD_BASE64(fido2_salt, fido2_salt_size)),
- JSON_BUILD_PAIR("hashedPassword", JSON_BUILD_STRING(hashed)),
- JSON_BUILD_PAIR("up", JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_UP))),
- JSON_BUILD_PAIR("uv", JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_UV))),
- JSON_BUILD_PAIR("clientPin", JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_PIN)))));
+ r = sd_json_build(&e, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("credential", SD_JSON_BUILD_BASE64(cid, cid_size)),
+ SD_JSON_BUILD_PAIR("salt", SD_JSON_BUILD_BASE64(fido2_salt, fido2_salt_size)),
+ SD_JSON_BUILD_PAIR("hashedPassword", SD_JSON_BUILD_STRING(hashed)),
+ SD_JSON_BUILD_PAIR("up", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_UP))),
+ SD_JSON_BUILD_PAIR("uv", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_UV))),
+ SD_JSON_BUILD_PAIR("clientPin", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(lock_with, FIDO2ENROLL_PIN)))));
if (r < 0)
return log_error_errno(r, "Failed to build FIDO2 salt JSON key object: %m");
- w = json_variant_ref(json_variant_by_key(*v, "privileged"));
- l = json_variant_ref(json_variant_by_key(w, "fido2HmacSalt"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(*v, "privileged"));
+ l = sd_json_variant_ref(sd_json_variant_by_key(w, "fido2HmacSalt"));
- r = json_variant_append_array(&l, e);
+ r = sd_json_variant_append_array(&l, e);
if (r < 0)
return log_error_errno(r, "Failed append FIDO2 salt: %m");
- r = json_variant_set_field(&w, "fido2HmacSalt", l);
+ r = sd_json_variant_set_field(&w, "fido2HmacSalt", l);
if (r < 0)
return log_error_errno(r, "Failed to set FDO2 salt: %m");
- r = json_variant_set_field(v, "privileged", w);
+ r = sd_json_variant_set_field(v, "privileged", w);
if (r < 0)
return log_error_errno(r, "Failed to update privileged field: %m");
#endif
int identity_add_fido2_parameters(
- JsonVariant **v,
+ sd_json_variant **v,
const char *device,
Fido2EnrollFlags lock_with,
int cred_alg) {
#if HAVE_LIBFIDO2
- JsonVariant *un, *realm, *rn;
+ sd_json_variant *un, *realm, *rn;
_cleanup_(erase_and_freep) void *secret = NULL, *salt = NULL;
_cleanup_(erase_and_freep) char *used_pin = NULL;
size_t cid_size, salt_size, secret_size;
assert(v);
assert(device);
- un = json_variant_by_key(*v, "userName");
+ un = sd_json_variant_by_key(*v, "userName");
if (!un)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"userName field of user record is missing");
- if (!json_variant_is_string(un))
+ if (!sd_json_variant_is_string(un))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"userName field of user record is not a string");
- realm = json_variant_by_key(*v, "realm");
+ realm = sd_json_variant_by_key(*v, "realm");
if (realm) {
- if (!json_variant_is_string(realm))
+ if (!sd_json_variant_is_string(realm))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"realm field of user record is not a string");
- fido_un = strjoina(json_variant_string(un), json_variant_string(realm));
+ fido_un = strjoina(sd_json_variant_string(un), sd_json_variant_string(realm));
} else
- fido_un = json_variant_string(un);
+ fido_un = sd_json_variant_string(un);
- rn = json_variant_by_key(*v, "realName");
- if (rn && !json_variant_is_string(rn))
+ rn = sd_json_variant_by_key(*v, "realName");
+ if (rn && !sd_json_variant_is_string(rn))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"realName field of user record is not a string");
/* rp_name= */ "Home Directory",
/* user_id= */ fido_un, strlen(fido_un), /* We pass the user ID and name as the same */
/* user_name= */ fido_un,
- /* user_display_name= */ rn ? json_variant_string(rn) : NULL,
+ /* user_display_name= */ rn ? sd_json_variant_string(rn) : NULL,
/* user_icon_name= */ NULL,
/* askpw_icon_name= */ "user-home",
/* askpw_credential= */ "home.token-pin",
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "json.h"
+#include "sd-json.h"
+
#include "libfido2-util.h"
-int identity_add_fido2_parameters(JsonVariant **v, const char *device, Fido2EnrollFlags lock_with, int cred_alg);
+int identity_add_fido2_parameters(sd_json_variant **v, const char *device, Fido2EnrollFlags lock_with, int cred_alg);
#include "pkcs11-util.h"
#include "strv.h"
-int identity_add_token_pin(JsonVariant **v, const char *pin) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL, *l = NULL;
+int identity_add_token_pin(sd_json_variant **v, const char *pin) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL, *l = NULL;
_cleanup_strv_free_erase_ char **pins = NULL;
int r;
if (isempty(pin))
return 0;
- w = json_variant_ref(json_variant_by_key(*v, "secret"));
- l = json_variant_ref(json_variant_by_key(w, "tokenPin"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(*v, "secret"));
+ l = sd_json_variant_ref(sd_json_variant_by_key(w, "tokenPin"));
- r = json_variant_strv(l, &pins);
+ r = sd_json_variant_strv(l, &pins);
if (r < 0)
return log_error_errno(r, "Failed to convert PIN array: %m");
strv_uniq(pins);
- l = json_variant_unref(l);
+ l = sd_json_variant_unref(l);
- r = json_variant_new_array_strv(&l, pins);
+ r = sd_json_variant_new_array_strv(&l, pins);
if (r < 0)
return log_error_errno(r, "Failed to allocate new PIN array JSON: %m");
- json_variant_sensitive(l);
+ sd_json_variant_sensitive(l);
- r = json_variant_set_field(&w, "tokenPin", l);
+ r = sd_json_variant_set_field(&w, "tokenPin", l);
if (r < 0)
return log_error_errno(r, "Failed to update PIN field: %m");
- r = json_variant_set_field(v, "secret", w);
+ r = sd_json_variant_set_field(v, "secret", w);
if (r < 0)
return log_error_errno(r, "Failed to update secret object: %m");
#if HAVE_P11KIT
-static int add_pkcs11_token_uri(JsonVariant **v, const char *uri) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+static int add_pkcs11_token_uri(sd_json_variant **v, const char *uri) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
_cleanup_strv_free_ char **l = NULL;
int r;
assert(v);
assert(uri);
- w = json_variant_ref(json_variant_by_key(*v, "pkcs11TokenUri"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(*v, "pkcs11TokenUri"));
if (w) {
- r = json_variant_strv(w, &l);
+ r = sd_json_variant_strv(w, &l);
if (r < 0)
return log_error_errno(r, "Failed to parse PKCS#11 token list: %m");
if (r < 0)
return log_oom();
- w = json_variant_unref(w);
- r = json_variant_new_array_strv(&w, l);
+ w = sd_json_variant_unref(w);
+ r = sd_json_variant_new_array_strv(&w, l);
if (r < 0)
return log_error_errno(r, "Failed to create PKCS#11 token URI JSON: %m");
- r = json_variant_set_field(v, "pkcs11TokenUri", w);
+ r = sd_json_variant_set_field(v, "pkcs11TokenUri", w);
if (r < 0)
return log_error_errno(r, "Failed to update PKCS#11 token URI list: %m");
}
static int add_pkcs11_encrypted_key(
- JsonVariant **v,
+ sd_json_variant **v,
const char *uri,
const void *encrypted_key, size_t encrypted_key_size,
const void *decrypted_key, size_t decrypted_key_size) {
- _cleanup_(json_variant_unrefp) JsonVariant *l = NULL, *w = NULL, *e = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL, *w = NULL, *e = NULL;
_cleanup_(erase_and_freep) char *base64_encoded = NULL, *hashed = NULL;
ssize_t base64_encoded_size;
int r;
if (r < 0)
return log_error_errno(errno_or_else(EINVAL), "Failed to UNIX hash secret key: %m");
- r = json_build(&e, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("uri", JSON_BUILD_STRING(uri)),
- JSON_BUILD_PAIR("data", JSON_BUILD_BASE64(encrypted_key, encrypted_key_size)),
- JSON_BUILD_PAIR("hashedPassword", JSON_BUILD_STRING(hashed))));
+ r = sd_json_build(&e, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("uri", SD_JSON_BUILD_STRING(uri)),
+ SD_JSON_BUILD_PAIR("data", SD_JSON_BUILD_BASE64(encrypted_key, encrypted_key_size)),
+ SD_JSON_BUILD_PAIR("hashedPassword", SD_JSON_BUILD_STRING(hashed))));
if (r < 0)
return log_error_errno(r, "Failed to build encrypted JSON key object: %m");
- w = json_variant_ref(json_variant_by_key(*v, "privileged"));
- l = json_variant_ref(json_variant_by_key(w, "pkcs11EncryptedKey"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(*v, "privileged"));
+ l = sd_json_variant_ref(sd_json_variant_by_key(w, "pkcs11EncryptedKey"));
- r = json_variant_append_array(&l, e);
+ r = sd_json_variant_append_array(&l, e);
if (r < 0)
return log_error_errno(r, "Failed append PKCS#11 encrypted key: %m");
- r = json_variant_set_field(&w, "pkcs11EncryptedKey", l);
+ r = sd_json_variant_set_field(&w, "pkcs11EncryptedKey", l);
if (r < 0)
return log_error_errno(r, "Failed to set PKCS#11 encrypted key: %m");
- r = json_variant_set_field(v, "privileged", w);
+ r = sd_json_variant_set_field(v, "privileged", w);
if (r < 0)
return log_error_errno(r, "Failed to update privileged field: %m");
return 0;
}
-int identity_add_pkcs11_key_data(JsonVariant **v, const char *uri) {
+int identity_add_pkcs11_key_data(sd_json_variant **v, const char *uri) {
_cleanup_(erase_and_freep) void *decrypted_key = NULL, *saved_key = NULL;
_cleanup_(erase_and_freep) char *pin = NULL;
size_t decrypted_key_size, saved_key_size;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "json.h"
+#include "sd-json.h"
-int identity_add_token_pin(JsonVariant **v, const char *pin);
+int identity_add_token_pin(sd_json_variant **v, const char *pin);
#if HAVE_P11KIT
-int identity_add_pkcs11_key_data(JsonVariant **v, const char *token_uri);
+int identity_add_pkcs11_key_data(sd_json_variant **v, const char *token_uri);
#else
-static inline int identity_add_pkcs11_key_data(JsonVariant **v, const char *token_uri) {
+static inline int identity_add_pkcs11_key_data(sd_json_variant **v, const char *token_uri) {
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "PKCS#11 tokens not supported on this build.");
}
#endif
#include "errno-util.h"
#include "glyph-util.h"
#include "homectl-recovery-key.h"
+#include "json-util.h"
#include "libcrypt-util.h"
#include "memory-util.h"
#include "qrcode-util.h"
#include "strv.h"
#include "terminal-util.h"
-static int add_privileged(JsonVariant **v, const char *hashed) {
- _cleanup_(json_variant_unrefp) JsonVariant *e = NULL, *w = NULL, *l = NULL;
+static int add_privileged(sd_json_variant **v, const char *hashed) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *e = NULL, *w = NULL, *l = NULL;
int r;
assert(v);
assert(hashed);
- r = json_build(&e, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("modhex64")),
- JSON_BUILD_PAIR("hashedPassword", JSON_BUILD_STRING(hashed))));
+ r = sd_json_build(&e, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("modhex64")),
+ SD_JSON_BUILD_PAIR("hashedPassword", SD_JSON_BUILD_STRING(hashed))));
if (r < 0)
return log_error_errno(r, "Failed to build recover key JSON object: %m");
- json_variant_sensitive(e);
+ sd_json_variant_sensitive(e);
- w = json_variant_ref(json_variant_by_key(*v, "privileged"));
- l = json_variant_ref(json_variant_by_key(w, "recoveryKey"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(*v, "privileged"));
+ l = sd_json_variant_ref(sd_json_variant_by_key(w, "recoveryKey"));
- r = json_variant_append_array(&l, e);
+ r = sd_json_variant_append_array(&l, e);
if (r < 0)
return log_error_errno(r, "Failed append recovery key: %m");
- r = json_variant_set_field(&w, "recoveryKey", l);
+ r = sd_json_variant_set_field(&w, "recoveryKey", l);
if (r < 0)
return log_error_errno(r, "Failed to set recovery key array: %m");
- r = json_variant_set_field(v, "privileged", w);
+ r = sd_json_variant_set_field(v, "privileged", w);
if (r < 0)
return log_error_errno(r, "Failed to update privileged field: %m");
return 0;
}
-static int add_public(JsonVariant **v) {
+static int add_public(sd_json_variant **v) {
_cleanup_strv_free_ char **types = NULL;
int r;
assert(v);
- r = json_variant_strv(json_variant_by_key(*v, "recoveryKeyType"), &types);
+ r = sd_json_variant_strv(sd_json_variant_by_key(*v, "recoveryKeyType"), &types);
if (r < 0)
return log_error_errno(r, "Failed to parse recovery key type list: %m");
if (r < 0)
return log_oom();
- r = json_variant_set_field_strv(v, "recoveryKeyType", types);
+ r = sd_json_variant_set_field_strv(v, "recoveryKeyType", types);
if (r < 0)
return log_error_errno(r, "Failed to update recovery key types: %m");
return 0;
}
-static int add_secret(JsonVariant **v, const char *password) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL, *l = NULL;
+static int add_secret(sd_json_variant **v, const char *password) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL, *l = NULL;
_cleanup_strv_free_erase_ char **passwords = NULL;
int r;
assert(v);
assert(password);
- w = json_variant_ref(json_variant_by_key(*v, "secret"));
- l = json_variant_ref(json_variant_by_key(w, "password"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(*v, "secret"));
+ l = sd_json_variant_ref(sd_json_variant_by_key(w, "password"));
- r = json_variant_strv(l, &passwords);
+ r = sd_json_variant_strv(l, &passwords);
if (r < 0)
return log_error_errno(r, "Failed to convert password array: %m");
if (r < 0)
return log_oom();
- r = json_variant_new_array_strv(&l, passwords);
+ r = sd_json_variant_new_array_strv(&l, passwords);
if (r < 0)
return log_error_errno(r, "Failed to allocate new password array JSON: %m");
- json_variant_sensitive(l);
+ sd_json_variant_sensitive(l);
- r = json_variant_set_field(&w, "password", l);
+ r = sd_json_variant_set_field(&w, "password", l);
if (r < 0)
return log_error_errno(r, "Failed to update password field: %m");
- r = json_variant_set_field(v, "secret", w);
+ r = sd_json_variant_set_field(v, "secret", w);
if (r < 0)
return log_error_errno(r, "Failed to update secret object: %m");
return 0;
}
-int identity_add_recovery_key(JsonVariant **v) {
+int identity_add_recovery_key(sd_json_variant **v) {
_cleanup_(erase_and_freep) char *password = NULL, *hashed = NULL;
int r;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "json.h"
+#include "sd-json.h"
-int identity_add_recovery_key(JsonVariant **v);
+int identity_add_recovery_key(sd_json_variant **v);
#include "homectl-fido2.h"
#include "homectl-pkcs11.h"
#include "homectl-recovery-key.h"
+#include "json-util.h"
#include "libfido2-util.h"
#include "locale-util.h"
#include "main-func.h"
static const char *arg_host = NULL;
static bool arg_offline = false;
static const char *arg_identity = NULL;
-static JsonVariant *arg_identity_extra = NULL;
-static JsonVariant *arg_identity_extra_privileged = NULL;
-static JsonVariant *arg_identity_extra_this_machine = NULL;
-static JsonVariant *arg_identity_extra_rlimits = NULL;
+static sd_json_variant *arg_identity_extra = NULL;
+static sd_json_variant *arg_identity_extra_privileged = NULL;
+static sd_json_variant *arg_identity_extra_this_machine = NULL;
+static sd_json_variant *arg_identity_extra_rlimits = NULL;
static char **arg_identity_filter = NULL; /* this one is also applied to 'privileged' and 'thisMachine' subobjects */
static char **arg_identity_filter_rlimits = NULL;
static uint64_t arg_disk_size = UINT64_MAX;
static int arg_fido2_cred_alg = 0;
#endif
static bool arg_recovery_key = false;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static bool arg_and_resize = false;
static bool arg_and_change_password = false;
static enum {
static bool arg_blob_clear = false;
static Hashmap *arg_blob_files = NULL;
-STATIC_DESTRUCTOR_REGISTER(arg_identity_extra, json_variant_unrefp);
-STATIC_DESTRUCTOR_REGISTER(arg_identity_extra_this_machine, json_variant_unrefp);
-STATIC_DESTRUCTOR_REGISTER(arg_identity_extra_privileged, json_variant_unrefp);
-STATIC_DESTRUCTOR_REGISTER(arg_identity_extra_rlimits, json_variant_unrefp);
+STATIC_DESTRUCTOR_REGISTER(arg_identity_extra, sd_json_variant_unrefp);
+STATIC_DESTRUCTOR_REGISTER(arg_identity_extra_this_machine, sd_json_variant_unrefp);
+STATIC_DESTRUCTOR_REGISTER(arg_identity_extra_privileged, sd_json_variant_unrefp);
+STATIC_DESTRUCTOR_REGISTER(arg_identity_extra_rlimits, sd_json_variant_unrefp);
STATIC_DESTRUCTOR_REGISTER(arg_identity_filter, strv_freep);
STATIC_DESTRUCTOR_REGISTER(arg_identity_filter_rlimits, strv_freep);
STATIC_DESTRUCTOR_REGISTER(arg_pkcs11_token_uri, strv_freep);
static bool identity_properties_specified(void) {
return
arg_identity ||
- !json_variant_is_blank_object(arg_identity_extra) ||
- !json_variant_is_blank_object(arg_identity_extra_privileged) ||
- !json_variant_is_blank_object(arg_identity_extra_this_machine) ||
- !json_variant_is_blank_object(arg_identity_extra_rlimits) ||
+ !sd_json_variant_is_blank_object(arg_identity_extra) ||
+ !sd_json_variant_is_blank_object(arg_identity_extra_privileged) ||
+ !sd_json_variant_is_blank_object(arg_identity_extra_this_machine) ||
+ !sd_json_variant_is_blank_object(arg_identity_extra_rlimits) ||
!strv_isempty(arg_identity_filter) ||
!strv_isempty(arg_identity_filter_rlimits) ||
!strv_isempty(arg_pkcs11_token_uri) ||
if (r < 0)
return bus_log_parse_error(r);
- if (!table_isempty(table) || !FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ if (!table_isempty(table) || !FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
r = table_set_sort(table, (size_t) 0);
if (r < 0)
return table_log_sort_error(r);
return r;
}
- if (arg_legend && !FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ if (arg_legend && !FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
if (table_isempty(table))
printf("No home areas.\n");
else
log_warning("Warning: lacking rights to acquire privileged fields of user record of '%s', output incomplete.", hr->user_name);
}
- if (arg_json_format_flags & JSON_FORMAT_OFF)
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF)
user_record_show(hr, true);
else {
_cleanup_(user_record_unrefp) UserRecord *stripped = NULL;
if (stripped)
hr = stripped;
- json_variant_dump(hr->json, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(hr->json, arg_json_format_flags, stdout, NULL);
}
}
STRV_FOREACH(i, items) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
const char *json;
int incomplete;
continue;
}
- r = json_parse(json, JSON_PARSE_SENSITIVE, &v, NULL, NULL);
+ r = sd_json_parse(json, SD_JSON_PARSE_SENSITIVE, &v, NULL, NULL);
if (r < 0) {
log_error_errno(r, "Failed to parse JSON identity: %m");
if (ret == 0)
return ret;
}
-static int update_last_change(JsonVariant **v, bool with_password, bool override) {
- JsonVariant *c;
+static int update_last_change(sd_json_variant **v, bool with_password, bool override) {
+ sd_json_variant *c;
usec_t n;
int r;
n = now(CLOCK_REALTIME);
- c = json_variant_by_key(*v, "lastChangeUSec");
+ c = sd_json_variant_by_key(*v, "lastChangeUSec");
if (c) {
uint64_t u;
if (!override)
goto update_password;
- if (!json_variant_is_unsigned(c))
+ if (!sd_json_variant_is_unsigned(c))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "lastChangeUSec field is not an unsigned integer, refusing.");
- u = json_variant_unsigned(c);
+ u = sd_json_variant_unsigned(c);
if (u >= n)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "lastChangeUSec is from the future, can't update.");
}
- r = json_variant_set_field_unsigned(v, "lastChangeUSec", n);
+ r = sd_json_variant_set_field_unsigned(v, "lastChangeUSec", n);
if (r < 0)
return log_error_errno(r, "Failed to update lastChangeUSec: %m");
if (!with_password)
return 0;
- c = json_variant_by_key(*v, "lastPasswordChangeUSec");
+ c = sd_json_variant_by_key(*v, "lastPasswordChangeUSec");
if (c) {
uint64_t u;
if (!override)
return 0;
- if (!json_variant_is_unsigned(c))
+ if (!sd_json_variant_is_unsigned(c))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "lastPasswordChangeUSec field is not an unsigned integer, refusing.");
- u = json_variant_unsigned(c);
+ u = sd_json_variant_unsigned(c);
if (u >= n)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "lastPasswordChangeUSec is from the future, can't update.");
}
- r = json_variant_set_field_unsigned(v, "lastPasswordChangeUSec", n);
+ r = sd_json_variant_set_field_unsigned(v, "lastPasswordChangeUSec", n);
if (r < 0)
return log_error_errno(r, "Failed to update lastPasswordChangeUSec: %m");
return 1;
}
-static int apply_identity_changes(JsonVariant **_v) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+static int apply_identity_changes(sd_json_variant **_v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(_v);
- v = json_variant_ref(*_v);
+ v = sd_json_variant_ref(*_v);
- r = json_variant_filter(&v, arg_identity_filter);
+ r = sd_json_variant_filter(&v, arg_identity_filter);
if (r < 0)
return log_error_errno(r, "Failed to filter identity: %m");
- r = json_variant_merge_object(&v, arg_identity_extra);
+ r = sd_json_variant_merge_object(&v, arg_identity_extra);
if (r < 0)
return log_error_errno(r, "Failed to merge identities: %m");
if (arg_identity_extra_this_machine || !strv_isempty(arg_identity_filter)) {
- _cleanup_(json_variant_unrefp) JsonVariant *per_machine = NULL, *mmid = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *per_machine = NULL, *mmid = NULL;
sd_id128_t mid;
r = sd_id128_get_machine(&mid);
if (r < 0)
return log_error_errno(r, "Failed to acquire machine ID: %m");
- r = json_variant_new_string(&mmid, SD_ID128_TO_STRING(mid));
+ r = sd_json_variant_new_string(&mmid, SD_ID128_TO_STRING(mid));
if (r < 0)
return log_error_errno(r, "Failed to allocate matchMachineId object: %m");
- per_machine = json_variant_ref(json_variant_by_key(v, "perMachine"));
+ per_machine = sd_json_variant_ref(sd_json_variant_by_key(v, "perMachine"));
if (per_machine) {
- _cleanup_(json_variant_unrefp) JsonVariant *npm = NULL, *add = NULL;
- _cleanup_free_ JsonVariant **array = NULL;
- JsonVariant *z;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *npm = NULL, *add = NULL;
+ _cleanup_free_ sd_json_variant **array = NULL;
+ sd_json_variant *z;
size_t i = 0;
- if (!json_variant_is_array(per_machine))
+ if (!sd_json_variant_is_array(per_machine))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "perMachine field is not an array, refusing.");
- array = new(JsonVariant*, json_variant_elements(per_machine) + 1);
+ array = new(sd_json_variant*, sd_json_variant_elements(per_machine) + 1);
if (!array)
return log_oom();
JSON_VARIANT_ARRAY_FOREACH(z, per_machine) {
- JsonVariant *u;
+ sd_json_variant *u;
- if (!json_variant_is_object(z))
+ if (!sd_json_variant_is_object(z))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "perMachine entry is not an object, refusing.");
array[i++] = z;
- u = json_variant_by_key(z, "matchMachineId");
+ u = sd_json_variant_by_key(z, "matchMachineId");
if (!u)
continue;
- if (!json_variant_equal(u, mmid))
+ if (!sd_json_variant_equal(u, mmid))
continue;
- r = json_variant_merge_object(&add, z);
+ r = sd_json_variant_merge_object(&add, z);
if (r < 0)
return log_error_errno(r, "Failed to merge perMachine entry: %m");
i--;
}
- r = json_variant_filter(&add, arg_identity_filter);
+ r = sd_json_variant_filter(&add, arg_identity_filter);
if (r < 0)
return log_error_errno(r, "Failed to filter perMachine: %m");
- r = json_variant_merge_object(&add, arg_identity_extra_this_machine);
+ r = sd_json_variant_merge_object(&add, arg_identity_extra_this_machine);
if (r < 0)
return log_error_errno(r, "Failed to merge in perMachine fields: %m");
if (arg_identity_filter_rlimits || arg_identity_extra_rlimits) {
- _cleanup_(json_variant_unrefp) JsonVariant *rlv = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *rlv = NULL;
- rlv = json_variant_ref(json_variant_by_key(add, "resourceLimits"));
+ rlv = sd_json_variant_ref(sd_json_variant_by_key(add, "resourceLimits"));
- r = json_variant_filter(&rlv, arg_identity_filter_rlimits);
+ r = sd_json_variant_filter(&rlv, arg_identity_filter_rlimits);
if (r < 0)
return log_error_errno(r, "Failed to filter resource limits: %m");
- r = json_variant_merge_object(&rlv, arg_identity_extra_rlimits);
+ r = sd_json_variant_merge_object(&rlv, arg_identity_extra_rlimits);
if (r < 0)
return log_error_errno(r, "Failed to set resource limits: %m");
- if (json_variant_is_blank_object(rlv)) {
- r = json_variant_filter(&add, STRV_MAKE("resourceLimits"));
+ if (sd_json_variant_is_blank_object(rlv)) {
+ r = sd_json_variant_filter(&add, STRV_MAKE("resourceLimits"));
if (r < 0)
return log_error_errno(r, "Failed to drop resource limits field from identity: %m");
} else {
- r = json_variant_set_field(&add, "resourceLimits", rlv);
+ r = sd_json_variant_set_field(&add, "resourceLimits", rlv);
if (r < 0)
return log_error_errno(r, "Failed to update resource limits of identity: %m");
}
}
- if (!json_variant_is_blank_object(add)) {
- r = json_variant_set_field(&add, "matchMachineId", mmid);
+ if (!sd_json_variant_is_blank_object(add)) {
+ r = sd_json_variant_set_field(&add, "matchMachineId", mmid);
if (r < 0)
return log_error_errno(r, "Failed to set matchMachineId field: %m");
array[i++] = add;
}
- r = json_variant_new_array(&npm, array, i);
+ r = sd_json_variant_new_array(&npm, array, i);
if (r < 0)
return log_error_errno(r, "Failed to allocate new perMachine array: %m");
- json_variant_unref(per_machine);
+ sd_json_variant_unref(per_machine);
per_machine = TAKE_PTR(npm);
} else {
- _cleanup_(json_variant_unrefp) JsonVariant *item = json_variant_ref(arg_identity_extra_this_machine);
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *item = sd_json_variant_ref(arg_identity_extra_this_machine);
if (arg_identity_extra_rlimits) {
- r = json_variant_set_field(&item, "resourceLimits", arg_identity_extra_rlimits);
+ r = sd_json_variant_set_field(&item, "resourceLimits", arg_identity_extra_rlimits);
if (r < 0)
return log_error_errno(r, "Failed to update resource limits of identity: %m");
}
- r = json_variant_set_field(&item, "matchMachineId", mmid);
+ r = sd_json_variant_set_field(&item, "matchMachineId", mmid);
if (r < 0)
return log_error_errno(r, "Failed to set matchMachineId field: %m");
- r = json_variant_append_array(&per_machine, item);
+ r = sd_json_variant_append_array(&per_machine, item);
if (r < 0)
return log_error_errno(r, "Failed to append to perMachine array: %m");
}
- r = json_variant_set_field(&v, "perMachine", per_machine);
+ r = sd_json_variant_set_field(&v, "perMachine", per_machine);
if (r < 0)
return log_error_errno(r, "Failed to update per machine record: %m");
}
if (arg_identity_extra_privileged || arg_identity_filter) {
- _cleanup_(json_variant_unrefp) JsonVariant *privileged = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *privileged = NULL;
- privileged = json_variant_ref(json_variant_by_key(v, "privileged"));
+ privileged = sd_json_variant_ref(sd_json_variant_by_key(v, "privileged"));
- r = json_variant_filter(&privileged, arg_identity_filter);
+ r = sd_json_variant_filter(&privileged, arg_identity_filter);
if (r < 0)
return log_error_errno(r, "Failed to filter identity (privileged part): %m");
- r = json_variant_merge_object(&privileged, arg_identity_extra_privileged);
+ r = sd_json_variant_merge_object(&privileged, arg_identity_extra_privileged);
if (r < 0)
return log_error_errno(r, "Failed to merge identities (privileged part): %m");
- if (json_variant_is_blank_object(privileged)) {
- r = json_variant_filter(&v, STRV_MAKE("privileged"));
+ if (sd_json_variant_is_blank_object(privileged)) {
+ r = sd_json_variant_filter(&v, STRV_MAKE("privileged"));
if (r < 0)
return log_error_errno(r, "Failed to drop privileged part from identity: %m");
} else {
- r = json_variant_set_field(&v, "privileged", privileged);
+ r = sd_json_variant_set_field(&v, "privileged", privileged);
if (r < 0)
return log_error_errno(r, "Failed to update privileged part of identity: %m");
}
}
if (arg_identity_filter_rlimits) {
- _cleanup_(json_variant_unrefp) JsonVariant *rlv = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *rlv = NULL;
- rlv = json_variant_ref(json_variant_by_key(v, "resourceLimits"));
+ rlv = sd_json_variant_ref(sd_json_variant_by_key(v, "resourceLimits"));
- r = json_variant_filter(&rlv, arg_identity_filter_rlimits);
+ r = sd_json_variant_filter(&rlv, arg_identity_filter_rlimits);
if (r < 0)
return log_error_errno(r, "Failed to filter resource limits: %m");
/* Note that we only filter resource limits here, but don't apply them. We do that in the perMachine section */
- if (json_variant_is_blank_object(rlv)) {
- r = json_variant_filter(&v, STRV_MAKE("resourceLimits"));
+ if (sd_json_variant_is_blank_object(rlv)) {
+ r = sd_json_variant_filter(&v, STRV_MAKE("resourceLimits"));
if (r < 0)
return log_error_errno(r, "Failed to drop resource limits field from identity: %m");
} else {
- r = json_variant_set_field(&v, "resourceLimits", rlv);
+ r = sd_json_variant_set_field(&v, "resourceLimits", rlv);
if (r < 0)
return log_error_errno(r, "Failed to update resource limits of identity: %m");
}
}
- json_variant_unref(*_v);
+ sd_json_variant_unref(*_v);
*_v = TAKE_PTR(v);
return 0;
}
-static int add_disposition(JsonVariant **v) {
+static int add_disposition(sd_json_variant **v) {
int r;
assert(v);
- if (json_variant_by_key(*v, "disposition"))
+ if (sd_json_variant_by_key(*v, "disposition"))
return 0;
/* Set the disposition to regular, if not configured explicitly */
- r = json_variant_set_field_string(v, "disposition", "regular");
+ r = sd_json_variant_set_field_string(v, "disposition", "regular");
if (r < 0)
return log_error_errno(r, "Failed to set disposition field: %m");
return 1;
}
-static int acquire_new_home_record(JsonVariant *input, UserRecord **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+static int acquire_new_home_record(sd_json_variant *input, UserRecord **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
int r;
if (input)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Two identity records specified, refusing.");
- r = json_parse_file(
+ r = sd_json_parse_file(
streq(arg_identity, "-") ? stdin : NULL,
- streq(arg_identity, "-") ? "<stdin>" : arg_identity, JSON_PARSE_SENSITIVE, &v, &line, &column);
+ streq(arg_identity, "-") ? "<stdin>" : arg_identity, SD_JSON_PARSE_SENSITIVE, &v, &line, &column);
if (r < 0)
return log_error_errno(r, "Failed to parse identity at %u:%u: %m", line, column);
} else
- v = json_variant_ref(input);
+ v = sd_json_variant_ref(input);
r = apply_identity_changes(&v);
if (r < 0)
return r;
if (DEBUG_LOGGING)
- json_variant_dump(v, JSON_FORMAT_PRETTY, NULL, NULL);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY, NULL, NULL);
hr = user_record_new();
if (!hr)
return sd_bus_message_close_container(m);
}
-static int create_home_common(JsonVariant *input) {
+static int create_home_common(sd_json_variant *input) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
_cleanup_hashmap_free_ Hashmap *blobs = NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_(erase_and_freep) char *formatted = NULL;
- r = json_variant_format(hr->json, 0, &formatted);
+ r = sd_json_variant_format(hr->json, 0, &formatted);
if (r < 0)
return log_error_errno(r, "Failed to format user record: %m");
/* If a username was specified, use it */
if (valid_user_group_name(argv[1], 0))
- r = json_variant_set_field_string(&arg_identity_extra, "userName", argv[1]);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "userName", argv[1]);
else {
_cleanup_free_ char *un = NULL, *rr = NULL;
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "User name '%s' is not valid.", argv[1]);
if (rr) {
- r = json_variant_set_field_string(&arg_identity_extra, "realm", rr);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "realm", rr);
if (r < 0)
return log_error_errno(r, "Failed to set realm field: %m");
}
- r = json_variant_set_field_string(&arg_identity_extra, "userName", un);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "userName", un);
}
if (r < 0)
return log_error_errno(r, "Failed to set userName field: %m");
const char *username,
UserRecord **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *json = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *json = NULL;
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
int r;
if (arg_identity) {
unsigned line, column;
- JsonVariant *un;
+ sd_json_variant *un;
- r = json_parse_file(
+ r = sd_json_parse_file(
streq(arg_identity, "-") ? stdin : NULL,
- streq(arg_identity, "-") ? "<stdin>" : arg_identity, JSON_PARSE_SENSITIVE, &json, &line, &column);
+ streq(arg_identity, "-") ? "<stdin>" : arg_identity, SD_JSON_PARSE_SENSITIVE, &json, &line, &column);
if (r < 0)
return log_error_errno(r, "Failed to parse identity at %u:%u: %m", line, column);
- un = json_variant_by_key(json, "userName");
+ un = sd_json_variant_by_key(json, "userName");
if (un) {
- if (!json_variant_is_string(un) || (username && !streq(json_variant_string(un), username)))
+ if (!sd_json_variant_is_string(un) || (username && !streq(sd_json_variant_string(un), username)))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "User name specified on command line and in JSON record do not match.");
} else {
if (!username)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No username specified.");
- r = json_variant_set_field_string(&arg_identity_extra, "userName", username);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "userName", username);
if (r < 0)
return log_error_errno(r, "Failed to set userName field: %m");
}
if (incomplete)
return log_error_errno(SYNTHETIC_ERRNO(EACCES), "Lacking rights to acquire user record including privileged metadata, can't update record.");
- r = json_parse(text, JSON_PARSE_SENSITIVE, &json, NULL, NULL);
+ r = sd_json_parse(text, SD_JSON_PARSE_SENSITIVE, &json, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to parse JSON identity: %m");
reply = sd_bus_message_unref(reply);
- r = json_variant_filter(&json, STRV_MAKE("binding", "status", "signature", "blobManifest"));
+ r = sd_json_variant_filter(&json, STRV_MAKE("binding", "status", "signature", "blobManifest"));
if (r < 0)
return log_error_errno(r, "Failed to strip binding and status from record to update: %m");
}
return r;
if (DEBUG_LOGGING)
- json_variant_dump(json, JSON_FORMAT_PRETTY, NULL, NULL);
+ sd_json_variant_dump(json, SD_JSON_FORMAT_PRETTY, NULL, NULL);
hr = user_record_new();
if (!hr)
if (r < 0)
return bus_log_create_error(r);
- r = json_variant_format(hr->json, 0, &formatted);
+ r = sd_json_variant_format(hr->json, 0, &formatted);
if (r < 0)
return log_error_errno(r, "Failed to format user record: %m");
return log_error_errno(r, "Failed to enumerate credentials: %m");
FOREACH_ARRAY(i, des->entries, des->n_entries) {
- _cleanup_(json_variant_unrefp) JsonVariant *identity = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *identity = NULL;
struct dirent *de = *i;
const char *e;
continue;
}
- r = json_parse_file_at(
+ r = sd_json_parse_file_at(
/* f= */ NULL,
fd,
de->d_name,
continue;
}
- JsonVariant *un;
- un = json_variant_by_key(identity, "userName");
+ sd_json_variant *un;
+ un = sd_json_variant_by_key(identity, "userName");
if (un) {
- if (!json_variant_is_string(un)) {
+ if (!sd_json_variant_is_string(un)) {
log_warning("User record from credential '%s' contains 'userName' field of invalid type, ignoring.", de->d_name);
continue;
}
- if (!streq(json_variant_string(un), e)) {
- log_warning("User record from credential '%s' contains 'userName' field (%s) that doesn't match credential name (%s), ignoring.", de->d_name, json_variant_string(un), e);
+ if (!streq(sd_json_variant_string(un), e)) {
+ log_warning("User record from credential '%s' contains 'userName' field (%s) that doesn't match credential name (%s), ignoring.", de->d_name, sd_json_variant_string(un), e);
continue;
}
} else {
- r = json_variant_set_field_string(&identity, "userName", e);
+ r = sd_json_variant_set_field_string(&identity, "userName", e);
if (r < 0)
return log_warning_errno(r, "Failed to set userName field: %m");
}
log_notice("Specified user '%s' exists already, try again.", username);
}
- r = json_variant_set_field_string(&arg_identity_extra, "userName", username);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "userName", username);
if (r < 0)
return log_error_errno(r, "Failed to set userName field: %m");
return log_oom();
/* Let's also drop the field if it was previously set to a new value on the same command line */
- r = json_variant_filter(&arg_identity_extra, STRV_MAKE(field));
+ r = sd_json_variant_filter(&arg_identity_extra, STRV_MAKE(field));
if (r < 0)
return log_error_errno(r, "Failed to filter JSON identity data: %m");
- r = json_variant_filter(&arg_identity_extra_this_machine, STRV_MAKE(field));
+ r = sd_json_variant_filter(&arg_identity_extra_this_machine, STRV_MAKE(field));
if (r < 0)
return log_error_errno(r, "Failed to filter JSON identity data: %m");
- r = json_variant_filter(&arg_identity_extra_privileged, STRV_MAKE(field));
+ r = sd_json_variant_filter(&arg_identity_extra_privileged, STRV_MAKE(field));
if (r < 0)
return log_error_errno(r, "Failed to filter JSON identity data: %m");
if (!valid_gecos(optarg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Real name '%s' not a valid GECOS field.", optarg);
- r = json_variant_set_field_string(&arg_identity_extra, "realName", optarg);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "realName", optarg);
if (r < 0)
return log_error_errno(r, "Failed to set realName field: %m");
if (!valid_home(hd))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Home directory '%s' not valid.", hd);
- r = json_variant_set_field_string(&arg_identity_extra, "homeDirectory", hd);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "homeDirectory", hd);
if (r < 0)
return log_error_errno(r, "Failed to set homeDirectory field: %m");
if (r == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Realm '%s' is not a valid DNS domain.", optarg);
- r = json_variant_set_field_string(&arg_identity_extra, "realm", optarg);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "realm", optarg);
if (r < 0)
return log_error_errno(r, "Failed to set realm field: %m");
break;
break;
}
- r = json_variant_set_field_string(&arg_identity_extra, field, optarg);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, field, optarg);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", field);
if (r < 0)
return log_error_errno(r, "Failed to validate CIFS service name: %s", optarg);
- r = json_variant_set_field_string(&arg_identity_extra, "cifsService", optarg);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "cifsService", optarg);
if (r < 0)
return log_error_errno(r, "Failed to set cifsService field: %m");
break;
}
- r = json_variant_set_field_string(&arg_identity_extra_privileged, "passwordHint", optarg);
+ r = sd_json_variant_set_field_string(&arg_identity_extra_privileged, "passwordHint", optarg);
if (r < 0)
return log_error_errno(r, "Failed to set passwordHint field: %m");
if (r < 0)
return log_error_errno(r, "Failed to parse nice level: %s", optarg);
- r = json_variant_set_field_integer(&arg_identity_extra, "niceLevel", nc);
+ r = sd_json_variant_set_field_integer(&arg_identity_extra, "niceLevel", nc);
if (r < 0)
return log_error_errno(r, "Failed to set niceLevel field: %m");
}
case ARG_RLIMIT: {
- _cleanup_(json_variant_unrefp) JsonVariant *jcur = NULL, *jmax = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *jcur = NULL, *jmax = NULL;
_cleanup_free_ char *field = NULL, *t = NULL;
const char *eq;
struct rlimit rl;
return r;
arg_identity_filter_rlimits = strv_free(arg_identity_filter_rlimits);
- arg_identity_extra_rlimits = json_variant_unref(arg_identity_extra_rlimits);
+ arg_identity_extra_rlimits = sd_json_variant_unref(arg_identity_extra_rlimits);
break;
}
if (r < 0)
return r;
- r = json_variant_filter(&arg_identity_extra_rlimits, STRV_MAKE(field));
+ r = sd_json_variant_filter(&arg_identity_extra_rlimits, STRV_MAKE(field));
if (r < 0)
return log_error_errno(r, "Failed to filter JSON identity data: %m");
if (r < 0)
return log_error_errno(r, "Failed to parse resource limit value: %s", eq + 1);
- r = rl.rlim_cur == RLIM_INFINITY ? json_variant_new_null(&jcur) : json_variant_new_unsigned(&jcur, rl.rlim_cur);
+ r = rl.rlim_cur == RLIM_INFINITY ? sd_json_variant_new_null(&jcur) : sd_json_variant_new_unsigned(&jcur, rl.rlim_cur);
if (r < 0)
return log_error_errno(r, "Failed to allocate current integer: %m");
- r = rl.rlim_max == RLIM_INFINITY ? json_variant_new_null(&jmax) : json_variant_new_unsigned(&jmax, rl.rlim_max);
+ r = rl.rlim_max == RLIM_INFINITY ? sd_json_variant_new_null(&jmax) : sd_json_variant_new_unsigned(&jmax, rl.rlim_max);
if (r < 0)
return log_error_errno(r, "Failed to allocate maximum integer: %m");
if (!t)
return log_oom();
- r = json_variant_set_fieldb(
+ r = sd_json_variant_set_fieldb(
&arg_identity_extra_rlimits, t,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("cur", JSON_BUILD_VARIANT(jcur)),
- JSON_BUILD_PAIR("max", JSON_BUILD_VARIANT(jmax))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("cur", SD_JSON_BUILD_VARIANT(jcur)),
+ SD_JSON_BUILD_PAIR("max", SD_JSON_BUILD_VARIANT(jmax))));
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", rlimit_to_string(l));
if (uid == UID_NOBODY)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "UID " UID_FMT " is nobody UID, refusing.", uid);
- r = json_variant_set_field_unsigned(&arg_identity_extra, "uid", uid);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, "uid", uid);
if (r < 0)
return log_error_errno(r, "Failed to set realm field: %m");
if (r < 0)
return r;
- r = json_variant_set_field_string(&arg_identity_extra_this_machine, field, v);
+ r = sd_json_variant_set_field_string(&arg_identity_extra_this_machine, field, v);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", v);
if (!valid_shell(optarg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Shell '%s' not valid.", optarg);
- r = json_variant_set_field_string(&arg_identity_extra, "shell", optarg);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "shell", optarg);
if (r < 0)
return log_error_errno(r, "Failed to set shell field: %m");
case ARG_SETENV: {
_cleanup_free_ char **l = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *ne = NULL;
- JsonVariant *e;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *ne = NULL;
+ sd_json_variant *e;
if (isempty(optarg)) {
r = drop_from_identity("environment");
break;
}
- e = json_variant_by_key(arg_identity_extra, "environment");
+ e = sd_json_variant_by_key(arg_identity_extra, "environment");
if (e) {
- r = json_variant_strv(e, &l);
+ r = sd_json_variant_strv(e, &l);
if (r < 0)
return log_error_errno(r, "Failed to parse JSON environment field: %m");
}
strv_sort(l);
- r = json_variant_new_array_strv(&ne, l);
+ r = sd_json_variant_new_array_strv(&ne, l);
if (r < 0)
return log_error_errno(r, "Failed to allocate environment list JSON: %m");
- r = json_variant_set_field(&arg_identity_extra, "environment", ne);
+ r = sd_json_variant_set_field(&arg_identity_extra, "environment", ne);
if (r < 0)
return log_error_errno(r, "Failed to set environment list: %m");
if (!timezone_is_valid(optarg, LOG_DEBUG))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Timezone '%s' is not valid.", optarg);
- r = json_variant_set_field_string(&arg_identity_extra, "timeZone", optarg);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "timeZone", optarg);
if (r < 0)
return log_error_errno(r, "Failed to set timezone field: %m");
if (r < 0)
return log_error_errno(r, "Failed to parse %s boolean: %m", field);
- r = json_variant_set_field_boolean(&arg_identity_extra, field, r > 0);
+ r = sd_json_variant_set_field_boolean(&arg_identity_extra, field, r > 0);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", field);
}
case 'P':
- r = json_variant_set_field_boolean(&arg_identity_extra, "enforcePasswordPolicy", false);
+ r = sd_json_variant_set_field_boolean(&arg_identity_extra, "enforcePasswordPolicy", false);
if (r < 0)
return log_error_errno(r, "Failed to set enforcePasswordPolicy field: %m");
if (r < 0)
return r;
- r = json_variant_set_field_unsigned(&arg_identity_extra_this_machine, "diskSize", arg_disk_size);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra_this_machine, "diskSize", arg_disk_size);
if (r < 0)
return log_error_errno(r, "Failed to set diskSize field: %m");
if (r < 0)
return r;
- r = json_variant_set_field_unsigned(&arg_identity_extra_this_machine, "diskSizeRelative", arg_disk_size_relative);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra_this_machine, "diskSizeRelative", arg_disk_size_relative);
if (r < 0)
return log_error_errno(r, "Failed to set diskSizeRelative field: %m");
}
/* Automatically turn off the rebalance logic if user configured a size explicitly */
- r = json_variant_set_field_unsigned(&arg_identity_extra_this_machine, "rebalanceWeight", REBALANCE_WEIGHT_OFF);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra_this_machine, "rebalanceWeight", REBALANCE_WEIGHT_OFF);
if (r < 0)
return log_error_errno(r, "Failed to set rebalanceWeight field: %m");
if (r < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Access mode '%s' not valid.", optarg);
- r = json_variant_set_field_unsigned(&arg_identity_extra, "accessMode", mode);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, "accessMode", mode);
if (r < 0)
return log_error_errno(r, "Failed to set access mode field: %m");
if (r < 0)
return log_error_errno(r, "Failed to parse --luks-discard= parameter: %s", optarg);
- r = json_variant_set_field_boolean(&arg_identity_extra, "luksDiscard", r);
+ r = sd_json_variant_set_field_boolean(&arg_identity_extra, "luksDiscard", r);
if (r < 0)
return log_error_errno(r, "Failed to set discard field: %m");
if (r < 0)
return log_error_errno(r, "Failed to parse --luks-offline-discard= parameter: %s", optarg);
- r = json_variant_set_field_boolean(&arg_identity_extra, "luksOfflineDiscard", r);
+ r = sd_json_variant_set_field_boolean(&arg_identity_extra, "luksOfflineDiscard", r);
if (r < 0)
return log_error_errno(r, "Failed to set offline discard field: %m");
if (r < 0)
return log_error_errno(r, "Failed to parse %s parameter: %s", field, optarg);
- r = json_variant_set_field_unsigned(&arg_identity_extra, field, n);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, field, n);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", field);
if (r < 0)
return r;
- r = json_variant_set_field_unsigned(&arg_identity_extra, "luksSectorSize", ss);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, "luksSectorSize", ss);
if (r < 0)
return log_error_errno(r, "Failed to set sector size field: %m");
if (r < 0)
return log_error_errno(r, "Failed to parse umask: %m");
- r = json_variant_set_field_integer(&arg_identity_extra, "umask", m);
+ r = sd_json_variant_set_field_integer(&arg_identity_extra, "umask", m);
if (r < 0)
return log_error_errno(r, "Failed to set umask field: %m");
}
case ARG_SSH_AUTHORIZED_KEYS: {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_strv_free_ char **l = NULL, **add = NULL;
if (isempty(optarg)) {
return log_oom();
}
- v = json_variant_ref(json_variant_by_key(arg_identity_extra_privileged, "sshAuthorizedKeys"));
+ v = sd_json_variant_ref(sd_json_variant_by_key(arg_identity_extra_privileged, "sshAuthorizedKeys"));
if (v) {
- r = json_variant_strv(v, &l);
+ r = sd_json_variant_strv(v, &l);
if (r < 0)
return log_error_errno(r, "Failed to parse SSH authorized keys list: %m");
}
if (r < 0)
return log_oom();
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
- r = json_variant_new_array_strv(&v, l);
+ r = sd_json_variant_new_array_strv(&v, l);
if (r < 0)
return log_oom();
- r = json_variant_set_field(&arg_identity_extra_privileged, "sshAuthorizedKeys", v);
+ r = sd_json_variant_set_field(&arg_identity_extra_privileged, "sshAuthorizedKeys", v);
if (r < 0)
return log_error_errno(r, "Failed to set authorized keys: %m");
if (r < 0)
return log_error_errno(r, "Failed to parse %s parameter: %m", field);
- r = json_variant_set_field_unsigned(&arg_identity_extra, field, n);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, field, n);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", field);
break;
if (r < 0)
return log_error_errno(r, "Failed to parse %s parameter: %m", field);
- r = json_variant_set_field_unsigned(&arg_identity_extra, field, n);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, field, n);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", field);
break;
if (!string_is_safe(optarg))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Parameter for %s field not valid: %s", field, optarg);
- r = json_variant_set_field_string(
+ r = sd_json_variant_set_field_string(
IN_SET(c, ARG_STORAGE, ARG_FS_TYPE) ?
&arg_identity_extra_this_machine :
&arg_identity_extra, field, optarg);
if (r < 0)
return log_error_errno(r, "Failed to parse %s field: %s", field, optarg);
- r = json_variant_set_field_unsigned(&arg_identity_extra, field, t);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, field, t);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", field);
}
for (;;) {
- _cleanup_(json_variant_unrefp) JsonVariant *mo = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *mo = NULL;
_cleanup_strv_free_ char **list = NULL;
_cleanup_free_ char *word = NULL;
if (!valid_user_group_name(word, 0))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid group name %s.", word);
- mo = json_variant_ref(json_variant_by_key(arg_identity_extra, "memberOf"));
+ mo = sd_json_variant_ref(sd_json_variant_by_key(arg_identity_extra, "memberOf"));
- r = json_variant_strv(mo, &list);
+ r = sd_json_variant_strv(mo, &list);
if (r < 0)
return log_error_errno(r, "Failed to parse group list: %m");
strv_sort(list);
strv_uniq(list);
- mo = json_variant_unref(mo);
- r = json_variant_new_array_strv(&mo, list);
+ mo = sd_json_variant_unref(mo);
+ r = sd_json_variant_new_array_strv(&mo, list);
if (r < 0)
return log_error_errno(r, "Failed to create group list JSON: %m");
- r = json_variant_set_field(&arg_identity_extra, "memberOf", mo);
+ r = sd_json_variant_set_field(&arg_identity_extra, "memberOf", mo);
if (r < 0)
return log_error_errno(r, "Failed to update group list: %m");
}
if (r < 0)
return log_error_errno(r, "Failed to parse --tasks-max= parameter: %s", optarg);
- r = json_variant_set_field_unsigned(&arg_identity_extra, "tasksMax", u);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, "tasksMax", u);
if (r < 0)
return log_error_errno(r, "Failed to set tasksMax field: %m");
if (r < 0)
return log_error_errno(r, "Failed to parse %s parameter: %s", field, optarg);
- r = json_variant_set_field_unsigned(&arg_identity_extra_this_machine, field, u);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra_this_machine, field, u);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", field);
if (!CGROUP_WEIGHT_IS_OK(u))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Weight %" PRIu64 " is out of valid weight range.", u);
- r = json_variant_set_field_unsigned(&arg_identity_extra, field, u);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, field, u);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", field);
if (r < 0)
return log_error_errno(r, "Failed to parse --auto-resize-mode= argument: %s", optarg);
- r = json_variant_set_field_string(&arg_identity_extra, "autoResizeMode", auto_resize_mode_to_string(r));
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "autoResizeMode", auto_resize_mode_to_string(r));
if (r < 0)
return log_error_errno(r, "Failed to set autoResizeMode field: %m");
return r;
/* Add to main identity */
- r = json_variant_set_field_unsigned(&arg_identity_extra, "rebalanceWeight", u);
+ r = sd_json_variant_set_field_unsigned(&arg_identity_extra, "rebalanceWeight", u);
if (r < 0)
return log_error_errno(r, "Failed to set rebalanceWeight field: %m");
}
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
break;
case ARG_JSON:
else
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Specifying -E more than twice is not supported.");
- arg_json_format_flags &= ~JSON_FORMAT_OFF;
+ arg_json_format_flags &= ~SD_JSON_FORMAT_OFF;
if (arg_json_format_flags == 0)
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
break;
case ARG_EXPORT_FORMAT:
if (r < 0)
return r;
- r = json_variant_set_field_boolean(&arg_identity_extra, "dropCaches", r);
+ r = sd_json_variant_set_field_boolean(&arg_identity_extra, "dropCaches", r);
if (r < 0)
return log_error_errno(r, "Failed to set drop caches field: %m");
if (capability_set_to_strv(updated, &l) < 0)
return log_oom();
- r = json_variant_set_field_strv(&arg_identity_extra, field, l);
+ r = sd_json_variant_set_field_strv(&arg_identity_extra, field, l);
if (r < 0)
return log_error_errno(r, "Failed to set %s field: %m", field);
if (!strv_isempty(arg_languages)) {
char **additional;
- r = json_variant_set_field_string(&arg_identity_extra, "preferredLanguage", arg_languages[0]);
+ r = sd_json_variant_set_field_string(&arg_identity_extra, "preferredLanguage", arg_languages[0]);
if (r < 0)
return log_error_errno(r, "Failed to update preferred language: %m");
additional = strv_skip(arg_languages, 1);
if (!strv_isempty(additional)) {
- r = json_variant_set_field_strv(&arg_identity_extra, "additionalLanguages", additional);
+ r = sd_json_variant_set_field_strv(&arg_identity_extra, "additionalLanguages", additional);
if (r < 0)
return log_error_errno(r, "Failed to update additional language list: %m");
} else {
for (unsigned n_tries = 0;; n_tries++) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
if (n_tries >= 5)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
if (r < 0)
return bus_log_parse_error(r);
- r = json_parse(json, JSON_PARSE_SENSITIVE, &v, NULL, NULL);
+ r = sd_json_parse(json, SD_JSON_PARSE_SENSITIVE, &v, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to parse JSON identity: %m");
#include "strv.h"
int bus_message_read_secret(sd_bus_message *m, UserRecord **ret, sd_bus_error *error) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *full = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *full = NULL;
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
unsigned line = 0, column = 0;
const char *json;
if (r < 0)
return r;
- r = json_parse(json, JSON_PARSE_SENSITIVE, &v, &line, &column);
+ r = sd_json_parse(json, SD_JSON_PARSE_SENSITIVE, &v, &line, &column);
if (r < 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Failed to parse JSON secret record at %u:%u: %m", line, column);
- r = json_build(&full, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("secret", JSON_BUILD_VARIANT(v))));
+ r = sd_json_build(&full, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("secret", SD_JSON_BUILD_VARIANT(v))));
if (r < 0)
return r;
}
int bus_message_read_home_record(sd_bus_message *m, UserRecordLoadFlags flags, UserRecord **ret, sd_bus_error *error) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
unsigned line = 0, column = 0;
const char *json;
if (r < 0)
return r;
- r = json_parse(json, JSON_PARSE_SENSITIVE, &v, &line, &column);
+ r = sd_json_parse(json, SD_JSON_PARSE_SENSITIVE, &v, &line, &column);
if (r < 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Failed to parse JSON identity record at %u:%u: %m", line, column);
#pragma once
#include "sd-bus.h"
+#include "sd-json.h"
#include "hashmap.h"
-#include "json.h"
#include "user-record.h"
int bus_message_read_secret(sd_bus_message *m, UserRecord **ret, sd_bus_error *error);
if (r < 0)
return r;
- r = json_variant_format(augmented->json, 0, ret);
+ r = sd_json_variant_format(augmented->json, 0, ret);
if (r < 0)
return r;
#include "fs-util.h"
#include "glyph-util.h"
#include "home-util.h"
-#include "homed-home-bus.h"
#include "homed-home.h"
+#include "homed-home-bus.h"
+#include "json-util.h"
#include "memfd-util.h"
#include "missing_magic.h"
#include "missing_mman.h"
return -EINVAL;
if (FLAGS_SET(h->record->mask, USER_RECORD_STATUS)) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
/* Hmm, the existing record has status fields? If so, copy them over */
- v = json_variant_ref(hr->json);
- r = json_variant_set_field(&v, "status", json_variant_by_key(h->record->json, "status"));
+ v = sd_json_variant_ref(hr->json);
+ r = sd_json_variant_set_field(&v, "status", sd_json_variant_by_key(h->record->json, "status"));
if (r < 0)
return r;
}
int home_save_record(Home *h) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *text = NULL;
const char *fn;
int r;
assert(h);
- v = json_variant_ref(h->record->json);
- r = json_variant_normalize(&v);
+ v = sd_json_variant_ref(h->record->json);
+ r = sd_json_variant_normalize(&v);
if (r < 0)
log_warning_errno(r, "User record could not be normalized.");
- r = json_variant_format(v, JSON_FORMAT_PRETTY|JSON_FORMAT_NEWLINE, &text);
+ r = sd_json_variant_format(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_NEWLINE, &text);
if (r < 0)
return r;
}
static int home_parse_worker_stdout(int _fd, UserRecord **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_close_ int fd = _fd; /* take possession, even on failure */
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
_cleanup_fclose_ FILE *f = NULL;
rewind(f);
}
- r = json_parse_file(f, "stdout", JSON_PARSE_SENSITIVE, &v, &line, &column);
+ r = sd_json_parse_file(f, "stdout", SD_JSON_PARSE_SENSITIVE, &v, &line, &column);
if (r < 0)
return log_error_errno(r, "Failed to parse identity at %u:%u: %m", line, column);
UserRecord *secret,
Hashmap *blobs,
uint64_t flags) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *fdmap = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *fdmap = NULL;
_cleanup_(erase_and_freep) char *formatted = NULL;
_cleanup_close_ int stdin_fd = -EBADF, stdout_fd = -EBADF;
_cleanup_free_ int *blob_fds = NULL;
assert(h->worker_stdout_fd < 0);
assert(!h->worker_event_source);
- v = json_variant_ref(hr->json);
+ v = sd_json_variant_ref(hr->json);
if (secret) {
- JsonVariant *sub = NULL;
+ sd_json_variant *sub = NULL;
- sub = json_variant_by_key(secret->json, "secret");
+ sub = sd_json_variant_by_key(secret->json, "secret");
if (!sub)
return -ENOKEY;
- r = json_variant_set_field(&v, "secret", sub);
+ r = sd_json_variant_set_field(&v, "secret", sub);
if (r < 0)
return r;
}
/* homework needs to be able to tell the difference between blobs being null
* (the fdmap field is completely missing) and it being empty (the field is an
* empty object) */
- r = json_variant_new_object(&fdmap, NULL, 0);
+ r = sd_json_variant_new_object(&fdmap, NULL, 0);
if (r < 0)
return r;
HASHMAP_FOREACH_KEY(fd_ptr, blob_filename, blobs) {
blob_fds[i] = PTR_TO_FD(fd_ptr);
- r = json_variant_set_field_integer(&fdmap, blob_filename, i);
+ r = sd_json_variant_set_field_integer(&fdmap, blob_filename, i);
if (r < 0)
return r;
i++;
}
- r = json_variant_set_field(&v, HOMEWORK_BLOB_FDMAP_FIELD, fdmap);
+ r = sd_json_variant_set_field(&v, HOMEWORK_BLOB_FDMAP_FIELD, fdmap);
if (r < 0)
return r;
}
- r = json_variant_format(v, 0, &formatted);
+ r = sd_json_variant_format(v, 0, &formatted);
if (r < 0)
return r;
}
static int user_record_extend_with_binding(UserRecord *hr, UserRecord *with_binding, UserRecordLoadFlags flags, UserRecord **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *nr = NULL;
- JsonVariant *binding;
+ sd_json_variant *binding;
int r;
assert(hr);
assert(with_binding);
assert(ret);
- assert_se(v = json_variant_ref(hr->json));
+ assert_se(v = sd_json_variant_ref(hr->json));
- binding = json_variant_by_key(with_binding->json, "binding");
+ binding = sd_json_variant_by_key(with_binding->json, "binding");
if (binding) {
- r = json_variant_set_field(&v, "binding", binding);
+ r = sd_json_variant_set_field(&v, "binding", binding);
if (r < 0)
return r;
}
UserRecord **ret) {
uint64_t disk_size = UINT64_MAX, disk_usage = UINT64_MAX, disk_free = UINT64_MAX, disk_ceiling = UINT64_MAX, disk_floor = UINT64_MAX;
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL, *v = NULL, *m = NULL, *status = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL, *v = NULL, *m = NULL, *status = NULL;
_cleanup_(user_record_unrefp) UserRecord *ur = NULL;
statfs_f_type_t magic;
const char *fstype;
if (disk_ceiling == UINT64_MAX || disk_ceiling > USER_DISK_SIZE_MAX)
disk_ceiling = USER_DISK_SIZE_MAX;
- r = json_build(&status,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("state", JSON_BUILD_STRING(home_state_to_string(state))),
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Home")),
- JSON_BUILD_PAIR("useFallback", JSON_BUILD_BOOLEAN(!HOME_STATE_IS_ACTIVE(state))),
- JSON_BUILD_PAIR("fallbackShell", JSON_BUILD_CONST_STRING(BINDIR "/systemd-home-fallback-shell")),
- JSON_BUILD_PAIR("fallbackHomeDirectory", JSON_BUILD_CONST_STRING("/")),
- JSON_BUILD_PAIR_CONDITION(disk_size != UINT64_MAX, "diskSize", JSON_BUILD_UNSIGNED(disk_size)),
- JSON_BUILD_PAIR_CONDITION(disk_usage != UINT64_MAX, "diskUsage", JSON_BUILD_UNSIGNED(disk_usage)),
- JSON_BUILD_PAIR_CONDITION(disk_free != UINT64_MAX, "diskFree", JSON_BUILD_UNSIGNED(disk_free)),
- JSON_BUILD_PAIR_CONDITION(disk_ceiling != UINT64_MAX, "diskCeiling", JSON_BUILD_UNSIGNED(disk_ceiling)),
- JSON_BUILD_PAIR_CONDITION(disk_floor != UINT64_MAX, "diskFloor", JSON_BUILD_UNSIGNED(disk_floor)),
- JSON_BUILD_PAIR_CONDITION(h->signed_locally >= 0, "signedLocally", JSON_BUILD_BOOLEAN(h->signed_locally)),
- JSON_BUILD_PAIR_CONDITION(fstype, "fileSystemType", JSON_BUILD_STRING(fstype)),
- JSON_BUILD_PAIR_CONDITION(access_mode != MODE_INVALID, "accessMode", JSON_BUILD_UNSIGNED(access_mode))
+ r = sd_json_build(&status,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("state", SD_JSON_BUILD_STRING(home_state_to_string(state))),
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Home")),
+ SD_JSON_BUILD_PAIR("useFallback", SD_JSON_BUILD_BOOLEAN(!HOME_STATE_IS_ACTIVE(state))),
+ SD_JSON_BUILD_PAIR("fallbackShell", JSON_BUILD_CONST_STRING(BINDIR "/systemd-home-fallback-shell")),
+ SD_JSON_BUILD_PAIR("fallbackHomeDirectory", JSON_BUILD_CONST_STRING("/")),
+ SD_JSON_BUILD_PAIR_CONDITION(disk_size != UINT64_MAX, "diskSize", SD_JSON_BUILD_UNSIGNED(disk_size)),
+ SD_JSON_BUILD_PAIR_CONDITION(disk_usage != UINT64_MAX, "diskUsage", SD_JSON_BUILD_UNSIGNED(disk_usage)),
+ SD_JSON_BUILD_PAIR_CONDITION(disk_free != UINT64_MAX, "diskFree", SD_JSON_BUILD_UNSIGNED(disk_free)),
+ SD_JSON_BUILD_PAIR_CONDITION(disk_ceiling != UINT64_MAX, "diskCeiling", SD_JSON_BUILD_UNSIGNED(disk_ceiling)),
+ SD_JSON_BUILD_PAIR_CONDITION(disk_floor != UINT64_MAX, "diskFloor", SD_JSON_BUILD_UNSIGNED(disk_floor)),
+ SD_JSON_BUILD_PAIR_CONDITION(h->signed_locally >= 0, "signedLocally", SD_JSON_BUILD_BOOLEAN(h->signed_locally)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!fstype, "fileSystemType", SD_JSON_BUILD_STRING(fstype)),
+ SD_JSON_BUILD_PAIR_CONDITION(access_mode != MODE_INVALID, "accessMode", SD_JSON_BUILD_UNSIGNED(access_mode))
));
if (r < 0)
return r;
- j = json_variant_ref(h->record->json);
- v = json_variant_ref(json_variant_by_key(j, "status"));
- m = json_variant_ref(json_variant_by_key(v, SD_ID128_TO_STRING(id)));
+ j = sd_json_variant_ref(h->record->json);
+ v = sd_json_variant_ref(sd_json_variant_by_key(j, "status"));
+ m = sd_json_variant_ref(sd_json_variant_by_key(v, SD_ID128_TO_STRING(id)));
- r = json_variant_filter(&m, STRV_MAKE("diskSize", "diskUsage", "diskFree", "diskCeiling", "diskFloor", "signedLocally"));
+ r = sd_json_variant_filter(&m, STRV_MAKE("diskSize", "diskUsage", "diskFree", "diskCeiling", "diskFloor", "signedLocally"));
if (r < 0)
return r;
- r = json_variant_merge_object(&m, status);
+ r = sd_json_variant_merge_object(&m, status);
if (r < 0)
return r;
- r = json_variant_set_field(&v, SD_ID128_TO_STRING(id), m);
+ r = sd_json_variant_set_field(&v, SD_ID128_TO_STRING(id), m);
if (r < 0)
return r;
- r = json_variant_set_field(&j, "status", v);
+ r = sd_json_variant_set_field(&j, "status", v);
if (r < 0)
return r;
int dir_fd,
const char *fname) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
unsigned line, column;
int r, is_signed;
if (st.st_size == 0)
goto unlink_this_file;
- r = json_parse_file_at(NULL, dir_fd, fname, JSON_PARSE_SENSITIVE, &v, &line, &column);
+ r = sd_json_parse_file_at(NULL, dir_fd, fname, SD_JSON_PARSE_SENSITIVE, &v, &line, &column);
if (r < 0)
return log_error_errno(r, "Failed to parse identity record at %s:%u%u: %m", fname, line, column);
- if (json_variant_is_blank_object(v))
+ if (sd_json_variant_is_blank_object(v))
goto unlink_this_file;
hr = user_record_new();
return peer_uid == 0 || peer_uid == h->uid;
}
-static int build_user_json(Home *h, bool trusted, JsonVariant **ret) {
+static int build_user_json(Home *h, bool trusted, sd_json_variant **ret) {
_cleanup_(user_record_unrefp) UserRecord *augmented = NULL;
UserRecordLoadFlags flags;
int r;
if (r < 0)
return r;
- return json_build(ret, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("record", JSON_BUILD_VARIANT(augmented->json)),
- JSON_BUILD_PAIR("incomplete", JSON_BUILD_BOOLEAN(augmented->incomplete))));
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_VARIANT(augmented->json)),
+ SD_JSON_BUILD_PAIR("incomplete", SD_JSON_BUILD_BOOLEAN(augmented->incomplete))));
}
static bool home_user_match_lookup_parameters(LookupParameters *p, Home *h) {
return true;
}
-int vl_method_get_user_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+int vl_method_get_user_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "uid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
LookupParameters p = {
.uid = UID_INVALID,
};
if (r < 0)
return r;
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
}
trusted = client_is_trusted(link, h);
return varlink_reply(link, v);
}
-static int build_group_json(Home *h, JsonVariant **ret) {
+static int build_group_json(Home *h, sd_json_variant **ret) {
_cleanup_(group_record_unrefp) GroupRecord *g = NULL;
int r;
assert(!FLAGS_SET(g->mask, USER_RECORD_SECRET));
assert(!FLAGS_SET(g->mask, USER_RECORD_PRIVILEGED));
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("record", JSON_BUILD_VARIANT(g->json))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_VARIANT(g->json))));
}
static bool home_group_match_lookup_parameters(LookupParameters *p, Home *h) {
return true;
}
-int vl_method_get_group_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+int vl_method_get_group_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
LookupParameters p = {
.gid = GID_INVALID,
};
if (r < 0)
return r;
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
}
r = build_group_json(h, &v);
return varlink_reply(link, v);
}
-int vl_method_get_memberships(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+int vl_method_get_memberships(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), JSON_SAFE },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), SD_JSON_SAFE },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
if (!strv_contains(h->record->member_of, p.group_name))
return varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
- return varlink_replyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(h->user_name)),
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(p.group_name))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(h->user_name)),
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(p.group_name))));
}
STRV_FOREACH(i, h->record->member_of) {
if (last) {
- r = varlink_notifyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(h->user_name)),
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(last))));
+ r = varlink_notifyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(h->user_name)),
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(last))));
if (r < 0)
return r;
}
}
if (last)
- return varlink_replyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(h->user_name)),
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(last))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(h->user_name)),
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(last))));
} else if (p.group_name) {
const char *last = NULL;
continue;
if (last) {
- r = varlink_notifyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(last)),
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(p.group_name))));
+ r = varlink_notifyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(last)),
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(p.group_name))));
if (r < 0)
return r;
}
}
if (last)
- return varlink_replyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(last)),
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(p.group_name))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(last)),
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(p.group_name))));
} else {
const char *last_user_name = NULL, *last_group_name = NULL;
if (last_user_name) {
assert(last_group_name);
- r = varlink_notifyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(last_user_name)),
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(last_group_name))));
+ r = varlink_notifyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(last_user_name)),
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(last_group_name))));
if (r < 0)
return r;
if (last_user_name) {
assert(last_group_name);
- return varlink_replyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(last_user_name)),
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(last_group_name))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(last_user_name)),
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(last_group_name))));
}
}
#include "homed-manager.h"
-int vl_method_get_user_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
-int vl_method_get_group_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
-int vl_method_get_memberships(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
+int vl_method_get_user_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
+int vl_method_get_group_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
+int vl_method_get_memberships(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
#include "homework-luks.h"
#include "homework-mount.h"
#include "io-util.h"
+#include "json-util.h"
#include "keyring-util.h"
#include "memory-util.h"
#include "missing_magic.h"
assert(h);
for (int token = 0; token < sym_crypt_token_max(CRYPT_LUKS2); token++) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *rr = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *rr = NULL;
_cleanup_(EVP_CIPHER_CTX_freep) EVP_CIPHER_CTX *context = NULL;
_cleanup_(user_record_unrefp) UserRecord *lhr = NULL;
_cleanup_free_ void *encrypted = NULL, *iv = NULL;
_cleanup_free_ char *decrypted = NULL;
const char *text, *type;
crypt_token_info state;
- JsonVariant *jr, *jiv;
+ sd_json_variant *jr, *jiv;
unsigned line, column;
const EVP_CIPHER *cc;
if (r < 0)
return log_error_errno(r, "Failed to read LUKS token %i: %m", token);
- r = json_parse(text, JSON_PARSE_SENSITIVE, &v, &line, &column);
+ r = sd_json_parse(text, SD_JSON_PARSE_SENSITIVE, &v, &line, &column);
if (r < 0)
return log_error_errno(r, "Failed to parse LUKS token JSON data %u:%u: %m", line, column);
- jr = json_variant_by_key(v, "record");
+ jr = sd_json_variant_by_key(v, "record");
if (!jr)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "LUKS token lacks 'record' field.");
- jiv = json_variant_by_key(v, "iv");
+ jiv = sd_json_variant_by_key(v, "iv");
if (!jiv)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "LUKS token lacks 'iv' field.");
- r = json_variant_unbase64(jr, &encrypted, &encrypted_size);
+ r = sd_json_variant_unbase64(jr, &encrypted, &encrypted_size);
if (r < 0)
return log_error_errno(r, "Failed to base64 decode record: %m");
- r = json_variant_unbase64(jiv, &iv, &iv_size);
+ r = sd_json_variant_unbase64(jiv, &iv, &iv_size);
if (r < 0)
return log_error_errno(r, "Failed to base64 decode IV: %m");
decrypted[decrypted_size] = 0;
- r = json_parse(decrypted, JSON_PARSE_SENSITIVE, &rr, NULL, NULL);
+ r = sd_json_parse(decrypted, SD_JSON_PARSE_SENSITIVE, &rr, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to parse decrypted JSON record, refusing.");
int r, encrypted_size_out1 = 0, encrypted_size_out2 = 0, iv_size, key_size;
_cleanup_(EVP_CIPHER_CTX_freep) EVP_CIPHER_CTX *context = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ void *iv = NULL, *encrypted = NULL;
size_t text_length, encrypted_size;
_cleanup_free_ char *text = NULL;
if (EVP_EncryptInit_ex(context, cc, NULL, volume_key, iv) != 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to initialize encryption context.");
- r = json_variant_format(hr->json, 0, &text);
+ r = sd_json_variant_format(hr->json, 0, &text);
if (r < 0)
return log_error_errno(r, "Failed to format user record for LUKS: %m");
assert((size_t) encrypted_size_out1 + (size_t) encrypted_size_out2 <= encrypted_size);
- r = json_build(&v,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-homed")),
- JSON_BUILD_PAIR("keyslots", JSON_BUILD_EMPTY_ARRAY),
- JSON_BUILD_PAIR("record", JSON_BUILD_BASE64(encrypted, encrypted_size_out1 + encrypted_size_out2)),
- JSON_BUILD_PAIR("iv", JSON_BUILD_BASE64(iv, iv_size))));
+ r = sd_json_build(&v,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-homed")),
+ SD_JSON_BUILD_PAIR("keyslots", SD_JSON_BUILD_EMPTY_ARRAY),
+ SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_BASE64(encrypted, encrypted_size_out1 + encrypted_size_out2)),
+ SD_JSON_BUILD_PAIR("iv", SD_JSON_BUILD_BASE64(iv, iv_size))));
if (r < 0)
return log_error_errno(r, "Failed to prepare LUKS JSON token object: %m");
- r = json_variant_format(v, 0, ret);
+ r = sd_json_variant_format(v, 0, ret);
if (r < 0)
return log_error_errno(r, "Failed to format encrypted user record for LUKS: %m");
#include "format-util.h"
#include "fs-util.h"
#include "home-util.h"
+#include "homework.h"
#include "homework-blob.h"
#include "homework-cifs.h"
#include "homework-directory.h"
#include "homework-luks.h"
#include "homework-mount.h"
#include "homework-pkcs11.h"
-#include "homework.h"
+#include "json-util.h"
#include "libcrypt-util.h"
#include "main-func.h"
#include "memory-util.h"
/* First, let's see if we already have a volume key from the keyring */
if (cache->volume_key &&
- json_variant_is_blank_object(json_variant_by_key(secret->json, "secret"))) {
+ sd_json_variant_is_blank_object(sd_json_variant_by_key(secret->json, "secret"))) {
log_info("LUKS volume key from keyring unlocks user record.");
return 1;
}
return 0;
}
-static int read_identity_file(int root_fd, JsonVariant **ret) {
+static int read_identity_file(int root_fd, sd_json_variant **ret) {
_cleanup_fclose_ FILE *identity_file = NULL;
_cleanup_close_ int identity_fd = -EBADF;
unsigned line, column;
if (!identity_file)
return log_oom();
- r = json_parse_file(identity_file, ".identity", JSON_PARSE_SENSITIVE, ret, &line, &column);
+ r = sd_json_parse_file(identity_file, ".identity", SD_JSON_PARSE_SENSITIVE, ret, &line, &column);
if (r < 0)
return log_error_errno(r, "[.identity:%u:%u] Failed to parse JSON data: %m", line, column);
return 0;
}
-static int write_identity_file(int root_fd, JsonVariant *v, uid_t uid) {
- _cleanup_(json_variant_unrefp) JsonVariant *normalized = NULL;
+static int write_identity_file(int root_fd, sd_json_variant *v, uid_t uid) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *normalized = NULL;
_cleanup_fclose_ FILE *identity_file = NULL;
_cleanup_close_ int identity_fd = -EBADF;
_cleanup_free_ char *fn = NULL;
assert(root_fd >= 0);
assert(v);
- normalized = json_variant_ref(v);
+ normalized = sd_json_variant_ref(v);
- r = json_variant_normalize(&normalized);
+ r = sd_json_variant_normalize(&normalized);
if (r < 0)
log_warning_errno(r, "Failed to normalize user record, ignoring: %m");
goto fail;
}
- json_variant_dump(normalized, JSON_FORMAT_PRETTY, identity_file, NULL);
+ sd_json_variant_dump(normalized, SD_JSON_FORMAT_PRETTY, identity_file, NULL);
r = fflush_and_check(identity_file);
if (r < 0) {
UserRecord **ret_new_home) {
_cleanup_(user_record_unrefp) UserRecord *embedded_home = NULL, *intermediate_home = NULL, *new_home = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(h);
static int run(int argc, char *argv[]) {
_cleanup_(user_record_unrefp) UserRecord *home = NULL, *new_home = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_fclose_ FILE *opened_file = NULL;
_cleanup_hashmap_free_ Hashmap *blobs = NULL;
unsigned line = 0, column = 0;
const char *json_path = NULL, *blob_filename;
FILE *json_file;
usec_t start;
- JsonVariant *fdmap, *blob_fd_variant;
+ sd_json_variant *fdmap, *blob_fd_variant;
int r;
start = now(CLOCK_MONOTONIC);
json_file = stdin;
}
- r = json_parse_file(json_file, json_path, JSON_PARSE_SENSITIVE, &v, &line, &column);
+ r = sd_json_parse_file(json_file, json_path, SD_JSON_PARSE_SENSITIVE, &v, &line, &column);
if (r < 0)
return log_error_errno(r, "[%s:%u:%u] Failed to parse JSON data: %m", json_path, line, column);
- fdmap = json_variant_by_key(v, HOMEWORK_BLOB_FDMAP_FIELD);
+ fdmap = sd_json_variant_by_key(v, HOMEWORK_BLOB_FDMAP_FIELD);
if (fdmap) {
r = hashmap_ensure_allocated(&blobs, &blob_fd_hash_ops);
if (r < 0)
_cleanup_free_ char *filename = NULL;
_cleanup_close_ int fd = -EBADF;
- assert(json_variant_is_integer(blob_fd_variant));
- assert(json_variant_integer(blob_fd_variant) >= 0);
- assert(json_variant_integer(blob_fd_variant) <= INT_MAX - SD_LISTEN_FDS_START);
- fd = SD_LISTEN_FDS_START + (int) json_variant_integer(blob_fd_variant);
+ assert(sd_json_variant_is_integer(blob_fd_variant));
+ assert(sd_json_variant_integer(blob_fd_variant) >= 0);
+ assert(sd_json_variant_integer(blob_fd_variant) <= INT_MAX - SD_LISTEN_FDS_START);
+ fd = SD_LISTEN_FDS_START + (int) sd_json_variant_integer(blob_fd_variant);
if (DEBUG_LOGGING) {
_cleanup_free_ char *resolved = NULL;
TAKE_FD(fd);
}
- r = json_variant_filter(&v, STRV_MAKE(HOMEWORK_BLOB_FDMAP_FIELD));
+ r = sd_json_variant_filter(&v, STRV_MAKE(HOMEWORK_BLOB_FDMAP_FIELD));
if (r < 0)
return log_error_errno(r, "Failed to strip internal fdmap from JSON: %m");
}
* prepare a fresh record, send to us, and only if it works use it without having to keep a local
* copy. */
if (new_home)
- json_variant_dump(new_home->json, JSON_FORMAT_NEWLINE, stdout, NULL);
+ sd_json_variant_dump(new_home->json, SD_JSON_FORMAT_NEWLINE, stdout, NULL);
return 0;
}
PamBusData **bus_data) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *ur = NULL;
_cleanup_free_ char *homed_field = NULL;
const char *json = NULL;
TAKE_PTR(json_copy);
}
- r = json_parse(json, JSON_PARSE_SENSITIVE, &v, NULL, NULL);
+ r = sd_json_parse(json, SD_JSON_PARSE_SENSITIVE, &v, NULL, NULL);
if (r < 0)
return pam_syslog_errno(handle, LOG_ERR, r, "Failed to parse JSON user record: %m");
#include "fd-util.h"
#include "fileio.h"
+#include "json-util.h"
#include "memstream-util.h"
#include "openssl-util.h"
#include "user-record-sign.h"
static int user_record_signable_json(UserRecord *ur, char **ret) {
_cleanup_(user_record_unrefp) UserRecord *reduced = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
int r;
assert(ur);
if (r < 0)
return r;
- j = json_variant_ref(reduced->json);
+ j = sd_json_variant_ref(reduced->json);
- r = json_variant_normalize(&j);
+ r = sd_json_variant_normalize(&j);
if (r < 0)
return r;
- return json_variant_format(j, 0, ret);
+ return sd_json_variant_format(j, 0, ret);
}
int user_record_sign(UserRecord *ur, EVP_PKEY *private_key, UserRecord **ret) {
_cleanup_(memstream_done) MemStream m = {};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *signed_ur = NULL;
_cleanup_free_ char *text = NULL, *key = NULL;
_cleanup_free_ void *signature = NULL;
if (r < 0)
return r;
- v = json_variant_ref(ur->json);
+ v = sd_json_variant_ref(ur->json);
- r = json_variant_set_fieldb(
+ r = sd_json_variant_set_fieldb(
&v,
"signature",
- JSON_BUILD_ARRAY(
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("data", JSON_BUILD_BASE64(signature, signature_size)),
- JSON_BUILD_PAIR("key", JSON_BUILD_STRING(key)))));
+ SD_JSON_BUILD_ARRAY(
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("data", SD_JSON_BUILD_BASE64(signature, signature_size)),
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_STRING(key)))));
if (r < 0)
return r;
if (DEBUG_LOGGING)
- json_variant_dump(v, JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR_AUTO, NULL, NULL);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL);
signed_ur = user_record_new();
if (!signed_ur)
int user_record_verify(UserRecord *ur, EVP_PKEY *public_key) {
_cleanup_free_ char *text = NULL;
unsigned n_good = 0, n_bad = 0;
- JsonVariant *array, *e;
+ sd_json_variant *array, *e;
int r;
assert(ur);
assert(public_key);
- array = json_variant_by_key(ur->json, "signature");
+ array = sd_json_variant_by_key(ur->json, "signature");
if (!array)
return USER_RECORD_UNSIGNED;
- if (!json_variant_is_array(array))
+ if (!sd_json_variant_is_array(array))
return -EINVAL;
- if (json_variant_elements(array) == 0)
+ if (sd_json_variant_elements(array) == 0)
return USER_RECORD_UNSIGNED;
r = user_record_signable_json(ur, &text);
_cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX *md_ctx = NULL;
_cleanup_free_ void *signature = NULL;
size_t signature_size = 0;
- JsonVariant *data;
+ sd_json_variant *data;
- if (!json_variant_is_object(e))
+ if (!sd_json_variant_is_object(e))
return -EINVAL;
- data = json_variant_by_key(e, "data");
+ data = sd_json_variant_by_key(e, "data");
if (!data)
return -EINVAL;
- r = json_variant_unbase64(data, &signature, &signature_size);
+ r = sd_json_variant_unbase64(data, &signature, &signature_size);
if (r < 0)
return r;
}
int user_record_has_signature(UserRecord *ur) {
- JsonVariant *array;
+ sd_json_variant *array;
- array = json_variant_by_key(ur->json, "signature");
+ array = sd_json_variant_by_key(ur->json, "signature");
if (!array)
return false;
- if (!json_variant_is_array(array))
+ if (!sd_json_variant_is_array(array))
return -EINVAL;
- return json_variant_elements(array) > 0;
+ return sd_json_variant_elements(array) > 0;
}
#include <sys/xattr.h>
+#include "sd-json.h"
+
#include "errno-util.h"
#include "fd-util.h"
#include "home-util.h"
#include "id128-util.h"
+#include "json-util.h"
#include "libcrypt-util.h"
#include "memory-util.h"
-#include "recovery-key.h"
#include "mountpoint-util.h"
#include "path-util.h"
+#include "recovery-key.h"
#include "sha256.h"
#include "stat-util.h"
#include "user-record-util.h"
if (!hd)
return -ENOMEM;
- r = json_build(&h->json,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(user_name)),
- JSON_BUILD_PAIR_CONDITION(!!rr, "realm", JSON_BUILD_STRING(realm)),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("regular")),
- JSON_BUILD_PAIR("binding", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR(SD_ID128_TO_STRING(mid), JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("imagePath", JSON_BUILD_STRING(image_path)),
- JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_STRING(hd)),
- JSON_BUILD_PAIR("storage", JSON_BUILD_STRING(user_storage_to_string(storage))),
- JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(uid)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(gid))))))));
+ r = sd_json_build(&h->json,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(user_name)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!rr, "realm", SD_JSON_BUILD_STRING(realm)),
+ SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("regular")),
+ SD_JSON_BUILD_PAIR("binding", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR(SD_ID128_TO_STRING(mid), SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("imagePath", SD_JSON_BUILD_STRING(image_path)),
+ SD_JSON_BUILD_PAIR("homeDirectory", SD_JSON_BUILD_STRING(hd)),
+ SD_JSON_BUILD_PAIR("storage", SD_JSON_BUILD_STRING(user_storage_to_string(storage))),
+ SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(uid)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(gid))))))));
if (r < 0)
return r;
if (!description)
return -ENOMEM;
- r = json_build(&g->json,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(un)),
- JSON_BUILD_PAIR_CONDITION(!!rr, "realm", JSON_BUILD_STRING(rr)),
- JSON_BUILD_PAIR("description", JSON_BUILD_STRING(description)),
- JSON_BUILD_PAIR("binding", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR(SD_ID128_TO_STRING(mid), JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(user_record_gid(h))))))),
- JSON_BUILD_PAIR_CONDITION(h->disposition >= 0, "disposition", JSON_BUILD_STRING(user_disposition_to_string(user_record_disposition(h)))),
- JSON_BUILD_PAIR("status", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR(SD_ID128_TO_STRING(mid), JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Home"))))))));
+ r = sd_json_build(&g->json,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(un)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!rr, "realm", SD_JSON_BUILD_STRING(rr)),
+ SD_JSON_BUILD_PAIR("description", SD_JSON_BUILD_STRING(description)),
+ SD_JSON_BUILD_PAIR("binding", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR(SD_ID128_TO_STRING(mid), SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(user_record_gid(h))))))),
+ SD_JSON_BUILD_PAIR_CONDITION(h->disposition >= 0, "disposition", SD_JSON_BUILD_STRING(user_disposition_to_string(user_record_disposition(h)))),
+ SD_JSON_BUILD_PAIR("status", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR(SD_ID128_TO_STRING(mid), SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Home"))))))));
if (r < 0)
return r;
} else
result = USER_RECONCILE_HOST_WON;
} else {
- _cleanup_(json_variant_unrefp) JsonVariant *extended = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *extended = NULL;
_cleanup_(user_record_unrefp) UserRecord *merged = NULL;
- JsonVariant *e;
+ sd_json_variant *e;
/* The embedded version is newer */
return -ESTALE;
/* Copy in the binding data */
- extended = json_variant_ref(embedded->json);
+ extended = sd_json_variant_ref(embedded->json);
- e = json_variant_by_key(host->json, "binding");
+ e = sd_json_variant_by_key(host->json, "binding");
if (e) {
- r = json_variant_set_field(&extended, "binding", e);
+ r = sd_json_variant_set_field(&extended, "binding", e);
if (r < 0)
return r;
}
uid_t uid,
gid_t gid) {
- _cleanup_(json_variant_unrefp) JsonVariant *new_binding_entry = NULL, *binding = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *new_binding_entry = NULL, *binding = NULL;
_cleanup_free_ char *blob = NULL, *ip = NULL, *hd = NULL, *ip_auto = NULL, *lc = NULL, *lcm = NULL, *fst = NULL;
sd_id128_t mid;
int r;
return -ENOMEM;
}
- r = json_build(&new_binding_entry,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("blobDirectory", JSON_BUILD_STRING(blob)),
- JSON_BUILD_PAIR_CONDITION(!!image_path, "imagePath", JSON_BUILD_STRING(image_path)),
- JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(partition_uuid), "partitionUuid", JSON_BUILD_STRING(SD_ID128_TO_UUID_STRING(partition_uuid))),
- JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(luks_uuid), "luksUuid", JSON_BUILD_STRING(SD_ID128_TO_UUID_STRING(luks_uuid))),
- JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(fs_uuid), "fileSystemUuid", JSON_BUILD_STRING(SD_ID128_TO_UUID_STRING(fs_uuid))),
- JSON_BUILD_PAIR_CONDITION(!!luks_cipher, "luksCipher", JSON_BUILD_STRING(luks_cipher)),
- JSON_BUILD_PAIR_CONDITION(!!luks_cipher_mode, "luksCipherMode", JSON_BUILD_STRING(luks_cipher_mode)),
- JSON_BUILD_PAIR_CONDITION(luks_volume_key_size != UINT64_MAX, "luksVolumeKeySize", JSON_BUILD_UNSIGNED(luks_volume_key_size)),
- JSON_BUILD_PAIR_CONDITION(!!file_system_type, "fileSystemType", JSON_BUILD_STRING(file_system_type)),
- JSON_BUILD_PAIR_CONDITION(!!home_directory, "homeDirectory", JSON_BUILD_STRING(home_directory)),
- JSON_BUILD_PAIR_CONDITION(uid_is_valid(uid), "uid", JSON_BUILD_UNSIGNED(uid)),
- JSON_BUILD_PAIR_CONDITION(gid_is_valid(gid), "gid", JSON_BUILD_UNSIGNED(gid)),
- JSON_BUILD_PAIR_CONDITION(storage >= 0, "storage", JSON_BUILD_STRING(user_storage_to_string(storage)))));
+ r = sd_json_build(&new_binding_entry,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("blobDirectory", SD_JSON_BUILD_STRING(blob)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!image_path, "imagePath", SD_JSON_BUILD_STRING(image_path)),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(partition_uuid), "partitionUuid", SD_JSON_BUILD_STRING(SD_ID128_TO_UUID_STRING(partition_uuid))),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(luks_uuid), "luksUuid", SD_JSON_BUILD_STRING(SD_ID128_TO_UUID_STRING(luks_uuid))),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(fs_uuid), "fileSystemUuid", SD_JSON_BUILD_STRING(SD_ID128_TO_UUID_STRING(fs_uuid))),
+ SD_JSON_BUILD_PAIR_CONDITION(!!luks_cipher, "luksCipher", SD_JSON_BUILD_STRING(luks_cipher)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!luks_cipher_mode, "luksCipherMode", SD_JSON_BUILD_STRING(luks_cipher_mode)),
+ SD_JSON_BUILD_PAIR_CONDITION(luks_volume_key_size != UINT64_MAX, "luksVolumeKeySize", SD_JSON_BUILD_UNSIGNED(luks_volume_key_size)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!file_system_type, "fileSystemType", SD_JSON_BUILD_STRING(file_system_type)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!home_directory, "homeDirectory", SD_JSON_BUILD_STRING(home_directory)),
+ SD_JSON_BUILD_PAIR_CONDITION(uid_is_valid(uid), "uid", SD_JSON_BUILD_UNSIGNED(uid)),
+ SD_JSON_BUILD_PAIR_CONDITION(gid_is_valid(gid), "gid", SD_JSON_BUILD_UNSIGNED(gid)),
+ SD_JSON_BUILD_PAIR_CONDITION(storage >= 0, "storage", SD_JSON_BUILD_STRING(user_storage_to_string(storage)))));
if (r < 0)
return r;
- binding = json_variant_ref(json_variant_by_key(h->json, "binding"));
+ binding = sd_json_variant_ref(sd_json_variant_by_key(h->json, "binding"));
if (binding) {
- _cleanup_(json_variant_unrefp) JsonVariant *be = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *be = NULL;
/* Merge the new entry with an old one, if that exists */
- be = json_variant_ref(json_variant_by_key(binding, SD_ID128_TO_STRING(mid)));
+ be = sd_json_variant_ref(sd_json_variant_by_key(binding, SD_ID128_TO_STRING(mid)));
if (be) {
- r = json_variant_merge_object(&be, new_binding_entry);
+ r = sd_json_variant_merge_object(&be, new_binding_entry);
if (r < 0)
return r;
- json_variant_unref(new_binding_entry);
+ sd_json_variant_unref(new_binding_entry);
new_binding_entry = TAKE_PTR(be);
}
}
- r = json_variant_set_field(&binding, SD_ID128_TO_STRING(mid), new_binding_entry);
+ r = sd_json_variant_set_field(&binding, SD_ID128_TO_STRING(mid), new_binding_entry);
if (r < 0)
return r;
- r = json_variant_set_field(&h->json, "binding", binding);
+ r = sd_json_variant_set_field(&h->json, "binding", binding);
if (r < 0)
return r;
}
int user_record_set_disk_size(UserRecord *h, uint64_t disk_size) {
- _cleanup_(json_variant_unrefp) JsonVariant *new_per_machine = NULL, *midv = NULL, *midav = NULL, *ne = NULL;
- _cleanup_free_ JsonVariant **array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *new_per_machine = NULL, *midv = NULL, *midav = NULL, *ne = NULL;
+ _cleanup_free_ sd_json_variant **array = NULL;
size_t idx = SIZE_MAX, n;
- JsonVariant *per_machine;
+ sd_json_variant *per_machine;
sd_id128_t mid;
int r;
if (r < 0)
return r;
- r = json_variant_new_string(&midv, SD_ID128_TO_STRING(mid));
+ r = sd_json_variant_new_string(&midv, SD_ID128_TO_STRING(mid));
if (r < 0)
return r;
- r = json_variant_new_array(&midav, (JsonVariant*[]) { midv }, 1);
+ r = sd_json_variant_new_array(&midav, (sd_json_variant*[]) { midv }, 1);
if (r < 0)
return r;
- per_machine = json_variant_by_key(h->json, "perMachine");
+ per_machine = sd_json_variant_by_key(h->json, "perMachine");
if (per_machine) {
size_t i;
- if (!json_variant_is_array(per_machine))
+ if (!sd_json_variant_is_array(per_machine))
return -EINVAL;
- n = json_variant_elements(per_machine);
+ n = sd_json_variant_elements(per_machine);
- array = new(JsonVariant*, n + 1);
+ array = new(sd_json_variant*, n + 1);
if (!array)
return -ENOMEM;
for (i = 0; i < n; i++) {
- JsonVariant *m;
+ sd_json_variant *m;
- array[i] = json_variant_by_index(per_machine, i);
+ array[i] = sd_json_variant_by_index(per_machine, i);
- if (!json_variant_is_object(array[i]))
+ if (!sd_json_variant_is_object(array[i]))
return -EINVAL;
- m = json_variant_by_key(array[i], "matchMachineId");
+ m = sd_json_variant_by_key(array[i], "matchMachineId");
if (!m) {
/* No machineId field? Let's ignore this, but invalidate what we found so far */
idx = SIZE_MAX;
continue;
}
- if (json_variant_equal(m, midv) ||
- json_variant_equal(m, midav)) {
+ if (sd_json_variant_equal(m, midv) ||
+ sd_json_variant_equal(m, midav)) {
/* Matches exactly what we are looking for. Let's use this */
idx = i;
continue;
}
- r = per_machine_id_match(m, JSON_PERMISSIVE);
+ r = per_machine_id_match(m, SD_JSON_PERMISSIVE);
if (r < 0)
return r;
if (r > 0)
if (idx == SIZE_MAX)
idx = n++; /* Nothing suitable found, place new entry at end */
else
- ne = json_variant_ref(array[idx]);
+ ne = sd_json_variant_ref(array[idx]);
} else {
- array = new(JsonVariant*, 1);
+ array = new(sd_json_variant*, 1);
if (!array)
return -ENOMEM;
}
if (!ne) {
- r = json_variant_set_field(&ne, "matchMachineId", midav);
+ r = sd_json_variant_set_field(&ne, "matchMachineId", midav);
if (r < 0)
return r;
}
- r = json_variant_set_field_unsigned(&ne, "diskSize", disk_size);
+ r = sd_json_variant_set_field_unsigned(&ne, "diskSize", disk_size);
if (r < 0)
return r;
assert(idx < n);
array[idx] = ne;
- r = json_variant_new_array(&new_per_machine, array, n);
+ r = sd_json_variant_new_array(&new_per_machine, array, n);
if (r < 0)
return r;
- r = json_variant_set_field(&h->json, "perMachine", new_per_machine);
+ r = sd_json_variant_set_field(&h->json, "perMachine", new_per_machine);
if (r < 0)
return r;
}
int user_record_update_last_changed(UserRecord *h, bool with_password) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
usec_t n;
int r;
if (h->last_password_change_usec != UINT64_MAX && h->last_password_change_usec >= n)
return -ECHRNG;
- v = json_variant_ref(h->json);
+ v = sd_json_variant_ref(h->json);
- r = json_variant_set_field_unsigned(&v, "lastChangeUSec", n);
+ r = sd_json_variant_set_field_unsigned(&v, "lastChangeUSec", n);
if (r < 0)
return r;
if (with_password) {
- r = json_variant_set_field_unsigned(&v, "lastPasswordChangeUSec", n);
+ r = sd_json_variant_set_field_unsigned(&v, "lastPasswordChangeUSec", n);
if (r < 0)
return r;
h->last_change_usec = n;
- json_variant_unref(h->json);
+ sd_json_variant_unref(h->json);
h->json = TAKE_PTR(v);
h->mask |= USER_RECORD_REGULAR;
}
int user_record_make_hashed_password(UserRecord *h, char **secret, bool extend) {
- _cleanup_(json_variant_unrefp) JsonVariant *priv = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *priv = NULL;
_cleanup_strv_free_ char **np = NULL;
int r;
return r;
}
- priv = json_variant_ref(json_variant_by_key(h->json, "privileged"));
+ priv = sd_json_variant_ref(sd_json_variant_by_key(h->json, "privileged"));
if (strv_isempty(np))
- r = json_variant_filter(&priv, STRV_MAKE("hashedPassword"));
+ r = sd_json_variant_filter(&priv, STRV_MAKE("hashedPassword"));
else {
- _cleanup_(json_variant_unrefp) JsonVariant *new_array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *new_array = NULL;
- r = json_variant_new_array_strv(&new_array, np);
+ r = sd_json_variant_new_array_strv(&new_array, np);
if (r < 0)
return r;
- r = json_variant_set_field(&priv, "hashedPassword", new_array);
- if (r < 0)
- return r;
+ r = sd_json_variant_set_field(&priv, "hashedPassword", new_array);
}
+ if (r < 0)
+ return r;
- r = json_variant_set_field(&h->json, "privileged", priv);
+ r = sd_json_variant_set_field(&h->json, "privileged", priv);
if (r < 0)
return r;
strv_free_and_replace(h->hashed_password, np);
- SET_FLAG(h->mask, USER_RECORD_PRIVILEGED, !json_variant_is_blank_object(priv));
+ SET_FLAG(h->mask, USER_RECORD_PRIVILEGED, !sd_json_variant_is_blank_object(priv));
return 0;
}
int user_record_set_hashed_password(UserRecord *h, char **hashed_password) {
- _cleanup_(json_variant_unrefp) JsonVariant *priv = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *priv = NULL;
_cleanup_strv_free_ char **copy = NULL;
int r;
assert(h);
- priv = json_variant_ref(json_variant_by_key(h->json, "privileged"));
+ priv = sd_json_variant_ref(sd_json_variant_by_key(h->json, "privileged"));
if (strv_isempty(hashed_password))
- r = json_variant_filter(&priv, STRV_MAKE("hashedPassword"));
+ r = sd_json_variant_filter(&priv, STRV_MAKE("hashedPassword"));
else {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
copy = strv_copy(hashed_password);
if (!copy)
strv_uniq(copy);
- r = json_variant_new_array_strv(&array, copy);
+ r = sd_json_variant_new_array_strv(&array, copy);
if (r < 0)
return r;
- r = json_variant_set_field(&priv, "hashedPassword", array);
+ r = sd_json_variant_set_field(&priv, "hashedPassword", array);
}
if (r < 0)
return r;
- r = json_variant_set_field(&h->json, "privileged", priv);
+ r = sd_json_variant_set_field(&h->json, "privileged", priv);
if (r < 0)
return r;
strv_free_and_replace(h->hashed_password, copy);
- SET_FLAG(h->mask, USER_RECORD_PRIVILEGED, !json_variant_is_blank_object(priv));
+ SET_FLAG(h->mask, USER_RECORD_PRIVILEGED, !sd_json_variant_is_blank_object(priv));
return 0;
}
int user_record_set_password(UserRecord *h, char **password, bool prepend) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
_cleanup_strv_free_erase_ char **e = NULL;
int r;
strv_uniq(e);
}
- w = json_variant_ref(json_variant_by_key(h->json, "secret"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(h->json, "secret"));
if (strv_isempty(e))
- r = json_variant_filter(&w, STRV_MAKE("password"));
+ r = sd_json_variant_filter(&w, STRV_MAKE("password"));
else {
- _cleanup_(json_variant_unrefp) JsonVariant *l = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
- r = json_variant_new_array_strv(&l, e);
+ r = sd_json_variant_new_array_strv(&l, e);
if (r < 0)
return r;
- json_variant_sensitive(l);
+ sd_json_variant_sensitive(l);
- r = json_variant_set_field(&w, "password", l);
+ r = sd_json_variant_set_field(&w, "password", l);
}
if (r < 0)
return r;
- json_variant_sensitive(w);
+ sd_json_variant_sensitive(w);
- r = json_variant_set_field(&h->json, "secret", w);
+ r = sd_json_variant_set_field(&h->json, "secret", w);
if (r < 0)
return r;
strv_free_and_replace(h->password, e);
- SET_FLAG(h->mask, USER_RECORD_SECRET, !json_variant_is_blank_object(w));
+ SET_FLAG(h->mask, USER_RECORD_SECRET, !sd_json_variant_is_blank_object(w));
return 0;
}
int user_record_set_token_pin(UserRecord *h, char **pin, bool prepend) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
_cleanup_strv_free_erase_ char **e = NULL;
int r;
strv_uniq(e);
}
- w = json_variant_ref(json_variant_by_key(h->json, "secret"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(h->json, "secret"));
if (strv_isempty(e))
- r = json_variant_filter(&w, STRV_MAKE("tokenPin"));
+ r = sd_json_variant_filter(&w, STRV_MAKE("tokenPin"));
else {
- _cleanup_(json_variant_unrefp) JsonVariant *l = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
- r = json_variant_new_array_strv(&l, e);
+ r = sd_json_variant_new_array_strv(&l, e);
if (r < 0)
return r;
- json_variant_sensitive(l);
+ sd_json_variant_sensitive(l);
- r = json_variant_set_field(&w, "tokenPin", l);
+ r = sd_json_variant_set_field(&w, "tokenPin", l);
}
if (r < 0)
return r;
- json_variant_sensitive(w);
+ sd_json_variant_sensitive(w);
- r = json_variant_set_field(&h->json, "secret", w);
+ r = sd_json_variant_set_field(&h->json, "secret", w);
if (r < 0)
return r;
strv_free_and_replace(h->token_pin, e);
- SET_FLAG(h->mask, USER_RECORD_SECRET, !json_variant_is_blank_object(w));
+ SET_FLAG(h->mask, USER_RECORD_SECRET, !sd_json_variant_is_blank_object(w));
return 0;
}
int user_record_set_pkcs11_protected_authentication_path_permitted(UserRecord *h, int b) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
int r;
assert(h);
- w = json_variant_ref(json_variant_by_key(h->json, "secret"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(h->json, "secret"));
if (b < 0)
- r = json_variant_filter(&w, STRV_MAKE("pkcs11ProtectedAuthenticationPathPermitted"));
+ r = sd_json_variant_filter(&w, STRV_MAKE("pkcs11ProtectedAuthenticationPathPermitted"));
else
- r = json_variant_set_field_boolean(&w, "pkcs11ProtectedAuthenticationPathPermitted", b);
+ r = sd_json_variant_set_field_boolean(&w, "pkcs11ProtectedAuthenticationPathPermitted", b);
if (r < 0)
return r;
- if (json_variant_is_blank_object(w))
- r = json_variant_filter(&h->json, STRV_MAKE("secret"));
+ if (sd_json_variant_is_blank_object(w))
+ r = sd_json_variant_filter(&h->json, STRV_MAKE("secret"));
else {
- json_variant_sensitive(w);
+ sd_json_variant_sensitive(w);
- r = json_variant_set_field(&h->json, "secret", w);
+ r = sd_json_variant_set_field(&h->json, "secret", w);
}
if (r < 0)
return r;
h->pkcs11_protected_authentication_path_permitted = b;
- SET_FLAG(h->mask, USER_RECORD_SECRET, !json_variant_is_blank_object(w));
+ SET_FLAG(h->mask, USER_RECORD_SECRET, !sd_json_variant_is_blank_object(w));
return 0;
}
int user_record_set_fido2_user_presence_permitted(UserRecord *h, int b) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
int r;
assert(h);
- w = json_variant_ref(json_variant_by_key(h->json, "secret"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(h->json, "secret"));
if (b < 0)
- r = json_variant_filter(&w, STRV_MAKE("fido2UserPresencePermitted"));
+ r = sd_json_variant_filter(&w, STRV_MAKE("fido2UserPresencePermitted"));
else
- r = json_variant_set_field_boolean(&w, "fido2UserPresencePermitted", b);
+ r = sd_json_variant_set_field_boolean(&w, "fido2UserPresencePermitted", b);
if (r < 0)
return r;
- if (json_variant_is_blank_object(w))
- r = json_variant_filter(&h->json, STRV_MAKE("secret"));
+ if (sd_json_variant_is_blank_object(w))
+ r = sd_json_variant_filter(&h->json, STRV_MAKE("secret"));
else
- r = json_variant_set_field(&h->json, "secret", w);
+ r = sd_json_variant_set_field(&h->json, "secret", w);
if (r < 0)
return r;
h->fido2_user_presence_permitted = b;
- SET_FLAG(h->mask, USER_RECORD_SECRET, !json_variant_is_blank_object(w));
+ SET_FLAG(h->mask, USER_RECORD_SECRET, !sd_json_variant_is_blank_object(w));
return 0;
}
int user_record_set_fido2_user_verification_permitted(UserRecord *h, int b) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
int r;
assert(h);
- w = json_variant_ref(json_variant_by_key(h->json, "secret"));
+ w = sd_json_variant_ref(sd_json_variant_by_key(h->json, "secret"));
if (b < 0)
- r = json_variant_filter(&w, STRV_MAKE("fido2UserVerificationPermitted"));
+ r = sd_json_variant_filter(&w, STRV_MAKE("fido2UserVerificationPermitted"));
else
- r = json_variant_set_field_boolean(&w, "fido2UserVerificationPermitted", b);
+ r = sd_json_variant_set_field_boolean(&w, "fido2UserVerificationPermitted", b);
if (r < 0)
return r;
- if (json_variant_is_blank_object(w))
- r = json_variant_filter(&h->json, STRV_MAKE("secret"));
+ if (sd_json_variant_is_blank_object(w))
+ r = sd_json_variant_filter(&h->json, STRV_MAKE("secret"));
else
- r = json_variant_set_field(&h->json, "secret", w);
+ r = sd_json_variant_set_field(&h->json, "secret", w);
if (r < 0)
return r;
h->fido2_user_verification_permitted = b;
- SET_FLAG(h->mask, USER_RECORD_SECRET, !json_variant_is_blank_object(w));
+ SET_FLAG(h->mask, USER_RECORD_SECRET, !sd_json_variant_is_blank_object(w));
return 0;
}
-static bool per_machine_entry_empty(JsonVariant *v) {
+static bool per_machine_entry_empty(sd_json_variant *v) {
const char *k;
- _unused_ JsonVariant *e;
+ _unused_ sd_json_variant *e;
JSON_VARIANT_OBJECT_FOREACH(k, e, v)
if (!STR_IN_SET(k, "matchMachineId", "matchHostname"))
}
int user_record_set_password_change_now(UserRecord *h, int b) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
- JsonVariant *per_machine;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
+ sd_json_variant *per_machine;
int r;
assert(h);
- w = json_variant_ref(h->json);
+ w = sd_json_variant_ref(h->json);
if (b < 0)
- r = json_variant_filter(&w, STRV_MAKE("passwordChangeNow"));
+ r = sd_json_variant_filter(&w, STRV_MAKE("passwordChangeNow"));
else
- r = json_variant_set_field_boolean(&w, "passwordChangeNow", b);
+ r = sd_json_variant_set_field_boolean(&w, "passwordChangeNow", b);
if (r < 0)
return r;
/* Also drop the field from all perMachine entries */
- per_machine = json_variant_by_key(w, "perMachine");
+ per_machine = sd_json_variant_by_key(w, "perMachine");
if (per_machine) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
- JsonVariant *e;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
+ sd_json_variant *e;
JSON_VARIANT_ARRAY_FOREACH(e, per_machine) {
- _cleanup_(json_variant_unrefp) JsonVariant *z = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *z = NULL;
- if (!json_variant_is_object(e))
+ if (!sd_json_variant_is_object(e))
return -EINVAL;
- z = json_variant_ref(e);
+ z = sd_json_variant_ref(e);
- r = json_variant_filter(&z, STRV_MAKE("passwordChangeNow"));
+ r = sd_json_variant_filter(&z, STRV_MAKE("passwordChangeNow"));
if (r < 0)
return r;
if (per_machine_entry_empty(z))
continue;
- r = json_variant_append_array(&array, z);
+ r = sd_json_variant_append_array(&array, z);
if (r < 0)
return r;
}
- if (json_variant_is_blank_array(array))
- r = json_variant_filter(&w, STRV_MAKE("perMachine"));
+ if (sd_json_variant_is_blank_array(array))
+ r = sd_json_variant_filter(&w, STRV_MAKE("perMachine"));
else
- r = json_variant_set_field(&w, "perMachine", array);
+ r = sd_json_variant_set_field(&w, "perMachine", array);
if (r < 0)
return r;
- SET_FLAG(h->mask, USER_RECORD_PER_MACHINE, !json_variant_is_blank_array(array));
+ SET_FLAG(h->mask, USER_RECORD_PER_MACHINE, !sd_json_variant_is_blank_array(array));
}
- json_variant_unref(h->json);
+ sd_json_variant_unref(h->json);
h->json = TAKE_PTR(w);
h->password_change_now = b;
}
int user_record_good_authentication(UserRecord *h) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL, *z = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL, *z = NULL;
uint64_t counter, usec;
sd_id128_t mid;
int r;
if (r < 0)
return r;
- v = json_variant_ref(h->json);
- w = json_variant_ref(json_variant_by_key(v, "status"));
- z = json_variant_ref(json_variant_by_key(w, SD_ID128_TO_STRING(mid)));
+ v = sd_json_variant_ref(h->json);
+ w = sd_json_variant_ref(sd_json_variant_by_key(v, "status"));
+ z = sd_json_variant_ref(sd_json_variant_by_key(w, SD_ID128_TO_STRING(mid)));
- r = json_variant_set_field_unsigned(&z, "goodAuthenticationCounter", counter);
+ r = sd_json_variant_set_field_unsigned(&z, "goodAuthenticationCounter", counter);
if (r < 0)
return r;
- r = json_variant_set_field_unsigned(&z, "lastGoodAuthenticationUSec", usec);
+ r = sd_json_variant_set_field_unsigned(&z, "lastGoodAuthenticationUSec", usec);
if (r < 0)
return r;
- r = json_variant_set_field(&w, SD_ID128_TO_STRING(mid), z);
+ r = sd_json_variant_set_field(&w, SD_ID128_TO_STRING(mid), z);
if (r < 0)
return r;
- r = json_variant_set_field(&v, "status", w);
+ r = sd_json_variant_set_field(&v, "status", w);
if (r < 0)
return r;
- json_variant_unref(h->json);
+ sd_json_variant_unref(h->json);
h->json = TAKE_PTR(v);
h->good_authentication_counter = counter;
}
int user_record_bad_authentication(UserRecord *h) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL, *z = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL, *z = NULL;
uint64_t counter, usec;
sd_id128_t mid;
int r;
if (r < 0)
return r;
- v = json_variant_ref(h->json);
- w = json_variant_ref(json_variant_by_key(v, "status"));
- z = json_variant_ref(json_variant_by_key(w, SD_ID128_TO_STRING(mid)));
+ v = sd_json_variant_ref(h->json);
+ w = sd_json_variant_ref(sd_json_variant_by_key(v, "status"));
+ z = sd_json_variant_ref(sd_json_variant_by_key(w, SD_ID128_TO_STRING(mid)));
- r = json_variant_set_field_unsigned(&z, "badAuthenticationCounter", counter);
+ r = sd_json_variant_set_field_unsigned(&z, "badAuthenticationCounter", counter);
if (r < 0)
return r;
- r = json_variant_set_field_unsigned(&z, "lastBadAuthenticationUSec", usec);
+ r = sd_json_variant_set_field_unsigned(&z, "lastBadAuthenticationUSec", usec);
if (r < 0)
return r;
- r = json_variant_set_field(&w, SD_ID128_TO_STRING(mid), z);
+ r = sd_json_variant_set_field(&w, SD_ID128_TO_STRING(mid), z);
if (r < 0)
return r;
- r = json_variant_set_field(&v, "status", w);
+ r = sd_json_variant_set_field(&v, "status", w);
if (r < 0)
return r;
- json_variant_unref(h->json);
+ sd_json_variant_unref(h->json);
h->json = TAKE_PTR(v);
h->bad_authentication_counter = counter;
}
int user_record_ratelimit(UserRecord *h) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL, *z = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL, *z = NULL;
usec_t usec, new_ratelimit_begin_usec, new_ratelimit_count;
sd_id128_t mid;
int r;
if (r < 0)
return r;
- v = json_variant_ref(h->json);
- w = json_variant_ref(json_variant_by_key(v, "status"));
- z = json_variant_ref(json_variant_by_key(w, SD_ID128_TO_STRING(mid)));
+ v = sd_json_variant_ref(h->json);
+ w = sd_json_variant_ref(sd_json_variant_by_key(v, "status"));
+ z = sd_json_variant_ref(sd_json_variant_by_key(w, SD_ID128_TO_STRING(mid)));
- r = json_variant_set_field_unsigned(&z, "rateLimitBeginUSec", new_ratelimit_begin_usec);
+ r = sd_json_variant_set_field_unsigned(&z, "rateLimitBeginUSec", new_ratelimit_begin_usec);
if (r < 0)
return r;
- r = json_variant_set_field_unsigned(&z, "rateLimitCount", new_ratelimit_count);
+ r = sd_json_variant_set_field_unsigned(&z, "rateLimitCount", new_ratelimit_count);
if (r < 0)
return r;
- r = json_variant_set_field(&w, SD_ID128_TO_STRING(mid), z);
+ r = sd_json_variant_set_field(&w, SD_ID128_TO_STRING(mid), z);
if (r < 0)
return r;
- r = json_variant_set_field(&v, "status", w);
+ r = sd_json_variant_set_field(&v, "status", w);
if (r < 0)
return r;
- json_variant_unref(h->json);
+ sd_json_variant_unref(h->json);
h->json = TAKE_PTR(v);
h->ratelimit_begin_usec = new_ratelimit_begin_usec;
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Cannot manage custom blob directories.");
}
- if (json_variant_by_key(hr->json, HOMEWORK_BLOB_FDMAP_FIELD))
+ if (sd_json_variant_by_key(hr->json, HOMEWORK_BLOB_FDMAP_FIELD))
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "User record contains unsafe internal fields.");
return 0;
}
int user_record_set_rebalance_weight(UserRecord *h, uint64_t weight) {
- _cleanup_(json_variant_unrefp) JsonVariant *new_per_machine_array = NULL, *machine_id_variant = NULL,
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *new_per_machine_array = NULL, *machine_id_variant = NULL,
*machine_id_array = NULL, *per_machine_entry = NULL;
- _cleanup_free_ JsonVariant **array = NULL;
+ _cleanup_free_ sd_json_variant **array = NULL;
size_t idx = SIZE_MAX, n;
- JsonVariant *per_machine;
+ sd_json_variant *per_machine;
sd_id128_t mid;
int r;
if (r < 0)
return r;
- r = json_variant_new_id128(&machine_id_variant, mid);
+ r = sd_json_variant_new_id128(&machine_id_variant, mid);
if (r < 0)
return r;
- r = json_variant_new_array(&machine_id_array, (JsonVariant*[]) { machine_id_variant }, 1);
+ r = sd_json_variant_new_array(&machine_id_array, (sd_json_variant*[]) { machine_id_variant }, 1);
if (r < 0)
return r;
- per_machine = json_variant_by_key(h->json, "perMachine");
+ per_machine = sd_json_variant_by_key(h->json, "perMachine");
if (per_machine) {
- if (!json_variant_is_array(per_machine))
+ if (!sd_json_variant_is_array(per_machine))
return -EINVAL;
- n = json_variant_elements(per_machine);
+ n = sd_json_variant_elements(per_machine);
- array = new(JsonVariant*, n + 1);
+ array = new(sd_json_variant*, n + 1);
if (!array)
return -ENOMEM;
for (size_t i = 0; i < n; i++) {
- JsonVariant *m;
+ sd_json_variant *m;
- array[i] = json_variant_by_index(per_machine, i);
+ array[i] = sd_json_variant_by_index(per_machine, i);
- if (!json_variant_is_object(array[i]))
+ if (!sd_json_variant_is_object(array[i]))
return -EINVAL;
- m = json_variant_by_key(array[i], "matchMachineId");
+ m = sd_json_variant_by_key(array[i], "matchMachineId");
if (!m) {
/* No machineId field? Let's ignore this, but invalidate what we found so far */
idx = SIZE_MAX;
continue;
}
- if (json_variant_equal(m, machine_id_variant) ||
- json_variant_equal(m, machine_id_array)) {
+ if (sd_json_variant_equal(m, machine_id_variant) ||
+ sd_json_variant_equal(m, machine_id_array)) {
/* Matches exactly what we are looking for. Let's use this */
idx = i;
continue;
}
- r = per_machine_id_match(m, JSON_PERMISSIVE);
+ r = per_machine_id_match(m, SD_JSON_PERMISSIVE);
if (r < 0)
return r;
if (r > 0)
if (idx == SIZE_MAX)
idx = n++; /* Nothing suitable found, place new entry at end */
else
- per_machine_entry = json_variant_ref(array[idx]);
+ per_machine_entry = sd_json_variant_ref(array[idx]);
} else {
- array = new(JsonVariant*, 1);
+ array = new(sd_json_variant*, 1);
if (!array)
return -ENOMEM;
}
if (!per_machine_entry) {
- r = json_variant_set_field(&per_machine_entry, "matchMachineId", machine_id_array);
+ r = sd_json_variant_set_field(&per_machine_entry, "matchMachineId", machine_id_array);
if (r < 0)
return r;
}
if (weight == REBALANCE_WEIGHT_UNSET)
- r = json_variant_set_field(&per_machine_entry, "rebalanceWeight", NULL); /* set explicitly to NULL (so that the perMachine setting we are setting here can override the global setting) */
+ r = sd_json_variant_set_field(&per_machine_entry, "rebalanceWeight", NULL); /* set explicitly to NULL (so that the perMachine setting we are setting here can override the global setting) */
else
- r = json_variant_set_field_unsigned(&per_machine_entry, "rebalanceWeight", weight);
+ r = sd_json_variant_set_field_unsigned(&per_machine_entry, "rebalanceWeight", weight);
if (r < 0)
return r;
assert(idx < n);
array[idx] = per_machine_entry;
- r = json_variant_new_array(&new_per_machine_array, array, n);
+ r = sd_json_variant_new_array(&new_per_machine_array, array, n);
if (r < 0)
return r;
- r = json_variant_set_field(&h->json, "perMachine", new_per_machine_array);
+ r = sd_json_variant_set_field(&h->json, "perMachine", new_per_machine_array);
if (r < 0)
return r;
}
int user_record_ensure_blob_manifest(UserRecord *h, Hashmap *blobs, const char **ret_failed) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_hashmap_free_ Hashmap *manifest = NULL;
const char *filename;
void *key, *value;
HASHMAP_FOREACH_KEY(value, filename, blobs) {
_cleanup_free_ char *filename_dup = NULL;
_cleanup_free_ uint8_t *hash = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *hash_json = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *hash_json = NULL;
int fd = PTR_TO_FD(value);
off_t initial, size;
if (lseek(fd, initial, SEEK_SET) < 0)
return -errno;
- r = json_variant_new_hex(&hash_json, hash, SHA256_DIGEST_SIZE);
+ r = sd_json_variant_new_hex(&hash_json, hash, SHA256_DIGEST_SIZE);
if (r < 0)
return r;
TAKE_PTR(filename_dup); /* Ownership transfers to hashmap */
TAKE_PTR(hash);
- r = json_variant_set_field(&v, filename, hash_json);
+ r = sd_json_variant_set_field(&v, filename, hash_json);
if (r < 0)
return r;
#include "sd-bus.h"
#include "sd-id128.h"
+#include "sd-json.h"
#include "alloc-util.h"
#include "architecture.h"
#include "format-table.h"
#include "hostname-setup.h"
#include "hostname-util.h"
-#include "json.h"
#include "main-func.h"
#include "parse-argument.h"
#include "pretty-print.h"
static bool arg_transient = false;
static bool arg_pretty = false;
static bool arg_static = false;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
typedef struct StatusInfo {
const char *hostname;
sd_bus *bus = userdata;
int r;
- if (arg_json_format_flags != JSON_FORMAT_OFF) {
+ if (arg_json_format_flags != SD_JSON_FORMAT_OFF) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
const char *text = NULL;
r = bus_call_method(bus, bus_hostname, "Describe", &error, &reply, NULL);
if (r < 0)
return bus_log_parse_error(r);
- r = json_parse(text, 0, &v, NULL, NULL);
+ r = sd_json_parse(text, 0, &v, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to parse JSON: %m");
- json_variant_dump(v, arg_json_format_flags, NULL, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, NULL, NULL);
return 0;
}
break;
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
break;
case '?':
#include <unistd.h>
#include "sd-device.h"
+#include "sd-json.h"
#include "alloc-util.h"
#include "bus-common-errors.h"
#include "hostname-setup.h"
#include "hostname-util.h"
#include "id128-util.h"
-#include "json.h"
+#include "json-util.h"
#include "main-func.h"
#include "missing_capability.h"
#include "nscd-flush.h"
return sd_bus_reply_method_return(m, "s", serial);
}
-static int build_describe_response(Context *c, bool privileged, JsonVariant **ret) {
+static int build_describe_response(Context *c, bool privileged, sd_json_variant **ret) {
_cleanup_free_ char *hn = NULL, *dhn = NULL, *in = NULL,
*chassis = NULL, *vendor = NULL, *model = NULL, *serial = NULL, *firmware_version = NULL,
*firmware_vendor = NULL;
_cleanup_strv_free_ char **os_release_pairs = NULL, **machine_info_pairs = NULL;
usec_t firmware_date = USEC_INFINITY, eol = USEC_INFINITY;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
sd_id128_t machine_id, boot_id, product_uuid = SD_ID128_NULL;
unsigned local_cid = VMADDR_CID_ANY;
struct utsname u;
(void) load_os_release_pairs(/* root= */ NULL, &os_release_pairs);
(void) load_env_file_pairs(/* f=*/ NULL, "/etc/machine-info", &machine_info_pairs);
- r = json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("Hostname", JSON_BUILD_STRING(hn)),
- JSON_BUILD_PAIR("StaticHostname", JSON_BUILD_STRING(c->data[PROP_STATIC_HOSTNAME])),
- JSON_BUILD_PAIR("PrettyHostname", JSON_BUILD_STRING(c->data[PROP_PRETTY_HOSTNAME])),
- JSON_BUILD_PAIR("DefaultHostname", JSON_BUILD_STRING(dhn)),
- JSON_BUILD_PAIR("HostnameSource", JSON_BUILD_STRING(hostname_source_to_string(c->hostname_source))),
- JSON_BUILD_PAIR("IconName", JSON_BUILD_STRING(in ?: c->data[PROP_ICON_NAME])),
- JSON_BUILD_PAIR("Chassis", JSON_BUILD_STRING(chassis)),
- JSON_BUILD_PAIR("Deployment", JSON_BUILD_STRING(c->data[PROP_DEPLOYMENT])),
- JSON_BUILD_PAIR("Location", JSON_BUILD_STRING(c->data[PROP_LOCATION])),
- JSON_BUILD_PAIR("KernelName", JSON_BUILD_STRING(u.sysname)),
- JSON_BUILD_PAIR("KernelRelease", JSON_BUILD_STRING(u.release)),
- JSON_BUILD_PAIR("KernelVersion", JSON_BUILD_STRING(u.version)),
- JSON_BUILD_PAIR("OperatingSystemPrettyName", JSON_BUILD_STRING(c->data[PROP_OS_PRETTY_NAME])),
- JSON_BUILD_PAIR("OperatingSystemCPEName", JSON_BUILD_STRING(c->data[PROP_OS_CPE_NAME])),
- JSON_BUILD_PAIR("OperatingSystemHomeURL", JSON_BUILD_STRING(c->data[PROP_OS_HOME_URL])),
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("Hostname", SD_JSON_BUILD_STRING(hn)),
+ SD_JSON_BUILD_PAIR("StaticHostname", SD_JSON_BUILD_STRING(c->data[PROP_STATIC_HOSTNAME])),
+ SD_JSON_BUILD_PAIR("PrettyHostname", SD_JSON_BUILD_STRING(c->data[PROP_PRETTY_HOSTNAME])),
+ SD_JSON_BUILD_PAIR("DefaultHostname", SD_JSON_BUILD_STRING(dhn)),
+ SD_JSON_BUILD_PAIR("HostnameSource", SD_JSON_BUILD_STRING(hostname_source_to_string(c->hostname_source))),
+ SD_JSON_BUILD_PAIR("IconName", SD_JSON_BUILD_STRING(in ?: c->data[PROP_ICON_NAME])),
+ SD_JSON_BUILD_PAIR("Chassis", SD_JSON_BUILD_STRING(chassis)),
+ SD_JSON_BUILD_PAIR("Deployment", SD_JSON_BUILD_STRING(c->data[PROP_DEPLOYMENT])),
+ SD_JSON_BUILD_PAIR("Location", SD_JSON_BUILD_STRING(c->data[PROP_LOCATION])),
+ SD_JSON_BUILD_PAIR("KernelName", SD_JSON_BUILD_STRING(u.sysname)),
+ SD_JSON_BUILD_PAIR("KernelRelease", SD_JSON_BUILD_STRING(u.release)),
+ SD_JSON_BUILD_PAIR("KernelVersion", SD_JSON_BUILD_STRING(u.version)),
+ SD_JSON_BUILD_PAIR("OperatingSystemPrettyName", SD_JSON_BUILD_STRING(c->data[PROP_OS_PRETTY_NAME])),
+ SD_JSON_BUILD_PAIR("OperatingSystemCPEName", SD_JSON_BUILD_STRING(c->data[PROP_OS_CPE_NAME])),
+ SD_JSON_BUILD_PAIR("OperatingSystemHomeURL", SD_JSON_BUILD_STRING(c->data[PROP_OS_HOME_URL])),
JSON_BUILD_PAIR_FINITE_USEC("OperatingSystemSupportEnd", eol),
- JSON_BUILD_PAIR("OperatingSystemReleaseData", JSON_BUILD_STRV_ENV_PAIR(os_release_pairs)),
- JSON_BUILD_PAIR("MachineInformationData", JSON_BUILD_STRV_ENV_PAIR(machine_info_pairs)),
- JSON_BUILD_PAIR("HardwareVendor", JSON_BUILD_STRING(vendor ?: c->data[PROP_HARDWARE_VENDOR])),
- JSON_BUILD_PAIR("HardwareModel", JSON_BUILD_STRING(model ?: c->data[PROP_HARDWARE_MODEL])),
- JSON_BUILD_PAIR("HardwareSerial", JSON_BUILD_STRING(serial)),
- JSON_BUILD_PAIR("FirmwareVersion", JSON_BUILD_STRING(firmware_version)),
- JSON_BUILD_PAIR("FirmwareVendor", JSON_BUILD_STRING(firmware_vendor)),
+ SD_JSON_BUILD_PAIR("OperatingSystemReleaseData", JSON_BUILD_STRV_ENV_PAIR(os_release_pairs)),
+ SD_JSON_BUILD_PAIR("MachineInformationData", JSON_BUILD_STRV_ENV_PAIR(machine_info_pairs)),
+ SD_JSON_BUILD_PAIR("HardwareVendor", SD_JSON_BUILD_STRING(vendor ?: c->data[PROP_HARDWARE_VENDOR])),
+ SD_JSON_BUILD_PAIR("HardwareModel", SD_JSON_BUILD_STRING(model ?: c->data[PROP_HARDWARE_MODEL])),
+ SD_JSON_BUILD_PAIR("HardwareSerial", SD_JSON_BUILD_STRING(serial)),
+ SD_JSON_BUILD_PAIR("FirmwareVersion", SD_JSON_BUILD_STRING(firmware_version)),
+ SD_JSON_BUILD_PAIR("FirmwareVendor", SD_JSON_BUILD_STRING(firmware_vendor)),
JSON_BUILD_PAIR_FINITE_USEC("FirmwareDate", firmware_date),
- JSON_BUILD_PAIR_ID128("MachineID", machine_id),
- JSON_BUILD_PAIR_ID128("BootID", boot_id),
- JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(product_uuid), "ProductUUID", JSON_BUILD_ID128(product_uuid)),
- JSON_BUILD_PAIR_CONDITION(sd_id128_is_null(product_uuid), "ProductUUID", JSON_BUILD_NULL),
- JSON_BUILD_PAIR_CONDITION(local_cid != VMADDR_CID_ANY, "VSockCID", JSON_BUILD_UNSIGNED(local_cid)),
- JSON_BUILD_PAIR_CONDITION(local_cid == VMADDR_CID_ANY, "VSockCID", JSON_BUILD_NULL)));
+ SD_JSON_BUILD_PAIR_ID128("MachineID", machine_id),
+ SD_JSON_BUILD_PAIR_ID128("BootID", boot_id),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(product_uuid), "ProductUUID", SD_JSON_BUILD_ID128(product_uuid)),
+ SD_JSON_BUILD_PAIR_CONDITION(sd_id128_is_null(product_uuid), "ProductUUID", SD_JSON_BUILD_NULL),
+ SD_JSON_BUILD_PAIR_CONDITION(local_cid != VMADDR_CID_ANY, "VSockCID", SD_JSON_BUILD_UNSIGNED(local_cid)),
+ SD_JSON_BUILD_PAIR_CONDITION(local_cid == VMADDR_CID_ANY, "VSockCID", SD_JSON_BUILD_NULL)));
if (r < 0)
return log_error_errno(r, "Failed to build JSON data: %m");
}
static int method_describe(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
Context *c = ASSERT_PTR(userdata);
_cleanup_free_ char *text = NULL;
bool privileged;
if (r < 0)
return r;
- r = json_variant_format(v, 0, &text);
+ r = sd_json_variant_format(v, 0, &text);
if (r < 0)
return log_error_errno(r, "Failed to format JSON data: %m");
return 0;
}
-static int vl_method_describe(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
+static int vl_method_describe(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
VARLINK_DISPATCH_POLKIT_FIELD,
{}
};
* the product ID which we'll check explicitly. */
privileged = r > 0;
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = build_describe_response(c, privileged, &v);
if (r < 0)
return r;
static bool arg_value = false;
static PagerFlags arg_pager_flags = 0;
static bool arg_legend = true;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static int verb_new(int argc, char **argv, void *userdata) {
return id128_print_new(arg_mode);
break;
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
break;
case ARG_JSON:
static bool arg_ask_password = true;
static ImportVerify arg_verify = IMPORT_VERIFY_SIGNATURE;
static const char* arg_format = NULL;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static ImageClass arg_image_class = _IMAGE_CLASS_INVALID;
#define PROGRESS_PREFIX "Total: "
if (r < 0)
return table_log_add_error(r);
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
r = table_add_many(
t,
TABLE_STRING, read_only ? "ro" : "rw",
break;
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
arg_legend = false;
break;
}
}
- if (table_isempty(table) && FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ if (table_isempty(table) && FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
if (!arg_quiet)
log_notice("No namespaces found.");
} else {
JournalctlAction arg_action = ACTION_SHOW;
OutputMode arg_output = OUTPUT_SHORT;
-JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
PagerFlags arg_pager_flags = 0;
bool arg_utc = false;
bool arg_follow = false;
arg_quiet = true;
if (OUTPUT_MODE_IS_JSON(arg_output))
- arg_json_format_flags = output_mode_to_json_format_flags(arg_output) | JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = output_mode_to_json_format_flags(arg_output) | SD_JSON_FORMAT_COLOR_AUTO;
else
- arg_json_format_flags = JSON_FORMAT_OFF;
+ arg_json_format_flags = SD_JSON_FORMAT_OFF;
break;
#include <stdbool.h>
#include "sd-id128.h"
+#include "sd-json.h"
-#include "json.h"
#include "output-mode.h"
#include "pager.h"
#include "pcre2-util.h"
extern JournalctlAction arg_action;
extern OutputMode arg_output;
-extern JsonFormatFlags arg_json_format_flags;
+extern sd_json_format_flags_t arg_json_format_flags;
extern PagerFlags arg_pager_flags;
extern bool arg_utc;
extern bool arg_follow;
#include "journald-client.h"
#include "nulstr-util.h"
#include "pcre2-util.h"
+#include "strv.h"
/* This consumes both `allow_list` and `deny_list` arguments. Hence, those arguments are not owned by the
* caller anymore and should not be freed. */
varlink_unref(userdata);
}
-static int vl_method_synchronize(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_synchronize(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
_cleanup_(sd_event_source_unrefp) sd_event_source *event_source = NULL;
Server *s = ASSERT_PTR(userdata);
int r;
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
log_info("Received client request to sync journal.");
return 0;
}
-static int vl_method_rotate(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_rotate(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
Server *s = ASSERT_PTR(userdata);
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
log_info("Received client request to rotate journal, rotating.");
return varlink_reply(link, NULL);
}
-static int vl_method_flush_to_var(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_flush_to_var(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
Server *s = ASSERT_PTR(userdata);
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
if (s->namespace)
return varlink_error(link, "io.systemd.Journal.NotSupportedByNamespaces", NULL);
return varlink_reply(link, NULL);
}
-static int vl_method_relinquish_var(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_relinquish_var(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
Server *s = ASSERT_PTR(userdata);
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
if (s->namespace)
return varlink_error(link, "io.systemd.Journal.NotSupportedByNamespaces", NULL);
static char *arg_xbootldr_path = NULL;
static int arg_make_entry_directory = -1; /* tristate */
static PagerFlags arg_pager_flags = 0;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static char *arg_root = NULL;
static char *arg_image = NULL;
static ImagePolicy *arg_image_policy = NULL;
if (r < 0)
return table_log_add_error(r);
- if (arg_json_format_flags & JSON_FORMAT_OFF) {
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF) {
r = table_add_many(t,
TABLE_FIELD, "Plugin Arguments",
TABLE_STRV, strv_skip(c->argv, 1));
#pragma once
#include "sd-dhcp-client-id.h"
+#include "sd-json.h"
#include "dhcp-duid-internal.h"
-#include "json.h"
#include "macro.h"
#include "siphash24.h"
#include "sparse-endian.h"
void client_id_hash_func(const sd_dhcp_client_id *client_id, struct siphash *state);
int client_id_compare_func(const sd_dhcp_client_id *a, const sd_dhcp_client_id *b);
-int json_dispatch_client_id(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
+int json_dispatch_client_id(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
#pragma once
#include "sd-dhcp-server-lease.h"
+#include "sd-json.h"
#include "dhcp-client-id-internal.h"
#include "dhcp-server-internal.h"
-#include "json.h"
#include "time-util.h"
typedef struct sd_dhcp_server_lease {
sd_dhcp_server_lease* dhcp_server_get_static_lease(sd_dhcp_server *server, const DHCPRequest *req);
-int dhcp_server_bound_leases_append_json(sd_dhcp_server *server, JsonVariant **v);
-int dhcp_server_static_leases_append_json(sd_dhcp_server *server, JsonVariant **v);
+int dhcp_server_bound_leases_append_json(sd_dhcp_server *server, sd_json_variant **v);
+int dhcp_server_static_leases_append_json(sd_dhcp_server *server, sd_json_variant **v);
int dhcp_server_save_leases(sd_dhcp_server *server);
int dhcp_server_load_leases(sd_dhcp_server *server);
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_lldp_rx_unrefp) sd_lldp_rx *lldp_rx = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(memstream_done) MemStream m = {};
FILE *f;
assert_se(lldp_rx_build_neighbors_json(lldp_rx, &v) >= 0);
assert_se(f = memstream_init(&m));
- (void) json_variant_dump(v, JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR, f, NULL);
+ (void) sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR, f, NULL);
assert_se(sd_lldp_rx_stop(lldp_rx) >= 0);
assert_se(sd_lldp_rx_detach_event(lldp_rx) >= 0);
#include "ether-addr-util.h"
#include "hexdecoct.h"
#include "in-addr-util.h"
+#include "json-util.h"
#include "lldp-neighbor.h"
#include "memory-util.h"
#include "missing_network.h"
return 0;
}
-int lldp_neighbor_build_json(sd_lldp_neighbor *n, JsonVariant **ret) {
+int lldp_neighbor_build_json(sd_lldp_neighbor *n, sd_json_variant **ret) {
const char *chassis_id = NULL, *port_id = NULL, *port_description = NULL,
*system_name = NULL, *system_description = NULL;
uint16_t cc = 0;
valid_cc = sd_lldp_neighbor_get_enabled_capabilities(n, &cc) >= 0;
- return json_build(ret, JSON_BUILD_OBJECT(
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
JSON_BUILD_PAIR_STRING_NON_EMPTY("ChassisID", chassis_id),
- JSON_BUILD_PAIR_BYTE_ARRAY("RawChassisID", n->id.chassis_id, n->id.chassis_id_size),
+ SD_JSON_BUILD_PAIR_BYTE_ARRAY("RawChassisID", n->id.chassis_id, n->id.chassis_id_size),
JSON_BUILD_PAIR_STRING_NON_EMPTY("PortID", port_id),
- JSON_BUILD_PAIR_BYTE_ARRAY("RawPortID", n->id.port_id, n->id.port_id_size),
+ SD_JSON_BUILD_PAIR_BYTE_ARRAY("RawPortID", n->id.port_id, n->id.port_id_size),
JSON_BUILD_PAIR_STRING_NON_EMPTY("PortDescription", port_description),
JSON_BUILD_PAIR_STRING_NON_EMPTY("SystemName", system_name),
JSON_BUILD_PAIR_STRING_NON_EMPTY("SystemDescription", system_description),
- JSON_BUILD_PAIR_CONDITION(valid_cc, "EnabledCapabilities", JSON_BUILD_UNSIGNED(cc))));
+ SD_JSON_BUILD_PAIR_CONDITION(valid_cc, "EnabledCapabilities", SD_JSON_BUILD_UNSIGNED(cc))));
}
#include <stdbool.h>
#include <sys/types.h>
+#include "sd-json.h"
#include "sd-lldp-rx.h"
#include "hash-funcs.h"
-#include "json.h"
#include "lldp-rx-internal.h"
#include "time-util.h"
int lldp_neighbor_parse(sd_lldp_neighbor *n);
void lldp_neighbor_start_ttl(sd_lldp_neighbor *n);
bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b);
-int lldp_neighbor_build_json(sd_lldp_neighbor *n, JsonVariant **ret);
+int lldp_neighbor_build_json(sd_lldp_neighbor *n, sd_json_variant **ret);
#pragma once
#include "sd-event.h"
+#include "sd-json.h"
#include "sd-lldp-rx.h"
#include "hashmap.h"
-#include "json.h"
#include "network-common.h"
#include "prioq.h"
const char* lldp_rx_event_to_string(sd_lldp_rx_event_t e) _const_;
sd_lldp_rx_event_t lldp_rx_event_from_string(const char *s) _pure_;
-int lldp_rx_build_neighbors_json(sd_lldp_rx *lldp_rx, JsonVariant **ret);
+int lldp_rx_build_neighbors_json(sd_lldp_rx *lldp_rx, sd_json_variant **ret);
#define log_lldp_rx_errno(lldp_rx, error, fmt, ...) \
log_interface_prefix_full_errno( \
#include "alloc-util.h"
#include "dhcp-client-id-internal.h"
#include "iovec-util.h"
+#include "json-util.h"
#include "unaligned.h"
#include "utf8.h"
return memcmp_nn(a->raw, a->size, b->raw, b->size);
}
-int json_dispatch_client_id(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+int json_dispatch_client_id(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
sd_dhcp_client_id *client_id = ASSERT_PTR(userdata);
_cleanup_(iovec_done) struct iovec iov = {};
int r;
#include "dhcp-server-lease-internal.h"
#include "fd-util.h"
#include "fs-util.h"
+#include "json-util.h"
#include "mkdir.h"
#include "tmpfile-util.h"
return 0;
}
-static int dhcp_server_lease_append_json(sd_dhcp_server_lease *lease, JsonVariant **ret) {
+static int dhcp_server_lease_append_json(sd_dhcp_server_lease *lease, sd_json_variant **ret) {
assert(lease);
assert(ret);
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_BYTE_ARRAY("ClientId", lease->client_id.raw, lease->client_id.size),
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_BYTE_ARRAY("ClientId", lease->client_id.raw, lease->client_id.size),
JSON_BUILD_PAIR_IN4_ADDR_NON_NULL("Address", &(struct in_addr) { .s_addr = lease->address }),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Hostname", lease->hostname)));
}
-int dhcp_server_bound_leases_append_json(sd_dhcp_server *server, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+int dhcp_server_bound_leases_append_json(sd_dhcp_server *server, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
sd_dhcp_server_lease *lease;
usec_t now_b, now_r;
int r;
return r;
HASHMAP_FOREACH(lease, server->bound_leases_by_client_id) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
r = dhcp_server_lease_append_json(lease, &w);
if (r < 0)
usec_t exp_r = map_clock_usec_raw(lease->expiration, now_b, now_r);
- r = json_variant_merge_objectb(&w,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("ExpirationUSec", lease->expiration),
- JSON_BUILD_PAIR_UNSIGNED("ExpirationRealtimeUSec", exp_r)));
+ r = sd_json_variant_merge_objectb(&w,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("ExpirationUSec", lease->expiration),
+ SD_JSON_BUILD_PAIR_UNSIGNED("ExpirationRealtimeUSec", exp_r)));
if (r < 0)
return r;
- r = json_variant_append_array(&array, w);
+ r = sd_json_variant_append_array(&array, w);
if (r < 0)
return r;
}
return json_variant_set_field_non_null(v, "Leases", array);
}
-int dhcp_server_static_leases_append_json(sd_dhcp_server *server, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+int dhcp_server_static_leases_append_json(sd_dhcp_server *server, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
sd_dhcp_server_lease *lease;
int r;
assert(v);
HASHMAP_FOREACH(lease, server->static_leases_by_client_id) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
r = dhcp_server_lease_append_json(lease, &w);
if (r < 0)
return r;
- r = json_variant_append_array(&array, w);
+ r = sd_json_variant_append_array(&array, w);
if (r < 0)
return r;
}
}
int dhcp_server_save_leases(sd_dhcp_server *server) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *temp_path = NULL;
_cleanup_fclose_ FILE *f = NULL;
sd_id128_t boot_id;
if (r < 0)
return r;
- r = json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_ID128("BootID", boot_id),
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_ID128("BootID", boot_id),
JSON_BUILD_PAIR_IN4_ADDR("Address", &(struct in_addr) { .s_addr = server->address }),
- JSON_BUILD_PAIR_UNSIGNED("PrefixLength",
+ SD_JSON_BUILD_PAIR_UNSIGNED("PrefixLength",
in4_addr_netmask_to_prefixlen(&(struct in_addr) { .s_addr = server->netmask }))));
if (r < 0)
return r;
(void) fchmod(fileno(f), 0644);
- r = json_variant_dump(v, JSON_FORMAT_NEWLINE | JSON_FORMAT_FLUSH, f, /* prefix = */ NULL);
+ r = sd_json_variant_dump(v, SD_JSON_FORMAT_NEWLINE | SD_JSON_FORMAT_FLUSH, f, /* prefix = */ NULL);
if (r < 0)
goto failure;
return r;
}
-static int json_dispatch_dhcp_lease(sd_dhcp_server *server, JsonVariant *v, bool use_boottime) {
- static const JsonDispatch dispatch_table_boottime[] = {
- { "ClientId", JSON_VARIANT_ARRAY, json_dispatch_client_id, offsetof(sd_dhcp_server_lease, client_id), JSON_MANDATORY },
- { "Address", JSON_VARIANT_ARRAY, json_dispatch_in_addr, offsetof(sd_dhcp_server_lease, address), JSON_MANDATORY },
- { "Hostname", JSON_VARIANT_STRING, json_dispatch_string, offsetof(sd_dhcp_server_lease, hostname), 0 },
- { "ExpirationUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(sd_dhcp_server_lease, expiration), JSON_MANDATORY },
- { "ExpirationRealtimeUSec", _JSON_VARIANT_TYPE_INVALID, NULL, 0, JSON_MANDATORY },
+static int json_dispatch_dhcp_lease(sd_dhcp_server *server, sd_json_variant *v, bool use_boottime) {
+ static const sd_json_dispatch_field dispatch_table_boottime[] = {
+ { "ClientId", SD_JSON_VARIANT_ARRAY, json_dispatch_client_id, offsetof(sd_dhcp_server_lease, client_id), SD_JSON_MANDATORY },
+ { "Address", SD_JSON_VARIANT_ARRAY, json_dispatch_in_addr, offsetof(sd_dhcp_server_lease, address), SD_JSON_MANDATORY },
+ { "Hostname", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(sd_dhcp_server_lease, hostname), 0 },
+ { "ExpirationUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(sd_dhcp_server_lease, expiration), SD_JSON_MANDATORY },
+ { "ExpirationRealtimeUSec", _SD_JSON_VARIANT_TYPE_INVALID, NULL, 0, SD_JSON_MANDATORY },
{}
}, dispatch_table_realtime[] = {
- { "ClientId", JSON_VARIANT_ARRAY, json_dispatch_client_id, offsetof(sd_dhcp_server_lease, client_id), JSON_MANDATORY },
- { "Address", JSON_VARIANT_ARRAY, json_dispatch_in_addr, offsetof(sd_dhcp_server_lease, address), JSON_MANDATORY },
- { "Hostname", JSON_VARIANT_STRING, json_dispatch_string, offsetof(sd_dhcp_server_lease, hostname), 0 },
- { "ExpirationUSec", _JSON_VARIANT_TYPE_INVALID, NULL, 0, JSON_MANDATORY },
- { "ExpirationRealtimeUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(sd_dhcp_server_lease, expiration), JSON_MANDATORY },
+ { "ClientId", SD_JSON_VARIANT_ARRAY, json_dispatch_client_id, offsetof(sd_dhcp_server_lease, client_id), SD_JSON_MANDATORY },
+ { "Address", SD_JSON_VARIANT_ARRAY, json_dispatch_in_addr, offsetof(sd_dhcp_server_lease, address), SD_JSON_MANDATORY },
+ { "Hostname", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(sd_dhcp_server_lease, hostname), 0 },
+ { "ExpirationUSec", _SD_JSON_VARIANT_TYPE_INVALID, NULL, 0, SD_JSON_MANDATORY },
+ { "ExpirationRealtimeUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(sd_dhcp_server_lease, expiration), SD_JSON_MANDATORY },
{}
};
.n_ref = 1,
};
- r = json_dispatch(v, use_boottime ? dispatch_table_boottime : dispatch_table_realtime, JSON_ALLOW_EXTENSIONS, lease);
+ r = sd_json_dispatch(v, use_boottime ? dispatch_table_boottime : dispatch_table_realtime, SD_JSON_ALLOW_EXTENSIONS, lease);
if (r < 0)
return r;
sd_id128_t boot_id;
struct in_addr address;
uint8_t prefixlen;
- JsonVariant *leases;
+ sd_json_variant *leases;
} SavedInfo;
static void saved_info_done(SavedInfo *info) {
if (!info)
return;
- json_variant_unref(info->leases);
+ sd_json_variant_unref(info->leases);
}
static int load_leases_file(int dir_fd, const char *path, SavedInfo *ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(dir_fd >= 0 || dir_fd == AT_FDCWD);
assert(path);
assert(ret);
- r = json_parse_file_at(
+ r = sd_json_parse_file_at(
/* f = */ NULL,
dir_fd,
path,
if (r < 0)
return r;
- static const JsonDispatch dispatch_lease_file_table[] = {
- { "BootID", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(SavedInfo, boot_id), JSON_MANDATORY },
- { "Address", JSON_VARIANT_ARRAY, json_dispatch_in_addr, offsetof(SavedInfo, address), JSON_MANDATORY },
- { "PrefixLength", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint8, offsetof(SavedInfo, prefixlen), JSON_MANDATORY },
- { "Leases", JSON_VARIANT_ARRAY, json_dispatch_variant, offsetof(SavedInfo, leases), JSON_MANDATORY },
+ static const sd_json_dispatch_field dispatch_lease_file_table[] = {
+ { "BootID", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(SavedInfo, boot_id), SD_JSON_MANDATORY },
+ { "Address", SD_JSON_VARIANT_ARRAY, json_dispatch_in_addr, offsetof(SavedInfo, address), SD_JSON_MANDATORY },
+ { "PrefixLength", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint8, offsetof(SavedInfo, prefixlen), SD_JSON_MANDATORY },
+ { "Leases", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(SavedInfo, leases), SD_JSON_MANDATORY },
{}
};
- return json_dispatch(v, dispatch_lease_file_table, JSON_ALLOW_EXTENSIONS, ret);
+ return sd_json_dispatch(v, dispatch_lease_file_table, SD_JSON_ALLOW_EXTENSIONS, ret);
}
int dhcp_server_load_leases(sd_dhcp_server *server) {
n = hashmap_size(server->bound_leases_by_client_id);
- JsonVariant *i;
+ sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, info.leases)
RET_GATHER(r, json_dispatch_dhcp_lease(server, i, /* use_boottime = */ sd_id128_equal(info.boot_id, boot_id)));
#include <linux/sockios.h>
#include <sys/ioctl.h>
+#include "sd-json.h"
#include "sd-lldp-rx.h"
#include "alloc-util.h"
#include "ether-addr-util.h"
#include "event-util.h"
#include "fd-util.h"
-#include "json.h"
#include "lldp-neighbor.h"
#include "lldp-network.h"
#include "lldp-rx-internal.h"
return k;
}
-int lldp_rx_build_neighbors_json(sd_lldp_rx *lldp_rx, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+int lldp_rx_build_neighbors_json(sd_lldp_rx *lldp_rx, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(lldp_rx);
sd_lldp_neighbor *n;
HASHMAP_FOREACH(n, lldp_rx->neighbor_by_id) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
r = lldp_neighbor_build_json(n, &w);
if (r < 0)
return r;
- r = json_variant_append_array(&v, w);
+ r = sd_json_variant_append_array(&v, w);
if (r < 0)
return r;
}
LIBSYSTEMD_257 {
global:
sd_bus_pending_method_calls;
+ sd_json_build;
+ sd_json_buildv;
+ sd_json_dispatch;
+ sd_json_dispatch_const_string;
+ sd_json_dispatch_full;
+ sd_json_dispatch_id128;
+ sd_json_dispatch_int16;
+ sd_json_dispatch_int32;
+ sd_json_dispatch_int64;
+ sd_json_dispatch_int8;
+ sd_json_dispatch_intbool;
+ sd_json_dispatch_stdbool;
+ sd_json_dispatch_string;
+ sd_json_dispatch_strv;
+ sd_json_dispatch_tristate;
+ sd_json_dispatch_uid_gid;
+ sd_json_dispatch_uint16;
+ sd_json_dispatch_uint32;
+ sd_json_dispatch_uint64;
+ sd_json_dispatch_uint8;
+ sd_json_dispatch_unsupported;
+ sd_json_dispatch_variant;
+ sd_json_dispatch_variant_noref;
+ sd_json_parse;
+ sd_json_parse_continue;
+ sd_json_parse_file;
+ sd_json_parse_file_at;
+ sd_json_parse_with_source;
+ sd_json_parse_with_source_continue;
+ sd_json_variant_append_array;
+ sd_json_variant_append_array_nodup;
+ sd_json_variant_append_arrayb;
+ sd_json_variant_boolean;
+ sd_json_variant_by_index;
+ sd_json_variant_by_key;
+ sd_json_variant_by_key_full;
+ sd_json_variant_dump;
+ sd_json_variant_elements;
+ sd_json_variant_equal;
+ sd_json_variant_filter;
+ sd_json_variant_find;
+ sd_json_variant_format;
+ sd_json_variant_get_source;
+ sd_json_variant_has_type;
+ sd_json_variant_integer;
+ sd_json_variant_is_array;
+ sd_json_variant_is_blank_array;
+ sd_json_variant_is_blank_object;
+ sd_json_variant_is_boolean;
+ sd_json_variant_is_integer;
+ sd_json_variant_is_negative;
+ sd_json_variant_is_normalized;
+ sd_json_variant_is_null;
+ sd_json_variant_is_number;
+ sd_json_variant_is_object;
+ sd_json_variant_is_real;
+ sd_json_variant_is_sensitive;
+ sd_json_variant_is_sensitive_recursive;
+ sd_json_variant_is_sorted;
+ sd_json_variant_is_string;
+ sd_json_variant_is_unsigned;
+ sd_json_variant_merge_object;
+ sd_json_variant_merge_objectb;
+ sd_json_variant_new_array;
+ sd_json_variant_new_array_bytes;
+ sd_json_variant_new_array_strv;
+ sd_json_variant_new_base32hex;
+ sd_json_variant_new_base64;
+ sd_json_variant_new_boolean;
+ sd_json_variant_new_hex;
+ sd_json_variant_new_id128;
+ sd_json_variant_new_integer;
+ sd_json_variant_new_null;
+ sd_json_variant_new_object;
+ sd_json_variant_new_octescape;
+ sd_json_variant_new_real;
+ sd_json_variant_new_string;
+ sd_json_variant_new_stringn;
+ sd_json_variant_new_unsigned;
+ sd_json_variant_new_uuid;
+ sd_json_variant_normalize;
+ sd_json_variant_real;
+ sd_json_variant_ref;
+ sd_json_variant_sensitive;
+ sd_json_variant_set_field;
+ sd_json_variant_set_field_boolean;
+ sd_json_variant_set_field_integer;
+ sd_json_variant_set_field_string;
+ sd_json_variant_set_field_strv;
+ sd_json_variant_set_field_unsigned;
+ sd_json_variant_set_fieldb;
+ sd_json_variant_sort;
+ sd_json_variant_string;
+ sd_json_variant_strv;
+ sd_json_variant_type;
+ sd_json_variant_unbase64;
+ sd_json_variant_unhex;
+ sd_json_variant_unref;
+ sd_json_variant_unref_many;
+ sd_json_variant_unsigned;
} LIBSYSTEMD_256;
############################################################
+sd_json_sources = files(
+ 'sd-json/json-util.c',
+ 'sd-json/sd-json.c',
+)
+
+############################################################
+
libsystemd_sources = files(
'sd-bus/bus-common-errors.c',
'sd-bus/bus-container.c',
'sd-network/sd-network.c',
'sd-path/sd-path.c',
'sd-resolve/sd-resolve.c',
-) + sd_journal_sources + id128_sources + sd_daemon_sources + sd_event_sources + sd_login_sources
+) + sd_journal_sources + id128_sources + sd_daemon_sources + sd_event_sources + sd_login_sources + sd_json_sources
libsystemd_c_args = ['-fvisibility=default']
c_args : libsystemd_c_args,
link_with : [libbasic],
dependencies : [threads,
+ libm,
librt,
userspace],
build_by_default : false)
#pragma once
-#include "json.h"
+#include "sd-json.h"
/* This header should include all prototypes only the JSON parser itself and
* its tests need access to. Normal code consuming the JSON parser should not
#define JSON_VALUE_NULL ((JsonValue) {})
-/* We use fake JsonVariant objects for some special values, in order to avoid memory allocations for them. Note that
+/* We use fake sd_json_variant objects for some special values, in order to avoid memory allocations for them. Note that
* effectively this means that there are multiple ways to encode the same objects: via these magic values or as
- * properly allocated JsonVariant. We convert between both on-the-fly as necessary. */
+ * properly allocated sd_json_variant. We convert between both on-the-fly as necessary. */
enum
{
_JSON_VARIANT_MAGIC_TRUE = 1,
-#define JSON_VARIANT_MAGIC_TRUE ((JsonVariant*) _JSON_VARIANT_MAGIC_TRUE)
+#define JSON_VARIANT_MAGIC_TRUE ((sd_json_variant*) _JSON_VARIANT_MAGIC_TRUE)
_JSON_VARIANT_MAGIC_FALSE,
-#define JSON_VARIANT_MAGIC_FALSE ((JsonVariant*) _JSON_VARIANT_MAGIC_FALSE)
+#define JSON_VARIANT_MAGIC_FALSE ((sd_json_variant*) _JSON_VARIANT_MAGIC_FALSE)
_JSON_VARIANT_MAGIC_NULL,
-#define JSON_VARIANT_MAGIC_NULL ((JsonVariant*) _JSON_VARIANT_MAGIC_NULL)
+#define JSON_VARIANT_MAGIC_NULL ((sd_json_variant*) _JSON_VARIANT_MAGIC_NULL)
_JSON_VARIANT_MAGIC_ZERO_INTEGER,
-#define JSON_VARIANT_MAGIC_ZERO_INTEGER ((JsonVariant*) _JSON_VARIANT_MAGIC_ZERO_INTEGER)
+#define JSON_VARIANT_MAGIC_ZERO_INTEGER ((sd_json_variant*) _JSON_VARIANT_MAGIC_ZERO_INTEGER)
_JSON_VARIANT_MAGIC_ZERO_UNSIGNED,
-#define JSON_VARIANT_MAGIC_ZERO_UNSIGNED ((JsonVariant*) _JSON_VARIANT_MAGIC_ZERO_UNSIGNED)
+#define JSON_VARIANT_MAGIC_ZERO_UNSIGNED ((sd_json_variant*) _JSON_VARIANT_MAGIC_ZERO_UNSIGNED)
_JSON_VARIANT_MAGIC_ZERO_REAL,
-#define JSON_VARIANT_MAGIC_ZERO_REAL ((JsonVariant*) _JSON_VARIANT_MAGIC_ZERO_REAL)
+#define JSON_VARIANT_MAGIC_ZERO_REAL ((sd_json_variant*) _JSON_VARIANT_MAGIC_ZERO_REAL)
_JSON_VARIANT_MAGIC_EMPTY_STRING,
-#define JSON_VARIANT_MAGIC_EMPTY_STRING ((JsonVariant*) _JSON_VARIANT_MAGIC_EMPTY_STRING)
+#define JSON_VARIANT_MAGIC_EMPTY_STRING ((sd_json_variant*) _JSON_VARIANT_MAGIC_EMPTY_STRING)
_JSON_VARIANT_MAGIC_EMPTY_ARRAY,
-#define JSON_VARIANT_MAGIC_EMPTY_ARRAY ((JsonVariant*) _JSON_VARIANT_MAGIC_EMPTY_ARRAY)
+#define JSON_VARIANT_MAGIC_EMPTY_ARRAY ((sd_json_variant*) _JSON_VARIANT_MAGIC_EMPTY_ARRAY)
_JSON_VARIANT_MAGIC_EMPTY_OBJECT,
-#define JSON_VARIANT_MAGIC_EMPTY_OBJECT ((JsonVariant*) _JSON_VARIANT_MAGIC_EMPTY_OBJECT)
+#define JSON_VARIANT_MAGIC_EMPTY_OBJECT ((sd_json_variant*) _JSON_VARIANT_MAGIC_EMPTY_OBJECT)
__JSON_VARIANT_MAGIC_MAX
-#define _JSON_VARIANT_MAGIC_MAX ((JsonVariant*) __JSON_VARIANT_MAGIC_MAX)
+#define _JSON_VARIANT_MAGIC_MAX ((sd_json_variant*) __JSON_VARIANT_MAGIC_MAX)
};
/* This is only safe as long as we don't define more than 4K magic pointers, i.e. the page size of the simplest
--- /dev/null
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+
+#include "alloc-util.h"
+#include "glyph-util.h"
+#include "in-addr-util.h"
+#include "iovec-util.h"
+#include "json-util.h"
+#include "path-util.h"
+#include "string-util.h"
+#include "user-util.h"
+
+int json_dispatch_unbase64_iovec(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
+ _cleanup_free_ void *buffer = NULL;
+ struct iovec *iov = ASSERT_PTR(userdata);
+ size_t sz;
+ int r;
+
+ 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_json_variant_unbase64(variant, &buffer, &sz);
+ if (r < 0)
+ return json_log(variant, flags, r, "JSON field '%s' is not valid Base64 data.", strna(name));
+
+ free_and_replace(iov->iov_base, buffer);
+ iov->iov_len = sz;
+ return 0;
+}
+
+int json_dispatch_byte_array_iovec(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
+ _cleanup_free_ uint8_t *buffer = NULL;
+ struct iovec *iov = ASSERT_PTR(userdata);
+ size_t sz, k = 0;
+
+ assert(variant);
+
+ if (!sd_json_variant_is_array(variant))
+ return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
+
+ sz = sd_json_variant_elements(variant);
+
+ buffer = new(uint8_t, sz + 1);
+ if (!buffer)
+ return json_log(variant, flags, SYNTHETIC_ERRNO(ENOMEM), "Out of memory.");
+
+ sd_json_variant *i;
+ JSON_VARIANT_ARRAY_FOREACH(i, variant) {
+ uint64_t b;
+
+ if (!sd_json_variant_is_unsigned(i))
+ return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Element %zu of JSON field '%s' is not an unsigned integer.", k, strna(name));
+
+ b = sd_json_variant_unsigned(i);
+ if (b > 0xff)
+ return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL),
+ "Element %zu of JSON field '%s' is out of range 0%s255.",
+ k, strna(name), special_glyph(SPECIAL_GLYPH_ELLIPSIS));
+
+ buffer[k++] = (uint8_t) b;
+ }
+ assert(k == sz);
+
+ /* Append a NUL byte for safety, like we do in memdup_suffix0() and others. */
+ buffer[sz] = 0;
+
+ free_and_replace(iov->iov_base, buffer);
+ iov->iov_len = sz;
+ return 0;
+}
+
+int json_dispatch_user_group_name(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
+ char **s = userdata;
+ const char *n;
+ int r;
+
+ if (sd_json_variant_is_null(variant)) {
+ *s = mfree(*s);
+ 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));
+
+ n = sd_json_variant_string(variant);
+ if (!valid_user_group_name(n, FLAGS_SET(flags, SD_JSON_RELAX) ? VALID_USER_RELAX : 0))
+ return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid user/group name.", strna(name));
+
+ r = free_and_strdup(s, n);
+ if (r < 0)
+ return json_log(variant, flags, r, "Failed to allocate string: %m");
+
+ return 0;
+}
+
+int json_dispatch_in_addr(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
+ struct in_addr *address = ASSERT_PTR(userdata);
+ _cleanup_(iovec_done) struct iovec iov = {};
+ int r;
+
+ r = json_dispatch_byte_array_iovec(name, variant, flags, &iov);
+ if (r < 0)
+ return r;
+
+ if (iov.iov_len != sizeof(struct in_addr))
+ return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is array of unexpected size.", strna(name));
+
+ memcpy(address, iov.iov_base, iov.iov_len);
+ return 0;
+}
+
+int json_dispatch_path(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
+ char **p = ASSERT_PTR(userdata);
+ const char *path;
+
+ assert(variant);
+
+ if (sd_json_variant_is_null(variant)) {
+ *p = mfree(*p);
+ 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));
+
+ path = sd_json_variant_string(variant);
+ if (!((flags & SD_JSON_SAFE) ? path_is_normalized(path) : path_is_valid(path)))
+ return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a normalized file system path.", strna(name));
+ if (!path_is_absolute(path))
+ return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an absolute file system path.", strna(name));
+
+ if (free_and_strdup(p, path) < 0)
+ return json_log_oom(variant, flags);
+
+ return 0;
+}
--- /dev/null
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#pragma once
+
+#include <syslog.h>
+
+#include "sd-json.h"
+
+#include "macro.h"
+
+#define JSON_VARIANT_REPLACE(v, q) \
+ do { \
+ typeof(v)* _v = &(v); \
+ typeof(q) _q = (q); \
+ sd_json_variant_unref(*_v); \
+ *_v = _q; \
+ } while(false)
+
+static inline int json_variant_set_field_non_null(sd_json_variant **v, const char *field, sd_json_variant *value) {
+ return value && !sd_json_variant_is_null(value) ? sd_json_variant_set_field(v, field, value) : 0;
+}
+
+struct json_variant_foreach_state {
+ sd_json_variant *variant;
+ size_t idx;
+};
+
+#define _JSON_VARIANT_ARRAY_FOREACH(i, v, state) \
+ for (struct json_variant_foreach_state state = { (v), 0 }; \
+ sd_json_variant_is_array(state.variant) && \
+ state.idx < sd_json_variant_elements(state.variant) && \
+ ({ i = sd_json_variant_by_index(state.variant, state.idx); \
+ true; }); \
+ state.idx++)
+#define JSON_VARIANT_ARRAY_FOREACH(i, v) \
+ _JSON_VARIANT_ARRAY_FOREACH(i, v, UNIQ_T(state, UNIQ))
+
+#define _JSON_VARIANT_OBJECT_FOREACH(k, e, v, state) \
+ for (struct json_variant_foreach_state state = { (v), 0 }; \
+ sd_json_variant_is_object(state.variant) && \
+ state.idx < sd_json_variant_elements(state.variant) && \
+ ({ k = sd_json_variant_string(sd_json_variant_by_index(state.variant, state.idx)); \
+ e = sd_json_variant_by_index(state.variant, state.idx + 1); \
+ true; }); \
+ state.idx += 2)
+#define JSON_VARIANT_OBJECT_FOREACH(k, e, v) \
+ _JSON_VARIANT_OBJECT_FOREACH(k, e, v, UNIQ_T(state, UNIQ))
+
+#define JSON_DISPATCH_ENUM_DEFINE(name, type, func) \
+ int name(const char *n, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) { \
+ type *c = ASSERT_PTR(userdata); \
+ \
+ assert(variant); \
+ \
+ if (sd_json_variant_is_null(variant)) { \
+ *c = (type) -EINVAL; \
+ 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(n)); \
+ \
+ type cc = func(sd_json_variant_string(variant)); \
+ if (cc < 0) \
+ return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Value of JSON field '%s' not recognized.", strna(n)); \
+ \
+ *c = cc; \
+ return 0; \
+ }
+
+static inline int json_dispatch_level(sd_json_dispatch_flags_t flags) {
+
+ /* Did the user request no logging? If so, then never log higher than LOG_DEBUG. Also, if this is marked as
+ * debug message, then also log at debug level. */
+
+ if (!(flags & SD_JSON_LOG) ||
+ (flags & SD_JSON_DEBUG))
+ return LOG_DEBUG;
+
+ /* Are we invoked in permissive mode, or is this explicitly marked as warning message? Then this should be
+ * printed at LOG_WARNING */
+ if (flags & (SD_JSON_PERMISSIVE|SD_JSON_WARNING))
+ return LOG_WARNING;
+
+ /* Otherwise it's an error. */
+ return LOG_ERR;
+}
+
+int json_log_internal(sd_json_variant *variant, int level, int error, const char *file, int line, const char *func, const char *format, ...) _printf_(7, 8);
+
+#define json_log(variant, flags, error, ...) \
+ ({ \
+ int _level = json_dispatch_level(flags), _e = (error); \
+ (log_get_max_level() >= LOG_PRI(_level)) \
+ ? json_log_internal(variant, _level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \
+ : -ERRNO_VALUE(_e); \
+ })
+
+#define json_log_oom(variant, flags) \
+ json_log(variant, flags, SYNTHETIC_ERRNO(ENOMEM), "Out of memory.")
+
+int json_dispatch_unbase64_iovec(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int json_dispatch_byte_array_iovec(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int json_dispatch_user_group_name(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int json_dispatch_in_addr(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int json_dispatch_path(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+
+static inline int json_variant_unbase64_iovec(sd_json_variant *v, struct iovec *ret) {
+ return sd_json_variant_unbase64(v, ret ? &ret->iov_base : NULL, ret ? &ret->iov_len : NULL);
+}
+
+static inline int json_variant_unhex_iovec(sd_json_variant *v, struct iovec *ret) {
+ return sd_json_variant_unhex(v, ret ? &ret->iov_base : NULL, ret ? &ret->iov_len : NULL);
+}
+
+#define JSON_VARIANT_STRING_CONST(x) _JSON_VARIANT_STRING_CONST(UNIQ, (x))
+
+#define _JSON_VARIANT_STRING_CONST(xq, x) \
+ ({ \
+ _align_(2) static const char UNIQ_T(json_string_const, xq)[] = (x); \
+ assert((((uintptr_t) UNIQ_T(json_string_const, xq)) & 1) == 0); \
+ (sd_json_variant*) ((uintptr_t) UNIQ_T(json_string_const, xq) + 1); \
+ })
+
+enum {
+ /* This extends the _SD_JSON_BUILD_* enums we define in the public API with some additional values
+ * that we want to keep private for now. (Mostly because the underlying structures are not public, or
+ * because we aren't sure yet they are useful for others). */
+ _JSON_BUILD_STRV_ENV_PAIR = _SD_JSON_BUILD_MAX,
+ _JSON_BUILD_IOVEC_BASE64,
+ _JSON_BUILD_IOVEC_HEX,
+ _JSON_BUILD_HW_ADDR,
+ _JSON_BUILD_STRING_SET,
+
+ _JSON_BUILD_PAIR_UNSIGNED_NON_ZERO,
+ _JSON_BUILD_PAIR_FINITE_USEC,
+ _JSON_BUILD_PAIR_STRING_NON_EMPTY,
+ _JSON_BUILD_PAIR_STRV_NON_EMPTY,
+ _JSON_BUILD_PAIR_VARIANT_NON_NULL,
+ /* _SD_JSON_BUILD_PAIR_VARIANT_ARRAY_NON_EMPTY, */
+ _JSON_BUILD_PAIR_IN4_ADDR_NON_NULL,
+ _JSON_BUILD_PAIR_IN6_ADDR_NON_NULL,
+ _JSON_BUILD_PAIR_IN_ADDR_NON_NULL,
+ _JSON_BUILD_PAIR_ETHER_ADDR_NON_NULL,
+ _JSON_BUILD_PAIR_HW_ADDR_NON_NULL,
+
+ _SD_JSON_BUILD_REALLYMAX,
+};
+
+#define JSON_BUILD_STRV_ENV_PAIR(l) _JSON_BUILD_STRV_ENV_PAIR, (char**) { l }
+#define JSON_BUILD_IOVEC_BASE64(iov) _JSON_BUILD_IOVEC_BASE64, (const struct iovec*) { iov }
+#define JSON_BUILD_IOVEC_HEX(iov) _JSON_BUILD_IOVEC_HEX, (const struct iovec*) { iov }
+#define JSON_BUILD_CONST_STRING(s) _SD_JSON_BUILD_VARIANT, JSON_VARIANT_STRING_CONST(s)
+#define JSON_BUILD_IN4_ADDR(v) SD_JSON_BUILD_BYTE_ARRAY((const struct in_addr*) { v }, sizeof(struct in_addr))
+#define JSON_BUILD_IN6_ADDR(v) SD_JSON_BUILD_BYTE_ARRAY((const struct in6_addr*) { v }, sizeof(struct in6_addr))
+#define JSON_BUILD_IN_ADDR(v, f) SD_JSON_BUILD_BYTE_ARRAY(((const union in_addr_union*) { v })->bytes, FAMILY_ADDRESS_SIZE_SAFE(f))
+#define JSON_BUILD_ETHER_ADDR(v) SD_JSON_BUILD_BYTE_ARRAY(((const struct ether_addr*) { v })->ether_addr_octet, sizeof(struct ether_addr))
+#define JSON_BUILD_HW_ADDR(v) _JSON_BUILD_HW_ADDR, (const struct hw_addr_data*) { v }
+#define JSON_BUILD_STRING_SET(s) _JSON_BUILD_STRING_SET, (Set *) { s }
+
+#define JSON_BUILD_PAIR_UNSIGNED_NON_ZERO(name, u) _JSON_BUILD_PAIR_UNSIGNED_NON_ZERO, (const char*) { name }, (uint64_t) { u }
+#define JSON_BUILD_PAIR_FINITE_USEC(name, u) _JSON_BUILD_PAIR_FINITE_USEC, (const char*) { name }, (usec_t) { u }
+#define JSON_BUILD_PAIR_STRING_NON_EMPTY(name, s) _JSON_BUILD_PAIR_STRING_NON_EMPTY, (const char*) { name }, (const char*) { s }
+#define JSON_BUILD_PAIR_STRV_NON_EMPTY(name, l) _JSON_BUILD_PAIR_STRV_NON_EMPTY, (const char*) { name }, (char**) { l }
+#define JSON_BUILD_PAIR_VARIANT_NON_NULL(name, v) _JSON_BUILD_PAIR_VARIANT_NON_NULL, (const char*) { name }, (sd_json_variant*) { v }
+#define JSON_BUILD_PAIR_IN4_ADDR_NON_NULL(name, v) _JSON_BUILD_PAIR_IN4_ADDR_NON_NULL, (const char*) { name }, (const struct in_addr*) { v }
+#define JSON_BUILD_PAIR_IN6_ADDR_NON_NULL(name, v) _JSON_BUILD_PAIR_IN6_ADDR_NON_NULL, (const char*) { name }, (const struct in6_addr*) { v }
+#define JSON_BUILD_PAIR_IN_ADDR_NON_NULL(name, v, f) _JSON_BUILD_PAIR_IN_ADDR_NON_NULL, (const char*) { name }, (const union in_addr_union*) { v }, (int) { f }
+#define JSON_BUILD_PAIR_ETHER_ADDR_NON_NULL(name, v) _JSON_BUILD_PAIR_ETHER_ADDR_NON_NULL, (const char*) { name }, (const struct ether_addr*) { v }
+#define JSON_BUILD_PAIR_HW_ADDR_NON_NULL(name, v) _JSON_BUILD_PAIR_HW_ADDR_NON_NULL, (const char*) { name }, (const struct hw_addr_data*) { v }
+
+#define JSON_BUILD_PAIR_IOVEC_BASE64(name, iov) SD_JSON_BUILD_PAIR(name, JSON_BUILD_IOVEC_BASE64(iov))
+#define JSON_BUILD_PAIR_IOVEC_HEX(name, iov) SD_JSON_BUILD_PAIR(name, JSON_BUILD_IOVEC_HEX(iov))
+#define JSON_BUILD_PAIR_IN4_ADDR(name, v) SD_JSON_BUILD_PAIR(name, JSON_BUILD_IN4_ADDR(v))
+#define JSON_BUILD_PAIR_IN6_ADDR(name, v) SD_JSON_BUILD_PAIR(name, JSON_BUILD_IN6_ADDR(v))
+#define JSON_BUILD_PAIR_IN_ADDR(name, v, f) SD_JSON_BUILD_PAIR(name, JSON_BUILD_IN_ADDR(v, f))
+#define JSON_BUILD_PAIR_ETHER_ADDR(name, v) SD_JSON_BUILD_PAIR(name, JSON_BUILD_ETHER_ADDR(v))
+#define JSON_BUILD_PAIR_HW_ADDR(name, v) SD_JSON_BUILD_PAIR(name, JSON_BUILD_HW_ADDR(v))
+#define JSON_BUILD_PAIR_STRING_SET(name, s) SD_JSON_BUILD_PAIR(name, JSON_BUILD_STRING_SET(s))
#include <stdlib.h>
#include <sys/types.h>
+#include "sd-json.h"
#include "sd-messages.h"
#include "alloc-util.h"
#include "errno-util.h"
#include "escape.h"
+#include "ether-addr-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "float.h"
#include "glyph-util.h"
#include "hexdecoct.h"
+#include "in-addr-util.h"
#include "iovec-util.h"
#include "json-internal.h"
-#include "json.h"
+#include "json-util.h"
#include "macro.h"
#include "math-util.h"
#include "memory-util.h"
} JsonSource;
/* On x86-64 this whole structure should have a size of 6 * 64 bit = 48 bytes */
-struct JsonVariant {
+struct sd_json_variant {
union {
/* We either maintain a reference counter for this variant itself, or we are embedded into an
* array/object, in which case only that surrounding object is ref-counted. (If 'embedded' is false,
* see below.) */
unsigned n_ref;
- /* If this JsonVariant is part of an array/object, then this field points to the surrounding
+ /* If this sd_json_variant is part of an array/object, then this field points to the surrounding
* JSON_VARIANT_ARRAY/JSON_VARIANT_OBJECT object. (If 'embedded' is true, see below.) */
- JsonVariant *parent;
+ sd_json_variant *parent;
};
/* If this was parsed from some file or buffer, this stores where from, as well as the source line/column */
JsonSource *source;
unsigned line, column;
- /* The current 'depth' of the JsonVariant, i.e. how many levels of member variants this has */
+ /* The current 'depth' of the sd_json_variant, i.e. how many levels of member variants this has */
uint16_t depth;
- JsonVariantType type:8;
+ int type:8; /* actually sd_json_variant_type_t, but reduced to 8bit size */
/* A marker whether this variant is embedded into in array/object or not. If true, the 'parent' pointer above
* is valid. If false, the 'n_ref' field above is valid instead. */
size_t n_elements;
/* If is_reference as indicated above is set, this is where the reference object is actually stored. */
- JsonVariant *reference;
+ sd_json_variant *reference;
- /* Strings are placed immediately after the structure. Note that when this is a JsonVariant
+ /* Strings are placed immediately after the structure. Note that when this is a sd_json_variant
* embedded into an array we might encode strings up to INLINE_STRING_LENGTH characters
* directly inside the element, while longer strings are stored as references. When this
* object is not embedded into an array, but stand-alone, we allocate the right size for the
};
};
-/* Inside string arrays we have a series of JsonVariant structures one after the other. In this case, strings longer
+/* Inside string arrays we have a series of sd_json_variant structures one after the other. In this case, strings longer
* than INLINE_STRING_MAX are stored as references, and all shorter ones inline. (This means — on x86-64 — strings up
* to 7 chars are stored within the array elements, and all others in separate allocations) */
-#define INLINE_STRING_MAX (sizeof(JsonVariant) - offsetof(JsonVariant, string) - 1U)
+#define INLINE_STRING_MAX (sizeof(sd_json_variant) - offsetof(sd_json_variant, string) - 1U)
/* Let's make sure this structure isn't increased in size accidentally. This check is only for our most relevant arch
* (x86-64). */
#if defined(__x86_64__) && __SIZEOF_POINTER__ == 8
-assert_cc(sizeof(JsonVariant) == 40U);
+assert_cc(sizeof(sd_json_variant) == 40U);
assert_cc(INLINE_STRING_MAX == 7U);
#endif
DEFINE_TRIVIAL_CLEANUP_FUNC(JsonSource*, json_source_unref);
-/* There are four kind of JsonVariant* pointers:
+/* There are four kind of sd_json_variant* pointers:
*
* 1. NULL
* 2. A 'regular' one, i.e. pointing to malloc() memory
* otherwise #4. This makes use of the fact that malloc() will return "maximum aligned" memory, which definitely
* means the pointer is even. This means we can use the uneven pointers to reference static strings, as long as we
* make sure that all static strings used like this are aligned to 2 (or higher), and that we mask the bit on
- * access. The JSON_VARIANT_STRING_CONST() macro encodes strings as JsonVariant* pointers, with the bit set. */
+ * access. The JSON_VARIANT_STRING_CONST() macro encodes strings as sd_json_variant* pointers, with the bit set. */
-static bool json_variant_is_magic(const JsonVariant *v) {
+static bool json_variant_is_magic(const sd_json_variant *v) {
if (!v)
return false;
return v < _JSON_VARIANT_MAGIC_MAX;
}
-static bool json_variant_is_const_string(const JsonVariant *v) {
+static bool json_variant_is_const_string(const sd_json_variant *v) {
if (v < _JSON_VARIANT_MAGIC_MAX)
return false;
- /* A proper JsonVariant is aligned to whatever malloc() aligns things too, which is definitely not uneven. We
+ /* A proper sd_json_variant is aligned to whatever malloc() aligns things too, which is definitely not uneven. We
* hence use all uneven pointers as indicators for const strings. */
return (((uintptr_t) v) & 1) != 0;
}
-static bool json_variant_is_regular(const JsonVariant *v) {
+static bool json_variant_is_regular(const sd_json_variant *v) {
if (v < _JSON_VARIANT_MAGIC_MAX)
return false;
return (((uintptr_t) v) & 1) == 0;
}
-static JsonVariant *json_variant_dereference(JsonVariant *v) {
+static sd_json_variant *json_variant_dereference(sd_json_variant *v) {
/* Recursively dereference variants that are references to other variants */
return json_variant_dereference(v->reference);
}
-static uint16_t json_variant_depth(JsonVariant *v) {
+static uint16_t json_variant_depth(sd_json_variant *v) {
v = json_variant_dereference(v);
if (!v)
return v->depth;
}
-static JsonVariant *json_variant_formalize(JsonVariant *v) {
+static sd_json_variant *json_variant_formalize(sd_json_variant *v) {
/* Converts json variant pointers to their normalized form, i.e. fully dereferenced and wherever
* possible converted to the "magic" version if there is one */
v = json_variant_dereference(v);
- switch (json_variant_type(v)) {
+ switch (sd_json_variant_type(v)) {
- case JSON_VARIANT_BOOLEAN:
- return json_variant_boolean(v) ? JSON_VARIANT_MAGIC_TRUE : JSON_VARIANT_MAGIC_FALSE;
+ case SD_JSON_VARIANT_BOOLEAN:
+ return sd_json_variant_boolean(v) ? JSON_VARIANT_MAGIC_TRUE : JSON_VARIANT_MAGIC_FALSE;
- case JSON_VARIANT_NULL:
+ case SD_JSON_VARIANT_NULL:
return JSON_VARIANT_MAGIC_NULL;
- case JSON_VARIANT_INTEGER:
- return json_variant_integer(v) == 0 ? JSON_VARIANT_MAGIC_ZERO_INTEGER : v;
+ case SD_JSON_VARIANT_INTEGER:
+ return sd_json_variant_integer(v) == 0 ? JSON_VARIANT_MAGIC_ZERO_INTEGER : v;
- case JSON_VARIANT_UNSIGNED:
- return json_variant_unsigned(v) == 0 ? JSON_VARIANT_MAGIC_ZERO_UNSIGNED : v;
+ case SD_JSON_VARIANT_UNSIGNED:
+ return sd_json_variant_unsigned(v) == 0 ? JSON_VARIANT_MAGIC_ZERO_UNSIGNED : v;
- case JSON_VARIANT_REAL:
- return iszero_safe(json_variant_real(v)) ? JSON_VARIANT_MAGIC_ZERO_REAL : v;
+ case SD_JSON_VARIANT_REAL:
+ return iszero_safe(sd_json_variant_real(v)) ? JSON_VARIANT_MAGIC_ZERO_REAL : v;
- case JSON_VARIANT_STRING:
- return isempty(json_variant_string(v)) ? JSON_VARIANT_MAGIC_EMPTY_STRING : v;
+ case SD_JSON_VARIANT_STRING:
+ return isempty(sd_json_variant_string(v)) ? JSON_VARIANT_MAGIC_EMPTY_STRING : v;
- case JSON_VARIANT_ARRAY:
- return json_variant_elements(v) == 0 ? JSON_VARIANT_MAGIC_EMPTY_ARRAY : v;
+ case SD_JSON_VARIANT_ARRAY:
+ return sd_json_variant_elements(v) == 0 ? JSON_VARIANT_MAGIC_EMPTY_ARRAY : v;
- case JSON_VARIANT_OBJECT:
- return json_variant_elements(v) == 0 ? JSON_VARIANT_MAGIC_EMPTY_OBJECT : v;
+ case SD_JSON_VARIANT_OBJECT:
+ return sd_json_variant_elements(v) == 0 ? JSON_VARIANT_MAGIC_EMPTY_OBJECT : v;
default:
return v;
}
}
-static JsonVariant *json_variant_conservative_formalize(JsonVariant *v) {
+static sd_json_variant *json_variant_conservative_formalize(sd_json_variant *v) {
/* Much like json_variant_formalize(), but won't simplify if the variant has a source/line location
* attached to it, in order not to lose context */
return json_variant_formalize(v);
}
-static int json_variant_new(JsonVariant **ret, JsonVariantType type, size_t space) {
- JsonVariant *v;
+static int json_variant_new(sd_json_variant **ret, sd_json_variant_type_t type, size_t space) {
+ sd_json_variant *v;
assert_return(ret, -EINVAL);
- v = malloc0(MAX(sizeof(JsonVariant),
- offsetof(JsonVariant, value) + space));
+ v = malloc0(MAX(sizeof(sd_json_variant),
+ offsetof(sd_json_variant, value) + space));
if (!v)
return -ENOMEM;
return 0;
}
-int json_variant_new_integer(JsonVariant **ret, int64_t i) {
- JsonVariant *v;
+_public_ int sd_json_variant_new_integer(sd_json_variant **ret, int64_t i) {
+ sd_json_variant *v;
int r;
assert_return(ret, -EINVAL);
return 0;
}
- r = json_variant_new(&v, JSON_VARIANT_INTEGER, sizeof(i));
+ r = json_variant_new(&v, SD_JSON_VARIANT_INTEGER, sizeof(i));
if (r < 0)
return r;
return 0;
}
-int json_variant_new_unsigned(JsonVariant **ret, uint64_t u) {
- JsonVariant *v;
+_public_ int sd_json_variant_new_unsigned(sd_json_variant **ret, uint64_t u) {
+ sd_json_variant *v;
int r;
assert_return(ret, -EINVAL);
return 0;
}
- r = json_variant_new(&v, JSON_VARIANT_UNSIGNED, sizeof(u));
+ r = json_variant_new(&v, SD_JSON_VARIANT_UNSIGNED, sizeof(u));
if (r < 0)
return r;
return 0;
}
-int json_variant_new_real(JsonVariant **ret, double d) {
- JsonVariant *v;
+_public_ int sd_json_variant_new_real(sd_json_variant **ret, double d) {
+ sd_json_variant *v;
int r;
assert_return(ret, -EINVAL);
return 0;
}
- r = json_variant_new(&v, JSON_VARIANT_REAL, sizeof(d));
+ r = json_variant_new(&v, SD_JSON_VARIANT_REAL, sizeof(d));
if (r < 0)
return r;
return 0;
}
-int json_variant_new_boolean(JsonVariant **ret, bool b) {
+_public_ int sd_json_variant_new_boolean(sd_json_variant **ret, int b) {
assert_return(ret, -EINVAL);
if (b)
return 0;
}
-int json_variant_new_null(JsonVariant **ret) {
+_public_ int sd_json_variant_new_null(sd_json_variant **ret) {
assert_return(ret, -EINVAL);
*ret = JSON_VARIANT_MAGIC_NULL;
return 0;
}
-int json_variant_new_stringn(JsonVariant **ret, const char *s, size_t n) {
- JsonVariant *v;
+_public_ int sd_json_variant_new_stringn(sd_json_variant **ret, const char *s, size_t n) {
+ sd_json_variant *v;
int r;
assert_return(ret, -EINVAL);
if (!s) {
assert_return(IN_SET(n, 0, SIZE_MAX), -EINVAL);
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
}
if (n == SIZE_MAX) /* determine length automatically */
n = strlen(s);
if (!utf8_is_valid_n(s, n)) /* JSON strings must be valid UTF-8 */
return -EUCLEAN;
- r = json_variant_new(&v, JSON_VARIANT_STRING, n + 1);
+ r = json_variant_new(&v, SD_JSON_VARIANT_STRING, n + 1);
if (r < 0)
return r;
return 0;
}
-int json_variant_new_base64(JsonVariant **ret, const void *p, size_t n) {
+_public_ int sd_json_variant_new_string(sd_json_variant **ret, const char *s) {
+ return sd_json_variant_new_stringn(ret, s, SIZE_MAX);
+}
+
+_public_ int sd_json_variant_new_base64(sd_json_variant **ret, const void *p, size_t n) {
_cleanup_free_ char *s = NULL;
ssize_t k;
if (k < 0)
return k;
- return json_variant_new_stringn(ret, s, k);
+ return sd_json_variant_new_stringn(ret, s, k);
}
-int json_variant_new_base32hex(JsonVariant **ret, const void *p, size_t n) {
+_public_ int sd_json_variant_new_base32hex(sd_json_variant **ret, const void *p, size_t n) {
_cleanup_free_ char *s = NULL;
assert_return(ret, -EINVAL);
if (!s)
return -ENOMEM;
- return json_variant_new_string(ret, s);
+ return sd_json_variant_new_string(ret, s);
}
-int json_variant_new_hex(JsonVariant **ret, const void *p, size_t n) {
+_public_ int sd_json_variant_new_hex(sd_json_variant **ret, const void *p, size_t n) {
_cleanup_free_ char *s = NULL;
assert_return(ret, -EINVAL);
if (!s)
return -ENOMEM;
- return json_variant_new_stringn(ret, s, n*2);
+ return sd_json_variant_new_stringn(ret, s, n*2);
}
-int json_variant_new_octescape(JsonVariant **ret, const void *p, size_t n) {
+_public_ int sd_json_variant_new_octescape(sd_json_variant **ret, const void *p, size_t n) {
_cleanup_free_ char *s = NULL;
assert_return(ret, -EINVAL);
if (!s)
return -ENOMEM;
- return json_variant_new_string(ret, s);
+ return sd_json_variant_new_string(ret, s);
}
-int json_variant_new_id128(JsonVariant **ret, sd_id128_t id) {
- return json_variant_new_string(ret, SD_ID128_TO_STRING(id));
+_public_ int sd_json_variant_new_id128(sd_json_variant **ret, sd_id128_t id) {
+ return sd_json_variant_new_string(ret, SD_ID128_TO_STRING(id));
}
-int json_variant_new_uuid(JsonVariant **ret, sd_id128_t id) {
- return json_variant_new_string(ret, SD_ID128_TO_UUID_STRING(id));
+_public_ int sd_json_variant_new_uuid(sd_json_variant **ret, sd_id128_t id) {
+ return sd_json_variant_new_string(ret, SD_ID128_TO_UUID_STRING(id));
}
-static void json_variant_set(JsonVariant *a, JsonVariant *b) {
+static void json_variant_set(sd_json_variant *a, sd_json_variant *b) {
assert(a);
b = json_variant_dereference(b);
if (!b) {
- a->type = JSON_VARIANT_NULL;
+ a->type = SD_JSON_VARIANT_NULL;
return;
}
- a->type = json_variant_type(b);
+ a->type = sd_json_variant_type(b);
switch (a->type) {
- case JSON_VARIANT_INTEGER:
- a->value.integer = json_variant_integer(b);
+ case SD_JSON_VARIANT_INTEGER:
+ a->value.integer = sd_json_variant_integer(b);
break;
- case JSON_VARIANT_UNSIGNED:
- a->value.unsig = json_variant_unsigned(b);
+ case SD_JSON_VARIANT_UNSIGNED:
+ a->value.unsig = sd_json_variant_unsigned(b);
break;
- case JSON_VARIANT_REAL:
- a->value.real = json_variant_real(b);
+ case SD_JSON_VARIANT_REAL:
+ a->value.real = sd_json_variant_real(b);
break;
- case JSON_VARIANT_BOOLEAN:
- a->value.boolean = json_variant_boolean(b);
+ case SD_JSON_VARIANT_BOOLEAN:
+ a->value.boolean = sd_json_variant_boolean(b);
break;
- case JSON_VARIANT_STRING: {
+ case SD_JSON_VARIANT_STRING: {
const char *s;
- assert_se(s = json_variant_string(b));
+ assert_se(s = sd_json_variant_string(b));
/* Short strings we can store inline */
if (strnlen(s, INLINE_STRING_MAX+1) <= INLINE_STRING_MAX) {
_fallthrough_;
}
- case JSON_VARIANT_ARRAY:
- case JSON_VARIANT_OBJECT:
+ case SD_JSON_VARIANT_ARRAY:
+ case SD_JSON_VARIANT_OBJECT:
a->is_reference = true;
- a->reference = json_variant_ref(json_variant_conservative_formalize(b));
+ a->reference = sd_json_variant_ref(json_variant_conservative_formalize(b));
break;
- case JSON_VARIANT_NULL:
+ case SD_JSON_VARIANT_NULL:
break;
default:
}
}
-static void json_variant_copy_source(JsonVariant *v, JsonVariant *from) {
+static void json_variant_copy_source(sd_json_variant *v, sd_json_variant *from) {
assert(v);
if (!json_variant_is_regular(from))
v->source = json_source_ref(from->source);
}
-static int _json_variant_array_put_element(JsonVariant *array, JsonVariant *element) {
+static int json_variant_array_put_element(sd_json_variant *array, sd_json_variant *element) {
assert(array);
- JsonVariant *w = array + 1 + array->n_elements;
+ sd_json_variant *w = array + 1 + array->n_elements;
uint16_t d = json_variant_depth(element);
if (d >= DEPTH_MAX) /* Refuse too deep nesting */
array->depth = d + 1;
array->n_elements++;
- *w = (JsonVariant) {
+ *w = (sd_json_variant) {
.is_embedded = true,
.parent = array,
};
json_variant_set(w, element);
json_variant_copy_source(w, element);
- if (!json_variant_is_normalized(element))
+ if (!sd_json_variant_is_normalized(element))
array->normalized = false;
return 0;
}
-int json_variant_new_array(JsonVariant **ret, JsonVariant **array, size_t n) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+_public_ int sd_json_variant_new_array(sd_json_variant **ret, sd_json_variant **array, size_t n) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert_return(ret, -EINVAL);
}
assert_return(array, -EINVAL);
- v = new(JsonVariant, n + 1);
+ v = new(sd_json_variant, n + 1);
if (!v)
return -ENOMEM;
- *v = (JsonVariant) {
+ *v = (sd_json_variant) {
.n_ref = 1,
- .type = JSON_VARIANT_ARRAY,
+ .type = SD_JSON_VARIANT_ARRAY,
.normalized = true,
};
while (v->n_elements < n) {
- r = _json_variant_array_put_element(v, array[v->n_elements]);
+ r = json_variant_array_put_element(v, array[v->n_elements]);
if (r < 0)
return r;
}
return 0;
}
-int json_variant_new_array_bytes(JsonVariant **ret, const void *p, size_t n) {
+_public_ int sd_json_variant_new_array_bytes(sd_json_variant **ret, const void *p, size_t n) {
assert_return(ret, -EINVAL);
if (n == 0) {
*ret = JSON_VARIANT_MAGIC_EMPTY_ARRAY;
}
assert_return(p, -EINVAL);
- JsonVariant *v = new(JsonVariant, n + 1);
+ sd_json_variant *v = new(sd_json_variant, n + 1);
if (!v)
return -ENOMEM;
- *v = (JsonVariant) {
+ *v = (sd_json_variant) {
.n_ref = 1,
- .type = JSON_VARIANT_ARRAY,
+ .type = SD_JSON_VARIANT_ARRAY,
.n_elements = n,
.depth = 1,
};
for (size_t i = 0; i < n; i++) {
- JsonVariant *w = v + 1 + i;
+ sd_json_variant *w = v + 1 + i;
- *w = (JsonVariant) {
+ *w = (sd_json_variant) {
.is_embedded = true,
.parent = v,
- .type = JSON_VARIANT_UNSIGNED,
+ .type = SD_JSON_VARIANT_UNSIGNED,
.value.unsig = ((const uint8_t*) p)[i],
};
}
return 0;
}
-int json_variant_new_array_strv(JsonVariant **ret, char **l) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+_public_ int sd_json_variant_new_array_strv(sd_json_variant **ret, char **l) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
size_t n;
int r;
return 0;
}
- v = new(JsonVariant, n + 1);
+ v = new(sd_json_variant, n + 1);
if (!v)
return -ENOMEM;
- *v = (JsonVariant) {
+ *v = (sd_json_variant) {
.n_ref = 1,
- .type = JSON_VARIANT_ARRAY,
+ .type = SD_JSON_VARIANT_ARRAY,
.depth = 1,
};
for (v->n_elements = 0; v->n_elements < n; v->n_elements++) {
- JsonVariant *w = v + 1 + v->n_elements;
+ sd_json_variant *w = v + 1 + v->n_elements;
size_t k;
- *w = (JsonVariant) {
+ *w = (sd_json_variant) {
.is_embedded = true,
.parent = v,
- .type = JSON_VARIANT_STRING,
+ .type = SD_JSON_VARIANT_STRING,
};
k = strlen(l[v->n_elements]);
if (k > INLINE_STRING_MAX) {
/* If string is too long, store it as reference. */
- r = json_variant_new_string(&w->reference, l[v->n_elements]);
+ r = sd_json_variant_new_string(&w->reference, l[v->n_elements]);
if (r < 0)
return r;
return 0;
}
-int json_variant_new_object(JsonVariant **ret, JsonVariant **array, size_t n) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+_public_ int sd_json_variant_new_object(sd_json_variant **ret, sd_json_variant **array, size_t n) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
const char *prev = NULL;
bool sorted = true, normalized = true;
assert_return(array, -EINVAL);
assert_return(n % 2 == 0, -EINVAL);
- v = new(JsonVariant, n + 1);
+ v = new(sd_json_variant, n + 1);
if (!v)
return -ENOMEM;
- *v = (JsonVariant) {
+ *v = (sd_json_variant) {
.n_ref = 1,
- .type = JSON_VARIANT_OBJECT,
+ .type = SD_JSON_VARIANT_OBJECT,
};
for (v->n_elements = 0; v->n_elements < n; v->n_elements++) {
- JsonVariant *w = v + 1 + v->n_elements,
+ sd_json_variant *w = v + 1 + v->n_elements,
*c = array[v->n_elements];
uint16_t d;
if ((v->n_elements & 1) == 0) {
const char *k;
- if (!json_variant_is_string(c))
+ if (!sd_json_variant_is_string(c))
return -EINVAL; /* Every second one needs to be a string, as it is the key name */
- assert_se(k = json_variant_string(c));
+ assert_se(k = sd_json_variant_string(c));
if (prev && strcmp(k, prev) <= 0)
sorted = normalized = false;
prev = k;
- } else if (!json_variant_is_normalized(c))
+ } else if (!sd_json_variant_is_normalized(c))
normalized = false;
d = json_variant_depth(c);
if (d >= v->depth)
v->depth = d + 1;
- *w = (JsonVariant) {
+ *w = (sd_json_variant) {
.is_embedded = true,
.parent = v,
};
return 0;
}
-static size_t json_variant_size(JsonVariant* v) {
+static size_t json_variant_size(sd_json_variant* v) {
if (!json_variant_is_regular(v))
return 0;
if (v->is_reference)
- return offsetof(JsonVariant, reference) + sizeof(JsonVariant*);
+ return offsetof(sd_json_variant, reference) + sizeof(sd_json_variant*);
switch (v->type) {
- case JSON_VARIANT_STRING:
- return offsetof(JsonVariant, string) + strlen(v->string) + 1;
+ case SD_JSON_VARIANT_STRING:
+ return offsetof(sd_json_variant, string) + strlen(v->string) + 1;
- case JSON_VARIANT_REAL:
- return offsetof(JsonVariant, value) + sizeof(double);
+ case SD_JSON_VARIANT_REAL:
+ return offsetof(sd_json_variant, value) + sizeof(double);
- case JSON_VARIANT_UNSIGNED:
- return offsetof(JsonVariant, value) + sizeof(uint64_t);
+ case SD_JSON_VARIANT_UNSIGNED:
+ return offsetof(sd_json_variant, value) + sizeof(uint64_t);
- case JSON_VARIANT_INTEGER:
- return offsetof(JsonVariant, value) + sizeof(int64_t);
+ case SD_JSON_VARIANT_INTEGER:
+ return offsetof(sd_json_variant, value) + sizeof(int64_t);
- case JSON_VARIANT_BOOLEAN:
- return offsetof(JsonVariant, value) + sizeof(bool);
+ case SD_JSON_VARIANT_BOOLEAN:
+ return offsetof(sd_json_variant, value) + sizeof(bool);
- case JSON_VARIANT_ARRAY:
- case JSON_VARIANT_OBJECT:
- return offsetof(JsonVariant, n_elements) + sizeof(size_t);
+ case SD_JSON_VARIANT_ARRAY:
+ case SD_JSON_VARIANT_OBJECT:
+ return offsetof(sd_json_variant, n_elements) + sizeof(size_t);
- case JSON_VARIANT_NULL:
- return offsetof(JsonVariant, value);
+ case SD_JSON_VARIANT_NULL:
+ return offsetof(sd_json_variant, value);
default:
assert_not_reached();
}
}
-static void json_variant_free_inner(JsonVariant *v, bool force_sensitive) {
+static void json_variant_free_inner(sd_json_variant *v, bool force_sensitive) {
bool sensitive;
assert(v);
if (v->is_reference) {
if (sensitive)
- json_variant_sensitive(v->reference);
+ sd_json_variant_sensitive(v->reference);
- json_variant_unref(v->reference);
+ sd_json_variant_unref(v->reference);
return;
}
- if (IN_SET(v->type, JSON_VARIANT_ARRAY, JSON_VARIANT_OBJECT))
+ if (IN_SET(v->type, SD_JSON_VARIANT_ARRAY, SD_JSON_VARIANT_OBJECT))
for (size_t i = 0; i < v->n_elements; i++)
json_variant_free_inner(v + 1 + i, sensitive);
explicit_bzero_safe(v, json_variant_size(v));
}
-static unsigned json_variant_n_ref(const JsonVariant *v) {
+static unsigned json_variant_n_ref(const sd_json_variant *v) {
/* Return the number of references to v.
* 0 => NULL or not a regular object or embedded.
* >0 => number of references
return v->n_ref;
}
-JsonVariant *json_variant_ref(JsonVariant *v) {
+_public_ sd_json_variant *sd_json_variant_ref(sd_json_variant *v) {
if (!v)
return NULL;
if (!json_variant_is_regular(v))
return v;
if (v->is_embedded)
- json_variant_ref(v->parent); /* ref the compounding variant instead */
+ sd_json_variant_ref(v->parent); /* ref the compounding variant instead */
else {
assert(v->n_ref > 0);
v->n_ref++;
return v;
}
-JsonVariant *json_variant_unref(JsonVariant *v) {
+_public_ sd_json_variant *sd_json_variant_unref(sd_json_variant *v) {
if (!v)
return NULL;
if (!json_variant_is_regular(v))
return NULL;
if (v->is_embedded)
- json_variant_unref(v->parent);
+ sd_json_variant_unref(v->parent);
else {
assert(v->n_ref > 0);
v->n_ref--;
return NULL;
}
-void json_variant_unref_many(JsonVariant **array, size_t n) {
+_public_ void sd_json_variant_unref_many(sd_json_variant **array, size_t n) {
assert(array || n == 0);
for (size_t i = 0; i < n; i++)
- json_variant_unref(array[i]);
+ sd_json_variant_unref(array[i]);
free(array);
}
-const char *json_variant_string(JsonVariant *v) {
+_public_ const char *sd_json_variant_string(sd_json_variant *v) {
if (!v)
return NULL;
if (v == JSON_VARIANT_MAGIC_EMPTY_STRING)
}
if (v->is_reference)
- return json_variant_string(v->reference);
- if (v->type != JSON_VARIANT_STRING)
+ return sd_json_variant_string(v->reference);
+ if (v->type != SD_JSON_VARIANT_STRING)
goto mismatch;
return v->string;
return NULL;
}
-bool json_variant_boolean(JsonVariant *v) {
+_public_ int sd_json_variant_boolean(sd_json_variant *v) {
if (!v)
goto mismatch;
if (v == JSON_VARIANT_MAGIC_TRUE)
return false;
if (!json_variant_is_regular(v))
goto mismatch;
- if (v->type != JSON_VARIANT_BOOLEAN)
+ if (v->type != SD_JSON_VARIANT_BOOLEAN)
goto mismatch;
if (v->is_reference)
- return json_variant_boolean(v->reference);
+ return sd_json_variant_boolean(v->reference);
return v->value.boolean;
return false;
}
-int64_t json_variant_integer(JsonVariant *v) {
+_public_ int64_t sd_json_variant_integer(sd_json_variant *v) {
if (!v)
goto mismatch;
if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
if (!json_variant_is_regular(v))
goto mismatch;
if (v->is_reference)
- return json_variant_integer(v->reference);
+ return sd_json_variant_integer(v->reference);
switch (v->type) {
- case JSON_VARIANT_INTEGER:
+ case SD_JSON_VARIANT_INTEGER:
return v->value.integer;
- case JSON_VARIANT_UNSIGNED:
+ case SD_JSON_VARIANT_UNSIGNED:
if (v->value.unsig <= INT64_MAX)
return (int64_t) v->value.unsig;
log_debug("Unsigned integer %" PRIu64 " requested as signed integer and out of range, returning 0.", v->value.unsig);
return 0;
- case JSON_VARIANT_REAL: {
+ case SD_JSON_VARIANT_REAL: {
int64_t converted;
converted = (int64_t) v->value.real;
return 0;
}
-uint64_t json_variant_unsigned(JsonVariant *v) {
+_public_ uint64_t sd_json_variant_unsigned(sd_json_variant *v) {
if (!v)
goto mismatch;
if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
if (!json_variant_is_regular(v))
goto mismatch;
if (v->is_reference)
- return json_variant_integer(v->reference);
+ return sd_json_variant_integer(v->reference);
switch (v->type) {
- case JSON_VARIANT_INTEGER:
+ 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 JSON_VARIANT_UNSIGNED:
+ case SD_JSON_VARIANT_UNSIGNED:
return v->value.unsig;
- case JSON_VARIANT_REAL: {
+ case SD_JSON_VARIANT_REAL: {
uint64_t converted;
converted = (uint64_t) v->value.real;
return 0;
}
-double json_variant_real(JsonVariant *v) {
+_public_ double sd_json_variant_real(sd_json_variant *v) {
if (!v)
return 0.0;
if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
if (!json_variant_is_regular(v))
goto mismatch;
if (v->is_reference)
- return json_variant_real(v->reference);
+ return sd_json_variant_real(v->reference);
switch (v->type) {
- case JSON_VARIANT_REAL:
+ case SD_JSON_VARIANT_REAL:
return v->value.real;
- case JSON_VARIANT_INTEGER: {
+ case SD_JSON_VARIANT_INTEGER: {
double converted = (double) v->value.integer;
if ((int64_t) converted == v->value.integer)
return 0.0;
}
- case JSON_VARIANT_UNSIGNED: {
+ case SD_JSON_VARIANT_UNSIGNED: {
double converted = (double) v->value.unsig;
if ((uint64_t) converted == v->value.unsig)
return 0.0;
}
-bool json_variant_is_negative(JsonVariant *v) {
+_public_ int sd_json_variant_is_negative(sd_json_variant *v) {
if (!v)
goto mismatch;
if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
if (!json_variant_is_regular(v))
goto mismatch;
if (v->is_reference)
- return json_variant_is_negative(v->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
switch (v->type) {
- case JSON_VARIANT_REAL:
+ case SD_JSON_VARIANT_REAL:
return v->value.real < 0;
- case JSON_VARIANT_INTEGER:
+ case SD_JSON_VARIANT_INTEGER:
return v->value.integer < 0;
- case JSON_VARIANT_UNSIGNED:
+ case SD_JSON_VARIANT_UNSIGNED:
return false;
default:
return false;
}
-bool json_variant_is_blank_object(JsonVariant *v) {
+_public_ int sd_json_variant_is_blank_object(sd_json_variant *v) {
/* Returns true if the specified object is null or empty */
return !v ||
- json_variant_is_null(v) ||
- (json_variant_is_object(v) && json_variant_elements(v) == 0);
+ sd_json_variant_is_null(v) ||
+ (sd_json_variant_is_object(v) && sd_json_variant_elements(v) == 0);
}
-bool json_variant_is_blank_array(JsonVariant *v) {
+_public_ int sd_json_variant_is_blank_array(sd_json_variant *v) {
return !v ||
- json_variant_is_null(v) ||
- (json_variant_is_array(v) && json_variant_elements(v) == 0);
+ sd_json_variant_is_null(v) ||
+ (sd_json_variant_is_array(v) && sd_json_variant_elements(v) == 0);
}
-JsonVariantType json_variant_type(JsonVariant *v) {
+_public_ sd_json_variant_type_t sd_json_variant_type(sd_json_variant *v) {
if (!v)
- return _JSON_VARIANT_TYPE_INVALID;
+ return _SD_JSON_VARIANT_TYPE_INVALID;
if (json_variant_is_const_string(v))
- return JSON_VARIANT_STRING;
+ return SD_JSON_VARIANT_STRING;
if (v == JSON_VARIANT_MAGIC_TRUE || v == JSON_VARIANT_MAGIC_FALSE)
- return JSON_VARIANT_BOOLEAN;
+ return SD_JSON_VARIANT_BOOLEAN;
if (v == JSON_VARIANT_MAGIC_NULL)
- return JSON_VARIANT_NULL;
+ return SD_JSON_VARIANT_NULL;
if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER)
- return JSON_VARIANT_INTEGER;
+ return SD_JSON_VARIANT_INTEGER;
if (v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED)
- return JSON_VARIANT_UNSIGNED;
+ return SD_JSON_VARIANT_UNSIGNED;
if (v == JSON_VARIANT_MAGIC_ZERO_REAL)
- return JSON_VARIANT_REAL;
+ return SD_JSON_VARIANT_REAL;
if (v == JSON_VARIANT_MAGIC_EMPTY_STRING)
- return JSON_VARIANT_STRING;
+ return SD_JSON_VARIANT_STRING;
if (v == JSON_VARIANT_MAGIC_EMPTY_ARRAY)
- return JSON_VARIANT_ARRAY;
+ return SD_JSON_VARIANT_ARRAY;
if (v == JSON_VARIANT_MAGIC_EMPTY_OBJECT)
- return JSON_VARIANT_OBJECT;
+ return SD_JSON_VARIANT_OBJECT;
return v->type;
}
_function_no_sanitize_float_cast_overflow_
-bool json_variant_has_type(JsonVariant *v, JsonVariantType type) {
- JsonVariantType rt;
+_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. */
if (!v)
return false;
- rt = json_variant_type(v);
+ rt = sd_json_variant_type(v);
if (rt == type)
return true;
/* 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, JSON_VARIANT_INTEGER, JSON_VARIANT_UNSIGNED, JSON_VARIANT_REAL, JSON_VARIANT_NUMBER))
+ 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 */
return false;
/* Handle the "number" pseudo type */
- if (type == JSON_VARIANT_NUMBER)
- return IN_SET(rt, JSON_VARIANT_INTEGER, JSON_VARIANT_UNSIGNED, JSON_VARIANT_REAL);
+ 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 == JSON_VARIANT_INTEGER && type == JSON_VARIANT_UNSIGNED)
+ if (rt == SD_JSON_VARIANT_INTEGER && type == SD_JSON_VARIANT_UNSIGNED)
return v->value.integer >= 0;
- if (rt == JSON_VARIANT_UNSIGNED && type == JSON_VARIANT_INTEGER)
+ 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 == JSON_VARIANT_INTEGER && type == JSON_VARIANT_REAL)
+ if (rt == SD_JSON_VARIANT_INTEGER && type == SD_JSON_VARIANT_REAL)
return (int64_t) (double) v->value.integer == v->value.integer;
- if (rt == JSON_VARIANT_UNSIGNED && type == JSON_VARIANT_REAL)
+ 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 == JSON_VARIANT_REAL && type == JSON_VARIANT_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 == JSON_VARIANT_REAL && type == JSON_VARIANT_UNSIGNED)
+ 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;
}
-size_t json_variant_elements(JsonVariant *v) {
+_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 ||
return 0;
if (!json_variant_is_regular(v))
goto mismatch;
- if (!IN_SET(v->type, JSON_VARIANT_ARRAY, JSON_VARIANT_OBJECT))
+ if (!IN_SET(v->type, SD_JSON_VARIANT_ARRAY, SD_JSON_VARIANT_OBJECT))
goto mismatch;
if (v->is_reference)
- return json_variant_elements(v->reference);
+ return sd_json_variant_elements(v->reference);
return v->n_elements;
return 0;
}
-JsonVariant *json_variant_by_index(JsonVariant *v, size_t idx) {
+_public_ sd_json_variant *sd_json_variant_by_index(sd_json_variant *v, size_t idx) {
if (!v)
return NULL;
if (v == JSON_VARIANT_MAGIC_EMPTY_ARRAY ||
return NULL;
if (!json_variant_is_regular(v))
goto mismatch;
- if (!IN_SET(v->type, JSON_VARIANT_ARRAY, JSON_VARIANT_OBJECT))
+ if (!IN_SET(v->type, SD_JSON_VARIANT_ARRAY, SD_JSON_VARIANT_OBJECT))
goto mismatch;
if (v->is_reference)
- return json_variant_by_index(v->reference, idx);
+ return sd_json_variant_by_index(v->reference, idx);
if (idx >= v->n_elements)
return NULL;
return NULL;
}
-JsonVariant *json_variant_by_key_full(JsonVariant *v, const char *key, JsonVariant **ret_key) {
+_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 (!json_variant_is_regular(v))
goto mismatch;
- if (v->type != JSON_VARIANT_OBJECT)
+ if (v->type != SD_JSON_VARIANT_OBJECT)
goto mismatch;
if (v->is_reference)
- return json_variant_by_key(v->reference, key);
+ 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) {
- JsonVariant *p;
+ 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 = json_variant_string(p));
+ assert_se(f = sd_json_variant_string(p));
c = strcmp(key, f);
if (c == 0) {
/* The variant is not sorted, hence search for the field linearly */
for (size_t i = 0; i < v->n_elements; i += 2) {
- JsonVariant *p;
+ sd_json_variant *p;
p = json_variant_dereference(v + 1 + i);
- if (!json_variant_has_type(p, JSON_VARIANT_STRING))
+ if (!sd_json_variant_has_type(p, SD_JSON_VARIANT_STRING))
continue;
- if (streq(json_variant_string(p), key)) {
+ if (streq(sd_json_variant_string(p), key)) {
if (ret_key)
*ret_key = json_variant_conservative_formalize(v + 1 + i);
return NULL;
}
-JsonVariant *json_variant_by_key(JsonVariant *v, const char *key) {
- return json_variant_by_key_full(v, key, 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);
}
-bool json_variant_equal(JsonVariant *a, JsonVariant *b) {
- JsonVariantType t;
+_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 = json_variant_type(a);
- if (!json_variant_has_type(b, t))
+ t = sd_json_variant_type(a);
+ if (!sd_json_variant_has_type(b, t))
return false;
switch (t) {
- case JSON_VARIANT_STRING:
- return streq(json_variant_string(a), json_variant_string(b));
+ case SD_JSON_VARIANT_STRING:
+ return streq(sd_json_variant_string(a), sd_json_variant_string(b));
- case JSON_VARIANT_INTEGER:
- return json_variant_integer(a) == json_variant_integer(b);
+ case SD_JSON_VARIANT_INTEGER:
+ return sd_json_variant_integer(a) == sd_json_variant_integer(b);
- case JSON_VARIANT_UNSIGNED:
- return json_variant_unsigned(a) == json_variant_unsigned(b);
+ case SD_JSON_VARIANT_UNSIGNED:
+ return sd_json_variant_unsigned(a) == sd_json_variant_unsigned(b);
- case JSON_VARIANT_REAL:
- return fp_equal(json_variant_real(a), json_variant_real(b));
+ case SD_JSON_VARIANT_REAL:
+ return fp_equal(sd_json_variant_real(a), sd_json_variant_real(b));
- case JSON_VARIANT_BOOLEAN:
- return json_variant_boolean(a) == json_variant_boolean(b);
+ case SD_JSON_VARIANT_BOOLEAN:
+ return sd_json_variant_boolean(a) == sd_json_variant_boolean(b);
- case JSON_VARIANT_NULL:
+ case SD_JSON_VARIANT_NULL:
return true;
- case JSON_VARIANT_ARRAY: {
- size_t n = json_variant_elements(a);
- if (n != json_variant_elements(b))
+ 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 (!json_variant_equal(json_variant_by_index(a, i), json_variant_by_index(b, 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 JSON_VARIANT_OBJECT: {
- size_t n = json_variant_elements(a);
- if (n != json_variant_elements(b))
+ 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' */
/* Match them against all keys in 'b' */
for (size_t j = 0; j < n; j += 2) {
- JsonVariant *key_b;
+ sd_json_variant *key_b;
- key_b = json_variant_by_index(b, j);
+ key_b = sd_json_variant_by_index(b, j);
/* During the first iteration unmark everything */
if (i == 0)
if (found)
continue;
- if (json_variant_equal(json_variant_by_index(a, i), key_b) &&
- json_variant_equal(json_variant_by_index(a, i+1), json_variant_by_index(b, j+1))) {
+ 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;
}
}
-void json_variant_sensitive(JsonVariant *v) {
+_public_ void sd_json_variant_sensitive(sd_json_variant *v) {
assert(v);
/* Marks a variant as "sensitive", so that it is erased from memory when it is destroyed. This is a
v->sensitive = true;
}
-bool json_variant_is_sensitive(JsonVariant *v) {
+_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;
}
-bool json_variant_is_sensitive_recursive(JsonVariant *v) {
+_public_ int sd_json_variant_is_sensitive_recursive(sd_json_variant *v) {
if (!v)
return false;
- if (json_variant_is_sensitive(v))
+ 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, JSON_VARIANT_ARRAY, JSON_VARIANT_OBJECT))
+ if (!IN_SET(v->type, SD_JSON_VARIANT_ARRAY, SD_JSON_VARIANT_OBJECT))
return false;
if (v->is_reference) {
- if (!json_variant_is_sensitive_recursive(v->reference))
+ if (!sd_json_variant_is_sensitive_recursive(v->reference))
return false;
return (v->recursive_sensitive = true);
}
- for (size_t i = 0; i < json_variant_elements(v); i++)
- if (json_variant_is_sensitive_recursive(json_variant_by_index(v, i)))
+ 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
return false;
}
-static void json_variant_propagate_sensitive(JsonVariant *from, JsonVariant *to) {
- if (json_variant_is_sensitive(from))
- json_variant_sensitive(to);
+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);
}
-int json_variant_get_source(JsonVariant *v, const char **ret_source, unsigned *ret_line, unsigned *ret_column) {
+_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)
return 0;
}
-static int print_source(FILE *f, JsonVariant *v, JsonFormatFlags flags, bool whitespace) {
+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, JSON_FORMAT_SOURCE|JSON_FORMAT_PRETTY))
+ if (!FLAGS_SET(flags, SD_JSON_FORMAT_SOURCE|SD_JSON_FORMAT_PRETTY))
return 0;
if (!json_variant_is_regular(v))
return 0;
}
-static void json_format_string(FILE *f, const char *q, JsonFormatFlags flags) {
+static void json_format_string(FILE *f, const char *q, sd_json_format_flags_t flags) {
assert(q);
fputc('"', f);
- if (flags & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ansi_green(), f);
for (; *q; q++)
break;
}
- if (flags & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
fputc('"', f);
}
-static int json_format(FILE *f, JsonVariant *v, JsonFormatFlags flags, const char *prefix) {
+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, JSON_FORMAT_CENSOR_SENSITIVE) && json_variant_is_sensitive(v)) {
- if (flags & JSON_FORMAT_COLOR)
+ 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 & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
return 0;
}
- switch (json_variant_type(v)) {
+ switch (sd_json_variant_type(v)) {
- case JSON_VARIANT_REAL: {
+ 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 & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ansi_highlight_blue(), f);
old_loc = uselocale(loc);
- fprintf(f, "%.*e", DECIMAL_DIG, json_variant_real(v));
+ fprintf(f, "%.*e", DECIMAL_DIG, sd_json_variant_real(v));
uselocale(old_loc);
- if (flags & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
freelocale(loc);
break;
}
- case JSON_VARIANT_INTEGER:
- if (flags & JSON_FORMAT_COLOR)
+ case SD_JSON_VARIANT_INTEGER:
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ansi_highlight_blue(), f);
- fprintf(f, "%" PRIdMAX, json_variant_integer(v));
+ fprintf(f, "%" PRIdMAX, sd_json_variant_integer(v));
- if (flags & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
break;
- case JSON_VARIANT_UNSIGNED:
- if (flags & JSON_FORMAT_COLOR)
+ case SD_JSON_VARIANT_UNSIGNED:
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ansi_highlight_blue(), f);
- fprintf(f, "%" PRIuMAX, json_variant_unsigned(v));
+ fprintf(f, "%" PRIuMAX, sd_json_variant_unsigned(v));
- if (flags & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
break;
- case JSON_VARIANT_BOOLEAN:
+ case SD_JSON_VARIANT_BOOLEAN:
- if (flags & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_HIGHLIGHT, f);
- if (json_variant_boolean(v))
+ if (sd_json_variant_boolean(v))
fputs("true", f);
else
fputs("false", f);
- if (flags & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
break;
- case JSON_VARIANT_NULL:
- if (flags & JSON_FORMAT_COLOR)
+ case SD_JSON_VARIANT_NULL:
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_HIGHLIGHT, f);
fputs("null", f);
- if (flags & JSON_FORMAT_COLOR)
+ if (flags & SD_JSON_FORMAT_COLOR)
fputs(ANSI_NORMAL, f);
break;
- case JSON_VARIANT_STRING:
- json_format_string(f, json_variant_string(v), flags);
+ case SD_JSON_VARIANT_STRING:
+ json_format_string(f, sd_json_variant_string(v), flags);
break;
- case JSON_VARIANT_ARRAY: {
- size_t n = json_variant_elements(v);
+ 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 & JSON_FORMAT_PRETTY) {
+ if (flags & SD_JSON_FORMAT_PRETTY) {
joined = strjoin(strempty(prefix), "\t");
if (!joined)
return -ENOMEM;
}
for (size_t i = 0; i < n; i++) {
- JsonVariant *e;
+ sd_json_variant *e;
- assert_se(e = json_variant_by_index(v, i));
+ assert_se(e = sd_json_variant_by_index(v, i));
if (i > 0) {
- if (flags & JSON_FORMAT_PRETTY)
+ if (flags & SD_JSON_FORMAT_PRETTY)
fputs(",\n", f);
else
fputc(',', f);
}
- if (flags & JSON_FORMAT_PRETTY) {
+ if (flags & SD_JSON_FORMAT_PRETTY) {
print_source(f, e, flags, false);
fputs(prefix2, f);
}
return r;
}
- if (flags & JSON_FORMAT_PRETTY) {
+ if (flags & SD_JSON_FORMAT_PRETTY) {
fputc('\n', f);
print_source(f, v, flags, true);
fputs(strempty(prefix), f);
break;
}
- case JSON_VARIANT_OBJECT: {
- size_t n = json_variant_elements(v);
+ 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 & JSON_FORMAT_PRETTY) {
+ if (flags & SD_JSON_FORMAT_PRETTY) {
joined = strjoin(strempty(prefix), "\t");
if (!joined)
return -ENOMEM;
}
for (size_t i = 0; i < n; i += 2) {
- JsonVariant *e;
+ sd_json_variant *e;
- e = json_variant_by_index(v, i);
+ e = sd_json_variant_by_index(v, i);
if (i > 0) {
- if (flags & JSON_FORMAT_PRETTY)
+ if (flags & SD_JSON_FORMAT_PRETTY)
fputs(",\n", f);
else
fputc(',', f);
}
- if (flags & JSON_FORMAT_PRETTY) {
+ if (flags & SD_JSON_FORMAT_PRETTY) {
print_source(f, e, flags, false);
fputs(prefix2, f);
}
if (r < 0)
return r;
- fputs(flags & JSON_FORMAT_PRETTY ? " : " : ":", f);
+ fputs(flags & SD_JSON_FORMAT_PRETTY ? " : " : ":", f);
- r = json_format(f, json_variant_by_index(v, i+1), flags, prefix2);
+ r = json_format(f, sd_json_variant_by_index(v, i+1), flags, prefix2);
if (r < 0)
return r;
}
- if (flags & JSON_FORMAT_PRETTY) {
+ if (flags & SD_JSON_FORMAT_PRETTY) {
fputc('\n', f);
print_source(f, v, flags, true);
fputs(strempty(prefix), f);
return 0;
}
-int json_variant_format(JsonVariant *v, JsonFormatFlags flags, char **ret) {
+_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;
assert_return(v, -EINVAL);
assert_return(ret, -EINVAL);
- if (flags & JSON_FORMAT_OFF)
+ if (flags & SD_JSON_FORMAT_OFF)
return -ENOEXEC;
f = memstream_init(&m);
if (!f)
return -ENOMEM;
- r = json_variant_dump(v, flags, f, NULL);
+ r = sd_json_variant_dump(v, flags, f, NULL);
if (r < 0)
return r;
return sz;
}
-int json_variant_dump(JsonVariant *v, JsonFormatFlags flags, FILE *f, const char *prefix) {
+_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 & JSON_FORMAT_EMPTY_ARRAY)
+ if (flags & SD_JSON_FORMAT_EMPTY_ARRAY)
v = JSON_VARIANT_MAGIC_EMPTY_ARRAY;
else
return 0;
print_source(f, v, flags, false);
- if (((flags & (JSON_FORMAT_COLOR_AUTO|JSON_FORMAT_COLOR)) == JSON_FORMAT_COLOR_AUTO) && colors_enabled())
- flags |= JSON_FORMAT_COLOR;
+ 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 & (JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_PRETTY)) == JSON_FORMAT_PRETTY_AUTO))
- flags |= on_tty() ? JSON_FORMAT_PRETTY : JSON_FORMAT_NEWLINE;
+ 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 & JSON_FORMAT_SSE)
+ if (flags & SD_JSON_FORMAT_SSE)
fputs("data: ", f);
- if (flags & JSON_FORMAT_SEQ)
+ if (flags & SD_JSON_FORMAT_SEQ)
fputc('\x1e', f); /* ASCII Record Separator */
json_format(f, v, flags, prefix);
- if (flags & (JSON_FORMAT_PRETTY|JSON_FORMAT_SEQ|JSON_FORMAT_SSE|JSON_FORMAT_NEWLINE))
+ if (flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_SEQ|SD_JSON_FORMAT_SSE|SD_JSON_FORMAT_NEWLINE))
fputc('\n', f);
- if (flags & JSON_FORMAT_SSE)
+ if (flags & SD_JSON_FORMAT_SSE)
fputc('\n', f); /* In case of SSE add a second newline */
- if (flags & JSON_FORMAT_FLUSH)
+ if (flags & SD_JSON_FORMAT_FLUSH)
return fflush_and_check(f);
return 0;
}
-int json_variant_filter(JsonVariant **v, char **to_remove) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
- _cleanup_free_ JsonVariant **array = NULL;
+_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(v);
- if (json_variant_is_blank_object(*v))
+ if (sd_json_variant_is_blank_object(*v))
return 0;
- if (!json_variant_is_object(*v))
+ if (!sd_json_variant_is_object(*v))
return -EINVAL;
if (strv_isempty(to_remove))
return 0;
- for (size_t i = 0; i < json_variant_elements(*v); i += 2) {
- JsonVariant *p;
+ for (size_t i = 0; i < sd_json_variant_elements(*v); i += 2) {
+ sd_json_variant *p;
- p = json_variant_by_index(*v, i);
- if (!json_variant_has_type(p, JSON_VARIANT_STRING))
+ 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, json_variant_string(p))) {
+ if (strv_contains(to_remove, sd_json_variant_string(p))) {
if (!array) {
- array = new(JsonVariant*, json_variant_elements(*v) - 2);
+ array = new(sd_json_variant*, sd_json_variant_elements(*v) - 2);
if (!array)
return -ENOMEM;
for (k = 0; k < i; k++)
- array[k] = json_variant_by_index(*v, k);
+ array[k] = sd_json_variant_by_index(*v, k);
}
n++;
} else if (array) {
array[k++] = p;
- array[k++] = json_variant_by_index(*v, i + 1);
+ array[k++] = sd_json_variant_by_index(*v, i + 1);
}
}
if (n == 0)
return 0;
- r = json_variant_new_object(&w, array, k);
+ r = sd_json_variant_new_object(&w, array, k);
if (r < 0)
return r;
return (int) n;
}
-int json_variant_set_field(JsonVariant **v, const char *field, JsonVariant *value) {
- _cleanup_(json_variant_unrefp) JsonVariant *field_variant = NULL, *w = NULL;
- _cleanup_free_ JsonVariant **array = NULL;
+_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(v);
assert(field);
- if (json_variant_is_blank_object(*v)) {
- array = new(JsonVariant*, 2);
+ if (sd_json_variant_is_blank_object(*v)) {
+ array = new(sd_json_variant*, 2);
if (!array)
return -ENOMEM;
} else {
- if (!json_variant_is_object(*v))
+ if (!sd_json_variant_is_object(*v))
return -EINVAL;
- for (size_t i = 0; i < json_variant_elements(*v); i += 2) {
- JsonVariant *p;
+ for (size_t i = 0; i < sd_json_variant_elements(*v); i += 2) {
+ sd_json_variant *p;
- p = json_variant_by_index(*v, i);
- if (!json_variant_is_string(p))
+ p = sd_json_variant_by_index(*v, i);
+ if (!sd_json_variant_is_string(p))
return -EINVAL;
- if (streq(json_variant_string(p), field)) {
+ if (streq(sd_json_variant_string(p), field)) {
if (!array) {
- array = new(JsonVariant*, json_variant_elements(*v));
+ array = new(sd_json_variant*, sd_json_variant_elements(*v));
if (!array)
return -ENOMEM;
for (k = 0; k < i; k++)
- array[k] = json_variant_by_index(*v, k);
+ array[k] = sd_json_variant_by_index(*v, k);
}
} else if (array) {
array[k++] = p;
- array[k++] = json_variant_by_index(*v, i + 1);
+ array[k++] = sd_json_variant_by_index(*v, i + 1);
}
}
if (!array) {
- array = new(JsonVariant*, json_variant_elements(*v) + 2);
+ array = new(sd_json_variant*, sd_json_variant_elements(*v) + 2);
if (!array)
return -ENOMEM;
- for (k = 0; k < json_variant_elements(*v); k++)
- array[k] = json_variant_by_index(*v, k);
+ for (k = 0; k < sd_json_variant_elements(*v); k++)
+ array[k] = sd_json_variant_by_index(*v, k);
}
}
- r = json_variant_new_string(&field_variant, field);
+ r = sd_json_variant_new_string(&field_variant, field);
if (r < 0)
return r;
array[k++] = field_variant;
array[k++] = value;
- r = json_variant_new_object(&w, array, k);
+ r = sd_json_variant_new_object(&w, array, k);
if (r < 0)
return r;
return 1;
}
-int json_variant_set_fieldb(JsonVariant **v, const char *field, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+_public_ int sd_json_variant_set_fieldb(sd_json_variant **v, const char *field, ...) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
va_list ap;
int r;
va_start(ap, field);
- r = json_buildv(&w, ap);
+ r = sd_json_buildv(&w, ap);
va_end(ap);
if (r < 0)
return r;
- return json_variant_set_field(v, field, w);
+ return sd_json_variant_set_field(v, field, w);
}
-int json_variant_set_field_string(JsonVariant **v, const char *field, const char *value) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+_public_ int sd_json_variant_set_field_string(sd_json_variant **v, const char *field, const char *value) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
- r = json_variant_new_string(&m, value);
+ r = sd_json_variant_new_string(&m, value);
if (r < 0)
return r;
- return json_variant_set_field(v, field, m);
+ return sd_json_variant_set_field(v, field, m);
}
-int json_variant_set_field_integer(JsonVariant **v, const char *field, int64_t i) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+_public_ int sd_json_variant_set_field_integer(sd_json_variant **v, const char *field, int64_t i) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
- r = json_variant_new_integer(&m, i);
+ r = sd_json_variant_new_integer(&m, i);
if (r < 0)
return r;
- return json_variant_set_field(v, field, m);
+ return sd_json_variant_set_field(v, field, m);
}
-int json_variant_set_field_unsigned(JsonVariant **v, const char *field, uint64_t u) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+_public_ int sd_json_variant_set_field_unsigned(sd_json_variant **v, const char *field, uint64_t u) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
- r = json_variant_new_unsigned(&m, u);
+ r = sd_json_variant_new_unsigned(&m, u);
if (r < 0)
return r;
- return json_variant_set_field(v, field, m);
+ return sd_json_variant_set_field(v, field, m);
}
-int json_variant_set_field_boolean(JsonVariant **v, const char *field, bool b) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+_public_ int sd_json_variant_set_field_boolean(sd_json_variant **v, const char *field, int b) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
- r = json_variant_new_boolean(&m, b);
+ r = sd_json_variant_new_boolean(&m, b);
if (r < 0)
return r;
- return json_variant_set_field(v, field, m);
+ return sd_json_variant_set_field(v, field, m);
}
-int json_variant_set_field_strv(JsonVariant **v, const char *field, char **l) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+_public_ int sd_json_variant_set_field_strv(sd_json_variant **v, const char *field, char **l) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
- r = json_variant_new_array_strv(&m, l);
+ r = sd_json_variant_new_array_strv(&m, l);
if (r < 0)
return r;
- return json_variant_set_field(v, field, m);
+ return sd_json_variant_set_field(v, field, m);
}
-int json_variant_merge_object(JsonVariant **v, JsonVariant *m) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
- _cleanup_free_ JsonVariant **array = NULL;
+_public_ int sd_json_variant_merge_object(sd_json_variant **v, sd_json_variant *m) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
+ _cleanup_free_ sd_json_variant **array = NULL;
size_t v_elements, m_elements, k;
bool v_blank, m_blank;
int r;
m = json_variant_dereference(m);
- v_blank = json_variant_is_blank_object(*v);
- m_blank = json_variant_is_blank_object(m);
+ v_blank = sd_json_variant_is_blank_object(*v);
+ m_blank = sd_json_variant_is_blank_object(m);
- if (!v_blank && !json_variant_is_object(*v))
+ if (!v_blank && !sd_json_variant_is_object(*v))
return -EINVAL;
- if (!m_blank && !json_variant_is_object(m))
+ if (!m_blank && !sd_json_variant_is_object(m))
return -EINVAL;
if (m_blank)
return 0; /* nothing to do */
if (v_blank) {
- JSON_VARIANT_REPLACE(*v, json_variant_ref(m));
+ JSON_VARIANT_REPLACE(*v, sd_json_variant_ref(m));
return 1;
}
- v_elements = json_variant_elements(*v);
- m_elements = json_variant_elements(m);
+ v_elements = sd_json_variant_elements(*v);
+ m_elements = sd_json_variant_elements(m);
if (v_elements > SIZE_MAX - m_elements) /* overflow check */
return -ENOMEM;
- array = new(JsonVariant*, v_elements + m_elements);
+ array = new(sd_json_variant*, v_elements + m_elements);
if (!array)
return -ENOMEM;
k = 0;
for (size_t i = 0; i < v_elements; i += 2) {
- JsonVariant *u;
+ sd_json_variant *u;
- u = json_variant_by_index(*v, i);
- if (!json_variant_is_string(u))
+ u = sd_json_variant_by_index(*v, i);
+ if (!sd_json_variant_is_string(u))
return -EINVAL;
- if (json_variant_by_key(m, json_variant_string(u)))
+ if (sd_json_variant_by_key(m, sd_json_variant_string(u)))
continue; /* skip if exists in second variant */
array[k++] = u;
- array[k++] = json_variant_by_index(*v, i + 1);
+ array[k++] = sd_json_variant_by_index(*v, i + 1);
}
for (size_t i = 0; i < m_elements; i++)
- array[k++] = json_variant_by_index(m, i);
+ array[k++] = sd_json_variant_by_index(m, i);
- r = json_variant_new_object(&w, array, k);
+ r = sd_json_variant_new_object(&w, array, k);
if (r < 0)
return r;
return 1;
}
-int json_variant_merge_objectb(JsonVariant **v, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+_public_ int sd_json_variant_merge_objectb(sd_json_variant **v, ...) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
va_list ap;
int r;
va_start(ap, v);
- r = json_buildv(&w, ap);
+ r = sd_json_buildv(&w, ap);
va_end(ap);
if (r < 0)
return r;
- return json_variant_merge_object(v, w);
+ return sd_json_variant_merge_object(v, w);
}
-int json_variant_append_array(JsonVariant **v, JsonVariant *element) {
- _cleanup_(json_variant_unrefp) JsonVariant *nv = NULL;
+_public_ int sd_json_variant_append_array(sd_json_variant **v, sd_json_variant *element) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *nv = NULL;
bool blank;
int r;
assert(v);
assert(element);
- if (!*v || json_variant_is_null(*v))
+ if (!*v || sd_json_variant_is_null(*v))
blank = true;
- else if (json_variant_is_array(*v))
- blank = json_variant_elements(*v) == 0;
+ else if (sd_json_variant_is_array(*v))
+ blank = sd_json_variant_elements(*v) == 0;
else
return -EINVAL;
if (blank) {
- r = json_variant_new_array(&nv, (JsonVariant*[]) { element }, 1);
+ r = sd_json_variant_new_array(&nv, (sd_json_variant*[]) { element }, 1);
if (r < 0)
return r;
} else if (json_variant_n_ref(*v) == 1) {
* to itself, or one of the objects embedded in *v to *v. If the reference count grows, we
* need to fall back to the other method below. */
- _unused_ _cleanup_(json_variant_unrefp) JsonVariant *dummy = json_variant_ref(element);
+ _unused_ _cleanup_(sd_json_variant_unrefp) sd_json_variant *dummy = sd_json_variant_ref(element);
if (json_variant_n_ref(*v) == 1) {
/* We hold the only reference. Let's mutate the object. */
- size_t size = json_variant_elements(*v);
+ size_t size = sd_json_variant_elements(*v);
void *old = *v;
if (!GREEDY_REALLOC(*v, size + 1 + 1))
for (size_t i = 1; i < size; i++)
(*v)[1 + i].parent = *v;
- return _json_variant_array_put_element(*v, element);
+ return json_variant_array_put_element(*v, element);
}
}
if (!blank) {
- size_t size = json_variant_elements(*v);
+ size_t size = sd_json_variant_elements(*v);
- _cleanup_free_ JsonVariant **array = new(JsonVariant*, size + 1);
+ _cleanup_free_ sd_json_variant **array = new(sd_json_variant*, size + 1);
if (!array)
return -ENOMEM;
for (size_t i = 0; i < size; i++)
- array[i] = json_variant_by_index(*v, i);
+ array[i] = sd_json_variant_by_index(*v, i);
array[size] = element;
- r = json_variant_new_array(&nv, array, size + 1);
+ r = sd_json_variant_new_array(&nv, array, size + 1);
if (r < 0)
return r;
}
return 0;
}
-int json_variant_append_arrayb(JsonVariant **v, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+_public_ int sd_json_variant_append_arrayb(sd_json_variant **v, ...) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
va_list ap;
int r;
va_start(ap, v);
- r = json_buildv(&w, ap);
+ r = sd_json_buildv(&w, ap);
va_end(ap);
if (r < 0)
return r;
- return json_variant_append_array(v, w);
+ return sd_json_variant_append_array(v, w);
}
-JsonVariant *json_variant_find(JsonVariant *haystack, JsonVariant *needle) {
- JsonVariant *i;
+_public_ sd_json_variant *sd_json_variant_find(sd_json_variant *haystack, sd_json_variant *needle) {
+ sd_json_variant *i;
/* Find a json object in an array. Returns NULL if not found, or if the array is not actually an array. */
JSON_VARIANT_ARRAY_FOREACH(i, haystack)
- if (json_variant_equal(i, needle))
+ if (sd_json_variant_equal(i, needle))
return i;
return NULL;
}
-int json_variant_append_array_nodup(JsonVariant **v, JsonVariant *element) {
+_public_ int sd_json_variant_append_array_nodup(sd_json_variant **v, sd_json_variant *element) {
assert(v);
- if (json_variant_find(*v, element))
+ if (sd_json_variant_find(*v, element))
return 0;
- return json_variant_append_array(v, element);
+ return sd_json_variant_append_array(v, element);
}
-int json_variant_strv(JsonVariant *v, char ***ret) {
+_public_ int sd_json_variant_strv(sd_json_variant *v, char ***ret) {
char **l = NULL;
bool sensitive;
int r;
assert(ret);
- if (!v || json_variant_is_null(v)) {
+ if (!v || sd_json_variant_is_null(v)) {
l = new0(char*, 1);
if (!l)
return -ENOMEM;
return 0;
}
- if (!json_variant_is_array(v))
+ if (!sd_json_variant_is_array(v))
return -EINVAL;
- sensitive = json_variant_is_sensitive(v);
+ sensitive = sd_json_variant_is_sensitive(v);
- size_t n = json_variant_elements(v);
+ size_t n = sd_json_variant_elements(v);
l = new(char*, n+1);
if (!l)
return -ENOMEM;
for (size_t i = 0; i < n; i++) {
- JsonVariant *e;
+ sd_json_variant *e;
- assert_se(e = json_variant_by_index(v, i));
- sensitive = sensitive || json_variant_is_sensitive(e);
+ assert_se(e = sd_json_variant_by_index(v, i));
+ sensitive = sensitive || sd_json_variant_is_sensitive(e);
- if (!json_variant_is_string(e)) {
+ if (!sd_json_variant_is_string(e)) {
l[i] = NULL;
r = -EINVAL;
goto fail;
}
- l[i] = strdup(json_variant_string(e));
+ l[i] = strdup(sd_json_variant_string(e));
if (!l[i]) {
r = -ENOMEM;
goto fail;
return r;
}
-static int json_variant_copy(JsonVariant **nv, JsonVariant *v) {
- JsonVariantType t;
- JsonVariant *c;
+static int json_variant_copy(sd_json_variant **nv, sd_json_variant *v) {
+ sd_json_variant_type_t t;
+ sd_json_variant *c;
JsonValue value;
const void *source;
size_t k;
assert(v);
/* Let's copy the simple types literally, and the larger types by references */
- t = json_variant_type(v);
+ t = sd_json_variant_type(v);
switch (t) {
- case JSON_VARIANT_INTEGER:
+ case SD_JSON_VARIANT_INTEGER:
k = sizeof(int64_t);
- value.integer = json_variant_integer(v);
+ value.integer = sd_json_variant_integer(v);
source = &value;
break;
- case JSON_VARIANT_UNSIGNED:
+ case SD_JSON_VARIANT_UNSIGNED:
k = sizeof(uint64_t);
- value.unsig = json_variant_unsigned(v);
+ value.unsig = sd_json_variant_unsigned(v);
source = &value;
break;
- case JSON_VARIANT_REAL:
+ case SD_JSON_VARIANT_REAL:
k = sizeof(double);
- value.real = json_variant_real(v);
+ value.real = sd_json_variant_real(v);
source = &value;
break;
- case JSON_VARIANT_BOOLEAN:
+ case SD_JSON_VARIANT_BOOLEAN:
k = sizeof(bool);
- value.boolean = json_variant_boolean(v);
+ value.boolean = sd_json_variant_boolean(v);
source = &value;
break;
- case JSON_VARIANT_NULL:
+ case SD_JSON_VARIANT_NULL:
k = 0;
source = NULL;
break;
- case JSON_VARIANT_STRING:
- source = json_variant_string(v);
+ case SD_JSON_VARIANT_STRING:
+ source = sd_json_variant_string(v);
k = strnlen(source, INLINE_STRING_MAX + 1);
if (k <= INLINE_STRING_MAX) {
k++;
default:
/* Everything else copy by reference */
- c = malloc0(MAX(sizeof(JsonVariant),
- offsetof(JsonVariant, reference) + sizeof(JsonVariant*)));
+ c = malloc0(MAX(sizeof(sd_json_variant),
+ offsetof(sd_json_variant, reference) + sizeof(sd_json_variant*)));
if (!c)
return -ENOMEM;
c->n_ref = 1;
c->type = t;
c->is_reference = true;
- c->reference = json_variant_ref(json_variant_formalize(v));
+ c->reference = sd_json_variant_ref(json_variant_formalize(v));
*nv = c;
return 0;
}
- c = malloc0(MAX(sizeof(JsonVariant),
- offsetof(JsonVariant, value) + k));
+ c = malloc0(MAX(sizeof(sd_json_variant),
+ offsetof(sd_json_variant, value) + k));
if (!c)
return -ENOMEM;
return 0;
}
-static bool json_single_ref(JsonVariant *v) {
+static bool json_single_ref(sd_json_variant *v) {
/* Checks whether the caller is the single owner of the object, i.e. can get away with changing it */
return v->n_ref == 1;
}
-static int json_variant_set_source(JsonVariant **v, JsonSource *source, unsigned line, unsigned column) {
- JsonVariant *w;
+static int json_variant_set_source(sd_json_variant **v, JsonSource *source, unsigned line, unsigned column) {
+ sd_json_variant *w;
int r;
assert(v);
const char **p,
char **ret_string,
JsonValue *ret_value,
- unsigned *ret_line, /* 'ret_line' returns the line at the beginning of this token */
+ unsigned *ret_line, /* 'reterr_line' returns the line at the beginning of this token */
unsigned *ret_column,
void **state,
unsigned *line, /* 'line' is used as a line state, it always reflect the line we are at after the token was read */
}
typedef enum JsonExpect {
- /* The following values are used by json_parse() */
+ /* The following values are used by sd_json_parse() */
EXPECT_TOPLEVEL,
EXPECT_END,
EXPECT_OBJECT_FIRST_KEY,
EXPECT_ARRAY_NEXT_ELEMENT,
EXPECT_ARRAY_COMMA,
- /* And these are used by json_build() */
+ /* And these are used by sd_json_build() */
EXPECT_ARRAY_ELEMENT,
EXPECT_OBJECT_KEY,
} JsonExpect;
typedef struct JsonStack {
JsonExpect expect;
- JsonVariant **elements;
+ sd_json_variant **elements;
size_t n_elements;
unsigned line_before;
unsigned column_before;
static void json_stack_release(JsonStack *s) {
assert(s);
- CLEANUP_ARRAY(s->elements, s->n_elements, json_variant_unref_many);
+ CLEANUP_ARRAY(s->elements, s->n_elements, sd_json_variant_unref_many);
}
static int json_parse_internal(
const char **input,
JsonSource *source,
- JsonParseFlags flags,
- JsonVariant **ret,
+ sd_json_parse_flags_t flags,
+ sd_json_variant **ret,
unsigned *line,
unsigned *column,
bool continue_end) {
column = &column_buffer;
for (;;) {
- _cleanup_(json_variant_unrefp) JsonVariant *add = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *add = NULL;
_cleanup_free_ char *string = NULL;
unsigned line_token, column_token;
JsonStack *current;
assert(n_stack > 1);
- r = json_variant_new_object(&add, current->elements, current->n_elements);
+ r = sd_json_variant_new_object(&add, current->elements, current->n_elements);
if (r < 0)
goto finish;
assert(n_stack > 1);
- r = json_variant_new_array(&add, current->elements, current->n_elements);
+ r = sd_json_variant_new_array(&add, current->elements, current->n_elements);
if (r < 0)
goto finish;
goto finish;
}
- r = json_variant_new_string(&add, string);
+ r = sd_json_variant_new_string(&add, string);
if (r < 0)
goto finish;
goto finish;
}
- r = json_variant_new_real(&add, value.real);
+ r = sd_json_variant_new_real(&add, value.real);
if (r < 0)
goto finish;
goto finish;
}
- r = json_variant_new_integer(&add, value.integer);
+ r = sd_json_variant_new_integer(&add, value.integer);
if (r < 0)
goto finish;
goto finish;
}
- r = json_variant_new_unsigned(&add, value.unsig);
+ r = sd_json_variant_new_unsigned(&add, value.unsig);
if (r < 0)
goto finish;
goto finish;
}
- r = json_variant_new_boolean(&add, value.boolean);
+ r = sd_json_variant_new_boolean(&add, value.boolean);
if (r < 0)
goto finish;
goto finish;
}
- r = json_variant_new_null(&add);
+ r = sd_json_variant_new_null(&add);
if (r < 0)
goto finish;
/* If we are asked to make this parsed object sensitive, then let's apply this
* immediately after allocating each variant, so that when we abort half-way
* everything we already allocated that is then freed is correctly marked. */
- if (FLAGS_SET(flags, JSON_PARSE_SENSITIVE))
- json_variant_sensitive(add);
+ if (FLAGS_SET(flags, SD_JSON_PARSE_SENSITIVE))
+ sd_json_variant_sensitive(add);
(void) json_variant_set_source(&add, source, line_token, column_token);
assert(n_stack == 1);
assert(stack[0].n_elements == 1);
- *ret = json_variant_ref(stack[0].elements[0]);
+ *ret = sd_json_variant_ref(stack[0].elements[0]);
*input = p;
r = 0;
return r;
}
-int json_parse_with_source(
+_public_ int sd_json_parse_with_source(
const char *input,
const char *source,
- JsonParseFlags flags,
- JsonVariant **ret,
- unsigned *ret_line,
- unsigned *ret_column) {
+ sd_json_parse_flags_t flags,
+ sd_json_variant **ret,
+ unsigned *reterr_line,
+ unsigned *reterr_column) {
_cleanup_(json_source_unrefp) JsonSource *s = NULL;
return -ENOMEM;
}
- return json_parse_internal(&input, s, flags, ret, ret_line, ret_column, false);
+ return json_parse_internal(&input, s, flags, ret, reterr_line, reterr_column, false);
}
-int json_parse_with_source_continue(
+_public_ int sd_json_parse_with_source_continue(
const char **p,
const char *source,
- JsonParseFlags flags,
- JsonVariant **ret,
- unsigned *ret_line,
- unsigned *ret_column) {
+ sd_json_parse_flags_t flags,
+ sd_json_variant **ret,
+ unsigned *reterr_line,
+ unsigned *reterr_column) {
_cleanup_(json_source_unrefp) JsonSource *s = NULL;
return -ENOMEM;
}
- return json_parse_internal(p, s, flags, ret, ret_line, ret_column, true);
+ return json_parse_internal(p, s, flags, ret, reterr_line, reterr_column, true);
+}
+
+_public_ int sd_json_parse(
+ const char *string,
+ sd_json_parse_flags_t flags,
+ sd_json_variant **ret,
+ unsigned *reterr_line,
+ unsigned *reterr_column) {
+
+ return sd_json_parse_with_source(string, NULL, flags, ret, reterr_line, reterr_column);
+}
+
+_public_ int sd_json_parse_continue(
+ const char **p,
+ sd_json_parse_flags_t flags,
+ sd_json_variant **ret,
+ unsigned *reterr_line,
+ unsigned *reterr_column) {
+
+ return sd_json_parse_with_source_continue(p, NULL, flags, ret, reterr_line, reterr_column);
}
-int json_parse_file_at(
+_public_ int sd_json_parse_file_at(
FILE *f,
int dir_fd,
const char *path,
- JsonParseFlags flags,
- JsonVariant **ret,
- unsigned *ret_line,
- unsigned *ret_column) {
+ sd_json_parse_flags_t flags,
+ sd_json_variant **ret,
+ unsigned *reterr_line,
+ unsigned *reterr_column) {
_cleanup_free_ char *text = NULL;
int r;
if (isempty(text))
return -ENODATA;
- return json_parse_with_source(text, path, flags, ret, ret_line, ret_column);
+ return sd_json_parse_with_source(text, path, flags, ret, reterr_line, reterr_column);
}
-int json_buildv(JsonVariant **ret, va_list ap) {
+_public_ int sd_json_parse_file(
+ FILE *f,
+ const char *path,
+ sd_json_parse_flags_t flags,
+ sd_json_variant **ret,
+ unsigned *reterr_line,
+ unsigned *reterr_column) {
+
+ return sd_json_parse_file_at(f, AT_FDCWD, path, flags, ret, reterr_line, reterr_column);
+}
+
+_public_ int sd_json_buildv(sd_json_variant **ret, va_list ap) {
JsonStack *stack = NULL;
size_t n_stack = 1;
const char *name = NULL;
};
for (;;) {
- _cleanup_(json_variant_unrefp) JsonVariant *add = NULL, *add_more = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *add = NULL, *add_more = NULL;
size_t n_subtract = 0; /* how much to subtract from current->n_suppress, i.e. how many elements would
* have been added to the current variant */
JsonStack *current;
switch (command) {
- case _JSON_BUILD_STRING: {
+ case _SD_JSON_BUILD_STRING: {
const char *p;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
p = va_arg(ap, const char *);
if (current->n_suppress == 0) {
- r = json_variant_new_string(&add, p);
+ r = sd_json_variant_new_string(&add, p);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_INTEGER: {
+ case _SD_JSON_BUILD_INTEGER: {
int64_t j;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
j = va_arg(ap, int64_t);
if (current->n_suppress == 0) {
- r = json_variant_new_integer(&add, j);
+ r = sd_json_variant_new_integer(&add, j);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_UNSIGNED: {
+ case _SD_JSON_BUILD_UNSIGNED: {
uint64_t j;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
j = va_arg(ap, uint64_t);
if (current->n_suppress == 0) {
- r = json_variant_new_unsigned(&add, j);
+ r = sd_json_variant_new_unsigned(&add, j);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_REAL: {
+ case _SD_JSON_BUILD_REAL: {
double d;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
d = va_arg(ap, double);
if (current->n_suppress == 0) {
- r = json_variant_new_real(&add, d);
+ r = sd_json_variant_new_real(&add, d);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_BOOLEAN: {
+ case _SD_JSON_BUILD_BOOLEAN: {
bool b;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
b = va_arg(ap, int);
if (current->n_suppress == 0) {
- r = json_variant_new_boolean(&add, b);
+ r = sd_json_variant_new_boolean(&add, b);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_NULL:
+ case _SD_JSON_BUILD_NULL:
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
r = -EINVAL;
}
if (current->n_suppress == 0) {
- r = json_variant_new_null(&add);
+ r = sd_json_variant_new_null(&add);
if (r < 0)
goto finish;
}
break;
- case _JSON_BUILD_VARIANT:
+ case _SD_JSON_BUILD_VARIANT:
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
r = -EINVAL;
/* Note that we don't care for current->n_suppress here, after all the variant is already
* allocated anyway... */
- add = va_arg(ap, JsonVariant*);
+ add = va_arg(ap, sd_json_variant*);
if (!add)
add = JSON_VARIANT_MAGIC_NULL;
else
- json_variant_ref(add);
+ sd_json_variant_ref(add);
n_subtract = 1;
break;
- case _JSON_BUILD_VARIANT_ARRAY: {
- JsonVariant **array;
+ case _SD_JSON_BUILD_VARIANT_ARRAY: {
+ sd_json_variant **array;
size_t n;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
goto finish;
}
- array = va_arg(ap, JsonVariant**);
+ array = va_arg(ap, sd_json_variant**);
n = va_arg(ap, size_t);
if (current->n_suppress == 0) {
- r = json_variant_new_array(&add, array, n);
+ r = sd_json_variant_new_array(&add, array, n);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_LITERAL: {
+ case _SD_JSON_BUILD_LITERAL: {
const char *l;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
/* Note that we don't care for current->n_suppress here, we should generate parsing
* errors even in suppressed object properties */
- r = json_parse(l, 0, &add, NULL, NULL);
+ r = sd_json_parse(l, 0, &add, NULL, NULL);
if (r < 0)
goto finish;
} else
break;
}
- case _JSON_BUILD_ARRAY_BEGIN:
+ case _SD_JSON_BUILD_ARRAY_BEGIN:
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
r = -EINVAL;
break;
- case _JSON_BUILD_ARRAY_END:
+ case _SD_JSON_BUILD_ARRAY_END:
if (current->expect != EXPECT_ARRAY_ELEMENT) {
r = -EINVAL;
goto finish;
assert(n_stack > 1);
if (current->n_suppress == 0) {
- r = json_variant_new_array(&add, current->elements, current->n_elements);
+ r = sd_json_variant_new_array(&add, current->elements, current->n_elements);
if (r < 0)
goto finish;
}
break;
- case _JSON_BUILD_STRV: {
+ case _SD_JSON_BUILD_STRV: {
char **l;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
l = va_arg(ap, char **);
if (current->n_suppress == 0) {
- r = json_variant_new_array_strv(&add, l);
+ r = sd_json_variant_new_array_strv(&add, l);
if (r < 0)
goto finish;
}
}
if (current->n_suppress == 0) {
- r = json_variant_new_array_strv(&add, el);
+ r = sd_json_variant_new_array_strv(&add, el);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_BASE64:
- case _JSON_BUILD_BASE32HEX:
- case _JSON_BUILD_HEX:
- case _JSON_BUILD_OCTESCAPE: {
+ case _SD_JSON_BUILD_BASE64:
+ case _SD_JSON_BUILD_BASE32HEX:
+ case _SD_JSON_BUILD_HEX:
+ case _SD_JSON_BUILD_OCTESCAPE: {
const void *p;
size_t n;
n = va_arg(ap, size_t);
if (current->n_suppress == 0) {
- r = command == _JSON_BUILD_BASE64 ? json_variant_new_base64(&add, p, n) :
- command == _JSON_BUILD_BASE32HEX ? json_variant_new_base32hex(&add, p, n) :
- command == _JSON_BUILD_HEX ? json_variant_new_hex(&add, p, n) :
- json_variant_new_octescape(&add, p, n);
+ r = command == _SD_JSON_BUILD_BASE64 ? sd_json_variant_new_base64(&add, p, n) :
+ command == _SD_JSON_BUILD_BASE32HEX ? sd_json_variant_new_base32hex(&add, p, n) :
+ command == _SD_JSON_BUILD_HEX ? sd_json_variant_new_hex(&add, p, n) :
+ sd_json_variant_new_octescape(&add, p, n);
if (r < 0)
goto finish;
}
if (current->n_suppress == 0) {
if (iov)
- r = command == _JSON_BUILD_IOVEC_BASE64 ? json_variant_new_base64(&add, iov->iov_base, iov->iov_len) :
- json_variant_new_hex(&add, iov->iov_base, iov->iov_len);
+ r = command == _JSON_BUILD_IOVEC_BASE64 ? sd_json_variant_new_base64(&add, iov->iov_base, iov->iov_len) :
+ sd_json_variant_new_hex(&add, iov->iov_base, iov->iov_len);
else
- r = json_variant_new_string(&add, "");
+ r = sd_json_variant_new_string(&add, "");
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_ID128:
- case _JSON_BUILD_UUID: {
+ case _SD_JSON_BUILD_ID128:
+ case _SD_JSON_BUILD_UUID: {
const sd_id128_t *id;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
assert_se(id = va_arg(ap, sd_id128_t*));
if (current->n_suppress == 0) {
- r = command == _JSON_BUILD_ID128 ?
- json_variant_new_id128(&add, *id) :
- json_variant_new_uuid(&add, *id);
+ r = command == _SD_JSON_BUILD_ID128 ?
+ sd_json_variant_new_id128(&add, *id) :
+ sd_json_variant_new_uuid(&add, *id);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_BYTE_ARRAY: {
+ case _SD_JSON_BUILD_BYTE_ARRAY: {
const void *array;
size_t n;
n = va_arg(ap, size_t);
if (current->n_suppress == 0) {
- r = json_variant_new_array_bytes(&add, array, n);
+ r = sd_json_variant_new_array_bytes(&add, array, n);
if (r < 0)
goto finish;
}
assert_se(hw_addr = va_arg(ap, struct hw_addr_data*));
if (current->n_suppress == 0) {
- r = json_variant_new_array_bytes(&add, hw_addr->bytes, hw_addr->length);
+ r = sd_json_variant_new_array_bytes(&add, hw_addr->bytes, hw_addr->length);
if (r < 0)
goto finish;
}
if (r < 0)
goto finish;
- r = json_variant_new_array_strv(&add, sorted);
+ r = sd_json_variant_new_array_strv(&add, sorted);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_CALLBACK: {
- JsonBuildCallback cb;
+ case _SD_JSON_BUILD_CALLBACK: {
+ sd_json_build_callback_t cb;
void *userdata;
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
goto finish;
}
- cb = va_arg(ap, JsonBuildCallback);
+ cb = va_arg(ap, sd_json_build_callback_t);
userdata = va_arg(ap, void *);
if (current->n_suppress == 0) {
break;
}
- case _JSON_BUILD_OBJECT_BEGIN:
+ case _SD_JSON_BUILD_OBJECT_BEGIN:
if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
r = -EINVAL;
break;
- case _JSON_BUILD_OBJECT_END:
+ case _SD_JSON_BUILD_OBJECT_END:
if (current->expect != EXPECT_OBJECT_KEY) {
r = -EINVAL;
assert(n_stack > 1);
if (current->n_suppress == 0) {
- r = json_variant_new_object(&add, current->elements, current->n_elements);
+ r = sd_json_variant_new_object(&add, current->elements, current->n_elements);
if (r < 0)
goto finish;
}
break;
- case _JSON_BUILD_PAIR: {
+ case _SD_JSON_BUILD_PAIR: {
if (current->expect != EXPECT_OBJECT_KEY) {
r = -EINVAL;
name = va_arg(ap, const char *);
if (current->n_suppress == 0) {
- r = json_variant_new_string(&add, name);
+ r = sd_json_variant_new_string(&add, name);
if (r < 0)
goto finish;
}
break;
}
- case _JSON_BUILD_PAIR_CONDITION: {
+ case _SD_JSON_BUILD_PAIR_CONDITION: {
bool b;
if (current->expect != EXPECT_OBJECT_KEY) {
name = va_arg(ap, const char *);
if (b && current->n_suppress == 0) {
- r = json_variant_new_string(&add, name);
+ r = sd_json_variant_new_string(&add, name);
if (r < 0)
goto finish;
}
u = va_arg(ap, uint64_t);
if (u != 0 && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- r = json_variant_new_unsigned(&add_more, u);
+ r = sd_json_variant_new_unsigned(&add_more, u);
if (r < 0)
goto finish;
}
u = va_arg(ap, usec_t);
if (u != USEC_INFINITY && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- r = json_variant_new_unsigned(&add_more, u);
+ r = sd_json_variant_new_unsigned(&add_more, u);
if (r < 0)
goto finish;
}
s = va_arg(ap, const char *);
if (!isempty(s) && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- r = json_variant_new_string(&add_more, s);
+ r = sd_json_variant_new_string(&add_more, s);
if (r < 0)
goto finish;
}
l = va_arg(ap, char **);
if (!strv_isempty(l) && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- r = json_variant_new_array_strv(&add_more, l);
+ r = sd_json_variant_new_array_strv(&add_more, l);
if (r < 0)
goto finish;
}
}
case _JSON_BUILD_PAIR_VARIANT_NON_NULL: {
- JsonVariant *v;
+ sd_json_variant *v;
const char *n;
if (current->expect != EXPECT_OBJECT_KEY) {
}
n = va_arg(ap, const char *);
- v = va_arg(ap, JsonVariant *);
+ v = va_arg(ap, sd_json_variant *);
- if (v && !json_variant_is_null(v) && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ if (v && !sd_json_variant_is_null(v) && current->n_suppress == 0) {
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- add_more = json_variant_ref(v);
+ add_more = sd_json_variant_ref(v);
}
n_subtract = 2; /* we generated two item */
a = va_arg(ap, const struct in_addr *);
if (a && in4_addr_is_set(a) && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- r = json_variant_new_array_bytes(&add_more, a, sizeof(struct in_addr));
+ r = sd_json_variant_new_array_bytes(&add_more, a, sizeof(struct in_addr));
if (r < 0)
goto finish;
}
a = va_arg(ap, const struct in6_addr *);
if (a && in6_addr_is_set(a) && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- r = json_variant_new_array_bytes(&add_more, a, sizeof(struct in6_addr));
+ r = sd_json_variant_new_array_bytes(&add_more, a, sizeof(struct in6_addr));
if (r < 0)
goto finish;
}
f = va_arg(ap, int);
if (a && in_addr_is_set(f, a) && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- r = json_variant_new_array_bytes(&add_more, a->bytes, FAMILY_ADDRESS_SIZE(f));
+ r = sd_json_variant_new_array_bytes(&add_more, a->bytes, FAMILY_ADDRESS_SIZE(f));
if (r < 0)
goto finish;
}
a = va_arg(ap, const struct ether_addr *);
if (a && !ether_addr_is_null(a) && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- r = json_variant_new_array_bytes(&add_more, a->ether_addr_octet, sizeof(struct ether_addr));
+ r = sd_json_variant_new_array_bytes(&add_more, a->ether_addr_octet, sizeof(struct ether_addr));
if (r < 0)
goto finish;
}
a = va_arg(ap, const struct hw_addr_data *);
if (a && !hw_addr_is_null(a) && current->n_suppress == 0) {
- r = json_variant_new_string(&add, n);
+ r = sd_json_variant_new_string(&add, n);
if (r < 0)
goto finish;
- r = json_variant_new_array_bytes(&add_more, a->bytes, a->length);
+ r = sd_json_variant_new_array_bytes(&add_more, a->bytes, a->length);
if (r < 0)
goto finish;
}
assert(n_stack == 1);
assert(stack[0].n_elements == 1);
- *ret = json_variant_ref(stack[0].elements[0]);
+ *ret = sd_json_variant_ref(stack[0].elements[0]);
r = 0;
finish:
return r;
}
-int json_build(JsonVariant **ret, ...) {
+_public_ int sd_json_build(sd_json_variant **ret, ...) {
va_list ap;
int r;
va_start(ap, ret);
- r = json_buildv(ret, ap);
+ r = sd_json_buildv(ret, ap);
va_end(ap);
return r;
}
int json_log_internal(
- JsonVariant *variant,
+ sd_json_variant *variant,
int level,
int error,
const char *file,
va_end(ap);
if (variant) {
- r = json_variant_get_source(variant, &source, &source_line, &source_column);
+ r = sd_json_variant_get_source(variant, &source, &source_line, &source_column);
if (r < 0)
return r;
} else {
NULL);
}
-static void *dispatch_userdata(const JsonDispatch *p, void *userdata) {
+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
return SIZE_TO_PTR(p->offset);
}
-int json_dispatch_full(
- JsonVariant *v,
- const JsonDispatch table[],
- JsonDispatchCallback bad,
- JsonDispatchFlags flags,
+_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;
- if (!json_variant_is_object(v)) {
+ if (!sd_json_variant_is_object(v)) {
json_log(v, flags, 0, "JSON variant is not an object.");
- if (flags & JSON_PERMISSIVE)
+ if (flags & SD_JSON_PERMISSIVE)
return 0;
if (reterr_bad_field)
}
m = 0;
- for (const JsonDispatch *p = table; p->name; p++)
+ for (const sd_json_dispatch_field *p = table; p->name; p++)
m++;
found = newa0(bool, m);
- size_t n = json_variant_elements(v);
+ size_t n = sd_json_variant_elements(v);
for (size_t i = 0; i < n; i += 2) {
- JsonVariant *key, *value;
- const JsonDispatch *p;
+ sd_json_variant *key, *value;
+ const sd_json_dispatch_field *p;
- assert_se(key = json_variant_by_index(v, i));
- assert_se(value = json_variant_by_index(v, i+1));
+ 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->name; p++)
if (p->name == POINTER_MAX ||
- streq_ptr(json_variant_string(key), p->name))
+ streq_ptr(sd_json_variant_string(key), p->name))
break;
if (p->name) { /* Found a matching entry! 🙂 */
- JsonDispatchFlags merged_flags;
+ sd_json_dispatch_flags_t merged_flags;
merged_flags = flags | p->flags;
- if (p->type != _JSON_VARIANT_TYPE_INVALID &&
- !json_variant_has_type(value, p->type)) {
+ if (p->type != _SD_JSON_VARIANT_TYPE_INVALID &&
+ !sd_json_variant_has_type(value, p->type)) {
json_log(value, merged_flags, 0,
- "Object field '%s' has wrong type %s, expected %s.", json_variant_string(key),
- json_variant_type_to_string(json_variant_type(value)), json_variant_type_to_string(p->type));
+ "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 & JSON_PERMISSIVE)
+ if (merged_flags & SD_JSON_PERMISSIVE)
continue;
if (reterr_bad_field)
}
if (found[p-table]) {
- json_log(value, merged_flags, 0, "Duplicate object field '%s'.", json_variant_string(key));
+ json_log(value, merged_flags, 0, "Duplicate object field '%s'.", sd_json_variant_string(key));
- if (merged_flags & JSON_PERMISSIVE)
+ if (merged_flags & SD_JSON_PERMISSIVE)
continue;
if (reterr_bad_field)
found[p-table] = true;
if (p->callback) {
- r = p->callback(json_variant_string(key), value, merged_flags, dispatch_userdata(p, userdata));
+ r = p->callback(sd_json_variant_string(key), value, merged_flags, dispatch_userdata(p, userdata));
if (r < 0) {
- if (merged_flags & JSON_PERMISSIVE)
+ if (merged_flags & SD_JSON_PERMISSIVE)
continue;
if (reterr_bad_field)
- *reterr_bad_field = json_variant_string(key);
+ *reterr_bad_field = sd_json_variant_string(key);
return r;
}
} else { /* Didn't find a matching entry! ☹️ */
if (bad) {
- r = bad(json_variant_string(key), value, flags, userdata);
+ r = bad(sd_json_variant_string(key), value, flags, userdata);
if (r < 0) {
- if (flags & JSON_PERMISSIVE)
+ if (flags & SD_JSON_PERMISSIVE)
continue;
if (reterr_bad_field)
- *reterr_bad_field = json_variant_string(key);
+ *reterr_bad_field = sd_json_variant_string(key);
return r;
} else
done++;
} else {
- if (flags & JSON_ALLOW_EXTENSIONS) {
- json_log(value, flags|JSON_DEBUG, 0, "Unrecognized object field '%s', assuming extension.", json_variant_string(key));
+ if (flags & SD_JSON_ALLOW_EXTENSIONS) {
+ json_log(value, flags|SD_JSON_DEBUG, 0, "Unrecognized object field '%s', assuming extension.", sd_json_variant_string(key));
continue;
}
- json_log(value, flags, 0, "Unexpected object field '%s'.", json_variant_string(key));
- if (flags & JSON_PERMISSIVE)
+ 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 = json_variant_string(key);
+ *reterr_bad_field = sd_json_variant_string(key);
return -EADDRNOTAVAIL;
}
}
}
- for (const JsonDispatch *p = table; p->name; p++) {
- JsonDispatchFlags merged_flags = p->flags | flags;
+ for (const sd_json_dispatch_field *p = table; p->name; p++) {
+ sd_json_dispatch_flags_t merged_flags = p->flags | flags;
- if ((merged_flags & JSON_MANDATORY) && !found[p-table]) {
+ if ((merged_flags & SD_JSON_MANDATORY) && !found[p-table]) {
json_log(v, merged_flags, 0, "Missing object field '%s'.", p->name);
- if ((merged_flags & JSON_PERMISSIVE))
+ if ((merged_flags & SD_JSON_PERMISSIVE))
continue;
if (reterr_bad_field)
return done;
}
-int json_dispatch_boolean(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_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 = ASSERT_PTR(userdata);
assert(variant);
- if (!json_variant_is_boolean(variant))
+ 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 = json_variant_boolean(variant);
+ *b = sd_json_variant_boolean(variant);
return 0;
}
-int json_dispatch_tristate(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_public_ int sd_json_dispatch_intbool(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
int *b = ASSERT_PTR(userdata);
assert(variant);
- if (json_variant_is_null(variant)) {
+ 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 = ASSERT_PTR(userdata);
+
+ assert(variant);
+
+ if (sd_json_variant_is_null(variant)) {
*b = -1;
return 0;
}
- if (!json_variant_is_boolean(variant))
+ 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 = json_variant_boolean(variant);
+ *b = sd_json_variant_boolean(variant);
return 0;
}
-int json_dispatch_int64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_public_ int sd_json_dispatch_int64(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
int64_t *i = ASSERT_PTR(userdata);
assert(variant);
/* Also accept numbers formatted as string, to increase compatibility with less capable JSON
* implementations that cannot do 64bit integers. */
- if (json_variant_is_string(variant) && safe_atoi64(json_variant_string(variant), i) >= 0)
+ if (sd_json_variant_is_string(variant) && safe_atoi64(sd_json_variant_string(variant), i) >= 0)
return 0;
- if (!json_variant_is_integer(variant))
+ 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 = json_variant_integer(variant);
+ *i = sd_json_variant_integer(variant);
return 0;
}
-int json_dispatch_uint64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_public_ int sd_json_dispatch_uint64(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
uint64_t *u = ASSERT_PTR(userdata);
assert(variant);
/* 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 JsonDispatch to
- * JSON_UNSIGNED rather than _JSON_VARIANT_TYPE_INVALID, so that json_dispatch() already filters out
- * the non-matching type. */
+ * 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 (json_variant_is_string(variant) && safe_atou64(json_variant_string(variant), u) >= 0)
+ if (sd_json_variant_is_string(variant) && safe_atou64(sd_json_variant_string(variant), u) >= 0)
return 0;
- if (!json_variant_is_unsigned(variant))
+ 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 = json_variant_unsigned(variant);
+ *u = sd_json_variant_unsigned(variant);
return 0;
}
-int json_dispatch_uint32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_public_ int sd_json_dispatch_uint32(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
uint32_t *u = ASSERT_PTR(userdata);
uint64_t u64;
int r;
assert(variant);
- r = json_dispatch_uint64(name, variant, flags, &u64);
+ r = sd_json_dispatch_uint64(name, variant, flags, &u64);
if (r < 0)
return r;
return 0;
}
-int json_dispatch_int32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+/* 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 = ASSERT_PTR(userdata);
int64_t i64;
int r;
assert(variant);
- r = json_dispatch_int64(name, variant, flags, &i64);
+ r = sd_json_dispatch_int64(name, variant, flags, &i64);
if (r < 0)
return r;
return 0;
}
-int json_dispatch_int16(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+/* 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 = ASSERT_PTR(userdata);
int64_t i64;
int r;
assert(variant);
- r = json_dispatch_int64(name, variant, flags, &i64);
+ r = sd_json_dispatch_int64(name, variant, flags, &i64);
if (r < 0)
return r;
return 0;
}
-int json_dispatch_uint16(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_public_ int sd_json_dispatch_uint16(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
uint16_t *u = ASSERT_PTR(userdata);
uint64_t u64;
int r;
assert(variant);
- r = json_dispatch_uint64(name, variant, flags, &u64);
+ r = sd_json_dispatch_uint64(name, variant, flags, &u64);
if (r < 0)
return r;
return 0;
}
-int json_dispatch_int8(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_public_ int sd_json_dispatch_int8(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
int8_t *i = ASSERT_PTR(userdata);
int64_t i64;
int r;
assert(variant);
- r = json_dispatch_int64(name, variant, flags, &i64);
+ r = sd_json_dispatch_int64(name, variant, flags, &i64);
if (r < 0)
return r;
return 0;
}
-int json_dispatch_uint8(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_public_ int sd_json_dispatch_uint8(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
uint8_t *u = ASSERT_PTR(userdata);
uint64_t u64;
int r;
assert(variant);
- r = json_dispatch_uint64(name, variant, flags, &u64);
+ r = sd_json_dispatch_uint64(name, variant, flags, &u64);
if (r < 0)
return r;
return 0;
}
-int json_dispatch_string(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_public_ int sd_json_dispatch_string(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
char **s = ASSERT_PTR(userdata);
int r;
assert(variant);
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*s = mfree(*s);
return 0;
}
- if (!json_variant_is_string(variant))
+ 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 & JSON_SAFE) && !string_is_safe(json_variant_string(variant)))
+ if ((flags & SD_JSON_SAFE) && !string_is_safe(sd_json_variant_string(variant)))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' contains unsafe characters, refusing.", strna(name));
- r = free_and_strdup(s, json_variant_string(variant));
+ r = free_and_strdup(s, sd_json_variant_string(variant));
if (r < 0)
return json_log(variant, flags, r, "Failed to allocate string: %m");
return 0;
}
-int json_dispatch_const_string(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_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 = ASSERT_PTR(userdata);
assert(variant);
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*s = NULL;
return 0;
}
- if (!json_variant_is_string(variant))
+ 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 & JSON_SAFE) && !string_is_safe(json_variant_string(variant)))
+ if ((flags & SD_JSON_SAFE) && !string_is_safe(sd_json_variant_string(variant)))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' contains unsafe characters, refusing.", strna(name));
- *s = json_variant_string(variant);
+ *s = sd_json_variant_string(variant);
return 0;
}
-int json_dispatch_strv(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_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 = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
assert(variant);
- if (json_variant_is_null(variant)) {
+ 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 (json_variant_is_string(variant)) {
- if ((flags & JSON_SAFE) && !string_is_safe(json_variant_string(variant)))
+ if (sd_json_variant_is_string(variant)) {
+ if ((flags & SD_JSON_SAFE) && !string_is_safe(sd_json_variant_string(variant)))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' contains unsafe characters, refusing.", strna(name));
- l = strv_new(json_variant_string(variant));
+ l = strv_new(sd_json_variant_string(variant));
if (!l)
return log_oom();
return 0;
}
- if (!json_variant_is_array(variant))
+ 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 (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not a string.");
- if ((flags & JSON_SAFE) && !string_is_safe(json_variant_string(e)))
+ if ((flags & SD_JSON_SAFE) && !string_is_safe(sd_json_variant_string(e)))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' contains unsafe characters, refusing.", strna(name));
- r = strv_extend(&l, json_variant_string(e));
+ r = strv_extend(&l, sd_json_variant_string(e));
if (r < 0)
return json_log(e, flags, r, "Failed to append array element: %m");
}
return 0;
}
-int json_dispatch_variant(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- JsonVariant **p = ASSERT_PTR(userdata);
+_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 = ASSERT_PTR(userdata);
assert(variant);
/* Takes a reference */
- JSON_VARIANT_REPLACE(*p, json_variant_ref(variant));
+ JSON_VARIANT_REPLACE(*p, sd_json_variant_ref(variant));
return 0;
}
-int json_dispatch_variant_noref(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- JsonVariant **p = ASSERT_PTR(userdata);
+_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 = ASSERT_PTR(userdata);
assert(variant);
/* Doesn't take a reference */
return 0;
}
-int json_dispatch_uid_gid(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_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;
uint64_t k;
assert_cc((UID_INVALID < (uid_t) 0) == (GID_INVALID < (gid_t) 0));
REENABLE_WARNING;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*uid = UID_INVALID;
return 0;
}
- if (!json_variant_is_unsigned(variant))
+ if (!sd_json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
- k = json_variant_unsigned(variant);
+ k = sd_json_variant_unsigned(variant);
if (k > UINT32_MAX || !uid_is_valid(k))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid UID/GID.", strna(name));
return 0;
}
-int json_dispatch_user_group_name(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- char **s = userdata;
- const char *n;
- int r;
-
- if (json_variant_is_null(variant)) {
- *s = mfree(*s);
- return 0;
- }
-
- if (!json_variant_is_string(variant))
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
-
- n = json_variant_string(variant);
- if (!valid_user_group_name(n, FLAGS_SET(flags, JSON_RELAX) ? VALID_USER_RELAX : 0))
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid user/group name.", strna(name));
-
- r = free_and_strdup(s, n);
- if (r < 0)
- return json_log(variant, flags, r, "Failed to allocate string: %m");
-
- return 0;
-}
-
-int json_dispatch_path(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- const char *path;
- char **p = ASSERT_PTR(userdata);
-
- assert(variant);
-
- if (json_variant_is_null(variant)) {
- *p = mfree(*p);
- return 0;
- }
-
- if (!json_variant_is_string(variant))
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
-
- path = json_variant_string(variant);
- if (!(FLAGS_SET(flags, JSON_SAFE) ? path_is_normalized : path_is_valid)(path))
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid path.", strna(name));
- if (!path_is_absolute(path))
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' must be an absolute path.", strna(name));
-
- if (free_and_strdup(p, path) < 0)
- return json_log_oom(variant, flags);
-
- return 0;
-}
-
-int json_dispatch_id128(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_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;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*uuid = SD_ID128_NULL;
return 0;
}
- if (!json_variant_is_string(variant))
+ 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(json_variant_string(variant), uuid);
+ 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;
}
-int json_dispatch_unsupported(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+_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));
}
-int json_dispatch_unbase64_iovec(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- _cleanup_free_ void *buffer = NULL;
- struct iovec *iov = ASSERT_PTR(userdata);
- size_t sz;
- int r;
-
- if (!json_variant_is_string(variant))
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
-
- r = json_variant_unbase64(variant, &buffer, &sz);
- if (r < 0)
- return json_log(variant, flags, r, "JSON field '%s' is not valid Base64 data.", strna(name));
-
- free_and_replace(iov->iov_base, buffer);
- iov->iov_len = sz;
- return 0;
-}
-
-int json_dispatch_byte_array_iovec(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- _cleanup_free_ uint8_t *buffer = NULL;
- struct iovec *iov = ASSERT_PTR(userdata);
- size_t sz, k = 0;
-
- assert(variant);
-
- if (!json_variant_is_array(variant))
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
-
- sz = json_variant_elements(variant);
-
- buffer = new(uint8_t, sz + 1);
- if (!buffer)
- return json_log(variant, flags, SYNTHETIC_ERRNO(ENOMEM), "Out of memory.");
-
- JsonVariant *i;
- JSON_VARIANT_ARRAY_FOREACH(i, variant) {
- uint64_t b;
-
- if (!json_variant_is_unsigned(i))
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Element %zu of JSON field '%s' is not an unsigned integer.", k, strna(name));
-
- b = json_variant_unsigned(i);
- if (b > 0xff)
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL),
- "Element %zu of JSON field '%s' is out of range 0%s255.",
- k, strna(name), special_glyph(SPECIAL_GLYPH_ELLIPSIS));
-
- buffer[k++] = (uint8_t) b;
- }
- assert(k == sz);
-
- /* Append a NUL byte for safety, like we do in memdup_suffix0() and others. */
- buffer[sz] = 0;
-
- free_and_replace(iov->iov_base, buffer);
- iov->iov_len = sz;
- return 0;
-}
-
-int json_dispatch_in_addr(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- struct in_addr *address = ASSERT_PTR(userdata);
- _cleanup_(iovec_done) struct iovec iov = {};
- int r;
-
- r = json_dispatch_byte_array_iovec(name, variant, flags, &iov);
- if (r < 0)
- return r;
-
- if (iov.iov_len != sizeof(struct in_addr))
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is array of unexpected size.", strna(name));
-
- memcpy(address, iov.iov_base, iov.iov_len);
- return 0;
-}
-
static int json_cmp_strings(const void *x, const void *y) {
- JsonVariant *const *a = x, *const *b = y;
+ sd_json_variant *const *a = x, *const *b = y;
- if (!json_variant_is_string(*a) || !json_variant_is_string(*b))
+ if (!sd_json_variant_is_string(*a) || !sd_json_variant_is_string(*b))
return CMP(*a, *b);
- return strcmp(json_variant_string(*a), json_variant_string(*b));
+ return strcmp(sd_json_variant_string(*a), sd_json_variant_string(*b));
}
-int json_variant_sort(JsonVariant **v) {
- _cleanup_free_ JsonVariant **a = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *n = NULL;
+_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(v);
- if (json_variant_is_sorted(*v))
+ if (sd_json_variant_is_sorted(*v))
return 0;
- if (!json_variant_is_object(*v))
+ if (!sd_json_variant_is_object(*v))
return -EMEDIUMTYPE;
/* Sorts they key/value pairs in an object variant */
- m = json_variant_elements(*v);
- a = new(JsonVariant*, m);
+ 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] = json_variant_by_index(*v, i);
+ a[i] = sd_json_variant_by_index(*v, i);
- qsort(a, m/2, sizeof(JsonVariant*)*2, json_cmp_strings);
+ qsort(a, m/2, sizeof(sd_json_variant*)*2, json_cmp_strings);
- r = json_variant_new_object(&n, a, m);
+ r = sd_json_variant_new_object(&n, a, m);
if (r < 0)
return r;
return 1;
}
-int json_variant_normalize(JsonVariant **v) {
- _cleanup_free_ JsonVariant **a = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *n = NULL;
+_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(v);
- if (json_variant_is_normalized(*v))
+ if (sd_json_variant_is_normalized(*v))
return 0;
- if (!json_variant_is_object(*v) && !json_variant_is_array(*v))
+ 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 = json_variant_elements(*v);
- a = new(JsonVariant*, m);
+ m = sd_json_variant_elements(*v);
+ a = new(sd_json_variant*, m);
if (!a)
return -ENOMEM;
for (i = 0; i < m; ) {
- a[i] = json_variant_ref(json_variant_by_index(*v, i));
+ a[i] = sd_json_variant_ref(sd_json_variant_by_index(*v, i));
i++;
- r = json_variant_normalize(&a[i-1]);
+ r = sd_json_variant_normalize(&a[i-1]);
if (r < 0)
goto finish;
}
- qsort(a, m/2, sizeof(JsonVariant*)*2, json_cmp_strings);
+ qsort(a, m/2, sizeof(sd_json_variant*)*2, json_cmp_strings);
- if (json_variant_is_object(*v))
- r = json_variant_new_object(&n, a, m);
+ if (sd_json_variant_is_object(*v))
+ r = sd_json_variant_new_object(&n, a, m);
else {
- assert(json_variant_is_array(*v));
- r = json_variant_new_array(&n, a, m);
+ assert(sd_json_variant_is_array(*v));
+ r = sd_json_variant_new_array(&n, a, m);
}
if (r < 0)
goto finish;
finish:
for (size_t j = 0; j < i; j++)
- json_variant_unref(a[j]);
+ sd_json_variant_unref(a[j]);
return r;
}
-bool json_variant_is_normalized(JsonVariant *v) {
+_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 (json_variant_is_real(v) && !json_variant_is_integer(v) && !json_variant_is_unsigned(v))
+ 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 (!json_variant_is_object(v) && !json_variant_is_array(v))
+ 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 (json_variant_elements(v) == 0)
+ if (sd_json_variant_elements(v) == 0)
return true;
return v->normalized; /* For everything else there's an explicit boolean we maintain */
}
-bool json_variant_is_sorted(JsonVariant *v) {
+_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 (!json_variant_is_object(v))
+ if (!sd_json_variant_is_object(v))
return true;
- if (json_variant_elements(v) <= 1)
+ if (sd_json_variant_elements(v) <= 1)
return true;
return v->sorted;
}
-int json_variant_unbase64(JsonVariant *v, void **ret, size_t *ret_size) {
- if (!json_variant_is_string(v))
+_public_ int sd_json_variant_unbase64(sd_json_variant *v, void **ret, size_t *ret_size) {
+ if (!sd_json_variant_is_string(v))
return -EINVAL;
- return unbase64mem_full(json_variant_string(v), SIZE_MAX, /* secure= */ json_variant_is_sensitive(v), ret, ret_size);
+ return unbase64mem_full(sd_json_variant_string(v), SIZE_MAX, /* secure= */ sd_json_variant_is_sensitive(v), ret, ret_size);
}
-int json_variant_unhex(JsonVariant *v, void **ret, size_t *ret_size) {
- if (!json_variant_is_string(v))
+_public_ int sd_json_variant_unhex(sd_json_variant *v, void **ret, size_t *ret_size) {
+ if (!sd_json_variant_is_string(v))
return -EINVAL;
- return unhexmem_full(json_variant_string(v), SIZE_MAX, /* secure= */ json_variant_is_sensitive(v), ret, ret_size);
+ return unhexmem_full(sd_json_variant_string(v), SIZE_MAX, /* secure= */ sd_json_variant_is_sensitive(v), ret, ret_size);
}
-static const char* const json_variant_type_table[_JSON_VARIANT_TYPE_MAX] = {
- [JSON_VARIANT_STRING] = "string",
- [JSON_VARIANT_INTEGER] = "integer",
- [JSON_VARIANT_UNSIGNED] = "unsigned",
- [JSON_VARIANT_REAL] = "real",
- [JSON_VARIANT_NUMBER] = "number",
- [JSON_VARIANT_BOOLEAN] = "boolean",
- [JSON_VARIANT_ARRAY] = "array",
- [JSON_VARIANT_OBJECT] = "object",
- [JSON_VARIANT_NULL] = "null",
+static const char* const sd_json_variant_type_table[_SD_JSON_VARIANT_TYPE_MAX] = {
+ [SD_JSON_VARIANT_STRING] = "string",
+ [SD_JSON_VARIANT_INTEGER] = "integer",
+ [SD_JSON_VARIANT_UNSIGNED] = "unsigned",
+ [SD_JSON_VARIANT_REAL] = "real",
+ [SD_JSON_VARIANT_NUMBER] = "number",
+ [SD_JSON_VARIANT_BOOLEAN] = "boolean",
+ [SD_JSON_VARIANT_ARRAY] = "array",
+ [SD_JSON_VARIANT_OBJECT] = "object",
+ [SD_JSON_VARIANT_NULL] = "null",
};
-DEFINE_STRING_TABLE_LOOKUP(json_variant_type, JsonVariantType);
+DEFINE_STRING_TABLE_LOOKUP(sd_json_variant_type, sd_json_variant_type_t);
static bool arg_full = false;
static PagerFlags arg_pager_flags = 0;
static bool arg_legend = true;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static const char *arg_kill_whom = NULL;
static int arg_signal = SIGTERM;
static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
break;
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
arg_legend = false;
break;
if (r <= 0)
return r;
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
arg_legend = false;
break;
if (!IN_SET(r, PAM_SUCCESS, PAM_NO_MODULE_DATA))
return pam_syslog_pam_error(handle, LOG_ERR, r, "Failed to get PAM user record data: @PAMERR@");
if (r == PAM_SUCCESS && json) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
/* Parse cached record */
- r = json_parse(json, JSON_PARSE_SENSITIVE, &v, NULL, NULL);
+ r = sd_json_parse(json, SD_JSON_PARSE_SENSITIVE, &v, NULL, NULL);
if (r < 0)
return pam_syslog_errno(handle, LOG_ERR, r, "Failed to parse JSON user record: %m");
return PAM_USER_UNKNOWN;
}
- r = json_variant_format(ur->json, 0, &formatted);
+ r = sd_json_variant_format(ur->json, 0, &formatted);
if (r < 0)
return pam_syslog_errno(handle, LOG_ERR, r, "Failed to format user JSON: %m");
#include <limits.h>
#include "sd-id128.h"
+#include "sd-json.h"
#include "hostname-util.h"
-#include "json.h"
+#include "json-util.h"
#include "machine-varlink.h"
#include "machine.h"
#include "path-util.h"
static JSON_DISPATCH_ENUM_DEFINE(dispatch_machine_class, MachineClass, machine_class_from_string);
-static int machine_name(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int machine_name(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
char **m = ASSERT_PTR(userdata);
const char *hostname;
int r;
assert(variant);
- if (!json_variant_is_string(variant))
+ if (!sd_json_variant_is_string(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- hostname = json_variant_string(variant);
+ hostname = sd_json_variant_string(variant);
if (!hostname_is_valid(hostname, /* flags= */ 0))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Invalid machine name");
return 0;
}
-static int machine_leader(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int machine_leader(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
PidRef *leader = ASSERT_PTR(userdata);
_cleanup_(pidref_done) PidRef temp = PIDREF_NULL;
uint64_t k;
int r;
- if (!json_variant_is_unsigned(variant))
+ if (!sd_json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
- k = json_variant_unsigned(variant);
+ k = sd_json_variant_unsigned(variant);
if (k > PID_T_MAX || !pid_is_valid(k))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid PID.", strna(name));
return 0;
}
-static int machine_ifindices(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int machine_ifindices(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
Machine *m = ASSERT_PTR(userdata);
_cleanup_free_ int *netif = NULL;
size_t n_netif, k = 0;
assert(variant);
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
- n_netif = json_variant_elements(variant);
+ n_netif = sd_json_variant_elements(variant);
netif = new(int, n_netif);
if (!netif)
return json_log_oom(variant, flags);
- JsonVariant *i;
+ sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, variant) {
uint64_t b;
- if (!json_variant_is_unsigned(i))
+ if (!sd_json_variant_is_unsigned(i))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Element %zu of JSON field '%s' is not an unsigned integer.", k, strna(name));
- b = json_variant_unsigned(i);
+ b = sd_json_variant_unsigned(i);
if (b > INT_MAX || b <= 0)
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Invalid network interface index %"PRIu64, b);
return 0;
}
-static int machine_cid(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int machine_cid(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
unsigned cid, *c = ASSERT_PTR(userdata);
assert(variant);
- if (!json_variant_is_unsigned(variant))
+ if (!sd_json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- cid = json_variant_unsigned(variant);
+ cid = sd_json_variant_unsigned(variant);
if (!VSOCK_CID_IS_REGULAR(cid))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a regular VSOCK CID.", strna(name));
return 0;
}
-int vl_method_register(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+int vl_method_register(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
Manager *manager = ASSERT_PTR(userdata);
_cleanup_(machine_freep) Machine *machine = NULL;
int r;
- static const JsonDispatch dispatch_table[] = {
- { "name", JSON_VARIANT_STRING, machine_name, offsetof(Machine, name), JSON_MANDATORY },
- { "id", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(Machine, id), 0 },
- { "service", JSON_VARIANT_STRING, json_dispatch_string, offsetof(Machine, service), 0 },
- { "class", JSON_VARIANT_STRING, dispatch_machine_class, offsetof(Machine, class), JSON_MANDATORY },
- { "leader", JSON_VARIANT_UNSIGNED, machine_leader, offsetof(Machine, leader), 0 },
- { "rootDirectory", JSON_VARIANT_STRING, json_dispatch_path, offsetof(Machine, root_directory), 0 },
- { "ifIndices", JSON_VARIANT_ARRAY, machine_ifindices, 0, 0 },
- { "vSockCid", JSON_VARIANT_UNSIGNED, machine_cid, offsetof(Machine, vsock_cid), 0 },
- { "sshAddress", JSON_VARIANT_STRING, json_dispatch_string, offsetof(Machine, ssh_address), JSON_SAFE },
- { "sshPrivateKeyPath", JSON_VARIANT_STRING, json_dispatch_path, offsetof(Machine, ssh_private_key_path), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "name", SD_JSON_VARIANT_STRING, machine_name, offsetof(Machine, name), SD_JSON_MANDATORY },
+ { "id", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(Machine, id), 0 },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(Machine, service), 0 },
+ { "class", SD_JSON_VARIANT_STRING, dispatch_machine_class, offsetof(Machine, class), SD_JSON_MANDATORY },
+ { "leader", SD_JSON_VARIANT_UNSIGNED, machine_leader, offsetof(Machine, leader), 0 },
+ { "rootDirectory", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(Machine, root_directory), 0 },
+ { "ifIndices", SD_JSON_VARIANT_ARRAY, machine_ifindices, 0, 0 },
+ { "vSockCid", SD_JSON_VARIANT_UNSIGNED, machine_cid, offsetof(Machine, vsock_cid), 0 },
+ { "sshAddress", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(Machine, ssh_address), SD_JSON_SAFE },
+ { "sshPrivateKeyPath", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(Machine, ssh_private_key_path), 0 },
{}
};
#include "varlink.h"
-int vl_method_register(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
+int vl_method_register(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
#include "format-table.h"
#include "hostname-util.h"
#include "import-util.h"
+#include "in-addr-util.h"
#include "locale-util.h"
#include "log.h"
#include "logs-show.h"
table_set_header(table, arg_legend);
if (OUTPUT_MODE_IS_JSON(arg_output))
- r = table_print_json(table, NULL, output_mode_to_json_format_flags(arg_output) | JSON_FORMAT_COLOR_AUTO);
+ r = table_print_json(table, NULL, output_mode_to_json_format_flags(arg_output) | SD_JSON_FORMAT_COLOR_AUTO);
else
r = table_print(table, NULL);
if (r < 0)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "format-util.h"
+#include "json-util.h"
#include "machine-varlink.h"
#include "machined-varlink.h"
#include "mkdir.h"
const char *service;
} LookupParameters;
-static int build_user_json(const char *user_name, uid_t uid, const char *real_name, JsonVariant **ret) {
+static int build_user_json(const char *user_name, uid_t uid, const char *real_name, sd_json_variant **ret) {
assert(user_name);
assert(uid_is_valid(uid));
assert(ret);
- return json_build(ret, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("record", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(user_name)),
- JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(uid)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(GID_NOBODY)),
- JSON_BUILD_PAIR_CONDITION(!isempty(real_name), "realName", JSON_BUILD_STRING(real_name)),
- JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_CONST_STRING("/")),
- JSON_BUILD_PAIR("shell", JSON_BUILD_STRING(NOLOGIN)),
- JSON_BUILD_PAIR("locked", JSON_BUILD_BOOLEAN(true)),
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Machine")),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("container"))))));
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(user_name)),
+ SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(uid)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(GID_NOBODY)),
+ SD_JSON_BUILD_PAIR_CONDITION(!isempty(real_name), "realName", SD_JSON_BUILD_STRING(real_name)),
+ SD_JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_CONST_STRING("/")),
+ SD_JSON_BUILD_PAIR("shell", JSON_BUILD_CONST_STRING(NOLOGIN)),
+ SD_JSON_BUILD_PAIR("locked", SD_JSON_BUILD_BOOLEAN(true)),
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Machine")),
+ SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("container"))))));
}
static bool user_match_lookup_parameters(LookupParameters *p, const char *name, uid_t uid) {
return 0;
}
-static int vl_method_get_user_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_user_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "uid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
LookupParameters p = {
.uid = UID_INVALID,
};
return varlink_reply(link, v);
}
-static int build_group_json(const char *group_name, gid_t gid, const char *description, JsonVariant **ret) {
+static int build_group_json(const char *group_name, gid_t gid, const char *description, sd_json_variant **ret) {
assert(group_name);
assert(gid_is_valid(gid));
assert(ret);
- return json_build(ret, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("record", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(group_name)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(gid)),
- JSON_BUILD_PAIR_CONDITION(!isempty(description), "description", JSON_BUILD_STRING(description)),
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Machine")),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("container"))))));
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(group_name)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(gid)),
+ SD_JSON_BUILD_PAIR_CONDITION(!isempty(description), "description", SD_JSON_BUILD_STRING(description)),
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Machine")),
+ SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("container"))))));
}
static bool group_match_lookup_parameters(LookupParameters *p, const char *name, gid_t gid) {
return 0;
}
-static int vl_method_get_group_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_group_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
LookupParameters p = {
.gid = GID_INVALID,
};
return varlink_reply(link, v);
}
-static int vl_method_get_memberships(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_memberships(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), JSON_SAFE },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), SD_JSON_SAFE },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
#include "errno-util.h"
#include "fd-util.h"
#include "io-util.h"
+#include "json-util.h"
#include "main-func.h"
#include "missing_loop.h"
#include "namespace-util.h"
.default_flags = PARTITION_POLICY_IGNORE,
};
-static int json_dispatch_image_policy(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_image_policy(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
_cleanup_(image_policy_freep) ImagePolicy *q = NULL;
ImagePolicy **p = ASSERT_PTR(userdata);
int r;
assert(p);
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*p = image_policy_free(*p);
return 0;
}
- if (!json_variant_is_string(variant))
+ 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 = image_policy_from_string(json_variant_string(variant), &q);
+ r = image_policy_from_string(sd_json_variant_string(variant), &q);
if (r < 0)
return json_log(variant, flags, r, "JSON field '%s' is not a valid image policy.", strna(name));
static int vl_method_mount_image(
Varlink *link,
- JsonVariant *parameters,
+ sd_json_variant *parameters,
VarlinkMethodFlags flags,
void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "imageFileDescriptor", JSON_VARIANT_UNSIGNED, json_dispatch_uint, offsetof(MountImageParameters, image_fd_idx), JSON_MANDATORY },
- { "userNamespaceFileDescriptor", JSON_VARIANT_UNSIGNED, json_dispatch_uint, offsetof(MountImageParameters, userns_fd_idx), 0 },
- { "readOnly", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(MountImageParameters, read_only), 0 },
- { "growFileSystems", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(MountImageParameters, growfs), 0 },
- { "password", JSON_VARIANT_STRING, json_dispatch_string, offsetof(MountImageParameters, password), 0 },
- { "imagePolicy", JSON_VARIANT_STRING, json_dispatch_image_policy, offsetof(MountImageParameters, image_policy), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "imageFileDescriptor", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint, offsetof(MountImageParameters, image_fd_idx), SD_JSON_MANDATORY },
+ { "userNamespaceFileDescriptor", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint, offsetof(MountImageParameters, userns_fd_idx), 0 },
+ { "readOnly", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(MountImageParameters, read_only), 0 },
+ { "growFileSystems", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(MountImageParameters, growfs), 0 },
+ { "password", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(MountImageParameters, password), 0 },
+ { "imagePolicy", SD_JSON_VARIANT_STRING, json_dispatch_image_policy, offsetof(MountImageParameters, image_policy), 0 },
VARLINK_DISPATCH_POLKIT_FIELD,
{}
};
};
_cleanup_(dissected_image_unrefp) DissectedImage *di = NULL;
_cleanup_(loop_device_unrefp) LoopDevice *loop = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *aj = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *aj = NULL;
_cleanup_close_ int image_fd = -EBADF, userns_fd = -EBADF;
_cleanup_(image_policy_freep) ImagePolicy *use_policy = NULL;
Hashmap **polkit_registry = ASSERT_PTR(userdata);
assert(link);
assert(parameters);
- json_variant_sensitive(parameters); /* might contain passwords */
+ sd_json_variant_sensitive(parameters); /* might contain passwords */
r = varlink_get_peer_uid(link, &peer_uid);
if (r < 0)
return r;
for (PartitionDesignator d = 0; d < _PARTITION_DESIGNATOR_MAX; d++) {
- _cleanup_(json_variant_unrefp) JsonVariant *pj = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *pj = NULL;
DissectedPartition *pp = di->partitions + d;
int fd_idx;
TAKE_FD(pp->fsmount_fd);
- r = json_build(&pj,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("designator", JSON_BUILD_STRING(partition_designator_to_string(d))),
- JSON_BUILD_PAIR("writable", JSON_BUILD_BOOLEAN(pp->rw)),
- JSON_BUILD_PAIR("growFileSystem", JSON_BUILD_BOOLEAN(pp->growfs)),
- JSON_BUILD_PAIR_CONDITION(pp->partno > 0, "partitionNumber", JSON_BUILD_INTEGER(pp->partno)),
- JSON_BUILD_PAIR_CONDITION(pp->architecture > 0, "architecture", JSON_BUILD_STRING(architecture_to_string(pp->architecture))),
- JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(pp->uuid), "partitionUuid", JSON_BUILD_UUID(pp->uuid)),
- JSON_BUILD_PAIR("fileSystemType", JSON_BUILD_STRING(dissected_partition_fstype(pp))),
- JSON_BUILD_PAIR_CONDITION(pp->label, "partitionLabel", JSON_BUILD_STRING(pp->label)),
- JSON_BUILD_PAIR("size", JSON_BUILD_INTEGER(pp->size)),
- JSON_BUILD_PAIR("offset", JSON_BUILD_INTEGER(pp->offset)),
- JSON_BUILD_PAIR("mountFileDescriptor", JSON_BUILD_INTEGER(fd_idx))));
+ r = sd_json_build(&pj,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("designator", SD_JSON_BUILD_STRING(partition_designator_to_string(d))),
+ SD_JSON_BUILD_PAIR("writable", SD_JSON_BUILD_BOOLEAN(pp->rw)),
+ SD_JSON_BUILD_PAIR("growFileSystem", SD_JSON_BUILD_BOOLEAN(pp->growfs)),
+ SD_JSON_BUILD_PAIR_CONDITION(pp->partno > 0, "partitionNumber", SD_JSON_BUILD_INTEGER(pp->partno)),
+ SD_JSON_BUILD_PAIR_CONDITION(pp->architecture > 0, "architecture", SD_JSON_BUILD_STRING(architecture_to_string(pp->architecture))),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(pp->uuid), "partitionUuid", SD_JSON_BUILD_UUID(pp->uuid)),
+ SD_JSON_BUILD_PAIR("fileSystemType", SD_JSON_BUILD_STRING(dissected_partition_fstype(pp))),
+ SD_JSON_BUILD_PAIR_CONDITION(!!pp->label, "partitionLabel", SD_JSON_BUILD_STRING(pp->label)),
+ SD_JSON_BUILD_PAIR("size", SD_JSON_BUILD_INTEGER(pp->size)),
+ SD_JSON_BUILD_PAIR("offset", SD_JSON_BUILD_INTEGER(pp->offset)),
+ SD_JSON_BUILD_PAIR("mountFileDescriptor", SD_JSON_BUILD_INTEGER(fd_idx))));
if (r < 0)
return r;
- r = json_variant_append_array(&aj, pj);
+ r = sd_json_variant_append_array(&aj, pj);
if (r < 0)
return r;
}
loop_device_relinquish(loop);
- r = varlink_replyb(link, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("partitions", JSON_BUILD_VARIANT(aj)),
- JSON_BUILD_PAIR("imagePolicy", JSON_BUILD_STRING(ps)),
- JSON_BUILD_PAIR("imageSize", JSON_BUILD_INTEGER(di->image_size)),
- JSON_BUILD_PAIR("sectorSize", JSON_BUILD_INTEGER(di->sector_size)),
- JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(di->image_uuid), "imageUuid", JSON_BUILD_UUID(di->image_uuid))));
+ r = varlink_replyb(link, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("partitions", SD_JSON_BUILD_VARIANT(aj)),
+ SD_JSON_BUILD_PAIR("imagePolicy", SD_JSON_BUILD_STRING(ps)),
+ SD_JSON_BUILD_PAIR("imageSize", SD_JSON_BUILD_INTEGER(di->image_size)),
+ SD_JSON_BUILD_PAIR("sectorSize", SD_JSON_BUILD_INTEGER(di->sector_size)),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(di->image_uuid), "imageUuid", SD_JSON_BUILD_UUID(di->image_uuid))));
if (r < 0)
return r;
#include "sd-device.h"
#include "sd-dhcp-client.h"
#include "sd-hwdb.h"
+#include "sd-json.h"
#include "sd-netlink.h"
#include "sd-network.h"
#include "hwdb-util.h"
#include "ipvlan-util.h"
#include "journal-internal.h"
+#include "json-util.h"
#include "local-addresses.h"
#include "locale-util.h"
#include "logs-show.h"
bool arg_runtime = false;
unsigned arg_lines = 10;
char *arg_drop_in = NULL;
-JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
STATIC_DESTRUCTOR_REGISTER(arg_drop_in, freep);
static int varlink_connect_networkd(Varlink **ret_varlink) {
_cleanup_(varlink_flush_close_unrefp) Varlink *vl = NULL;
- JsonVariant *reply;
+ sd_json_variant *reply;
uint64_t id;
int r;
if (r < 0)
return r;
- static const JsonDispatch dispatch_table[] = {
- { "NamespaceId", JSON_VARIANT_UNSIGNED, json_dispatch_uint64, 0, JSON_MANDATORY },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "NamespaceId", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint64, 0, SD_JSON_MANDATORY },
{},
};
- r = json_dispatch(reply, dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, &id);
+ r = sd_json_dispatch(reply, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &id);
if (r < 0)
return r;
return 0;
}
-static int get_description(sd_bus *bus, JsonVariant **ret) {
+static int get_description(sd_bus *bus, sd_json_variant **ret) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
const char *text;
if (r < 0)
return bus_log_parse_error(r);
- r = json_parse(text, 0, ret, NULL, NULL);
+ r = sd_json_parse(text, 0, ret, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to parse JSON: %m");
}
static int dump_manager_description(sd_bus *bus) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(bus);
if (r < 0)
return r;
- json_variant_dump(v, arg_json_format_flags, NULL, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, NULL, NULL);
return 0;
}
static int dump_link_description(sd_bus *bus, char * const *patterns) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ bool *matched_patterns = NULL;
- JsonVariant *i;
+ sd_json_variant *i;
size_t c = 0;
int r;
if (!matched_patterns)
return log_oom();
- JSON_VARIANT_ARRAY_FOREACH(i, json_variant_by_key(v, "Interfaces")) {
+ JSON_VARIANT_ARRAY_FOREACH(i, sd_json_variant_by_key(v, "Interfaces")) {
char ifindex_str[DECIMAL_STR_MAX(int64_t)];
const char *name;
int64_t index;
size_t pos;
- name = json_variant_string(json_variant_by_key(i, "Name"));
- index = json_variant_integer(json_variant_by_key(i, "Index"));
+ name = sd_json_variant_string(sd_json_variant_by_key(i, "Name"));
+ index = sd_json_variant_integer(sd_json_variant_by_key(i, "Index"));
xsprintf(ifindex_str, "%" PRIi64, index);
if (!strv_fnmatch_full(patterns, ifindex_str, 0, &pos) &&
!strv_fnmatch_full(patterns, name, 0, &pos)) {
bool match = false;
- JsonVariant *a;
+ sd_json_variant *a;
- JSON_VARIANT_ARRAY_FOREACH(a, json_variant_by_key(i, "AlternativeNames"))
- if (strv_fnmatch_full(patterns, json_variant_string(a), 0, &pos)) {
+ JSON_VARIANT_ARRAY_FOREACH(a, sd_json_variant_by_key(i, "AlternativeNames"))
+ if (strv_fnmatch_full(patterns, sd_json_variant_string(a), 0, &pos)) {
match = true;
break;
}
}
matched_patterns[pos] = true;
- json_variant_dump(i, arg_json_format_flags, NULL, NULL);
+ sd_json_variant_dump(i, arg_json_format_flags, NULL, NULL);
c++;
}
if (r < 0)
return r;
- if (arg_json_format_flags != JSON_FORMAT_OFF) {
+ if (arg_json_format_flags != SD_JSON_FORMAT_OFF) {
if (arg_all || argc <= 1)
return dump_manager_description(bus);
else
int ifindex;
const char *ifname;
char **altnames;
- JsonVariant *v;
+ sd_json_variant *v;
} InterfaceInfo;
static void interface_info_done(InterfaceInfo *p) {
return;
strv_free(p->altnames);
- json_variant_unref(p->v);
+ sd_json_variant_unref(p->v);
}
-static const JsonDispatch interface_info_dispatch_table[] = {
- { "InterfaceIndex", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(InterfaceInfo, ifindex), JSON_MANDATORY },
- { "InterfaceName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(InterfaceInfo, ifname), JSON_MANDATORY },
- { "InterfaceAlternativeNames", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(InterfaceInfo, altnames), 0 },
- { "Neighbors", JSON_VARIANT_ARRAY, json_dispatch_variant, offsetof(InterfaceInfo, v), 0 },
+static const sd_json_dispatch_field interface_info_dispatch_table[] = {
+ { "InterfaceIndex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(InterfaceInfo, ifindex), SD_JSON_MANDATORY },
+ { "InterfaceName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(InterfaceInfo, ifname), SD_JSON_MANDATORY },
+ { "InterfaceAlternativeNames", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(InterfaceInfo, altnames), 0 },
+ { "Neighbors", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(InterfaceInfo, v), 0 },
{},
};
uint16_t capabilities;
} LLDPNeighborInfo;
-static const JsonDispatch lldp_neighbor_dispatch_table[] = {
- { "ChassisID", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LLDPNeighborInfo, chassis_id), 0 },
- { "PortID", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LLDPNeighborInfo, port_id), 0 },
- { "PortDescription", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LLDPNeighborInfo, port_description), 0 },
- { "SystemName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LLDPNeighborInfo, system_name), 0 },
- { "SystemDescription", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LLDPNeighborInfo, system_description), 0 },
- { "EnabledCapabilities", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint16, offsetof(LLDPNeighborInfo, capabilities), 0 },
+static const sd_json_dispatch_field lldp_neighbor_dispatch_table[] = {
+ { "ChassisID", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LLDPNeighborInfo, chassis_id), 0 },
+ { "PortID", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LLDPNeighborInfo, port_id), 0 },
+ { "PortDescription", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LLDPNeighborInfo, port_description), 0 },
+ { "SystemName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LLDPNeighborInfo, system_name), 0 },
+ { "SystemDescription", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LLDPNeighborInfo, system_description), 0 },
+ { "EnabledCapabilities", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(LLDPNeighborInfo, capabilities), 0 },
{},
};
static int dump_lldp_neighbors(Varlink *vl, Table *table, int ifindex) {
_cleanup_strv_free_ char **buf = NULL;
- JsonVariant *reply;
+ sd_json_variant *reply;
int r;
assert(vl);
assert(ifindex > 0);
r = varlink_callb_and_log(vl, "io.systemd.Network.GetLLDPNeighbors", &reply,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR_INTEGER("InterfaceIndex", ifindex)));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_INTEGER("InterfaceIndex", ifindex)));
if (r < 0)
return r;
- JsonVariant *i;
- JSON_VARIANT_ARRAY_FOREACH(i, json_variant_by_key(reply, "Neighbors")) {
+ sd_json_variant *i;
+ JSON_VARIANT_ARRAY_FOREACH(i, sd_json_variant_by_key(reply, "Neighbors")) {
_cleanup_(interface_info_done) InterfaceInfo info = {};
- r = json_dispatch(i, interface_info_dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, &info);
+ r = sd_json_dispatch(i, interface_info_dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &info);
if (r < 0)
return r;
if (info.ifindex != ifindex)
continue;
- JsonVariant *neighbor;
+ sd_json_variant *neighbor;
JSON_VARIANT_ARRAY_FOREACH(neighbor, info.v) {
LLDPNeighborInfo neighbor_info = {};
- r = json_dispatch(neighbor, lldp_neighbor_dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, &neighbor_info);
+ r = sd_json_dispatch(neighbor, lldp_neighbor_dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &neighbor_info);
if (r < 0)
return r;
if (r < 0)
return r;
- if (arg_json_format_flags != JSON_FORMAT_OFF) {
+ if (arg_json_format_flags != SD_JSON_FORMAT_OFF) {
if (arg_all || argc <= 1)
return dump_manager_description(bus);
else
return false;
}
-static int dump_lldp_neighbors_json(JsonVariant *reply, char * const *patterns) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL, *v = NULL;
+static int dump_lldp_neighbors_json(sd_json_variant *reply, char * const *patterns) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL, *v = NULL;
int r;
assert(reply);
if (strv_isempty(patterns))
- return json_variant_dump(reply, arg_json_format_flags, NULL, NULL);
+ return sd_json_variant_dump(reply, arg_json_format_flags, NULL, NULL);
/* Filter and dump the result. */
- JsonVariant *i;
- JSON_VARIANT_ARRAY_FOREACH(i, json_variant_by_key(reply, "Neighbors")) {
+ sd_json_variant *i;
+ JSON_VARIANT_ARRAY_FOREACH(i, sd_json_variant_by_key(reply, "Neighbors")) {
_cleanup_(interface_info_done) InterfaceInfo info = {};
- r = json_dispatch(i, interface_info_dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, &info);
+ r = sd_json_dispatch(i, interface_info_dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &info);
if (r < 0)
return r;
if (!interface_match_pattern(&info, patterns))
continue;
- r = json_variant_append_array(&array, i);
+ r = sd_json_variant_append_array(&array, i);
if (r < 0)
return log_error_errno(r, "Failed to append json variant to array: %m");
}
- r = json_build(&v,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(json_variant_is_blank_array(array), "Neighbors", JSON_BUILD_EMPTY_ARRAY),
- JSON_BUILD_PAIR_CONDITION(!json_variant_is_blank_array(array), "Neighbors", JSON_BUILD_VARIANT(array))));
+ r = sd_json_build(&v,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(sd_json_variant_is_blank_array(array), "Neighbors", SD_JSON_BUILD_EMPTY_ARRAY),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_json_variant_is_blank_array(array), "Neighbors", SD_JSON_BUILD_VARIANT(array))));
if (r < 0)
return log_error_errno(r, "Failed to build json varinat: %m");
- return json_variant_dump(v, arg_json_format_flags, NULL, NULL);
+ return sd_json_variant_dump(v, arg_json_format_flags, NULL, NULL);
}
static int link_lldp_status(int argc, char *argv[], void *userdata) {
_cleanup_(varlink_flush_close_unrefp) Varlink *vl = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
- JsonVariant *reply;
+ sd_json_variant *reply;
uint64_t all = 0;
TableCell *cell;
size_t m = 0;
if (r < 0)
return r;
- if (arg_json_format_flags != JSON_FORMAT_OFF)
+ if (arg_json_format_flags != SD_JSON_FORMAT_OFF)
return dump_lldp_neighbors_json(reply, strv_skip(argv, 1));
pager_open(arg_pager_flags);
assert_se(cell = table_get_cell(table, 0, 7));
table_set_minimum_width(table, cell, 11);
- JsonVariant *i;
- JSON_VARIANT_ARRAY_FOREACH(i, json_variant_by_key(reply, "Neighbors")) {
+ sd_json_variant *i;
+ JSON_VARIANT_ARRAY_FOREACH(i, sd_json_variant_by_key(reply, "Neighbors")) {
_cleanup_(interface_info_done) InterfaceInfo info = {};
- r = json_dispatch(i, interface_info_dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, &info);
+ r = sd_json_dispatch(i, interface_info_dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &info);
if (r < 0)
return r;
if (!interface_match_pattern(&info, strv_skip(argv, 1)))
continue;
- JsonVariant *neighbor;
+ sd_json_variant *neighbor;
JSON_VARIANT_ARRAY_FOREACH(neighbor, info.v) {
LLDPNeighborInfo neighbor_info = {};
- r = json_dispatch(neighbor, lldp_neighbor_dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, &neighbor_info);
+ r = sd_json_dispatch(neighbor, lldp_neighbor_dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &neighbor_info);
if (r < 0)
return r;
}
return varlink_callb_and_log(vl, "io.systemd.Network.SetPersistentStorage", /* reply = */ NULL,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR_BOOLEAN("Ready", ready)));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_BOOLEAN("Ready", ready)));
}
static int help(void) {
extern bool arg_runtime;
extern unsigned arg_lines;
extern char *arg_drop_in;
-extern JsonFormatFlags arg_json_format_flags;
+extern sd_json_format_flags_t arg_json_format_flags;
bool networkd_is_running(void);
int acquire_bus(sd_bus **ret);
#include "dhcp6-lease-internal.h"
#include "dns-domain.h"
#include "ip-protocol-list.h"
+#include "json-util.h"
#include "netif-util.h"
#include "networkd-address.h"
#include "networkd-dhcp-common.h"
#include "networkd-route.h"
#include "networkd-routing-policy-rule.h"
#include "sort-util.h"
+#include "strv.h"
#include "udev-util.h"
#include "user-util.h"
#include "wifi-util.h"
-static int address_append_json(Address *address, JsonVariant **array) {
+static int address_append_json(Address *address, sd_json_variant **array) {
_cleanup_free_ char *scope = NULL, *flags = NULL, *state = NULL;
int r;
if (r < 0)
return r;
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_INTEGER("Family", address->family),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_INTEGER("Family", address->family),
JSON_BUILD_PAIR_IN_ADDR("Address", &address->in_addr, address->family),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("Peer", &address->in_addr_peer, address->family),
JSON_BUILD_PAIR_IN4_ADDR_NON_NULL("Broadcast", &address->broadcast),
- JSON_BUILD_PAIR_UNSIGNED("PrefixLength", address->prefixlen),
- JSON_BUILD_PAIR_UNSIGNED("Scope", address->scope),
- JSON_BUILD_PAIR_STRING("ScopeString", scope),
- JSON_BUILD_PAIR_UNSIGNED("Flags", address->flags),
- JSON_BUILD_PAIR_STRING("FlagsString", flags),
+ SD_JSON_BUILD_PAIR_UNSIGNED("PrefixLength", address->prefixlen),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Scope", address->scope),
+ SD_JSON_BUILD_PAIR_STRING("ScopeString", scope),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Flags", address->flags),
+ SD_JSON_BUILD_PAIR_STRING("FlagsString", flags),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Label", address->label),
JSON_BUILD_PAIR_FINITE_USEC("PreferredLifetimeUSec", address->lifetime_preferred_usec),
JSON_BUILD_PAIR_FINITE_USEC("PreferredLifetimeUsec", address->lifetime_preferred_usec), /* for backward compat */
JSON_BUILD_PAIR_FINITE_USEC("ValidLifetimeUSec", address->lifetime_valid_usec),
JSON_BUILD_PAIR_FINITE_USEC("ValidLifetimeUsec", address->lifetime_valid_usec), /* for backward compat */
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(address->source)),
- JSON_BUILD_PAIR_STRING("ConfigState", state),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(address->source)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigState", state),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("ConfigProvider", &address->provider, address->family)));
}
-static int addresses_append_json(Set *addresses, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int addresses_append_json(Set *addresses, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
Address *address;
int r;
return json_variant_set_field_non_null(v, "Addresses", array);
}
-static int neighbor_append_json(Neighbor *n, JsonVariant **array) {
+static int neighbor_append_json(Neighbor *n, sd_json_variant **array) {
_cleanup_free_ char *state = NULL;
int r;
if (r < 0)
return r;
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_INTEGER("Family", n->family),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_INTEGER("Family", n->family),
JSON_BUILD_PAIR_IN_ADDR("Destination", &n->in_addr, n->family),
JSON_BUILD_PAIR_HW_ADDR("LinkLayerAddress", &n->ll_addr),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(n->source)),
- JSON_BUILD_PAIR_STRING("ConfigState", state)));
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(n->source)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigState", state)));
}
-static int neighbors_append_json(Set *neighbors, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int neighbors_append_json(Set *neighbors, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
Neighbor *neighbor;
int r;
return json_variant_set_field_non_null(v, "Neighbors", array);
}
-static int nexthop_group_build_json(NextHop *nexthop, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int nexthop_group_build_json(NextHop *nexthop, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
struct nexthop_grp *g;
int r;
assert(ret);
HASHMAP_FOREACH(g, nexthop->group) {
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("ID", g->id),
- JSON_BUILD_PAIR_UNSIGNED("Weight", g->weight+1)));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("ID", g->id),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Weight", g->weight+1)));
if (r < 0)
return r;
}
return 0;
}
-static int nexthop_append_json(NextHop *n, JsonVariant **array) {
- _cleanup_(json_variant_unrefp) JsonVariant *group = NULL;
+static int nexthop_append_json(NextHop *n, sd_json_variant **array) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *group = NULL;
_cleanup_free_ char *flags = NULL, *protocol = NULL, *state = NULL;
int r;
if (r < 0)
return r;
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("ID", n->id),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("ID", n->id),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("Gateway", &n->gw, n->family),
- JSON_BUILD_PAIR_UNSIGNED("Flags", n->flags),
- JSON_BUILD_PAIR_STRING("FlagsString", strempty(flags)),
- JSON_BUILD_PAIR_UNSIGNED("Protocol", n->protocol),
- JSON_BUILD_PAIR_STRING("ProtocolString", protocol),
- JSON_BUILD_PAIR_BOOLEAN("Blackhole", n->blackhole),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Flags", n->flags),
+ SD_JSON_BUILD_PAIR_STRING("FlagsString", strempty(flags)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Protocol", n->protocol),
+ SD_JSON_BUILD_PAIR_STRING("ProtocolString", protocol),
+ SD_JSON_BUILD_PAIR_BOOLEAN("Blackhole", n->blackhole),
JSON_BUILD_PAIR_VARIANT_NON_NULL("Group", group),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(n->source)),
- JSON_BUILD_PAIR_STRING("ConfigState", state)));
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(n->source)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigState", state)));
}
-static int nexthops_append_json(Manager *manager, int ifindex, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int nexthops_append_json(Manager *manager, int ifindex, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
NextHop *nexthop;
int r;
return json_variant_set_field_non_null(v, "NextHops", array);
}
-static int route_append_json(Route *route, JsonVariant **array) {
+static int route_append_json(Route *route, sd_json_variant **array) {
_cleanup_free_ char *scope = NULL, *protocol = NULL, *table = NULL, *flags = NULL, *state = NULL;
int r;
if (r < 0)
return r;
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_INTEGER("Family", route->family),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_INTEGER("Family", route->family),
JSON_BUILD_PAIR_IN_ADDR("Destination", &route->dst, route->family),
- JSON_BUILD_PAIR_UNSIGNED("DestinationPrefixLength", route->dst_prefixlen),
+ SD_JSON_BUILD_PAIR_UNSIGNED("DestinationPrefixLength", route->dst_prefixlen),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("Gateway", &route->nexthop.gw, route->nexthop.family),
- JSON_BUILD_PAIR_CONDITION(route->src_prefixlen > 0,
+ SD_JSON_BUILD_PAIR_CONDITION(route->src_prefixlen > 0,
"Source", JSON_BUILD_IN_ADDR(&route->src, route->family)),
JSON_BUILD_PAIR_UNSIGNED_NON_ZERO("SourcePrefixLength", route->src_prefixlen),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("PreferredSource", &route->prefsrc, route->family),
- JSON_BUILD_PAIR_UNSIGNED("Scope", route->scope),
- JSON_BUILD_PAIR_STRING("ScopeString", scope),
- JSON_BUILD_PAIR_UNSIGNED("Protocol", route->protocol),
- JSON_BUILD_PAIR_STRING("ProtocolString", protocol),
- JSON_BUILD_PAIR_UNSIGNED("Type", route->type),
- JSON_BUILD_PAIR_STRING("TypeString", route_type_to_string(route->type)),
- JSON_BUILD_PAIR_UNSIGNED("Priority", route->priority),
- JSON_BUILD_PAIR_UNSIGNED("Table", route->table),
- JSON_BUILD_PAIR_STRING("TableString", table),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Scope", route->scope),
+ SD_JSON_BUILD_PAIR_STRING("ScopeString", scope),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Protocol", route->protocol),
+ SD_JSON_BUILD_PAIR_STRING("ProtocolString", protocol),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Type", route->type),
+ SD_JSON_BUILD_PAIR_STRING("TypeString", route_type_to_string(route->type)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Priority", route->priority),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Table", route->table),
+ SD_JSON_BUILD_PAIR_STRING("TableString", table),
JSON_BUILD_PAIR_UNSIGNED_NON_ZERO("MTU", route_metric_get(&route->metric, RTAX_MTU)),
- JSON_BUILD_PAIR_UNSIGNED("Preference", route->pref),
- JSON_BUILD_PAIR_UNSIGNED("Flags", route->flags),
- JSON_BUILD_PAIR_STRING("FlagsString", strempty(flags)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Preference", route->pref),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Flags", route->flags),
+ SD_JSON_BUILD_PAIR_STRING("FlagsString", strempty(flags)),
JSON_BUILD_PAIR_FINITE_USEC("LifetimeUSec", route->lifetime_usec),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(route->source)),
- JSON_BUILD_PAIR_STRING("ConfigState", state),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(route->source)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigState", state),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("ConfigProvider", &route->provider, route->family)));
}
-static int routes_append_json(Manager *manager, int ifindex, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int routes_append_json(Manager *manager, int ifindex, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
Route *route;
int r;
return json_variant_set_field_non_null(v, "Routes", array);
}
-static int routing_policy_rule_append_json(RoutingPolicyRule *rule, JsonVariant **array) {
+static int routing_policy_rule_append_json(RoutingPolicyRule *rule, sd_json_variant **array) {
_cleanup_free_ char *table = NULL, *protocol = NULL, *state = NULL;
int r;
if (r < 0)
return r;
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_INTEGER("Family", rule->family),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_INTEGER("Family", rule->family),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("FromPrefix", &rule->from, rule->family),
- JSON_BUILD_PAIR_CONDITION(in_addr_is_set(rule->family, &rule->from),
- "FromPrefixLength", JSON_BUILD_UNSIGNED(rule->from_prefixlen)),
+ SD_JSON_BUILD_PAIR_CONDITION(in_addr_is_set(rule->family, &rule->from),
+ "FromPrefixLength", SD_JSON_BUILD_UNSIGNED(rule->from_prefixlen)),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("ToPrefix", &rule->to, rule->family),
- JSON_BUILD_PAIR_CONDITION(in_addr_is_set(rule->family, &rule->to),
- "ToPrefixLength", JSON_BUILD_UNSIGNED(rule->to_prefixlen)),
- JSON_BUILD_PAIR_UNSIGNED("Protocol", rule->protocol),
- JSON_BUILD_PAIR_STRING("ProtocolString", protocol),
- JSON_BUILD_PAIR_UNSIGNED("TOS", rule->tos),
- JSON_BUILD_PAIR_UNSIGNED("Type", rule->type),
- JSON_BUILD_PAIR_STRING("TypeString", fr_act_type_full_to_string(rule->type)),
- JSON_BUILD_PAIR_UNSIGNED("IPProtocol", rule->ipproto),
- JSON_BUILD_PAIR_STRING("IPProtocolString", ip_protocol_to_name(rule->ipproto)),
- JSON_BUILD_PAIR_UNSIGNED("Priority", rule->priority),
- JSON_BUILD_PAIR_UNSIGNED("FirewallMark", rule->fwmark),
- JSON_BUILD_PAIR_UNSIGNED("FirewallMask", rule->fwmask),
+ SD_JSON_BUILD_PAIR_CONDITION(in_addr_is_set(rule->family, &rule->to),
+ "ToPrefixLength", SD_JSON_BUILD_UNSIGNED(rule->to_prefixlen)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Protocol", rule->protocol),
+ SD_JSON_BUILD_PAIR_STRING("ProtocolString", protocol),
+ SD_JSON_BUILD_PAIR_UNSIGNED("TOS", rule->tos),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Type", rule->type),
+ SD_JSON_BUILD_PAIR_STRING("TypeString", fr_act_type_full_to_string(rule->type)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("IPProtocol", rule->ipproto),
+ SD_JSON_BUILD_PAIR_STRING("IPProtocolString", ip_protocol_to_name(rule->ipproto)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Priority", rule->priority),
+ SD_JSON_BUILD_PAIR_UNSIGNED("FirewallMark", rule->fwmark),
+ SD_JSON_BUILD_PAIR_UNSIGNED("FirewallMask", rule->fwmask),
JSON_BUILD_PAIR_UNSIGNED_NON_ZERO("Table", rule->table),
JSON_BUILD_PAIR_STRING_NON_EMPTY("TableString", table),
- JSON_BUILD_PAIR_BOOLEAN("Invert", rule->invert_rule),
- JSON_BUILD_PAIR_CONDITION(rule->suppress_prefixlen >= 0,
- "SuppressPrefixLength", JSON_BUILD_UNSIGNED(rule->suppress_prefixlen)),
- JSON_BUILD_PAIR_CONDITION(rule->suppress_ifgroup >= 0,
- "SuppressInterfaceGroup", JSON_BUILD_UNSIGNED(rule->suppress_ifgroup)),
- JSON_BUILD_PAIR_CONDITION(rule->sport.start != 0 || rule->sport.end != 0, "SourcePort",
- JSON_BUILD_ARRAY(JSON_BUILD_UNSIGNED(rule->sport.start), JSON_BUILD_UNSIGNED(rule->sport.end))),
- JSON_BUILD_PAIR_CONDITION(rule->dport.start != 0 || rule->dport.end != 0, "DestinationPort",
- JSON_BUILD_ARRAY(JSON_BUILD_UNSIGNED(rule->dport.start), JSON_BUILD_UNSIGNED(rule->dport.end))),
- JSON_BUILD_PAIR_CONDITION(rule->uid_range.start != UID_INVALID && rule->uid_range.end != UID_INVALID, "User",
- JSON_BUILD_ARRAY(JSON_BUILD_UNSIGNED(rule->uid_range.start), JSON_BUILD_UNSIGNED(rule->uid_range.end))),
+ SD_JSON_BUILD_PAIR_BOOLEAN("Invert", rule->invert_rule),
+ SD_JSON_BUILD_PAIR_CONDITION(rule->suppress_prefixlen >= 0,
+ "SuppressPrefixLength", SD_JSON_BUILD_UNSIGNED(rule->suppress_prefixlen)),
+ SD_JSON_BUILD_PAIR_CONDITION(rule->suppress_ifgroup >= 0,
+ "SuppressInterfaceGroup", SD_JSON_BUILD_UNSIGNED(rule->suppress_ifgroup)),
+ SD_JSON_BUILD_PAIR_CONDITION(rule->sport.start != 0 || rule->sport.end != 0, "SourcePort",
+ SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_UNSIGNED(rule->sport.start), SD_JSON_BUILD_UNSIGNED(rule->sport.end))),
+ SD_JSON_BUILD_PAIR_CONDITION(rule->dport.start != 0 || rule->dport.end != 0, "DestinationPort",
+ SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_UNSIGNED(rule->dport.start), SD_JSON_BUILD_UNSIGNED(rule->dport.end))),
+ SD_JSON_BUILD_PAIR_CONDITION(rule->uid_range.start != UID_INVALID && rule->uid_range.end != UID_INVALID, "User",
+ SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_UNSIGNED(rule->uid_range.start), SD_JSON_BUILD_UNSIGNED(rule->uid_range.end))),
JSON_BUILD_PAIR_STRING_NON_EMPTY("IncomingInterface", rule->iif),
JSON_BUILD_PAIR_STRING_NON_EMPTY("OutgoingInterface", rule->oif),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(rule->source)),
- JSON_BUILD_PAIR_STRING("ConfigState", state)));
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(rule->source)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigState", state)));
}
-static int routing_policy_rules_append_json(Set *rules, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int routing_policy_rules_append_json(Set *rules, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
RoutingPolicyRule *rule;
int r;
return json_variant_set_field_non_null(v, "RoutingPolicyRules", array);
}
-static int network_append_json(Network *network, JsonVariant **v) {
+static int network_append_json(Network *network, sd_json_variant **v) {
assert(v);
if (!network)
return 0;
- return json_variant_merge_objectb(
- v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("NetworkFile", network->filename),
- JSON_BUILD_PAIR_STRV("NetworkFileDropins", network->dropins),
- JSON_BUILD_PAIR_BOOLEAN("RequiredForOnline", network->required_for_online),
- JSON_BUILD_PAIR("RequiredOperationalStateForOnline",
- JSON_BUILD_ARRAY(JSON_BUILD_STRING(link_operstate_to_string(network->required_operstate_for_online.min)),
- JSON_BUILD_STRING(link_operstate_to_string(network->required_operstate_for_online.max)))),
- JSON_BUILD_PAIR_STRING("RequiredFamilyForOnline",
+ return sd_json_variant_merge_objectb(
+ v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("NetworkFile", network->filename),
+ SD_JSON_BUILD_PAIR_STRV("NetworkFileDropins", network->dropins),
+ SD_JSON_BUILD_PAIR_BOOLEAN("RequiredForOnline", network->required_for_online),
+ SD_JSON_BUILD_PAIR("RequiredOperationalStateForOnline",
+ SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_STRING(link_operstate_to_string(network->required_operstate_for_online.min)),
+ SD_JSON_BUILD_STRING(link_operstate_to_string(network->required_operstate_for_online.max)))),
+ SD_JSON_BUILD_PAIR_STRING("RequiredFamilyForOnline",
link_required_address_family_to_string(network->required_family_for_online)),
- JSON_BUILD_PAIR_STRING("ActivationPolicy",
+ SD_JSON_BUILD_PAIR_STRING("ActivationPolicy",
activation_policy_to_string(network->activation_policy))));
}
-static int device_append_json(sd_device *device, JsonVariant **v) {
+static int device_append_json(sd_device *device, sd_json_variant **v) {
_cleanup_strv_free_ char **link_dropins = NULL;
const char *link = NULL, *path = NULL, *vendor = NULL, *model = NULL, *joined;
int r;
(void) device_get_vendor_string(device, &vendor);
(void) device_get_model_string(device, &model);
- return json_variant_merge_objectb(
+ return sd_json_variant_merge_objectb(
v,
- JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_OBJECT(
JSON_BUILD_PAIR_STRING_NON_EMPTY("LinkFile", link),
JSON_BUILD_PAIR_STRV_NON_EMPTY("LinkFileDropins", link_dropins),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Path", path),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Model", model)));
}
-static int dns_append_json_one(Link *link, const struct in_addr_full *a, NetworkConfigSource s, const union in_addr_union *p, JsonVariant **array) {
+static int dns_append_json_one(Link *link, const struct in_addr_full *a, NetworkConfigSource s, const union in_addr_union *p, sd_json_variant **array) {
assert(link);
assert(a);
assert(array);
if (a->ifindex != 0 && a->ifindex != link->ifindex)
return 0;
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_INTEGER("Family", a->family),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_INTEGER("Family", a->family),
JSON_BUILD_PAIR_IN_ADDR("Address", &a->address, a->family),
JSON_BUILD_PAIR_UNSIGNED_NON_ZERO("Port", a->port),
- JSON_BUILD_PAIR_CONDITION(a->ifindex != 0, "InterfaceIndex", JSON_BUILD_INTEGER(a->ifindex)),
+ SD_JSON_BUILD_PAIR_CONDITION(a->ifindex != 0, "InterfaceIndex", SD_JSON_BUILD_INTEGER(a->ifindex)),
JSON_BUILD_PAIR_STRING_NON_EMPTY("ServerName", a->server_name),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s)),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("ConfigProvider", p, a->family)));
}
-static int dns_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int dns_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
int r;
assert(link);
return json_variant_set_field_non_null(v, "DNS", array);
}
-static int server_append_json_one_addr(int family, const union in_addr_union *a, NetworkConfigSource s, const union in_addr_union *p, JsonVariant **array) {
+static int server_append_json_one_addr(int family, const union in_addr_union *a, NetworkConfigSource s, const union in_addr_union *p, sd_json_variant **array) {
assert(IN_SET(family, AF_INET, AF_INET6));
assert(a);
assert(array);
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_INTEGER("Family", family),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_INTEGER("Family", family),
JSON_BUILD_PAIR_IN_ADDR("Address", a, family),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s)),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("ConfigProvider", p, family)));
}
-static int server_append_json_one_fqdn(int family, const char *fqdn, NetworkConfigSource s, const union in_addr_union *p, JsonVariant **array) {
+static int server_append_json_one_fqdn(int family, const char *fqdn, NetworkConfigSource s, const union in_addr_union *p, sd_json_variant **array) {
assert(IN_SET(family, AF_UNSPEC, AF_INET, AF_INET6));
assert(fqdn);
assert(array);
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("Server", fqdn),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s)),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("Server", fqdn),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s)),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("ConfigProvider", p, family)));
}
-static int server_append_json_one_string(const char *str, NetworkConfigSource s, JsonVariant **array) {
+static int server_append_json_one_string(const char *str, NetworkConfigSource s, sd_json_variant **array) {
union in_addr_union a;
int family;
return server_append_json_one_fqdn(AF_UNSPEC, str, s, NULL, array);
}
-static int ntp_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int ntp_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
int r;
assert(link);
return json_variant_set_field_non_null(v, "NTP", array);
}
-static int sip_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int sip_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
const struct in_addr *sip;
union in_addr_union s;
int n_sip, r;
return json_variant_set_field_non_null(v, "SIP", array);
}
-static int domain_append_json(int family, const char *domain, NetworkConfigSource s, const union in_addr_union *p, JsonVariant **array) {
+static int domain_append_json(int family, const char *domain, NetworkConfigSource s, const union in_addr_union *p, sd_json_variant **array) {
assert(IN_SET(family, AF_UNSPEC, AF_INET, AF_INET6));
assert(domain);
assert(array);
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("Domain", domain),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s)),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("Domain", domain),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s)),
JSON_BUILD_PAIR_IN_ADDR_NON_NULL("ConfigProvider", p, family)));
}
-static int domains_append_json(Link *link, bool is_route, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int domains_append_json(Link *link, bool is_route, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
OrderedSet *link_domains, *network_domains;
UseDomains use_domains;
union in_addr_union s;
return json_variant_set_field_non_null(v, is_route ? "RouteDomains" : "SearchDomains", array);
}
-static int nta_append_json(const char *nta, NetworkConfigSource s, JsonVariant **array) {
+static int nta_append_json(const char *nta, NetworkConfigSource s, sd_json_variant **array) {
assert(nta);
assert(array);
- return json_variant_append_arrayb(
+ return sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("DNSSECNegativeTrustAnchor", nta),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("DNSSECNegativeTrustAnchor", nta),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s))));
}
-static int ntas_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int ntas_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
const char *nta;
int r;
return json_variant_set_field_non_null(v, "DNSSECNegativeTrustAnchors", array);
}
-static int dns_misc_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int dns_misc_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
ResolveSupport resolve_support;
NetworkConfigSource source;
DnsOverTlsMode mode;
if (resolve_support >= 0) {
source = link->llmnr >= 0 ? NETWORK_CONFIG_SOURCE_RUNTIME : NETWORK_CONFIG_SOURCE_STATIC;
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("LLMNR", resolve_support_to_string(resolve_support)),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("LLMNR", resolve_support_to_string(resolve_support)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source))));
if (r < 0)
return r;
}
if (resolve_support >= 0) {
source = link->mdns >= 0 ? NETWORK_CONFIG_SOURCE_RUNTIME : NETWORK_CONFIG_SOURCE_STATIC;
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("MDNS", resolve_support_to_string(resolve_support)),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("MDNS", resolve_support_to_string(resolve_support)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source))));
if (r < 0)
return r;
}
if (t >= 0) {
source = link->dns_default_route >= 0 ? NETWORK_CONFIG_SOURCE_RUNTIME : NETWORK_CONFIG_SOURCE_STATIC;
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_BOOLEAN("DNSDefaultRoute", t),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_BOOLEAN("DNSDefaultRoute", t),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source))));
if (r < 0)
return r;
}
if (mode >= 0) {
source = link->dns_over_tls_mode >= 0 ? NETWORK_CONFIG_SOURCE_RUNTIME : NETWORK_CONFIG_SOURCE_STATIC;
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("DNSOverTLS", dns_over_tls_mode_to_string(mode)),
- JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("DNSOverTLS", dns_over_tls_mode_to_string(mode)),
+ SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source))));
if (r < 0)
return r;
}
return json_variant_set_field_non_null(v, "DNSSettings", array);
}
-static int captive_portal_append_json(Link *link, JsonVariant **v) {
+static int captive_portal_append_json(Link *link, sd_json_variant **v) {
const char *captive_portal;
int r;
if (r <= 0)
return r;
- return json_variant_merge_objectb(v, JSON_BUILD_OBJECT(JSON_BUILD_PAIR_STRING("CaptivePortal", captive_portal)));
+ return sd_json_variant_merge_objectb(v, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_STRING("CaptivePortal", captive_portal)));
}
-static int pref64_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL, *w = NULL;
+static int pref64_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL, *w = NULL;
NDiscPREF64 *i;
int r;
return 0;
SET_FOREACH(i, link->ndisc_pref64) {
- r = json_variant_append_arrayb(&array,
- JSON_BUILD_OBJECT(
+ r = sd_json_variant_append_arrayb(&array,
+ SD_JSON_BUILD_OBJECT(
JSON_BUILD_PAIR_IN6_ADDR_NON_NULL("Prefix", &i->prefix),
- JSON_BUILD_PAIR_UNSIGNED("PrefixLength", i->prefix_len),
+ SD_JSON_BUILD_PAIR_UNSIGNED("PrefixLength", i->prefix_len),
JSON_BUILD_PAIR_FINITE_USEC("LifetimeUSec", i->lifetime_usec),
JSON_BUILD_PAIR_IN6_ADDR_NON_NULL("ConfigProvider", &i->router)));
if (r < 0)
return json_variant_set_field_non_null(v, "NDisc", w);
}
-static int dhcp_server_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+static int dhcp_server_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
int r;
assert(link);
if (!link->dhcp_server)
return 0;
- r = json_build(&w,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("PoolOffset", link->dhcp_server->pool_offset),
- JSON_BUILD_PAIR_UNSIGNED("PoolSize", link->dhcp_server->pool_size)));
+ r = sd_json_build(&w,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("PoolOffset", link->dhcp_server->pool_offset),
+ SD_JSON_BUILD_PAIR_UNSIGNED("PoolSize", link->dhcp_server->pool_size)));
if (r < 0)
return r;
return json_variant_set_field_non_null(v, "DHCPServer", w);
}
-static int dhcp6_client_vendor_options_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int dhcp6_client_vendor_options_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
sd_dhcp6_option **options = NULL;
int r, n_vendor_options;
n_vendor_options = sd_dhcp6_lease_get_vendor_options(link->dhcp6_lease, &options);
FOREACH_ARRAY(option, options, n_vendor_options) {
- r = json_variant_append_arrayb(&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("EnterpriseId", (*option)->enterprise_identifier),
- JSON_BUILD_PAIR_UNSIGNED("SubOptionCode", (*option)->option),
- JSON_BUILD_PAIR_HEX("SubOptionData", (*option)->data, (*option)->length)));
+ r = sd_json_variant_append_arrayb(&array,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("EnterpriseId", (*option)->enterprise_identifier),
+ SD_JSON_BUILD_PAIR_UNSIGNED("SubOptionCode", (*option)->option),
+ SD_JSON_BUILD_PAIR_HEX("SubOptionData", (*option)->data, (*option)->length)));
if (r < 0)
return r;
}
return json_variant_set_field_non_null(v, "VendorSpecificOptions", array);
}
-static int dhcp6_client_lease_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+static int dhcp6_client_lease_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
usec_t ts = USEC_INFINITY, t1 = USEC_INFINITY, t2 = USEC_INFINITY;
int r;
if (r < 0 && r != -ENODATA)
return r;
- r = json_build(&w, JSON_BUILD_OBJECT(
+ r = sd_json_build(&w, SD_JSON_BUILD_OBJECT(
JSON_BUILD_PAIR_FINITE_USEC("Timeout1USec", t1),
JSON_BUILD_PAIR_FINITE_USEC("Timeout2USec", t2),
JSON_BUILD_PAIR_FINITE_USEC("LeaseTimestampUSec", ts)));
return json_variant_set_field_non_null(v, "Lease", w);
}
-static int dhcp6_client_pd_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int dhcp6_client_pd_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
int r;
assert(link);
if (r < 0)
return r;
- r = json_variant_append_arrayb(&array, JSON_BUILD_OBJECT(
+ r = sd_json_variant_append_arrayb(&array, SD_JSON_BUILD_OBJECT(
JSON_BUILD_PAIR_IN6_ADDR("Prefix", &prefix),
- JSON_BUILD_PAIR_UNSIGNED("PrefixLength", prefix_len),
+ SD_JSON_BUILD_PAIR_UNSIGNED("PrefixLength", prefix_len),
JSON_BUILD_PAIR_FINITE_USEC("PreferredLifetimeUSec", lifetime_preferred_usec),
JSON_BUILD_PAIR_FINITE_USEC("ValidLifetimeUSec", lifetime_valid_usec)));
if (r < 0)
return json_variant_set_field_non_null(v, "Prefixes", array);
}
-static int dhcp6_client_duid_append_json(Link *link, JsonVariant **v) {
+static int dhcp6_client_duid_append_json(Link *link, sd_json_variant **v) {
const sd_dhcp_duid *duid;
const void *data;
size_t data_size;
if (r < 0)
return 0;
- return json_variant_merge_objectb(v, JSON_BUILD_OBJECT(JSON_BUILD_PAIR_BYTE_ARRAY("DUID", data, data_size)));
+ return sd_json_variant_merge_objectb(v, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_BYTE_ARRAY("DUID", data, data_size)));
}
-static int dhcp6_client_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+static int dhcp6_client_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
int r;
assert(link);
return json_variant_set_field_non_null(v, "DHCPv6Client", w);
}
-static int dhcp_client_lease_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+static int dhcp_client_lease_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
usec_t lease_timestamp_usec = USEC_INFINITY, t1 = USEC_INFINITY, t2 = USEC_INFINITY;
int r;
if (r < 0 && r != -ENODATA)
return r;
- r = json_build(&w, JSON_BUILD_OBJECT(
+ r = sd_json_build(&w, SD_JSON_BUILD_OBJECT(
JSON_BUILD_PAIR_FINITE_USEC("LeaseTimestampUSec", lease_timestamp_usec),
JSON_BUILD_PAIR_FINITE_USEC("Timeout1USec", t1),
JSON_BUILD_PAIR_FINITE_USEC("Timeout2USec", t2)));
return json_variant_set_field_non_null(v, "Lease", w);
}
-static int dhcp_client_pd_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *addresses = NULL, *array = NULL;
+static int dhcp_client_pd_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *addresses = NULL, *array = NULL;
uint8_t ipv4masklen, sixrd_prefixlen;
struct in6_addr sixrd_prefix;
const struct in_addr *br_addresses;
return r;
FOREACH_ARRAY(br_address, br_addresses, n_br_addresses) {
- r = json_variant_append_arrayb(&addresses, JSON_BUILD_IN4_ADDR(br_address));
+ r = sd_json_variant_append_arrayb(&addresses, JSON_BUILD_IN4_ADDR(br_address));
if (r < 0)
return r;
}
- r = json_build(&array, JSON_BUILD_OBJECT(
+ r = sd_json_build(&array, SD_JSON_BUILD_OBJECT(
JSON_BUILD_PAIR_IN6_ADDR("Prefix", &sixrd_prefix),
- JSON_BUILD_PAIR_UNSIGNED("PrefixLength", sixrd_prefixlen),
- JSON_BUILD_PAIR_UNSIGNED("IPv4MaskLength", ipv4masklen),
+ SD_JSON_BUILD_PAIR_UNSIGNED("PrefixLength", sixrd_prefixlen),
+ SD_JSON_BUILD_PAIR_UNSIGNED("IPv4MaskLength", ipv4masklen),
JSON_BUILD_PAIR_VARIANT_NON_NULL("BorderRouters", addresses)));
if (r < 0)
return r;
return json_variant_set_field_non_null(v, "6rdPrefix", array);
}
-static int dhcp_client_private_options_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int dhcp_client_private_options_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
int r;
assert(link);
LIST_FOREACH(options, option, link->dhcp_lease->private_options) {
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("Option", option->tag),
- JSON_BUILD_PAIR_HEX("PrivateOptionData", option->data, option->length)));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("Option", option->tag),
+ SD_JSON_BUILD_PAIR_HEX("PrivateOptionData", option->data, option->length)));
if (r < 0)
return 0;
}
return json_variant_set_field_non_null(v, "PrivateOptions", array);
}
-static int dhcp_client_id_append_json(Link *link, JsonVariant **v) {
+static int dhcp_client_id_append_json(Link *link, sd_json_variant **v) {
const sd_dhcp_client_id *client_id;
const void *data;
size_t l;
if (r < 0)
return 0;
- return json_variant_merge_objectb(v, JSON_BUILD_OBJECT(JSON_BUILD_PAIR_BYTE_ARRAY("ClientIdentifier", data, l)));
+ return sd_json_variant_merge_objectb(v, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_BYTE_ARRAY("ClientIdentifier", data, l)));
}
-static int dhcp_client_append_json(Link *link, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+static int dhcp_client_append_json(Link *link, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
int r;
assert(link);
return json_variant_set_field_non_null(v, "DHCPv4Client", w);
}
-int link_build_json(Link *link, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+int link_build_json(Link *link, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *type = NULL, *flags = NULL;
int r;
if (r < 0)
return r;
- r = json_build(&v, JSON_BUILD_OBJECT(
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(
/* basic information */
- JSON_BUILD_PAIR_INTEGER("Index", link->ifindex),
- JSON_BUILD_PAIR_STRING("Name", link->ifname),
+ SD_JSON_BUILD_PAIR_INTEGER("Index", link->ifindex),
+ SD_JSON_BUILD_PAIR_STRING("Name", link->ifname),
JSON_BUILD_PAIR_STRV_NON_EMPTY("AlternativeNames", link->alternative_names),
- JSON_BUILD_PAIR_CONDITION(link->master_ifindex > 0,
- "MasterInterfaceIndex", JSON_BUILD_INTEGER(link->master_ifindex)),
+ SD_JSON_BUILD_PAIR_CONDITION(link->master_ifindex > 0,
+ "MasterInterfaceIndex", SD_JSON_BUILD_INTEGER(link->master_ifindex)),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Kind", link->kind),
- JSON_BUILD_PAIR_STRING("Type", type),
+ SD_JSON_BUILD_PAIR_STRING("Type", type),
JSON_BUILD_PAIR_STRING_NON_EMPTY("Driver", link->driver),
- JSON_BUILD_PAIR_UNSIGNED("Flags", link->flags),
- JSON_BUILD_PAIR_STRING("FlagsString", flags),
- JSON_BUILD_PAIR_UNSIGNED("KernelOperationalState", link->kernel_operstate),
- JSON_BUILD_PAIR_STRING("KernelOperationalStateString", kernel_operstate_to_string(link->kernel_operstate)),
- JSON_BUILD_PAIR_UNSIGNED("MTU", link->mtu),
- JSON_BUILD_PAIR_UNSIGNED("MinimumMTU", link->min_mtu),
- JSON_BUILD_PAIR_UNSIGNED("MaximumMTU", link->max_mtu),
+ SD_JSON_BUILD_PAIR_UNSIGNED("Flags", link->flags),
+ SD_JSON_BUILD_PAIR_STRING("FlagsString", flags),
+ SD_JSON_BUILD_PAIR_UNSIGNED("KernelOperationalState", link->kernel_operstate),
+ SD_JSON_BUILD_PAIR_STRING("KernelOperationalStateString", kernel_operstate_to_string(link->kernel_operstate)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("MTU", link->mtu),
+ SD_JSON_BUILD_PAIR_UNSIGNED("MinimumMTU", link->min_mtu),
+ SD_JSON_BUILD_PAIR_UNSIGNED("MaximumMTU", link->max_mtu),
JSON_BUILD_PAIR_HW_ADDR_NON_NULL("HardwareAddress", &link->hw_addr),
JSON_BUILD_PAIR_HW_ADDR_NON_NULL("PermanentHardwareAddress", &link->permanent_hw_addr),
JSON_BUILD_PAIR_HW_ADDR_NON_NULL("BroadcastAddress", &link->bcast_addr),
JSON_BUILD_PAIR_IN6_ADDR_NON_NULL("IPv6LinkLocalAddress", &link->ipv6ll_address),
/* wlan information */
- JSON_BUILD_PAIR_CONDITION(link->wlan_iftype > 0, "WirelessLanInterfaceType",
- JSON_BUILD_UNSIGNED(link->wlan_iftype)),
- JSON_BUILD_PAIR_CONDITION(link->wlan_iftype > 0, "WirelessLanInterfaceTypeString",
- JSON_BUILD_STRING(nl80211_iftype_to_string(link->wlan_iftype))),
+ SD_JSON_BUILD_PAIR_CONDITION(link->wlan_iftype > 0, "WirelessLanInterfaceType",
+ SD_JSON_BUILD_UNSIGNED(link->wlan_iftype)),
+ SD_JSON_BUILD_PAIR_CONDITION(link->wlan_iftype > 0, "WirelessLanInterfaceTypeString",
+ SD_JSON_BUILD_STRING(nl80211_iftype_to_string(link->wlan_iftype))),
JSON_BUILD_PAIR_STRING_NON_EMPTY("SSID", link->ssid),
JSON_BUILD_PAIR_ETHER_ADDR_NON_NULL("BSSID", &link->bssid),
/* link state */
- JSON_BUILD_PAIR_STRING("AdministrativeState", link_state_to_string(link->state)),
- JSON_BUILD_PAIR_STRING("OperationalState", link_operstate_to_string(link->operstate)),
- JSON_BUILD_PAIR_STRING("CarrierState", link_carrier_state_to_string(link->carrier_state)),
- JSON_BUILD_PAIR_STRING("AddressState", link_address_state_to_string(link->address_state)),
- JSON_BUILD_PAIR_STRING("IPv4AddressState", link_address_state_to_string(link->ipv4_address_state)),
- JSON_BUILD_PAIR_STRING("IPv6AddressState", link_address_state_to_string(link->ipv6_address_state)),
- JSON_BUILD_PAIR_STRING("OnlineState", link_online_state_to_string(link->online_state))));
+ SD_JSON_BUILD_PAIR_STRING("AdministrativeState", link_state_to_string(link->state)),
+ SD_JSON_BUILD_PAIR_STRING("OperationalState", link_operstate_to_string(link->operstate)),
+ SD_JSON_BUILD_PAIR_STRING("CarrierState", link_carrier_state_to_string(link->carrier_state)),
+ SD_JSON_BUILD_PAIR_STRING("AddressState", link_address_state_to_string(link->address_state)),
+ SD_JSON_BUILD_PAIR_STRING("IPv4AddressState", link_address_state_to_string(link->ipv4_address_state)),
+ SD_JSON_BUILD_PAIR_STRING("IPv6AddressState", link_address_state_to_string(link->ipv6_address_state)),
+ SD_JSON_BUILD_PAIR_STRING("OnlineState", link_online_state_to_string(link->online_state))));
if (r < 0)
return r;
return 0;
}
-static int links_append_json(Manager *manager, JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int links_append_json(Manager *manager, sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_free_ Link **links = NULL;
size_t n_links = 0;
int r;
return r;
FOREACH_ARRAY(link, links, n_links) {
- _cleanup_(json_variant_unrefp) JsonVariant *e = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *e = NULL;
r = link_build_json(*link, &e);
if (r < 0)
return r;
- r = json_variant_append_array(&array, e);
+ r = sd_json_variant_append_array(&array, e);
if (r < 0)
return r;
}
return json_variant_set_field_non_null(v, "Interfaces", array);
}
-int manager_build_json(Manager *manager, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+int manager_build_json(Manager *manager, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(manager);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "json.h"
+#include "sd-json.h"
typedef struct Link Link;
typedef struct Manager Manager;
-int link_build_json(Link *link, JsonVariant **ret);
-int manager_build_json(Manager *manager, JsonVariant **ret);
+int link_build_json(Link *link, sd_json_variant **ret);
+int manager_build_json(Manager *manager, sd_json_variant **ret);
int bus_link_method_describe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *text = NULL;
Link *link = ASSERT_PTR(userdata);
int r;
if (r < 0)
return log_link_error_errno(link, r, "Failed to build JSON data: %m");
- r = json_variant_format(v, 0, &text);
+ r = sd_json_variant_format(v, 0, &text);
if (r < 0)
return log_link_error_errno(link, r, "Failed to format JSON data: %m");
static int bus_method_describe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *text = NULL;
Manager *manager = ASSERT_PTR(userdata);
int r;
if (r < 0)
return log_error_errno(r, "Failed to build JSON data: %m");
- r = json_variant_format(v, 0, &text);
+ r = sd_json_variant_format(v, 0, &text);
if (r < 0)
return log_error_errno(r, "Failed to format JSON data: %m");
#include "bus-polkit.h"
#include "fd-util.h"
+#include "json-util.h"
#include "lldp-rx-internal.h"
#include "networkd-dhcp-server.h"
#include "networkd-manager-varlink.h"
#include "varlink.h"
#include "varlink-io.systemd.Network.h"
-static int vl_method_get_states(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_states(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
return varlink_replyb(link,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("AddressState", link_address_state_to_string(m->address_state)),
- JSON_BUILD_PAIR_STRING("IPv4AddressState", link_address_state_to_string(m->ipv4_address_state)),
- JSON_BUILD_PAIR_STRING("IPv6AddressState", link_address_state_to_string(m->ipv6_address_state)),
- JSON_BUILD_PAIR_STRING("CarrierState", link_carrier_state_to_string(m->carrier_state)),
- JSON_BUILD_PAIR_CONDITION(m->online_state >= 0, "OnlineState", JSON_BUILD_STRING(link_online_state_to_string(m->online_state))),
- JSON_BUILD_PAIR_STRING("OperationalState", link_operstate_to_string(m->operational_state))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("AddressState", link_address_state_to_string(m->address_state)),
+ SD_JSON_BUILD_PAIR_STRING("IPv4AddressState", link_address_state_to_string(m->ipv4_address_state)),
+ SD_JSON_BUILD_PAIR_STRING("IPv6AddressState", link_address_state_to_string(m->ipv6_address_state)),
+ SD_JSON_BUILD_PAIR_STRING("CarrierState", link_carrier_state_to_string(m->carrier_state)),
+ SD_JSON_BUILD_PAIR_CONDITION(m->online_state >= 0, "OnlineState", SD_JSON_BUILD_STRING(link_online_state_to_string(m->online_state))),
+ SD_JSON_BUILD_PAIR_STRING("OperationalState", link_operstate_to_string(m->operational_state))));
}
-static int vl_method_get_namespace_id(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_namespace_id(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
uint64_t inode = 0;
uint32_t nsid = UINT32_MAX;
int r;
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
/* Network namespaces have two identifiers: the inode number (which all namespace types have), and
log_full_errno(r == -ENODATA ? LOG_DEBUG : LOG_WARNING, r, "Failed to query network nsid, ignoring: %m");
return varlink_replyb(link,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("NamespaceId", inode),
- JSON_BUILD_PAIR_CONDITION(nsid == UINT32_MAX, "NamespaceNSID", JSON_BUILD_NULL),
- JSON_BUILD_PAIR_CONDITION(nsid != UINT32_MAX, "NamespaceNSID", JSON_BUILD_UNSIGNED(nsid))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("NamespaceId", inode),
+ SD_JSON_BUILD_PAIR_CONDITION(nsid == UINT32_MAX, "NamespaceNSID", SD_JSON_BUILD_NULL),
+ SD_JSON_BUILD_PAIR_CONDITION(nsid != UINT32_MAX, "NamespaceNSID", SD_JSON_BUILD_UNSIGNED(nsid))));
}
typedef struct InterfaceInfo {
const char *ifname;
} InterfaceInfo;
-static int dispatch_interface(Varlink *vlink, JsonVariant *parameters, Manager *manager, Link **ret) {
- static const JsonDispatch dispatch_table[] = {
- { "InterfaceIndex", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(InterfaceInfo, ifindex), 0 },
- { "InterfaceName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(InterfaceInfo, ifname), 0 },
+static int dispatch_interface(Varlink *vlink, sd_json_variant *parameters, Manager *manager, Link **ret) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "InterfaceIndex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(InterfaceInfo, ifindex), 0 },
+ { "InterfaceName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(InterfaceInfo, ifname), 0 },
{}
};
return 0;
}
-static int link_append_lldp_neighbors(Link *link, JsonVariant *v, JsonVariant **array) {
+static int link_append_lldp_neighbors(Link *link, sd_json_variant *v, sd_json_variant **array) {
assert(link);
assert(array);
- return json_variant_append_arrayb(array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_INTEGER("InterfaceIndex", link->ifindex),
- JSON_BUILD_PAIR_STRING("InterfaceName", link->ifname),
+ return sd_json_variant_append_arrayb(array,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_INTEGER("InterfaceIndex", link->ifindex),
+ SD_JSON_BUILD_PAIR_STRING("InterfaceName", link->ifname),
JSON_BUILD_PAIR_STRV_NON_EMPTY("InterfaceAlternativeNames", link->alternative_names),
- JSON_BUILD_PAIR_CONDITION(json_variant_is_blank_array(v), "Neighbors", JSON_BUILD_EMPTY_ARRAY),
- JSON_BUILD_PAIR_CONDITION(!json_variant_is_blank_array(v), "Neighbors", JSON_BUILD_VARIANT(v))));
+ SD_JSON_BUILD_PAIR_CONDITION(sd_json_variant_is_blank_array(v), "Neighbors", SD_JSON_BUILD_EMPTY_ARRAY),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_json_variant_is_blank_array(v), "Neighbors", SD_JSON_BUILD_VARIANT(v))));
}
-static int vl_method_get_lldp_neighbors(Varlink *vlink, JsonVariant *parameters, VarlinkMethodFlags flags, Manager *manager) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+static int vl_method_get_lldp_neighbors(Varlink *vlink, sd_json_variant *parameters, VarlinkMethodFlags flags, Manager *manager) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
Link *link = NULL;
int r;
return r;
if (link) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
if (link->lldp_rx) {
r = lldp_rx_build_neighbors_json(link->lldp_rx, &v);
return r;
} else
HASHMAP_FOREACH(link, manager->links_by_index) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
if (!link->lldp_rx)
continue;
if (r < 0)
return r;
- if (json_variant_is_blank_array(v))
+ if (sd_json_variant_is_blank_array(v))
continue;
r = link_append_lldp_neighbors(link, v, &array);
}
return varlink_replyb(vlink,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(json_variant_is_blank_array(array), "Neighbors", JSON_BUILD_EMPTY_ARRAY),
- JSON_BUILD_PAIR_CONDITION(!json_variant_is_blank_array(array), "Neighbors", JSON_BUILD_VARIANT(array))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(sd_json_variant_is_blank_array(array), "Neighbors", SD_JSON_BUILD_EMPTY_ARRAY),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_json_variant_is_blank_array(array), "Neighbors", SD_JSON_BUILD_VARIANT(array))));
}
-static int vl_method_set_persistent_storage(Varlink *vlink, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "Ready", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, 0, 0 },
+static int vl_method_set_persistent_storage(Varlink *vlink, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "Ready", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, 0, 0 },
{}
};
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
-#include "nspawn-bind-user.h"
+#include "json-util.h"
#include "nspawn.h"
+#include "nspawn-bind-user.h"
#include "path-util.h"
#include "user-util.h"
#include "userdb.h"
_cleanup_(group_record_unrefp) GroupRecord *converted_group = NULL;
_cleanup_(user_record_unrefp) UserRecord *converted_user = NULL;
_cleanup_free_ char *h = NULL;
- JsonVariant *p, *hp = NULL;
+ sd_json_variant *p, *hp = NULL;
int r;
assert(u);
return log_oom();
/* Acquire the source hashed password array as-is, so that it retains the JSON_VARIANT_SENSITIVE flag */
- p = json_variant_by_key(u->json, "privileged");
+ p = sd_json_variant_by_key(u->json, "privileged");
if (p)
- hp = json_variant_by_key(p, "hashedPassword");
+ hp = sd_json_variant_by_key(p, "hashedPassword");
r = user_record_build(
&converted_user,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(u->user_name)),
- JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(allocate_uid)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(allocate_uid)),
- JSON_BUILD_PAIR_CONDITION(u->disposition >= 0, "disposition", JSON_BUILD_STRING(user_disposition_to_string(u->disposition))),
- JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_STRING(h)),
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.NSpawn")),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(u->hashed_password), "privileged", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("hashedPassword", JSON_BUILD_VARIANT(hp))))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(u->user_name)),
+ SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(allocate_uid)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(allocate_uid)),
+ SD_JSON_BUILD_PAIR_CONDITION(u->disposition >= 0, "disposition", SD_JSON_BUILD_STRING(user_disposition_to_string(u->disposition))),
+ SD_JSON_BUILD_PAIR("homeDirectory", SD_JSON_BUILD_STRING(h)),
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.NSpawn")),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(u->hashed_password), "privileged", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("hashedPassword", SD_JSON_BUILD_VARIANT(hp))))));
if (r < 0)
return log_error_errno(r, "Failed to build container user record: %m");
r = group_record_build(
&converted_group,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(g->group_name)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(allocate_uid)),
- JSON_BUILD_PAIR_CONDITION(g->disposition >= 0, "disposition", JSON_BUILD_STRING(user_disposition_to_string(g->disposition))),
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.NSpawn"))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(g->group_name)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(allocate_uid)),
+ SD_JSON_BUILD_PAIR_CONDITION(g->disposition >= 0, "disposition", SD_JSON_BUILD_STRING(user_disposition_to_string(g->disposition))),
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.NSpawn"))));
if (r < 0)
return log_error_errno(r, "Failed to build container group record: %m");
static int write_and_symlink(
const char *root,
- JsonVariant *v,
+ sd_json_variant *v,
const char *name,
uid_t uid,
const char *suffix,
assert(uid_is_valid(uid));
assert(suffix);
- r = json_variant_format(v, JSON_FORMAT_NEWLINE, &j);
+ r = sd_json_variant_format(v, SD_JSON_FORMAT_NEWLINE, &j);
if (r < 0)
return log_error_errno(r, "Failed to format user record JSON: %m");
if (r < 0)
return log_error_errno(r, "Failed to extract privileged information from group record: %m");
- if (!json_variant_is_blank_object(shadow_group->json)) {
+ if (!sd_json_variant_is_blank_object(shadow_group->json)) {
r = write_and_symlink(
root,
shadow_group->json,
if (r < 0)
return log_error_errno(r, "Failed to extract privileged information from user record: %m");
- if (!json_variant_is_blank_object(shadow_user->json)) {
+ if (!sd_json_variant_is_blank_object(shadow_user->json)) {
r = write_and_symlink(
root,
shadow_user->json,
#include <linux/oom.h>
+#include "sd-json.h"
+
#include "bus-util.h"
#include "cap-list.h"
#include "cpu-set-util.h"
#include "format-util.h"
#include "fs-util.h"
#include "hostname-util.h"
-#include "json.h"
+#include "json-util.h"
#include "missing_sched.h"
#include "nspawn-oci.h"
#include "path-util.h"
*
*/
-static int oci_unexpected(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_unexpected(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
- "Unexpected OCI element '%s' of type '%s'.", name, json_variant_type_to_string(json_variant_type(v)));
+ "Unexpected OCI element '%s' of type '%s'.", name, sd_json_variant_type_to_string(sd_json_variant_type(v)));
}
-static int oci_dispatch(JsonVariant *v, const JsonDispatch table[], JsonDispatchFlags flags, void *userdata) {
- return json_dispatch_full(v, table, oci_unexpected, flags, userdata, /* reterr_bad_field= */ NULL);
+static int oci_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, oci_unexpected, flags, userdata, /* reterr_bad_field= */ NULL);
}
-static int oci_unsupported(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_unsupported(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
return json_log(v, flags, SYNTHETIC_ERRNO(EOPNOTSUPP),
- "Unsupported OCI element '%s' of type '%s'.", name, json_variant_type_to_string(json_variant_type(v)));
+ "Unsupported OCI element '%s' of type '%s'.", name, sd_json_variant_type_to_string(sd_json_variant_type(v)));
}
-static int oci_terminal(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_terminal(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
/* If not specified, or set to true, we'll default to either an interactive or a read-only
* console. If specified as false, we'll forcibly move to "pipe" mode though. */
- s->console_mode = json_variant_boolean(v) ? _CONSOLE_MODE_INVALID : CONSOLE_PIPE;
+ s->console_mode = sd_json_variant_boolean(v) ? _CONSOLE_MODE_INVALID : CONSOLE_PIPE;
return 0;
}
-static int oci_console_dimension(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int oci_console_dimension(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
unsigned *u = ASSERT_PTR(userdata);
uint64_t k;
- k = json_variant_unsigned(variant);
+ k = sd_json_variant_unsigned(variant);
if (k == 0)
return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE),
"Console size field '%s' is too small.", strna(name));
return 0;
}
-static int oci_console_size(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_console_size(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- static const JsonDispatch table[] = {
- { "height", JSON_VARIANT_UNSIGNED, oci_console_dimension, offsetof(Settings, console_height), JSON_MANDATORY },
- { "width", JSON_VARIANT_UNSIGNED, oci_console_dimension, offsetof(Settings, console_width), JSON_MANDATORY },
+ static const sd_json_dispatch_field table[] = {
+ { "height", SD_JSON_VARIANT_UNSIGNED, oci_console_dimension, offsetof(Settings, console_height), SD_JSON_MANDATORY },
+ { "width", SD_JSON_VARIANT_UNSIGNED, oci_console_dimension, offsetof(Settings, console_width), SD_JSON_MANDATORY },
{}
};
return oci_dispatch(v, table, flags, s);
}
-static int oci_absolute_path(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- char **p = ASSERT_PTR(userdata);
- const char *n;
-
- n = json_variant_string(v);
-
- if (!path_is_absolute(n))
- return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
- "Path in JSON field '%s' is not absolute: %s", strna(name), n);
-
- return free_and_strdup_warn(p, n);
-}
-
-static int oci_env(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_env(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
char ***l = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
const char *n;
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL),
"Environment array contains non-string.");
- assert_se(n = json_variant_string(e));
+ assert_se(n = sd_json_variant_string(e));
if (!env_assignment_is_valid(n))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL),
return 0;
}
-static int oci_args(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_args(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
_cleanup_strv_free_ char **l = NULL;
char ***value = ASSERT_PTR(userdata);
int r;
- r = json_variant_strv(v, &l);
+ r = sd_json_variant_strv(v, &l);
if (r < 0)
return json_log(v, flags, r, "Cannot parse arguments as list of strings: %m");
return strv_free_and_replace(*value, l);
}
-static int oci_rlimit_type(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_rlimit_type(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
const char *z;
int *type = ASSERT_PTR(userdata);
int t;
- z = startswith(json_variant_string(v), "RLIMIT_");
+ z = startswith(sd_json_variant_string(v), "RLIMIT_");
if (!z)
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"rlimit entry's name does not begin with 'RLIMIT_', refusing: %s",
- json_variant_string(v));
+ sd_json_variant_string(v));
t = rlimit_from_string(z);
if (t < 0)
return json_log(v, flags, t,
- "rlimit name unknown: %s", json_variant_string(v));
+ "rlimit name unknown: %s", sd_json_variant_string(v));
*type = t;
return 0;
}
-static int oci_rlimit_value(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_rlimit_value(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
rlim_t *value = ASSERT_PTR(userdata);
rlim_t z;
- if (json_variant_is_negative(v))
+ if (sd_json_variant_is_negative(v))
z = RLIM_INFINITY;
else {
- if (!json_variant_is_unsigned(v))
+ if (!sd_json_variant_is_unsigned(v))
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
"rlimits limit not unsigned, refusing.");
- z = (rlim_t) json_variant_unsigned(v);
+ z = (rlim_t) sd_json_variant_unsigned(v);
- if ((uint64_t) z != json_variant_unsigned(v))
+ if ((uint64_t) z != sd_json_variant_unsigned(v))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"rlimits limit out of range, refusing.");
}
return 0;
}
-static int oci_rlimits(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_rlimits(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
.hard = RLIM_INFINITY,
};
- static const JsonDispatch table[] = {
- { "soft", JSON_VARIANT_NUMBER, oci_rlimit_value, offsetof(struct rlimit_data, soft), JSON_MANDATORY },
- { "hard", JSON_VARIANT_NUMBER, oci_rlimit_value, offsetof(struct rlimit_data, hard), JSON_MANDATORY },
- { "type", JSON_VARIANT_STRING, oci_rlimit_type, offsetof(struct rlimit_data, type), JSON_MANDATORY },
+ static const sd_json_dispatch_field table[] = {
+ { "soft", SD_JSON_VARIANT_NUMBER, oci_rlimit_value, offsetof(struct rlimit_data, soft), SD_JSON_MANDATORY },
+ { "hard", SD_JSON_VARIANT_NUMBER, oci_rlimit_value, offsetof(struct rlimit_data, hard), SD_JSON_MANDATORY },
+ { "type", SD_JSON_VARIANT_STRING, oci_rlimit_type, offsetof(struct rlimit_data, type), SD_JSON_MANDATORY },
{}
};
return 0;
}
-static int oci_capability_array(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_capability_array(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
uint64_t *mask = ASSERT_PTR(userdata);
uint64_t m = 0;
- JsonVariant *e;
+ sd_json_variant *e;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
const char *n;
int cap;
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"Entry in capabilities array is not a string.");
- assert_se(n = json_variant_string(e));
+ assert_se(n = sd_json_variant_string(e));
cap = capability_from_name(n);
if (cap < 0)
return 0;
}
-static int oci_capabilities(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_capabilities(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "effective", JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, effective) },
- { "bounding", JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, bounding) },
- { "inheritable", JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, inheritable) },
- { "permitted", JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, permitted) },
- { "ambient", JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, ambient) },
+ static const sd_json_dispatch_field table[] = {
+ { "effective", SD_JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, effective) },
+ { "bounding", SD_JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, bounding) },
+ { "inheritable", SD_JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, inheritable) },
+ { "permitted", SD_JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, permitted) },
+ { "ambient", SD_JSON_VARIANT_ARRAY, oci_capability_array, offsetof(CapabilityQuintet, ambient) },
{}
};
return 0;
}
-static int oci_oom_score_adj(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_oom_score_adj(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
int64_t k;
- k = json_variant_integer(v);
+ k = sd_json_variant_integer(v);
if (k < OOM_SCORE_ADJ_MIN || k > OOM_SCORE_ADJ_MAX)
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"oomScoreAdj value out of range: %" PRIi64, k);
return 0;
}
-static int oci_uid_gid(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- uid_t *uid = ASSERT_PTR(userdata);
- uid_t u;
- uint64_t k;
-
- assert_cc(sizeof(uid_t) == sizeof(gid_t));
-
- k = json_variant_unsigned(v);
- u = (uid_t) k;
- if ((uint64_t) u != k)
- return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
- "UID/GID out of range: %" PRIu64, k);
-
- if (!uid_is_valid(u))
- return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
- "UID/GID is not valid: " UID_FMT, u);
-
- *uid = u;
- return 0;
-}
-
-static int oci_supplementary_gids(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_supplementary_gids(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
gid_t gid, *a;
- if (!json_variant_is_unsigned(e))
+ if (!sd_json_variant_is_unsigned(e))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"Supplementary GID entry is not a UID.");
- r = oci_uid_gid(name, e, flags, &gid);
+ r = sd_json_dispatch_uid_gid(name, e, flags, &gid);
if (r < 0)
return r;
return 0;
}
-static int oci_user(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_user(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "uid", JSON_VARIANT_UNSIGNED, oci_uid_gid, offsetof(Settings, uid), JSON_MANDATORY },
- { "gid", JSON_VARIANT_UNSIGNED, oci_uid_gid, offsetof(Settings, gid), JSON_MANDATORY },
- { "additionalGids", JSON_VARIANT_ARRAY, oci_supplementary_gids, 0, 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(Settings, uid), SD_JSON_MANDATORY },
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(Settings, gid), SD_JSON_MANDATORY },
+ { "additionalGids", SD_JSON_VARIANT_ARRAY, oci_supplementary_gids, 0, 0 },
{}
};
return oci_dispatch(v, table, flags, userdata);
}
-static int oci_process(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
-
- static const JsonDispatch table[] = {
- { "terminal", JSON_VARIANT_BOOLEAN, oci_terminal, 0, 0 },
- { "consoleSize", JSON_VARIANT_OBJECT, oci_console_size, 0, 0 },
- { "cwd", JSON_VARIANT_STRING, oci_absolute_path, offsetof(Settings, working_directory), 0 },
- { "env", JSON_VARIANT_ARRAY, oci_env, offsetof(Settings, environment), 0 },
- { "args", JSON_VARIANT_ARRAY, oci_args, offsetof(Settings, parameters), 0 },
- { "rlimits", JSON_VARIANT_ARRAY, oci_rlimits, 0, 0 },
- { "apparmorProfile", JSON_VARIANT_STRING, oci_unsupported, 0, JSON_PERMISSIVE },
- { "capabilities", JSON_VARIANT_OBJECT, oci_capabilities, 0, 0 },
- { "noNewPrivileges", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(Settings, no_new_privileges), 0 },
- { "oomScoreAdj", JSON_VARIANT_INTEGER, oci_oom_score_adj, 0, 0 },
- { "selinuxLabel", JSON_VARIANT_STRING, oci_unsupported, 0, JSON_PERMISSIVE },
- { "user", JSON_VARIANT_OBJECT, oci_user, 0, 0 },
+static int oci_process(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
+
+ static const sd_json_dispatch_field table[] = {
+ { "terminal", SD_JSON_VARIANT_BOOLEAN, oci_terminal, 0, 0 },
+ { "consoleSize", SD_JSON_VARIANT_OBJECT, oci_console_size, 0, 0 },
+ { "cwd", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(Settings, working_directory), 0 },
+ { "env", SD_JSON_VARIANT_ARRAY, oci_env, offsetof(Settings, environment), 0 },
+ { "args", SD_JSON_VARIANT_ARRAY, oci_args, offsetof(Settings, parameters), 0 },
+ { "rlimits", SD_JSON_VARIANT_ARRAY, oci_rlimits, 0, 0 },
+ { "apparmorProfile", SD_JSON_VARIANT_STRING, oci_unsupported, 0, SD_JSON_PERMISSIVE },
+ { "capabilities", SD_JSON_VARIANT_OBJECT, oci_capabilities, 0, 0 },
+ { "noNewPrivileges", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(Settings, no_new_privileges), 0 },
+ { "oomScoreAdj", SD_JSON_VARIANT_INTEGER, oci_oom_score_adj, 0, 0 },
+ { "selinuxLabel", SD_JSON_VARIANT_STRING, oci_unsupported, 0, SD_JSON_PERMISSIVE },
+ { "user", SD_JSON_VARIANT_OBJECT, oci_user, 0, 0 },
{}
};
return oci_dispatch(v, table, flags, userdata);
}
-static int oci_root(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_root(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
int r;
- static const JsonDispatch table[] = {
- { "path", JSON_VARIANT_STRING, json_dispatch_string, offsetof(Settings, root) },
- { "readonly", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(Settings, read_only) },
+ static const sd_json_dispatch_field table[] = {
+ { "path", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(Settings, root) },
+ { "readonly", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(Settings, read_only) },
{}
};
return 0;
}
-static int oci_hostname(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_hostname(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
const char *n;
- assert_se(n = json_variant_string(v));
+ assert_se(n = sd_json_variant_string(v));
if (!hostname_is_valid(n, 0))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
strv_free(data->options);
}
-static int oci_mounts(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_mounts(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
- static const JsonDispatch table[] = {
- { "destination", JSON_VARIANT_STRING, oci_absolute_path, offsetof(oci_mount_data, destination), JSON_MANDATORY },
- { "source", JSON_VARIANT_STRING, json_dispatch_string, offsetof(oci_mount_data, source), 0 },
- { "options", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(oci_mount_data, options), 0, },
- { "type", JSON_VARIANT_STRING, json_dispatch_string, offsetof(oci_mount_data, type), 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "destination", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(oci_mount_data, destination), SD_JSON_MANDATORY },
+ { "source", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(oci_mount_data, source), 0 },
+ { "options", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(oci_mount_data, options), 0, },
+ { "type", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(oci_mount_data, type), 0 },
{}
};
return 0;
}
-static int oci_namespace_type(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_namespace_type(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
unsigned long *nsflags = ASSERT_PTR(userdata);
const char *n;
- assert_se(n = json_variant_string(v));
+ assert_se(n = sd_json_variant_string(v));
/* We don't use namespace_flags_from_string() here, as the OCI spec uses slightly different names than the
* kernel here. */
free(data->path);
}
-static int oci_namespaces(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_namespaces(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
unsigned long n = 0;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
_cleanup_(namespace_data_done) struct namespace_data data = {};
- static const JsonDispatch table[] = {
- { "type", JSON_VARIANT_STRING, oci_namespace_type, offsetof(struct namespace_data, type), JSON_MANDATORY },
- { "path", JSON_VARIANT_STRING, oci_absolute_path, offsetof(struct namespace_data, path), 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "type", SD_JSON_VARIANT_STRING, oci_namespace_type, offsetof(struct namespace_data, type), SD_JSON_MANDATORY },
+ { "path", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(struct namespace_data, path), 0 },
{}
};
return 0;
}
-static int oci_uid_gid_range(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_uid_gid_range(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
uid_t *uid = ASSERT_PTR(userdata);
uid_t u;
uint64_t k;
* than a specific UID, and hence UID_INVALID has no special significance. OTOH a range of zero makes no
* sense. */
- k = json_variant_unsigned(v);
+ k = sd_json_variant_unsigned(v);
u = (uid_t) k;
if ((uint64_t) u != k)
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
return 0;
}
-static int oci_uid_gid_mappings(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_uid_gid_mappings(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
struct mapping_data {
uid_t host_id;
uid_t container_id;
.range = 0,
};
- static const JsonDispatch table[] = {
- { "containerID", JSON_VARIANT_UNSIGNED, oci_uid_gid, offsetof(struct mapping_data, container_id), JSON_MANDATORY },
- { "hostID", JSON_VARIANT_UNSIGNED, oci_uid_gid, offsetof(struct mapping_data, host_id), JSON_MANDATORY },
- { "size", JSON_VARIANT_UNSIGNED, oci_uid_gid_range, offsetof(struct mapping_data, range), JSON_MANDATORY },
+ static const sd_json_dispatch_field table[] = {
+ { "containerID", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(struct mapping_data, container_id), SD_JSON_MANDATORY },
+ { "hostID", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(struct mapping_data, host_id), SD_JSON_MANDATORY },
+ { "size", SD_JSON_VARIANT_UNSIGNED, oci_uid_gid_range, offsetof(struct mapping_data, range), SD_JSON_MANDATORY },
{}
};
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
- if (json_variant_elements(v) == 0)
+ if (sd_json_variant_elements(v) == 0)
return 0;
- if (json_variant_elements(v) > 1)
+ if (sd_json_variant_elements(v) > 1)
return json_log(v, flags, SYNTHETIC_ERRNO(EOPNOTSUPP),
"UID/GID mappings with more than one entry are not supported.");
- assert_se(e = json_variant_by_index(v, 0));
+ assert_se(e = sd_json_variant_by_index(v, 0));
r = oci_dispatch(e, table, flags, &data);
if (r < 0)
"UID/GID mappings with a non-zero container base are not supported.");
if (data.range < 0x10000)
- json_log(v, flags|JSON_WARNING, 0,
+ json_log(v, flags|SD_JSON_WARNING, 0,
"UID/GID mapping with less than 65536 UID/GIDS set up, you are looking for trouble.");
if (s->uid_range != UID_INVALID &&
return 0;
}
-static int oci_device_type(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_device_type(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
mode_t *mode = ASSERT_PTR(userdata);
const char *t;
- assert_se(t = json_variant_string(v));
+ assert_se(t = sd_json_variant_string(v));
if (STR_IN_SET(t, "c", "u"))
*mode = (*mode & ~S_IFMT) | S_IFCHR;
return 0;
}
-static int oci_device_major(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_device_major(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
unsigned *u = ASSERT_PTR(userdata);
uint64_t k;
- k = json_variant_unsigned(v);
+ k = sd_json_variant_unsigned(v);
if (!DEVICE_MAJOR_VALID(k))
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
"Device major %" PRIu64 " out of range.", k);
return 0;
}
-static int oci_device_minor(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_device_minor(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
unsigned *u = ASSERT_PTR(userdata);
uint64_t k;
- k = json_variant_unsigned(v);
+ k = sd_json_variant_unsigned(v);
if (!DEVICE_MINOR_VALID(k))
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
"Device minor %" PRIu64 " out of range.", k);
return 0;
}
-static int oci_device_file_mode(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_device_file_mode(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
mode_t *mode = ASSERT_PTR(userdata);
mode_t m;
uint64_t k;
- k = json_variant_unsigned(v);
+ k = sd_json_variant_unsigned(v);
m = (mode_t) k;
if ((m & ~07777) != 0 || (uint64_t) m != k)
return 0;
}
-static int oci_devices(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_devices(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
- static const JsonDispatch table[] = {
- { "type", JSON_VARIANT_STRING, oci_device_type, offsetof(DeviceNode, mode), JSON_MANDATORY },
- { "path", JSON_VARIANT_STRING, oci_absolute_path, offsetof(DeviceNode, path), JSON_MANDATORY },
- { "major", JSON_VARIANT_UNSIGNED, oci_device_major, offsetof(DeviceNode, major), 0 },
- { "minor", JSON_VARIANT_UNSIGNED, oci_device_minor, offsetof(DeviceNode, minor), 0 },
- { "fileMode", JSON_VARIANT_UNSIGNED, oci_device_file_mode, offsetof(DeviceNode, mode), 0 },
- { "uid", JSON_VARIANT_UNSIGNED, oci_uid_gid, offsetof(DeviceNode, uid), 0 },
- { "gid", JSON_VARIANT_UNSIGNED, oci_uid_gid, offsetof(DeviceNode, gid), 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "type", SD_JSON_VARIANT_STRING, oci_device_type, offsetof(DeviceNode, mode), SD_JSON_MANDATORY },
+ { "path", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(DeviceNode, path), SD_JSON_MANDATORY },
+ { "major", SD_JSON_VARIANT_UNSIGNED, oci_device_major, offsetof(DeviceNode, major), 0 },
+ { "minor", SD_JSON_VARIANT_UNSIGNED, oci_device_minor, offsetof(DeviceNode, minor), 0 },
+ { "fileMode", SD_JSON_VARIANT_UNSIGNED, oci_device_file_mode, offsetof(DeviceNode, mode), 0 },
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(DeviceNode, uid), 0 },
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(DeviceNode, gid), 0 },
{}
};
/* Suppress a couple of implicit device nodes */
r = devname_from_devnum(node->mode, makedev(node->major, node->minor), &path);
if (r < 0)
- json_log(e, flags|JSON_DEBUG, r, "Failed to resolve device node %u:%u, ignoring: %m", node->major, node->minor);
+ json_log(e, flags|SD_JSON_DEBUG, r, "Failed to resolve device node %u:%u, ignoring: %m", node->major, node->minor);
else {
if (PATH_IN_SET(path,
"/dev/null",
"/dev/pts/ptmx",
"/dev/console")) {
- json_log(e, flags|JSON_DEBUG, 0, "Ignoring devices item for device '%s', as it is implicitly created anyway.", path);
+ json_log(e, flags|SD_JSON_DEBUG, 0, "Ignoring devices item for device '%s', as it is implicitly created anyway.", path);
free(node->path);
continue;
}
return 0;
}
-static int oci_cgroups_path(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroups_path(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
_cleanup_free_ char *slice = NULL, *backwards = NULL;
Settings *s = ASSERT_PTR(userdata);
const char *p;
int r;
- assert_se(p = json_variant_string(v));
+ assert_se(p = sd_json_variant_string(v));
r = cg_path_get_slice(p, &slice);
if (r < 0)
return 0;
}
-static int oci_cgroup_device_type(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_device_type(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
mode_t *mode = ASSERT_PTR(userdata);
const char *n;
- assert_se(n = json_variant_string(v));
+ assert_se(n = sd_json_variant_string(v));
if (streq(n, "c"))
*mode = S_IFCHR;
unsigned minor;
};
-static int oci_cgroup_device_access(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_device_access(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
struct device_data *d = ASSERT_PTR(userdata);
bool r = false, w = false, m = false;
const char *s;
size_t i;
- assert_se(s = json_variant_string(v));
+ assert_se(s = sd_json_variant_string(v));
for (i = 0; s[i]; i++)
if (s[i] == 'r')
return 0;
}
-static int oci_cgroup_devices(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_devices(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
_cleanup_free_ struct device_data *list = NULL;
Settings *s = ASSERT_PTR(userdata);
size_t n_list = 0, i;
bool noop = false;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
.minor = UINT_MAX,
}, *a;
- static const JsonDispatch table[] = {
- { "allow", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct device_data, allow), JSON_MANDATORY },
- { "type", JSON_VARIANT_STRING, oci_cgroup_device_type, offsetof(struct device_data, type), 0 },
- { "major", JSON_VARIANT_UNSIGNED, oci_device_major, offsetof(struct device_data, major), 0 },
- { "minor", JSON_VARIANT_UNSIGNED, oci_device_minor, offsetof(struct device_data, minor), 0 },
- { "access", JSON_VARIANT_STRING, oci_cgroup_device_access, 0, 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "allow", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct device_data, allow), SD_JSON_MANDATORY },
+ { "type", SD_JSON_VARIANT_STRING, oci_cgroup_device_type, offsetof(struct device_data, type), 0 },
+ { "major", SD_JSON_VARIANT_UNSIGNED, oci_device_major, offsetof(struct device_data, major), 0 },
+ { "minor", SD_JSON_VARIANT_UNSIGNED, oci_device_minor, offsetof(struct device_data, minor), 0 },
+ { "access", SD_JSON_VARIANT_STRING, oci_cgroup_device_access, 0, 0 },
{}
};
* drop the kernel's default we ignore silently */
if (!data.r || !data.w || !data.m || data.type != 0 || data.major != UINT_MAX || data.minor != UINT_MAX)
- json_log(v, flags|JSON_WARNING, 0, "Devices cgroup allow list with arbitrary 'allow' entries not supported, ignoring.");
+ json_log(v, flags|SD_JSON_WARNING, 0, "Devices cgroup allow list with arbitrary 'allow' entries not supported, ignoring.");
/* We ignore the 'deny' entry as for us that's implied */
continue;
return 0;
}
-static int oci_cgroup_memory_limit(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_memory_limit(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
uint64_t *m = ASSERT_PTR(userdata);
uint64_t k;
- if (json_variant_is_negative(v)) {
+ if (sd_json_variant_is_negative(v)) {
*m = UINT64_MAX;
return 0;
}
- if (!json_variant_is_unsigned(v))
+ if (!sd_json_variant_is_unsigned(v))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"Memory limit is not an unsigned integer.");
- k = json_variant_unsigned(v);
+ k = sd_json_variant_unsigned(v);
if (k >= UINT64_MAX)
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
"Memory limit too large: %" PRIu64, k);
return 0;
}
-static int oci_cgroup_memory(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_memory(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
struct memory_data {
uint64_t limit;
.swap = UINT64_MAX,
};
- static const JsonDispatch table[] = {
- { "limit", JSON_VARIANT_NUMBER, oci_cgroup_memory_limit, offsetof(struct memory_data, limit), 0 },
- { "reservation", JSON_VARIANT_NUMBER, oci_cgroup_memory_limit, offsetof(struct memory_data, reservation), 0 },
- { "swap", JSON_VARIANT_NUMBER, oci_cgroup_memory_limit, offsetof(struct memory_data, swap), 0 },
- { "kernel", JSON_VARIANT_NUMBER, oci_unsupported, 0, JSON_PERMISSIVE },
- { "kernelTCP", JSON_VARIANT_NUMBER, oci_unsupported, 0, JSON_PERMISSIVE },
- { "swapiness", JSON_VARIANT_NUMBER, oci_unsupported, 0, JSON_PERMISSIVE },
- { "disableOOMKiller", JSON_VARIANT_BOOLEAN, oci_unsupported, 0, JSON_PERMISSIVE },
+ static const sd_json_dispatch_field table[] = {
+ { "limit", SD_JSON_VARIANT_NUMBER, oci_cgroup_memory_limit, offsetof(struct memory_data, limit), 0 },
+ { "reservation", SD_JSON_VARIANT_NUMBER, oci_cgroup_memory_limit, offsetof(struct memory_data, reservation), 0 },
+ { "swap", SD_JSON_VARIANT_NUMBER, oci_cgroup_memory_limit, offsetof(struct memory_data, swap), 0 },
+ { "kernel", SD_JSON_VARIANT_NUMBER, oci_unsupported, 0, SD_JSON_PERMISSIVE },
+ { "kernelTCP", SD_JSON_VARIANT_NUMBER, oci_unsupported, 0, SD_JSON_PERMISSIVE },
+ { "swapiness", SD_JSON_VARIANT_NUMBER, oci_unsupported, 0, SD_JSON_PERMISSIVE },
+ { "disableOOMKiller", SD_JSON_VARIANT_BOOLEAN, oci_unsupported, 0, SD_JSON_PERMISSIVE },
{}
};
CPUSet cpu_set;
};
-static int oci_cgroup_cpu_shares(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_cpu_shares(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
uint64_t *u = ASSERT_PTR(userdata);
uint64_t k;
- k = json_variant_unsigned(v);
+ k = sd_json_variant_unsigned(v);
if (k < CGROUP_CPU_SHARES_MIN || k > CGROUP_CPU_SHARES_MAX)
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
"shares value out of range.");
return 0;
}
-static int oci_cgroup_cpu_quota(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_cpu_quota(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
uint64_t *u = ASSERT_PTR(userdata);
uint64_t k;
- k = json_variant_unsigned(v);
+ k = sd_json_variant_unsigned(v);
if (k <= 0 || k >= UINT64_MAX)
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
"period/quota value out of range.");
return 0;
}
-static int oci_cgroup_cpu_cpus(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_cpu_cpus(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
struct cpu_data *data = ASSERT_PTR(userdata);
CPUSet set;
const char *n;
int r;
- assert_se(n = json_variant_string(v));
+ assert_se(n = sd_json_variant_string(v));
r = parse_cpu_set(n, &set);
if (r < 0)
return 0;
}
-static int oci_cgroup_cpu(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_cpu(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "shares", JSON_VARIANT_UNSIGNED, oci_cgroup_cpu_shares, offsetof(struct cpu_data, shares), 0 },
- { "quota", JSON_VARIANT_UNSIGNED, oci_cgroup_cpu_quota, offsetof(struct cpu_data, quota), 0 },
- { "period", JSON_VARIANT_UNSIGNED, oci_cgroup_cpu_quota, offsetof(struct cpu_data, period), 0 },
- { "realtimeRuntime", JSON_VARIANT_UNSIGNED, oci_unsupported, 0, 0 },
- { "realtimePeriod", JSON_VARIANT_UNSIGNED, oci_unsupported, 0, 0 },
- { "cpus", JSON_VARIANT_STRING, oci_cgroup_cpu_cpus, 0, 0 },
- { "mems", JSON_VARIANT_STRING, oci_unsupported, 0, 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "shares", SD_JSON_VARIANT_UNSIGNED, oci_cgroup_cpu_shares, offsetof(struct cpu_data, shares), 0 },
+ { "quota", SD_JSON_VARIANT_UNSIGNED, oci_cgroup_cpu_quota, offsetof(struct cpu_data, quota), 0 },
+ { "period", SD_JSON_VARIANT_UNSIGNED, oci_cgroup_cpu_quota, offsetof(struct cpu_data, period), 0 },
+ { "realtimeRuntime", SD_JSON_VARIANT_UNSIGNED, oci_unsupported, 0, 0 },
+ { "realtimePeriod", SD_JSON_VARIANT_UNSIGNED, oci_unsupported, 0, 0 },
+ { "cpus", SD_JSON_VARIANT_STRING, oci_cgroup_cpu_cpus, 0, 0 },
+ { "mems", SD_JSON_VARIANT_STRING, oci_unsupported, 0, 0 },
{}
};
return 0;
}
-static int oci_cgroup_block_io_weight(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_block_io_weight(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
uint64_t k;
int r;
- k = json_variant_unsigned(v);
+ k = sd_json_variant_unsigned(v);
if (k < CGROUP_BLKIO_WEIGHT_MIN || k > CGROUP_BLKIO_WEIGHT_MAX)
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
"Block I/O weight out of range.");
return 0;
}
-static int oci_cgroup_block_io_weight_device(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_block_io_weight_device(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
.weight = UINT64_MAX,
};
- static const JsonDispatch table[] = {
- { "major", JSON_VARIANT_UNSIGNED, oci_device_major, offsetof(struct device_data, major), JSON_MANDATORY },
- { "minor", JSON_VARIANT_UNSIGNED, oci_device_minor, offsetof(struct device_data, minor), JSON_MANDATORY },
- { "weight", JSON_VARIANT_UNSIGNED, json_dispatch_uint64, offsetof(struct device_data, weight), 0 },
- { "leafWeight", JSON_VARIANT_INTEGER, oci_unsupported, 0, JSON_PERMISSIVE },
+ static const sd_json_dispatch_field table[] = {
+ { "major", SD_JSON_VARIANT_UNSIGNED, oci_device_major, offsetof(struct device_data, major), SD_JSON_MANDATORY },
+ { "minor", SD_JSON_VARIANT_UNSIGNED, oci_device_minor, offsetof(struct device_data, minor), SD_JSON_MANDATORY },
+ { "weight", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint64, offsetof(struct device_data, weight), 0 },
+ { "leafWeight", SD_JSON_VARIANT_INTEGER, oci_unsupported, 0, SD_JSON_PERMISSIVE },
{}
};
return 0;
}
-static int oci_cgroup_block_io_throttle(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_block_io_throttle(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
const char *pname;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
pname = streq(name, "throttleReadBpsDevice") ? "IOReadBandwidthMax" :
.minor = UINT_MAX,
};
- static const JsonDispatch table[] = {
- { "major", JSON_VARIANT_UNSIGNED, oci_device_major, offsetof(struct device_data, major), JSON_MANDATORY },
- { "minor", JSON_VARIANT_UNSIGNED, oci_device_minor, offsetof(struct device_data, minor), JSON_MANDATORY },
- { "rate", JSON_VARIANT_UNSIGNED, json_dispatch_uint64, offsetof(struct device_data, rate), JSON_MANDATORY },
+ static const sd_json_dispatch_field table[] = {
+ { "major", SD_JSON_VARIANT_UNSIGNED, oci_device_major, offsetof(struct device_data, major), SD_JSON_MANDATORY },
+ { "minor", SD_JSON_VARIANT_UNSIGNED, oci_device_minor, offsetof(struct device_data, minor), SD_JSON_MANDATORY },
+ { "rate", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint64, offsetof(struct device_data, rate), SD_JSON_MANDATORY },
{}
};
return 0;
}
-static int oci_cgroup_block_io(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_block_io(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "weight", JSON_VARIANT_UNSIGNED, oci_cgroup_block_io_weight, 0, 0 },
- { "leafWeight", JSON_VARIANT_UNSIGNED, oci_unsupported, 0, JSON_PERMISSIVE },
- { "weightDevice", JSON_VARIANT_ARRAY, oci_cgroup_block_io_weight_device, 0, 0 },
- { "throttleReadBpsDevice", JSON_VARIANT_ARRAY, oci_cgroup_block_io_throttle, 0, 0 },
- { "throttleWriteBpsDevice", JSON_VARIANT_ARRAY, oci_cgroup_block_io_throttle, 0, 0 },
- { "throttleReadIOPSDevice", JSON_VARIANT_ARRAY, oci_cgroup_block_io_throttle, 0, 0 },
- { "throttleWriteIOPSDevice", JSON_VARIANT_ARRAY, oci_cgroup_block_io_throttle, 0, 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "weight", SD_JSON_VARIANT_UNSIGNED, oci_cgroup_block_io_weight, 0, 0 },
+ { "leafWeight", SD_JSON_VARIANT_UNSIGNED, oci_unsupported, 0, SD_JSON_PERMISSIVE },
+ { "weightDevice", SD_JSON_VARIANT_ARRAY, oci_cgroup_block_io_weight_device, 0, 0 },
+ { "throttleReadBpsDevice", SD_JSON_VARIANT_ARRAY, oci_cgroup_block_io_throttle, 0, 0 },
+ { "throttleWriteBpsDevice", SD_JSON_VARIANT_ARRAY, oci_cgroup_block_io_throttle, 0, 0 },
+ { "throttleReadIOPSDevice", SD_JSON_VARIANT_ARRAY, oci_cgroup_block_io_throttle, 0, 0 },
+ { "throttleWriteIOPSDevice", SD_JSON_VARIANT_ARRAY, oci_cgroup_block_io_throttle, 0, 0 },
{}
};
return oci_dispatch(v, table, flags, userdata);
}
-static int oci_cgroup_pids(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_cgroup_pids(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "limit", JSON_VARIANT_NUMBER, json_dispatch_variant, 0, JSON_MANDATORY },
+ static const sd_json_dispatch_field table[] = {
+ { "limit", SD_JSON_VARIANT_NUMBER, sd_json_dispatch_variant, 0, SD_JSON_MANDATORY },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *k = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *k = NULL;
Settings *s = ASSERT_PTR(userdata);
uint64_t m;
int r;
if (r < 0)
return r;
- if (json_variant_is_negative(k))
+ if (sd_json_variant_is_negative(k))
m = UINT64_MAX;
else {
- if (!json_variant_is_unsigned(k))
+ if (!sd_json_variant_is_unsigned(k))
return json_log(k, flags, SYNTHETIC_ERRNO(EINVAL),
"pids limit not unsigned integer, refusing.");
- m = (uint64_t) json_variant_unsigned(k);
+ m = (uint64_t) sd_json_variant_unsigned(k);
- if ((uint64_t) m != json_variant_unsigned(k))
+ if ((uint64_t) m != sd_json_variant_unsigned(k))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"pids limit out of range, refusing.");
}
return 0;
}
-static int oci_resources(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_resources(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "devices", JSON_VARIANT_ARRAY, oci_cgroup_devices, 0, 0 },
- { "memory", JSON_VARIANT_OBJECT, oci_cgroup_memory, 0, 0 },
- { "cpu", JSON_VARIANT_OBJECT, oci_cgroup_cpu, 0, 0 },
- { "blockIO", JSON_VARIANT_OBJECT, oci_cgroup_block_io, 0, 0 },
- { "hugepageLimits", JSON_VARIANT_ARRAY, oci_unsupported, 0, 0 },
- { "network", JSON_VARIANT_OBJECT, oci_unsupported, 0, 0 },
- { "pids", JSON_VARIANT_OBJECT, oci_cgroup_pids, 0, 0 },
- { "rdma", JSON_VARIANT_OBJECT, oci_unsupported, 0, 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "devices", SD_JSON_VARIANT_ARRAY, oci_cgroup_devices, 0, 0 },
+ { "memory", SD_JSON_VARIANT_OBJECT, oci_cgroup_memory, 0, 0 },
+ { "cpu", SD_JSON_VARIANT_OBJECT, oci_cgroup_cpu, 0, 0 },
+ { "blockIO", SD_JSON_VARIANT_OBJECT, oci_cgroup_block_io, 0, 0 },
+ { "hugepageLimits", SD_JSON_VARIANT_ARRAY, oci_unsupported, 0, 0 },
+ { "network", SD_JSON_VARIANT_OBJECT, oci_unsupported, 0, 0 },
+ { "pids", SD_JSON_VARIANT_OBJECT, oci_cgroup_pids, 0, 0 },
+ { "rdma", SD_JSON_VARIANT_OBJECT, oci_unsupported, 0, 0 },
{}
};
return true;
}
-static int oci_sysctl(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_sysctl(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *w;
+ sd_json_variant *w;
const char *k;
int r;
JSON_VARIANT_OBJECT_FOREACH(k, w, v) {
const char *m;
- if (!json_variant_is_string(w))
+ if (!sd_json_variant_is_string(w))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"sysctl parameter is not a string, refusing.");
- assert_se(m = json_variant_string(w));
+ assert_se(m = sd_json_variant_string(w));
if (!sysctl_key_valid(k))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
return -EINVAL;
}
-static int oci_seccomp_archs(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_seccomp_archs(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
scmp_filter_ctx *sc = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
uint32_t a;
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL),
"Architecture entry is not a string.");
- r = oci_seccomp_arch_from_string(json_variant_string(e), &a);
+ r = oci_seccomp_arch_from_string(sd_json_variant_string(e), &a);
if (r < 0)
- return json_log(e, flags, r, "Unknown architecture: %s", json_variant_string(e));
+ return json_log(e, flags, r, "Unknown architecture: %s", sd_json_variant_string(e));
r = seccomp_arch_add(sc, a);
if (r == -EEXIST)
free(rule->arguments);
};
-static int oci_seccomp_action(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_seccomp_action(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
uint32_t *action = ASSERT_PTR(userdata);
int r;
- r = oci_seccomp_action_from_string(json_variant_string(v), action);
+ r = oci_seccomp_action_from_string(sd_json_variant_string(v), action);
if (r < 0)
- return json_log(v, flags, r, "Unknown system call action '%s': %m", json_variant_string(v));
+ return json_log(v, flags, r, "Unknown system call action '%s': %m", sd_json_variant_string(v));
return 0;
}
-static int oci_seccomp_op(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_seccomp_op(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
enum scmp_compare *op = ASSERT_PTR(userdata);
int r;
- r = oci_seccomp_compare_from_string(json_variant_string(v), op);
+ r = oci_seccomp_compare_from_string(sd_json_variant_string(v), op);
if (r < 0)
- return json_log(v, flags, r, "Unknown seccomp operator '%s': %m", json_variant_string(v));
+ return json_log(v, flags, r, "Unknown seccomp operator '%s': %m", sd_json_variant_string(v));
return 0;
}
-static int oci_seccomp_args(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_seccomp_args(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
struct syscall_rule *rule = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
- static const struct JsonDispatch table[] = {
- { "index", JSON_VARIANT_UNSIGNED, json_dispatch_uint32, offsetof(struct scmp_arg_cmp, arg), JSON_MANDATORY },
- { "value", JSON_VARIANT_UNSIGNED, json_dispatch_uint64, offsetof(struct scmp_arg_cmp, datum_a), JSON_MANDATORY },
- { "valueTwo", JSON_VARIANT_UNSIGNED, json_dispatch_uint64, offsetof(struct scmp_arg_cmp, datum_b), 0 },
- { "op", JSON_VARIANT_STRING, oci_seccomp_op, offsetof(struct scmp_arg_cmp, op), JSON_MANDATORY },
+ static const struct sd_json_dispatch_field table[] = {
+ { "index", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint32, offsetof(struct scmp_arg_cmp, arg), SD_JSON_MANDATORY },
+ { "value", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint64, offsetof(struct scmp_arg_cmp, datum_a), SD_JSON_MANDATORY },
+ { "valueTwo", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint64, offsetof(struct scmp_arg_cmp, datum_b), 0 },
+ { "op", SD_JSON_VARIANT_STRING, oci_seccomp_op, offsetof(struct scmp_arg_cmp, op), SD_JSON_MANDATORY },
{},
};
expected = p->op == SCMP_CMP_MASKED_EQ ? 4 : 3;
if (r != expected)
- json_log(e, flags|JSON_WARNING, 0, "Wrong number of system call arguments for JSON data, ignoring.");
+ json_log(e, flags|SD_JSON_WARNING, 0, "Wrong number of system call arguments for JSON data, ignoring.");
/* Note that we are a bit sloppy here and do not insist that SCMP_CMP_MASKED_EQ gets two datum values,
* and the other only one. That's because buildah for example by default calls things with
return 0;
}
-static int oci_seccomp_syscalls(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_seccomp_syscalls(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
scmp_filter_ctx *sc = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
- static const JsonDispatch table[] = {
- { "names", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(struct syscall_rule, names), JSON_MANDATORY },
- { "action", JSON_VARIANT_STRING, oci_seccomp_action, offsetof(struct syscall_rule, action), JSON_MANDATORY },
- { "args", JSON_VARIANT_ARRAY, oci_seccomp_args, 0, 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "names", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(struct syscall_rule, names), SD_JSON_MANDATORY },
+ { "action", SD_JSON_VARIANT_STRING, oci_seccomp_action, offsetof(struct syscall_rule, action), SD_JSON_MANDATORY },
+ { "args", SD_JSON_VARIANT_ARRAY, oci_seccomp_args, 0, 0 },
{}
};
_cleanup_(syscall_rule_done) struct syscall_rule rule = {
}
#endif
-static int oci_seccomp(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_seccomp(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
#if HAVE_SECCOMP
- static const JsonDispatch table[] = {
- { "defaultAction", JSON_VARIANT_STRING, NULL, 0, JSON_MANDATORY },
- { "architectures", JSON_VARIANT_ARRAY, oci_seccomp_archs, 0, 0 },
- { "syscalls", JSON_VARIANT_ARRAY, oci_seccomp_syscalls, 0, 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "defaultAction", SD_JSON_VARIANT_STRING, NULL, 0, SD_JSON_MANDATORY },
+ { "architectures", SD_JSON_VARIANT_ARRAY, oci_seccomp_archs, 0, 0 },
+ { "syscalls", SD_JSON_VARIANT_ARRAY, oci_seccomp_syscalls, 0, 0 },
{}
};
_cleanup_(seccomp_releasep) scmp_filter_ctx sc = NULL;
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *def;
+ sd_json_variant *def;
uint32_t d;
int r;
- def = json_variant_by_key(v, "defaultAction");
+ def = sd_json_variant_by_key(v, "defaultAction");
if (!def)
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL), "defaultAction element missing.");
- if (!json_variant_is_string(def))
+ if (!sd_json_variant_is_string(def))
return json_log(def, flags, SYNTHETIC_ERRNO(EINVAL), "defaultAction is not a string.");
- r = oci_seccomp_action_from_string(json_variant_string(def), &d);
+ r = oci_seccomp_action_from_string(sd_json_variant_string(def), &d);
if (r < 0)
- return json_log(def, flags, r, "Unknown default action: %s", json_variant_string(def));
+ return json_log(def, flags, r, "Unknown default action: %s", sd_json_variant_string(def));
sc = seccomp_init(d);
if (!sc)
#endif
}
-static int oci_rootfs_propagation(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_rootfs_propagation(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
const char *s;
- s = json_variant_string(v);
+ s = sd_json_variant_string(v);
if (streq(s, "shared"))
return 0;
- json_log(v, flags|JSON_DEBUG, 0, "Ignoring rootfsPropagation setting '%s'.", s);
+ json_log(v, flags|SD_JSON_DEBUG, 0, "Ignoring rootfsPropagation setting '%s'.", s);
return 0;
}
-static int oci_masked_paths(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_masked_paths(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
_cleanup_free_ char *destination = NULL;
CustomMount *m;
const char *p;
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"Path is not a string, refusing.");
- assert_se(p = json_variant_string(e));
+ assert_se(p = sd_json_variant_string(e));
if (!path_is_absolute(p))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
return 0;
}
-static int oci_readonly_paths(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_readonly_paths(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
_cleanup_free_ char *source = NULL, *destination = NULL;
CustomMount *m;
const char *p;
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"Path is not a string, refusing.");
- assert_se(p = json_variant_string(e));
+ assert_se(p = sd_json_variant_string(e));
if (!path_is_absolute(p))
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
return 0;
}
-static int oci_linux(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
-
- static const JsonDispatch table[] = {
- { "namespaces", JSON_VARIANT_ARRAY, oci_namespaces, 0, 0 },
- { "uidMappings", JSON_VARIANT_ARRAY, oci_uid_gid_mappings, 0, 0 },
- { "gidMappings", JSON_VARIANT_ARRAY, oci_uid_gid_mappings, 0, 0 },
- { "devices", JSON_VARIANT_ARRAY, oci_devices, 0, 0 },
- { "cgroupsPath", JSON_VARIANT_STRING, oci_cgroups_path, 0, 0 },
- { "resources", JSON_VARIANT_OBJECT, oci_resources, 0, 0 },
- { "intelRdt", JSON_VARIANT_OBJECT, oci_unsupported, 0, JSON_PERMISSIVE },
- { "sysctl", JSON_VARIANT_OBJECT, oci_sysctl, 0, 0 },
- { "seccomp", JSON_VARIANT_OBJECT, oci_seccomp, 0, 0 },
- { "rootfsPropagation", JSON_VARIANT_STRING, oci_rootfs_propagation, 0, 0 },
- { "maskedPaths", JSON_VARIANT_ARRAY, oci_masked_paths, 0, 0 },
- { "readonlyPaths", JSON_VARIANT_ARRAY, oci_readonly_paths, 0, 0 },
- { "mountLabel", JSON_VARIANT_STRING, oci_unsupported, 0, JSON_PERMISSIVE },
+static int oci_linux(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
+
+ static const sd_json_dispatch_field table[] = {
+ { "namespaces", SD_JSON_VARIANT_ARRAY, oci_namespaces, 0, 0 },
+ { "uidMappings", SD_JSON_VARIANT_ARRAY, oci_uid_gid_mappings, 0, 0 },
+ { "gidMappings", SD_JSON_VARIANT_ARRAY, oci_uid_gid_mappings, 0, 0 },
+ { "devices", SD_JSON_VARIANT_ARRAY, oci_devices, 0, 0 },
+ { "cgroupsPath", SD_JSON_VARIANT_STRING, oci_cgroups_path, 0, 0 },
+ { "resources", SD_JSON_VARIANT_OBJECT, oci_resources, 0, 0 },
+ { "intelRdt", SD_JSON_VARIANT_OBJECT, oci_unsupported, 0, SD_JSON_PERMISSIVE },
+ { "sysctl", SD_JSON_VARIANT_OBJECT, oci_sysctl, 0, 0 },
+ { "seccomp", SD_JSON_VARIANT_OBJECT, oci_seccomp, 0, 0 },
+ { "rootfsPropagation", SD_JSON_VARIANT_STRING, oci_rootfs_propagation, 0, 0 },
+ { "maskedPaths", SD_JSON_VARIANT_ARRAY, oci_masked_paths, 0, 0 },
+ { "readonlyPaths", SD_JSON_VARIANT_ARRAY, oci_readonly_paths, 0, 0 },
+ { "mountLabel", SD_JSON_VARIANT_STRING, oci_unsupported, 0, SD_JSON_PERMISSIVE },
{}
};
return oci_dispatch(v, table, flags, userdata);
}
-static int oci_hook_timeout(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_hook_timeout(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
usec_t *u = ASSERT_PTR(userdata);
uint64_t k;
- k = json_variant_unsigned(v);
+ k = sd_json_variant_unsigned(v);
if (k == 0 || k > (UINT64_MAX-1)/USEC_PER_SEC)
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
"Hook timeout value out of range.");
return 0;
}
-static int oci_hooks_array(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_hooks_array(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
Settings *s = ASSERT_PTR(userdata);
- JsonVariant *e;
+ sd_json_variant *e;
int r;
JSON_VARIANT_ARRAY_FOREACH(e, v) {
- static const JsonDispatch table[] = {
- { "path", JSON_VARIANT_STRING, oci_absolute_path, offsetof(OciHook, path), JSON_MANDATORY },
- { "args", JSON_VARIANT_ARRAY, oci_args, offsetof(OciHook, args), 0 },
- { "env", JSON_VARIANT_ARRAY, oci_env, offsetof(OciHook, env), 0 },
- { "timeout", JSON_VARIANT_UNSIGNED, oci_hook_timeout, offsetof(OciHook, timeout), 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "path", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(OciHook, path), SD_JSON_MANDATORY },
+ { "args", SD_JSON_VARIANT_ARRAY, oci_args, offsetof(OciHook, args), 0, },
+ { "env", SD_JSON_VARIANT_ARRAY, oci_env, offsetof(OciHook, env), 0 },
+ { "timeout", SD_JSON_VARIANT_UNSIGNED, oci_hook_timeout, offsetof(OciHook, timeout), 0 },
{}
};
return 0;
}
-static int oci_hooks(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int oci_hooks(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "prestart", JSON_VARIANT_ARRAY, oci_hooks_array, 0, 0 },
- { "poststart", JSON_VARIANT_ARRAY, oci_hooks_array, 0, 0 },
- { "poststop", JSON_VARIANT_ARRAY, oci_hooks_array, 0, 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "prestart", SD_JSON_VARIANT_ARRAY, oci_hooks_array, 0, 0 },
+ { "poststart", SD_JSON_VARIANT_ARRAY, oci_hooks_array, 0, 0 },
+ { "poststop", SD_JSON_VARIANT_ARRAY, oci_hooks_array, 0, 0 },
{}
};
return oci_dispatch(v, table, flags, userdata);
}
-static int oci_annotations(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- JsonVariant *w;
+static int oci_annotations(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
+ sd_json_variant *w;
const char *k;
JSON_VARIANT_OBJECT_FOREACH(k, w, v) {
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
"Annotation with empty key, refusing.");
- if (!json_variant_is_string(w))
+ if (!sd_json_variant_is_string(w))
return json_log(w, flags, SYNTHETIC_ERRNO(EINVAL),
"Annotation has non-string value, refusing.");
- json_log(w, flags|JSON_DEBUG, 0, "Ignoring annotation '%s' with value '%s'.", k, json_variant_string(w));
+ json_log(w, flags|SD_JSON_DEBUG, 0, "Ignoring annotation '%s' with value '%s'.", k, sd_json_variant_string(w));
}
return 0;
int oci_load(FILE *f, const char *bundle, Settings **ret) {
- static const JsonDispatch table[] = {
- { "ociVersion", JSON_VARIANT_STRING, NULL, 0, JSON_MANDATORY },
- { "process", JSON_VARIANT_OBJECT, oci_process, 0, 0 },
- { "root", JSON_VARIANT_OBJECT, oci_root, 0, 0 },
- { "hostname", JSON_VARIANT_STRING, oci_hostname, 0, 0 },
- { "mounts", JSON_VARIANT_ARRAY, oci_mounts, 0, 0 },
- { "linux", JSON_VARIANT_OBJECT, oci_linux, 0, 0 },
- { "hooks", JSON_VARIANT_OBJECT, oci_hooks, 0, 0 },
- { "annotations", JSON_VARIANT_OBJECT, oci_annotations, 0, 0 },
+ static const sd_json_dispatch_field table[] = {
+ { "ociVersion", SD_JSON_VARIANT_STRING, NULL, 0, SD_JSON_MANDATORY },
+ { "process", SD_JSON_VARIANT_OBJECT, oci_process, 0, 0 },
+ { "root", SD_JSON_VARIANT_OBJECT, oci_root, 0, 0 },
+ { "hostname", SD_JSON_VARIANT_STRING, oci_hostname, 0, 0 },
+ { "mounts", SD_JSON_VARIANT_ARRAY, oci_mounts, 0, 0 },
+ { "linux", SD_JSON_VARIANT_OBJECT, oci_linux, 0, 0 },
+ { "hooks", SD_JSON_VARIANT_OBJECT, oci_hooks, 0, 0 },
+ { "annotations", SD_JSON_VARIANT_OBJECT, oci_annotations, 0, 0 },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *oci = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *oci = NULL;
_cleanup_(settings_freep) Settings *s = NULL;
unsigned line = 0, column = 0;
- JsonVariant *v;
+ sd_json_variant *v;
const char *path;
int r;
path = strjoina(bundle, "/config.json");
- r = json_parse_file(f, path, 0, &oci, &line, &column);
+ r = sd_json_parse_file(f, path, 0, &oci, &line, &column);
if (r < 0) {
if (line != 0 && column != 0)
return log_error_errno(r, "Failed to parse '%s' at %u:%u: %m", path, line, column);
return log_error_errno(r, "Failed to parse '%s': %m", path);
}
- v = json_variant_by_key(oci, "ociVersion");
+ v = sd_json_variant_by_key(oci, "ociVersion");
if (!v)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"JSON file '%s' is not an OCI bundle configuration file. Refusing.",
path);
- if (!streq_ptr(json_variant_string(v), "1.0.0"))
+ if (!streq_ptr(sd_json_variant_string(v), "1.0.0"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"OCI bundle version not supported: %s",
- strna(json_variant_string(v)));
+ strna(sd_json_variant_string(v)));
// {
// _cleanup_free_ char *formatted = NULL;
- // assert_se(json_variant_format(oci, JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR, &formatted) >= 0);
+ // assert_se(json_variant_format(oci, SD_JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR, &formatted) >= 0);
// fputs(formatted, stdout);
// }
#include "fs-util.h"
#include "group-record.h"
#include "io-util.h"
+#include "json-util.h"
#include "lock-util.h"
#include "main-func.h"
#include "missing_magic.h"
const char *service;
} LookupParameters;
-static int build_user_json(UserNamespaceInfo *userns_info, uid_t offset, JsonVariant **ret) {
+static int build_user_json(UserNamespaceInfo *userns_info, uid_t offset, sd_json_variant **ret) {
_cleanup_free_ char *name = NULL, *realname = NULL;
UserDisposition disposition;
int r;
if (r < 0)
return -ENOMEM;
- return json_build(ret, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(name)),
- JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(userns_info->start + offset)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(GID_NOBODY)),
- JSON_BUILD_PAIR("realName", JSON_BUILD_STRING(realname)),
- JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_CONST_STRING("/")),
- JSON_BUILD_PAIR("shell", JSON_BUILD_STRING(NOLOGIN)),
- JSON_BUILD_PAIR("locked", JSON_BUILD_BOOLEAN(true)),
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.NamespaceResource")),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_STRING(user_disposition_to_string(disposition)))));
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(name)),
+ SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(userns_info->start + offset)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(GID_NOBODY)),
+ SD_JSON_BUILD_PAIR("realName", SD_JSON_BUILD_STRING(realname)),
+ SD_JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_CONST_STRING("/")),
+ SD_JSON_BUILD_PAIR("shell", SD_JSON_BUILD_STRING(NOLOGIN)),
+ SD_JSON_BUILD_PAIR("locked", SD_JSON_BUILD_BOOLEAN(true)),
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.NamespaceResource")),
+ SD_JSON_BUILD_PAIR("disposition", SD_JSON_BUILD_STRING(user_disposition_to_string(disposition)))));
}
-static int vl_method_get_user_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_user_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "uid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), 0 },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), 0 },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
_cleanup_(userns_info_freep) UserNamespaceInfo *userns_info = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
LookupParameters p = {
.uid = UID_INVALID,
};
if (r < 0)
return r;
- return varlink_replyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("record", JSON_BUILD_VARIANT(v))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_VARIANT(v))));
not_found:
return varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
}
-static int build_group_json(UserNamespaceInfo *userns_info, gid_t offset, JsonVariant **ret) {
+static int build_group_json(UserNamespaceInfo *userns_info, gid_t offset, sd_json_variant **ret) {
_cleanup_free_ char *name = NULL, *description = NULL;
UserDisposition disposition;
int r;
if (r < 0)
return -ENOMEM;
- return json_build(ret, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(name)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(userns_info->start + offset)),
- JSON_BUILD_PAIR("description", JSON_BUILD_STRING(description)),
- JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.NamespaceResource")),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_STRING(user_disposition_to_string(disposition)))));
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(name)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(userns_info->start + offset)),
+ SD_JSON_BUILD_PAIR("description", SD_JSON_BUILD_STRING(description)),
+ SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.NamespaceResource")),
+ SD_JSON_BUILD_PAIR("disposition", SD_JSON_BUILD_STRING(user_disposition_to_string(disposition)))));
}
-static int vl_method_get_group_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_group_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), 0 },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), 0 },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
_cleanup_(userns_info_freep) UserNamespaceInfo *userns_info = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
LookupParameters p = {
.gid = GID_INVALID,
};
if (r < 0)
return r;
- return varlink_replyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("record", JSON_BUILD_VARIANT(v))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_VARIANT(v))));
not_found:
return varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
}
-static int vl_method_get_memberships(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), 0 },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), 0 },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+static int vl_method_get_memberships(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), 0 },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), 0 },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
unsigned userns_fd_idx;
} AllocateParameters;
-static int vl_method_allocate_user_range(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_allocate_user_range(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "name", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(AllocateParameters, name), JSON_MANDATORY },
- { "size", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(AllocateParameters, size), JSON_MANDATORY },
- { "target", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(AllocateParameters, target), 0 },
- { "userNamespaceFileDescriptor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(AllocateParameters, userns_fd_idx), JSON_MANDATORY },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(AllocateParameters, name), SD_JSON_MANDATORY },
+ { "size", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(AllocateParameters, size), SD_JSON_MANDATORY },
+ { "target", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(AllocateParameters, target), 0 },
+ { "userNamespaceFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(AllocateParameters, userns_fd_idx), SD_JSON_MANDATORY },
{}
};
/* Note, we'll not return UID values from the host, since the child might not run in the same
* user namespace as us. If they want to know the ranges they should read them off the userns fd, so
* that they are translated into their PoV */
- return varlink_replyb(link, JSON_BUILD_EMPTY_OBJECT);
+ return varlink_replyb(link, SD_JSON_BUILD_EMPTY_OBJECT);
fail:
/* Note: we don't have to clean-up the BPF maps in the error path: the bpf map type used will
unsigned userns_fd_idx;
} RegisterParameters;
-static int vl_method_register_user_namespace(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_register_user_namespace(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "name", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(RegisterParameters, name), JSON_MANDATORY },
- { "userNamespaceFileDescriptor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(RegisterParameters, userns_fd_idx), JSON_MANDATORY },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(RegisterParameters, name), SD_JSON_MANDATORY },
+ { "userNamespaceFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(RegisterParameters, userns_fd_idx), SD_JSON_MANDATORY },
{}
};
if (r < 0)
goto fail;
- return varlink_replyb(link, JSON_BUILD_EMPTY_OBJECT);
+ return varlink_replyb(link, SD_JSON_BUILD_EMPTY_OBJECT);
fail:
userns_registry_remove(registry_dir_fd, userns_info);
unsigned mount_fd_idx;
} AddMountParameters;
-static int vl_method_add_mount_to_user_namespace(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_add_mount_to_user_namespace(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch parameter_dispatch_table[] = {
- { "userNamespaceFileDescriptor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(AddMountParameters, userns_fd_idx), JSON_MANDATORY },
- { "mountFileDescriptor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(AddMountParameters, mount_fd_idx), JSON_MANDATORY },
+ static const sd_json_dispatch_field parameter_dispatch_table[] = {
+ { "userNamespaceFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(AddMountParameters, userns_fd_idx), SD_JSON_MANDATORY },
+ { "mountFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(AddMountParameters, mount_fd_idx), SD_JSON_MANDATORY },
{}
};
log_debug("Granting access to mount %i to user namespace " INO_FMT " ('%s')",
mnt_id, userns_st.st_ino, userns_info->name);
- return varlink_replyb(link, JSON_BUILD_EMPTY_OBJECT);
+ return varlink_replyb(link, SD_JSON_BUILD_EMPTY_OBJECT);
}
static int validate_cgroup(Varlink *link, int fd, uint64_t *ret_cgroup_id) {
unsigned cgroup_fd_idx;
} AddCGroupParameters;
-static int vl_method_add_cgroup_to_user_namespace(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch parameter_dispatch_table[] = {
- { "userNamespaceFileDescriptor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(AddCGroupParameters, userns_fd_idx), JSON_MANDATORY },
- { "controlGroupFileDescriptor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(AddCGroupParameters, cgroup_fd_idx), JSON_MANDATORY },
+static int vl_method_add_cgroup_to_user_namespace(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field parameter_dispatch_table[] = {
+ { "userNamespaceFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(AddCGroupParameters, userns_fd_idx), SD_JSON_MANDATORY },
+ { "controlGroupFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(AddCGroupParameters, cgroup_fd_idx), SD_JSON_MANDATORY },
{}
};
log_debug("Granting ownership to cgroup %" PRIu64 " to userns " INO_FMT " ('%s' @ UID " UID_FMT ")",
cgroup_id, userns_st.st_ino, userns_info->name, userns_info->start);
- return varlink_replyb(link, JSON_BUILD_EMPTY_OBJECT);
+ return varlink_replyb(link, SD_JSON_BUILD_EMPTY_OBJECT);
}
static uint64_t hash_ifname_id(UserNamespaceInfo *userns_info, const char *ifname) {
const char *mode;
} AddNetworkParameters;
-static int vl_method_add_netif_to_user_namespace(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch parameter_dispatch_table[] = {
- { "userNamespaceFileDescriptor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(AddNetworkParameters, userns_fd_idx), JSON_MANDATORY },
- { "networkNamespaceFileDescriptor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(AddNetworkParameters, netns_fd_idx), JSON_MANDATORY },
- { "namespaceInterfaceName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(AddNetworkParameters, ifname), 0 },
- { "mode", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(AddNetworkParameters, mode), JSON_MANDATORY },
+static int vl_method_add_netif_to_user_namespace(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field parameter_dispatch_table[] = {
+ { "userNamespaceFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(AddNetworkParameters, userns_fd_idx), SD_JSON_MANDATORY },
+ { "networkNamespaceFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(AddNetworkParameters, netns_fd_idx), SD_JSON_MANDATORY },
+ { "namespaceInterfaceName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(AddNetworkParameters, ifname), 0 },
+ { "mode", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(AddNetworkParameters, mode), SD_JSON_MANDATORY },
{}
};
log_debug("Adding veth tunnel %s from host to userns " INO_FMT " ('%s' @ UID " UID_FMT ", interface %s).",
ifname_host, userns_st.st_ino, userns_info->name, userns_info->start, ifname_namespace);
- return varlink_replyb(link, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("hostInterfaceName", JSON_BUILD_STRING(ifname_host)),
- JSON_BUILD_PAIR("namespaceInterfaceName", JSON_BUILD_STRING(ifname_namespace))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("hostInterfaceName", SD_JSON_BUILD_STRING(ifname_host)),
+ SD_JSON_BUILD_PAIR("namespaceInterfaceName", SD_JSON_BUILD_STRING(ifname_namespace))));
}
static int process_connection(VarlinkServer *server, int _fd) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "chase.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
#include "fs-util.h"
-#include "json.h"
+#include "json-util.h"
#include "missing_magic.h"
#include "path-util.h"
#include "recurse-dir.h"
return mfree(userns);
}
-static int dispatch_cgroups_array(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_cgroups_array(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
UserNamespaceInfo *info = ASSERT_PTR(userdata);
_cleanup_free_ uint64_t *cgroups = NULL;
size_t n_cgroups = 0;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
info->cgroups = mfree(info->cgroups);
info->n_cgroups = 0;
return 0;
}
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
- cgroups = new(uint64_t, json_variant_elements(variant));
+ cgroups = new(uint64_t, sd_json_variant_elements(variant));
if (!cgroups)
return json_log_oom(variant, flags);
- JsonVariant *e;
+ sd_json_variant *e;
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
bool found = false;
- if (!json_variant_is_unsigned(e))
+ if (!sd_json_variant_is_unsigned(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not a number.");
FOREACH_ARRAY(cg, cgroups, n_cgroups)
- if (*cg == json_variant_unsigned(e)) {
+ if (*cg == sd_json_variant_unsigned(e)) {
found = true;
break;
}
if (found) /* suppress duplicate */
continue;
- cgroups[n_cgroups++] = json_variant_unsigned(e);
+ cgroups[n_cgroups++] = sd_json_variant_unsigned(e);
}
- assert(n_cgroups <= json_variant_elements(variant));
+ assert(n_cgroups <= sd_json_variant_elements(variant));
free_and_replace(info->cgroups, cgroups);
info->n_cgroups = n_cgroups;
static int userns_registry_load(int dir_fd, const char *fn, UserNamespaceInfo **ret) {
- static const JsonDispatch dispatch_table[] = {
- { "owner", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(UserNamespaceInfo, owner), JSON_MANDATORY },
- { "name", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserNamespaceInfo, name), JSON_MANDATORY },
- { "userns", JSON_VARIANT_UNSIGNED, json_dispatch_uint64, offsetof(UserNamespaceInfo, userns_inode), JSON_MANDATORY },
- { "start", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(UserNamespaceInfo, start), 0 },
- { "size", JSON_VARIANT_UNSIGNED, json_dispatch_uint32, offsetof(UserNamespaceInfo, size), 0 },
- { "target", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(UserNamespaceInfo, target), 0 },
- { "cgroups", JSON_VARIANT_ARRAY, dispatch_cgroups_array, 0, 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "owner", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(UserNamespaceInfo, owner), SD_JSON_MANDATORY },
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserNamespaceInfo, name), SD_JSON_MANDATORY },
+ { "userns", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint64, offsetof(UserNamespaceInfo, userns_inode), SD_JSON_MANDATORY },
+ { "start", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(UserNamespaceInfo, start), 0 },
+ { "size", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uint32, offsetof(UserNamespaceInfo, size), 0 },
+ { "target", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(UserNamespaceInfo, target), 0 },
+ { "cgroups", SD_JSON_VARIANT_ARRAY, dispatch_cgroups_array, 0, 0 },
{}
};
_cleanup_(userns_info_freep) UserNamespaceInfo *userns_info = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_close_ int registry_fd = -EBADF;
int r;
dir_fd = registry_fd;
}
- r = json_parse_file_at(NULL, dir_fd, fn, 0, &v, NULL, NULL);
+ r = sd_json_parse_file_at(NULL, dir_fd, fn, 0, &v, NULL, NULL);
if (r < 0)
return r;
if (!userns_info)
return -ENOMEM;
- r = json_dispatch(v, dispatch_table, 0, userns_info);
+ r = sd_json_dispatch(v, dispatch_table, 0, userns_info);
if (r < 0)
return r;
dir_fd = registry_fd;
}
- _cleanup_(json_variant_unrefp) JsonVariant *cgroup_array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *cgroup_array = NULL;
FOREACH_ARRAY(cg, info->cgroups, info->n_cgroups) {
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&cgroup_array,
- JSON_BUILD_UNSIGNED(*cg));
+ SD_JSON_BUILD_UNSIGNED(*cg));
if (r < 0)
return r;
}
- _cleanup_(json_variant_unrefp) JsonVariant *def = NULL;
- r = json_build(&def, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("owner", JSON_BUILD_UNSIGNED(info->owner)),
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(info->name)),
- JSON_BUILD_PAIR("userns", JSON_BUILD_UNSIGNED(info->userns_inode)),
- JSON_BUILD_PAIR_CONDITION(uid_is_valid(info->start), "start", JSON_BUILD_UNSIGNED(info->start)),
- JSON_BUILD_PAIR_CONDITION(uid_is_valid(info->start), "size", JSON_BUILD_UNSIGNED(info->size)),
- JSON_BUILD_PAIR_CONDITION(uid_is_valid(info->start), "target", JSON_BUILD_UNSIGNED(info->target)),
- JSON_BUILD_PAIR_CONDITION(cgroup_array, "cgroups", JSON_BUILD_VARIANT(cgroup_array))));
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *def = NULL;
+ r = sd_json_build(&def, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("owner", SD_JSON_BUILD_UNSIGNED(info->owner)),
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(info->name)),
+ SD_JSON_BUILD_PAIR("userns", SD_JSON_BUILD_UNSIGNED(info->userns_inode)),
+ SD_JSON_BUILD_PAIR_CONDITION(uid_is_valid(info->start), "start", SD_JSON_BUILD_UNSIGNED(info->start)),
+ SD_JSON_BUILD_PAIR_CONDITION(uid_is_valid(info->start), "size", SD_JSON_BUILD_UNSIGNED(info->size)),
+ SD_JSON_BUILD_PAIR_CONDITION(uid_is_valid(info->start), "target", SD_JSON_BUILD_UNSIGNED(info->target)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!cgroup_array, "cgroups", SD_JSON_BUILD_VARIANT(cgroup_array))));
if (r < 0)
return r;
_cleanup_free_ char *def_buf = NULL;
- r = json_variant_format(def, 0, &def_buf);
+ r = sd_json_variant_format(def, 0, &def_buf);
if (r < 0)
return log_debug_errno(r, "Failed to format userns JSON object: %m");
#include "errno-util.h"
#include "glyph-util.h"
#include "in-addr-util.h"
+#include "json-util.h"
#include "macro.h"
#include "nss-util.h"
#include "resolved-def.h"
#include "strv.h"
#include "varlink.h"
-static JsonDispatchFlags json_dispatch_flags = JSON_ALLOW_EXTENSIONS;
+static sd_json_dispatch_flags_t json_dispatch_flags = SD_JSON_ALLOW_EXTENSIONS;
static void setup_logging(void) {
log_parse_environment_variables();
if (DEBUG_LOGGING)
- json_dispatch_flags = JSON_LOG;
+ json_dispatch_flags = SD_JSON_LOG;
}
static void setup_logging_once(void) {
return in6_addr_is_link_local(&in6) ? ifindex : 0;
}
-static int json_dispatch_ifindex(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_ifindex(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
int *ifi = ASSERT_PTR(userdata);
int64_t t;
assert(variant);
- if (!json_variant_is_integer(variant))
+ if (!sd_json_variant_is_integer(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
- t = json_variant_integer(variant);
+ t = sd_json_variant_integer(variant);
if (t > INT_MAX)
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is out of bounds for an interface index.", strna(name));
return 0;
}
-static int json_dispatch_family(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_family(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
int *family = ASSERT_PTR(userdata);
int64_t t;
assert(variant);
- if (!json_variant_is_integer(variant))
+ if (!sd_json_variant_is_integer(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
- t = json_variant_integer(variant);
+ t = sd_json_variant_integer(variant);
if (t < 0 || t > INT_MAX)
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid family.", strna(name));
}
typedef struct ResolveHostnameReply {
- JsonVariant *addresses;
+ sd_json_variant *addresses;
char *name;
uint64_t flags;
} ResolveHostnameReply;
static void resolve_hostname_reply_destroy(ResolveHostnameReply *p) {
assert(p);
- json_variant_unref(p->addresses);
+ sd_json_variant_unref(p->addresses);
free(p->name);
}
-static const JsonDispatch resolve_hostname_reply_dispatch_table[] = {
- { "addresses", JSON_VARIANT_ARRAY, json_dispatch_variant, offsetof(ResolveHostnameReply, addresses), JSON_MANDATORY },
- { "name", JSON_VARIANT_STRING, json_dispatch_string, offsetof(ResolveHostnameReply, name), 0 },
- { "flags", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(ResolveHostnameReply, flags), 0 },
+static const sd_json_dispatch_field resolve_hostname_reply_dispatch_table[] = {
+ { "addresses", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(ResolveHostnameReply, addresses), SD_JSON_MANDATORY },
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(ResolveHostnameReply, name), 0 },
+ { "flags", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(ResolveHostnameReply, flags), 0 },
{}
};
size_t address_size;
} AddressParameters;
-static int json_dispatch_address(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_address(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
AddressParameters *p = ASSERT_PTR(userdata);
union in_addr_union buf = {};
- JsonVariant *i;
+ sd_json_variant *i;
size_t n, k = 0;
assert(variant);
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
- n = json_variant_elements(variant);
+ n = sd_json_variant_elements(variant);
if (!IN_SET(n, 4, 16))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is array of unexpected size.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(i, variant) {
int64_t b;
- if (!json_variant_is_integer(i))
+ if (!sd_json_variant_is_integer(i))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Element %zu of JSON field '%s' is not an integer.", k, strna(name));
- b = json_variant_integer(i);
+ b = sd_json_variant_integer(i);
if (b < 0 || b > 0xff)
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL),
"Element %zu of JSON field '%s' is out of range 0%s255.",
return 0;
}
-static const JsonDispatch address_parameters_dispatch_table[] = {
- { "ifindex", JSON_VARIANT_INTEGER, json_dispatch_ifindex, offsetof(AddressParameters, ifindex), 0 },
- { "family", JSON_VARIANT_INTEGER, json_dispatch_family, offsetof(AddressParameters, family), JSON_MANDATORY },
- { "address", JSON_VARIANT_ARRAY, json_dispatch_address, 0, JSON_MANDATORY },
+static const sd_json_dispatch_field address_parameters_dispatch_table[] = {
+ { "ifindex", SD_JSON_VARIANT_INTEGER, json_dispatch_ifindex, offsetof(AddressParameters, ifindex), 0 },
+ { "family", SD_JSON_VARIANT_INTEGER, json_dispatch_family, offsetof(AddressParameters, family), SD_JSON_MANDATORY },
+ { "address", SD_JSON_VARIANT_ARRAY, json_dispatch_address, 0, SD_JSON_MANDATORY },
{}
};
int32_t *ttlp) {
_cleanup_(varlink_unrefp) Varlink *link = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *cparams = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *cparams = NULL;
_cleanup_(resolve_hostname_reply_destroy) ResolveHostnameReply p = {};
- JsonVariant *rparams, *entry;
+ sd_json_variant *rparams, *entry;
int r;
PROTECT_ERRNO;
if (r < 0)
goto fail;
- r = json_build(&cparams, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(name)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(query_flags()))));
+ r = sd_json_build(&cparams, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(name)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_UNSIGNED(query_flags()))));
if (r < 0)
goto fail;
goto not_found;
}
- r = json_dispatch(rparams, resolve_hostname_reply_dispatch_table, json_dispatch_flags, &p);
+ r = sd_json_dispatch(rparams, resolve_hostname_reply_dispatch_table, json_dispatch_flags, &p);
if (r < 0)
goto fail;
- if (json_variant_is_blank_object(p.addresses))
+ if (sd_json_variant_is_blank_object(p.addresses))
goto not_found;
size_t n_addresses = 0;
JSON_VARIANT_ARRAY_FOREACH(entry, p.addresses) {
AddressParameters q = {};
- r = json_dispatch(entry, address_parameters_dispatch_table, json_dispatch_flags, &q);
+ r = sd_json_dispatch(entry, address_parameters_dispatch_table, json_dispatch_flags, &q);
if (r < 0)
goto fail;
JSON_VARIANT_ARRAY_FOREACH(entry, p.addresses) {
AddressParameters q = {};
- r = json_dispatch(entry, address_parameters_dispatch_table, json_dispatch_flags, &q);
+ r = sd_json_dispatch(entry, address_parameters_dispatch_table, json_dispatch_flags, &q);
if (r < 0)
goto fail;
char **canonp) {
_cleanup_(varlink_unrefp) Varlink *link = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *cparams = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *cparams = NULL;
_cleanup_(resolve_hostname_reply_destroy) ResolveHostnameReply p = {};
- JsonVariant *rparams, *entry;
+ sd_json_variant *rparams, *entry;
int r;
PROTECT_ERRNO;
if (r < 0)
goto fail;
- r = json_build(&cparams, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("name", JSON_BUILD_STRING(name)),
- JSON_BUILD_PAIR("family", JSON_BUILD_INTEGER(af)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(query_flags()))));
+ r = sd_json_build(&cparams, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(name)),
+ SD_JSON_BUILD_PAIR("family", SD_JSON_BUILD_INTEGER(af)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_UNSIGNED(query_flags()))));
if (r < 0)
goto fail;
goto not_found;
}
- r = json_dispatch(rparams, resolve_hostname_reply_dispatch_table, json_dispatch_flags, &p);
+ r = sd_json_dispatch(rparams, resolve_hostname_reply_dispatch_table, json_dispatch_flags, &p);
if (r < 0)
goto fail;
- if (json_variant_is_blank_object(p.addresses))
+ if (sd_json_variant_is_blank_object(p.addresses))
goto not_found;
size_t n_addresses = 0;
JSON_VARIANT_ARRAY_FOREACH(entry, p.addresses) {
AddressParameters q = {};
- r = json_dispatch(entry, address_parameters_dispatch_table, json_dispatch_flags, &q);
+ r = sd_json_dispatch(entry, address_parameters_dispatch_table, json_dispatch_flags, &q);
if (r < 0)
goto fail;
JSON_VARIANT_ARRAY_FOREACH(entry, p.addresses) {
AddressParameters q = {};
- r = json_dispatch(entry, address_parameters_dispatch_table, json_dispatch_flags, &q);
+ r = sd_json_dispatch(entry, address_parameters_dispatch_table, json_dispatch_flags, &q);
if (r < 0)
goto fail;
}
typedef struct ResolveAddressReply {
- JsonVariant *names;
+ sd_json_variant *names;
uint64_t flags;
} ResolveAddressReply;
static void resolve_address_reply_destroy(ResolveAddressReply *p) {
assert(p);
- json_variant_unref(p->names);
+ sd_json_variant_unref(p->names);
}
-static const JsonDispatch resolve_address_reply_dispatch_table[] = {
- { "names", JSON_VARIANT_ARRAY, json_dispatch_variant, offsetof(ResolveAddressReply, names), JSON_MANDATORY },
- { "flags", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(ResolveAddressReply, flags), 0 },
+static const sd_json_dispatch_field resolve_address_reply_dispatch_table[] = {
+ { "names", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(ResolveAddressReply, names), SD_JSON_MANDATORY },
+ { "flags", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(ResolveAddressReply, flags), 0 },
{}
};
free(p->name);
}
-static const JsonDispatch name_parameters_dispatch_table[] = {
- { "ifindex", JSON_VARIANT_INTEGER, json_dispatch_ifindex, offsetof(NameParameters, ifindex), 0 },
- { "name", JSON_VARIANT_STRING, json_dispatch_string, offsetof(NameParameters, name), JSON_MANDATORY },
+static const sd_json_dispatch_field name_parameters_dispatch_table[] = {
+ { "ifindex", SD_JSON_VARIANT_INTEGER, json_dispatch_ifindex, offsetof(NameParameters, ifindex), 0 },
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(NameParameters, name), SD_JSON_MANDATORY },
{}
};
int32_t *ttlp) {
_cleanup_(varlink_unrefp) Varlink *link = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *cparams = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *cparams = NULL;
_cleanup_(resolve_address_reply_destroy) ResolveAddressReply p = {};
- JsonVariant *rparams, *entry;
+ sd_json_variant *rparams, *entry;
int r;
PROTECT_ERRNO;
if (r < 0)
goto fail;
- r = json_build(&cparams, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("address", JSON_BUILD_BYTE_ARRAY(addr, len)),
- JSON_BUILD_PAIR("family", JSON_BUILD_INTEGER(af)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(query_flags()))));
+ r = sd_json_build(&cparams, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("address", SD_JSON_BUILD_BYTE_ARRAY(addr, len)),
+ SD_JSON_BUILD_PAIR("family", SD_JSON_BUILD_INTEGER(af)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_UNSIGNED(query_flags()))));
if (r < 0)
goto fail;
goto not_found;
}
- r = json_dispatch(rparams, resolve_address_reply_dispatch_table, json_dispatch_flags, &p);
+ r = sd_json_dispatch(rparams, resolve_address_reply_dispatch_table, json_dispatch_flags, &p);
if (r < 0)
goto fail;
- if (json_variant_is_blank_object(p.names))
+ if (sd_json_variant_is_blank_object(p.names))
goto not_found;
size_t ms = 0, idx;
JSON_VARIANT_ARRAY_FOREACH(entry, p.names) {
_cleanup_(name_parameters_destroy) NameParameters q = {};
- r = json_dispatch(entry, name_parameters_dispatch_table, json_dispatch_flags, &q);
+ r = sd_json_dispatch(entry, name_parameters_dispatch_table, json_dispatch_flags, &q);
if (r < 0)
goto fail;
ms += ALIGN(strlen(q.name) + 1);
}
- size_t n_names = json_variant_elements(p.names);
+ size_t n_names = sd_json_variant_elements(p.names);
ms += ALIGN(len) + /* the address */
2 * sizeof(char*) + /* pointer to the address, plus trailing NULL */
n_names * sizeof(char*); /* pointers to aliases, plus trailing NULL */
JSON_VARIANT_ARRAY_FOREACH(entry, p.names) {
_cleanup_(name_parameters_destroy) NameParameters q = {};
- r = json_dispatch(entry, name_parameters_dispatch_table, json_dispatch_flags, &q);
+ r = sd_json_dispatch(entry, name_parameters_dispatch_table, json_dispatch_flags, &q);
if (r < 0)
goto fail;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-daemon.h"
+#include "sd-json.h"
#include "bus-log-control-api.h"
#include "bus-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
+#include "json-util.h"
#include "memory-util.h"
#include "memstream-util.h"
#include "oomd-manager-bus.h"
static JSON_DISPATCH_ENUM_DEFINE(dispatch_managed_oom_mode, ManagedOOMMode, managed_oom_mode_from_string);
-static int process_managed_oom_message(Manager *m, uid_t uid, JsonVariant *parameters) {
- JsonVariant *c, *cgroups;
+static int process_managed_oom_message(Manager *m, uid_t uid, sd_json_variant *parameters) {
+ sd_json_variant *c, *cgroups;
int r;
- static const JsonDispatch dispatch_table[] = {
- { "mode", JSON_VARIANT_STRING, dispatch_managed_oom_mode, offsetof(ManagedOOMMessage, mode), JSON_MANDATORY },
- { "path", JSON_VARIANT_STRING, json_dispatch_string, offsetof(ManagedOOMMessage, path), JSON_MANDATORY },
- { "property", JSON_VARIANT_STRING, json_dispatch_string, offsetof(ManagedOOMMessage, property), JSON_MANDATORY },
- { "limit", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint32, offsetof(ManagedOOMMessage, limit), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "mode", SD_JSON_VARIANT_STRING, dispatch_managed_oom_mode, offsetof(ManagedOOMMessage, mode), SD_JSON_MANDATORY },
+ { "path", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(ManagedOOMMessage, path), SD_JSON_MANDATORY },
+ { "property", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(ManagedOOMMessage, property), SD_JSON_MANDATORY },
+ { "limit", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint32, offsetof(ManagedOOMMessage, limit), 0 },
{},
};
assert(m);
assert(parameters);
- cgroups = json_variant_by_key(parameters, "cgroups");
+ cgroups = sd_json_variant_by_key(parameters, "cgroups");
if (!cgroups)
return -EINVAL;
Hashmap *monitor_hm;
loadavg_t limit;
- if (!json_variant_is_object(c))
+ if (!sd_json_variant_is_object(c))
continue;
- r = json_dispatch(c, dispatch_table, 0, &message);
+ r = sd_json_dispatch(c, dispatch_table, 0, &message);
if (r == -ENOMEM)
return r;
if (r < 0)
static int process_managed_oom_request(
Varlink *link,
- JsonVariant *parameters,
+ sd_json_variant *parameters,
VarlinkMethodFlags flags,
void *userdata) {
Manager *m = ASSERT_PTR(userdata);
static int process_managed_oom_reply(
Varlink *link,
- JsonVariant *parameters,
+ sd_json_variant *parameters,
const char *error_id,
VarlinkReplyFlags flags,
void *userdata) {
#include "sd-device.h"
#include "sd-id128.h"
+#include "sd-json.h"
#include "alloc-util.h"
#include "blkid-util.h"
#include "id128-util.h"
#include "initrd-util.h"
#include "io-util.h"
-#include "json.h"
+#include "json-util.h"
#include "list.h"
#include "loop-util.h"
#include "main-func.h"
static int arg_pretty = -1;
static uint64_t arg_size = UINT64_MAX;
static bool arg_size_auto = false;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static bool arg_legend = true;
static void *arg_key = NULL;
const size_t roothash_col = 14, dropin_files_col = 15, split_path_col = 16;
bool has_roothash = false, has_dropin_files = false, has_split_path = false;
- if ((arg_json_format_flags & JSON_FORMAT_OFF) && context->n_partitions == 0) {
+ if ((arg_json_format_flags & SD_JSON_FORMAT_OFF) && context->n_partitions == 0) {
log_info("Empty partition table.");
return 0;
}
return log_oom();
if (!DEBUG_LOGGING) {
- if (arg_json_format_flags & JSON_FORMAT_OFF)
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF)
(void) table_set_display(t, (size_t) 0, (size_t) 1, (size_t) 2, (size_t) 3, (size_t) 4,
(size_t) 8, (size_t) 9, (size_t) 12, roothash_col, dropin_files_col,
split_path_col);
has_split_path = has_split_path || !isempty(p->split_path);
}
- if ((arg_json_format_flags & JSON_FORMAT_OFF) && (sum_padding > 0 || sum_size > 0)) {
+ if ((arg_json_format_flags & SD_JSON_FORMAT_OFF) && (sum_padding > 0 || sum_size > 0)) {
const char *a, *b;
a = strjoina(special_glyph(SPECIAL_GLYPH_SIGMA), " = ", FORMAT_BYTES(sum_size));
assert(context);
- if (arg_pretty == 0 && FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (arg_pretty == 0 && FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
return 0;
/* If we're outputting JSON, only dump after doing all operations so we can include the roothashes
* in the output. */
- if (!late && !FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!late && !FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
return 0;
/* If we're not outputting JSON, only dump again after doing all operations if there are any
* roothashes that we need to communicate to the user. */
- if (late && FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF) && !context_has_roothash(context))
+ if (late && FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF) && !context_has_roothash(context))
return 0;
r = context_dump_partitions(context);
/* Only write the partition bar once, even if we're writing the partition table twice to communicate
* roothashes. */
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF) && !late) {
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF) && !late) {
putc('\n', stdout);
r = context_dump_partition_bar(context);
#if HAVE_TPM2
_cleanup_(iovec_done) struct iovec pubkey = {}, blob = {}, srk = {};
_cleanup_(iovec_done_erase) struct iovec secret = {};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
ssize_t base64_encoded_size;
int keyslot;
TPM2Flags flags = 0;
}
static int partition_format_verity_sig(Context *context, Partition *p) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(iovec_done) struct iovec sig = {};
_cleanup_free_ char *text = NULL, *hint = NULL;
Partition *hp;
if (r < 0)
return log_error_errno(r, "Unable to calculate X509 certificate fingerprint: %m");
- r = json_build(&v,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("rootHash", JSON_BUILD_HEX(hp->roothash.iov_base, hp->roothash.iov_len)),
- JSON_BUILD_PAIR(
- "certificateFingerprint",
- JSON_BUILD_HEX(fp, sizeof(fp))
- ),
- JSON_BUILD_PAIR("signature", JSON_BUILD_IOVEC_BASE64(&sig))
+ r = sd_json_build(&v,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("rootHash", SD_JSON_BUILD_HEX(hp->roothash.iov_base, hp->roothash.iov_len)),
+ SD_JSON_BUILD_PAIR("certificateFingerprint", SD_JSON_BUILD_HEX(fp, sizeof(fp))),
+ SD_JSON_BUILD_PAIR("signature", JSON_BUILD_IOVEC_BASE64(&sig))
)
);
if (r < 0)
return log_error_errno(r, "Failed to build verity signature JSON object: %m");
- r = json_variant_format(v, 0, &text);
+ r = sd_json_variant_format(v, 0, &text);
if (r < 0)
return log_error_errno(r, "Failed to format verity signature JSON object: %m");
#include <getopt.h>
-#include <sd-messages.h>
+#include "sd-json.h"
+#include "sd-messages.h"
#include "build.h"
#include "efi-loader.h"
#include "escape.h"
+#include "json-util.h"
#include "main-func.h"
#include "openssl-util.h"
#include "parse-argument.h"
iovec_done(&p->data);
}
-static int vl_method_extend(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_extend(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "pcr", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(MethodExtendParameters, pcr), JSON_MANDATORY },
- { "text", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(MethodExtendParameters, text), 0 },
- { "data", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(MethodExtendParameters, data), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "pcr", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(MethodExtendParameters, pcr), SD_JSON_MANDATORY },
+ { "text", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MethodExtendParameters, text), 0 },
+ { "data", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(MethodExtendParameters, data), 0 },
{}
};
_cleanup_(method_extend_parameters_done) MethodExtendParameters p = {
#include <sys/file.h>
#include "sd-device.h"
+#include "sd-json.h"
#include "ask-password-api.h"
#include "blockdev-util.h"
#include "hash-funcs.h"
#include "hexdecoct.h"
#include "initrd-util.h"
+#include "json-util.h"
#include "main-func.h"
#include "mkdir-label.h"
#include "openssl-util.h"
} RecoveryPinMode;
static PagerFlags arg_pager_flags = 0;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF|JSON_FORMAT_NEWLINE;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF|SD_JSON_FORMAT_NEWLINE;
static char **arg_components = NULL;
static uint32_t arg_pcr_mask = 0;
static char *arg_pcrlock_path = NULL;
/* Data for userspace events (i.e. those generated by systemd in userspace */
Tpm2UserspaceEventType userspace_event_type;
- JsonVariant *userspace_content;
+ sd_json_variant *userspace_content;
/* Validation result for the event payload itself, if the record contains enough information to validate the hash */
EventPayloadValid event_payload_valid;
free(record->description);
free(record->firmware_payload);
- json_variant_unref(record->userspace_content);
+ sd_json_variant_unref(record->userspace_content);
while ((bank = LIST_POP(banks, record->banks)))
event_log_record_bank_free(bank);
return 0;
}
-static int event_log_record_parse_json(EventLogRecord *record, JsonVariant *j) {
+static int event_log_record_parse_json(EventLogRecord *record, sd_json_variant *j) {
const char *rectype = NULL;
- JsonVariant *x, *k;
+ sd_json_variant *x, *k;
uint64_t u;
int r;
assert(record);
assert(j);
- if (!json_variant_is_object(j))
+ if (!sd_json_variant_is_object(j))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "record object is not an object.");
- x = json_variant_by_key(j, "pcr");
+ x = sd_json_variant_by_key(j, "pcr");
if (!x)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'pcr' field missing from TPM measurement log file entry.");
- if (!json_variant_is_unsigned(x))
+ if (!sd_json_variant_is_unsigned(x))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'pcr' field is not an integer.");
- u = json_variant_unsigned(x);
+ u = sd_json_variant_unsigned(x);
if (u >= TPM2_PCRS_MAX)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'pcr' field is out of range.");
- record->pcr = json_variant_unsigned(x);
+ record->pcr = sd_json_variant_unsigned(x);
- x = json_variant_by_key(j, "digests");
+ x = sd_json_variant_by_key(j, "digests");
if (!x)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'digests' field missing from TPM measurement log file entry.");
- if (!json_variant_is_array(x))
+ if (!sd_json_variant_is_array(x))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'digests' field is not an array.");
JSON_VARIANT_ARRAY_FOREACH(k, x) {
_cleanup_free_ void *hash = NULL;
size_t hash_size;
- JsonVariant *a, *h;
+ sd_json_variant *a, *h;
int na;
- a = json_variant_by_key(k, "hashAlg");
+ a = sd_json_variant_by_key(k, "hashAlg");
if (!a)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'digests' field element lacks 'hashAlg' field.");
- if (!json_variant_is_string(a))
+ if (!sd_json_variant_is_string(a))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'hashAlg' field is not a string.");
- na = tpm2_hash_alg_from_string(json_variant_string(a));
+ na = tpm2_hash_alg_from_string(sd_json_variant_string(a));
if (na < 0) {
- log_debug_errno(na, "Unsupported hash '%s' in userspace event log, ignoring: %m", json_variant_string(a));
+ log_debug_errno(na, "Unsupported hash '%s' in userspace event log, ignoring: %m", sd_json_variant_string(a));
continue;
}
- h = json_variant_by_key(k, "digest");
+ h = sd_json_variant_by_key(k, "digest");
if (!h)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'digests' field lacks 'digest' field.");
- r = json_variant_unhex(h, &hash, &hash_size);
+ r = sd_json_variant_unhex(h, &hash, &hash_size);
if (r < 0)
return log_error_errno(r, "Failed to decode digest: %m");
return log_error_errno(r, "Failed to add bank to event log record: %m");
}
- x = json_variant_by_key(j, "content_type");
+ x = sd_json_variant_by_key(j, "content_type");
if (!x)
log_debug("'content_type' missing from TPM measurement log file entry, ignoring.");
else {
- if (!json_variant_is_string(x))
+ if (!sd_json_variant_is_string(x))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'content_type' field is not a string.");
- rectype = json_variant_string(x);
+ rectype = sd_json_variant_string(x);
}
if (streq_ptr(rectype, "systemd")) {
- JsonVariant *y;
+ sd_json_variant *y;
- x = json_variant_by_key(j, "content");
+ x = sd_json_variant_by_key(j, "content");
if (!x)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'content' field missing from TPM measurement log file entry.");
- if (!json_variant_is_object(x))
+ if (!sd_json_variant_is_object(x))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'content' sub-object is not an object.");
- y = json_variant_by_key(x, "string");
+ y = sd_json_variant_by_key(x, "string");
if (y) {
- if (!json_variant_is_string(y))
+ if (!sd_json_variant_is_string(y))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'string' field is not a string.");
- r = free_and_strdup_warn(&record->description, json_variant_string(y));
+ r = free_and_strdup_warn(&record->description, sd_json_variant_string(y));
if (r < 0)
return r;
}
- y = json_variant_by_key(x, "eventType");
+ y = sd_json_variant_by_key(x, "eventType");
if (y) {
- if (!json_variant_is_string(y))
+ if (!sd_json_variant_is_string(y))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "'eventType' field is not a string.");
- record->userspace_event_type = tpm2_userspace_event_type_from_string(json_variant_string(y));
+ record->userspace_event_type = tpm2_userspace_event_type_from_string(sd_json_variant_string(y));
if (record->userspace_event_type < 0)
- log_debug_errno(record->userspace_event_type, "Unknown userspace event type '%s', ignoring.", json_variant_string(y));
+ log_debug_errno(record->userspace_event_type, "Unknown userspace event type '%s', ignoring.", sd_json_variant_string(y));
}
- json_variant_unref(record->userspace_content);
- record->userspace_content = json_variant_ref(x);
+ sd_json_variant_unref(record->userspace_content);
+ record->userspace_content = sd_json_variant_ref(x);
}
return 0;
return log_error_errno(errno, "Failed to lock userspace TPM measurement log file: %m");
for (;;) {
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
EventLogRecord *record;
int ch;
continue;
}
- r = json_parse(b, 0, &j, NULL, NULL);
+ r = sd_json_parse(b, 0, &j, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to parse local TPM measurement log file: %m");
_cleanup_free_ unsigned char *payload_hash = NULL;
unsigned payload_hash_size;
- JsonVariant *js;
+ sd_json_variant *js;
const char *s;
int mdsz;
if (!record->userspace_content)
return 0;
- js = json_variant_by_key(record->userspace_content, "string");
+ js = sd_json_variant_by_key(record->userspace_content, "string");
if (!js)
return 0;
- assert(json_variant_is_string(js));
- s = json_variant_string(js);
+ assert(sd_json_variant_is_string(js));
+ s = sd_json_variant_string(js);
mdsz = EVP_MD_size(md);
assert(mdsz > 0);
static int event_log_add_component_file(EventLog *el, EventLogComponent *component, const char *path) {
_cleanup_(event_log_component_variant_freep) EventLogComponentVariant *variant = NULL;
_cleanup_free_ char *fname = NULL, *id = NULL, *path_copy = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
- JsonVariant *records;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
+ sd_json_variant *records;
const char *e;
int r;
if (!GREEDY_REALLOC(component->variants, component->n_variants+1))
return log_oom();
- r = json_parse_file(
+ r = sd_json_parse_file(
/* f= */ NULL,
path,
/* flags= */ 0,
return 0;
}
- if (!json_variant_is_object(j)) {
+ if (!sd_json_variant_is_object(j)) {
log_warning_errno(r, "Component file %s does not contain JSON object, ignoring.", path);
return 0;
}
.id = TAKE_PTR(id),
};
- records = json_variant_by_key(j, "records");
+ records = sd_json_variant_by_key(j, "records");
if (records) {
- JsonVariant *rj;
+ sd_json_variant *rj;
- if (!json_variant_is_array(records)) {
+ if (!sd_json_variant_is_array(records)) {
log_warning_errno(r, "Component records field of file %s is not an array, ignoring.", path);
return 0;
}
if (r < 0)
return table_log_add_error(r);
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF) &&
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF) &&
el->primary_algorithm != UINT16_MAX &&
*alg != el->primary_algorithm)
(void) table_hide_column_from_display(table, c);
return 0;
}
-static int show_log_table(EventLog *el, JsonVariant **ret_variant) {
+static int show_log_table(EventLog *el, sd_json_variant **ret_variant) {
_cleanup_(table_unrefp) Table *table = NULL;
int r;
(void) table_hide_column_from_display(table, table_get_columns(table) - 3); /* hide source */
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
(void) table_hide_column_from_display(table, (size_t) 1); /* hide color block column */
(void) table_set_json_field_name(table, phase_column, "phase");
return true;
}
-static int show_pcr_table(EventLog *el, JsonVariant **ret_variant) {
+static int show_pcr_table(EventLog *el, sd_json_variant **ret_variant) {
_cleanup_(table_unrefp) Table *table = NULL;
int r;
if (r < 0)
return r;
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
(void) table_hide_column_from_display(table, (size_t) 1, (size_t) 2); /* hide color block and emoji column */
else if (!emoji_enabled())
(void) table_hide_column_from_display(table, (size_t) 2);
if (r < 0)
return log_error_errno(r, "Failed to output table: %m");
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
printf("\n"
"%sLegend: H → PCR hash value matches event log%s\n"
"%s R → All event log records for this PCR have a matching component%s\n"
}
static int verb_show_log(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *log_table = NULL, *pcr_table = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *log_table = NULL, *pcr_table = NULL;
_cleanup_(event_log_freep) EventLog *el = NULL;
- bool want_json = !FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF);
+ bool want_json = !FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF);
int r;
r = event_log_load_and_process(&el);
return r;
if (want_json) {
- _cleanup_(json_variant_unrefp) JsonVariant *object = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *object = NULL;
- r = json_build(&object, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("log", log_table),
- JSON_BUILD_PAIR_VARIANT("pcrs", pcr_table)));
+ r = sd_json_build(&object, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("log", log_table),
+ SD_JSON_BUILD_PAIR_VARIANT("pcrs", pcr_table)));
if (r < 0)
return log_error_errno(r, "Failed to generate combined object: %m");
- r = json_variant_dump(object, arg_json_format_flags, stdout, /* prefix= */ NULL);
+ r = sd_json_variant_dump(object, arg_json_format_flags, stdout, /* prefix= */ NULL);
if (r < 0)
return log_error_errno(r, "Failed to dump JSON object: %m");
}
return 0;
}
-static int event_log_record_to_cel(EventLogRecord *record, uint64_t *recnum, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *ja = NULL, *fj = NULL;
- JsonVariant *cd = NULL;
+static int event_log_record_to_cel(EventLogRecord *record, uint64_t *recnum, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *ja = NULL, *fj = NULL;
+ sd_json_variant *cd = NULL;
const char *ct = NULL;
int r;
assert(ret);
LIST_FOREACH(banks, bank, record->banks) {
- r = json_variant_append_arrayb(
- &ja, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("hashAlg", tpm2_hash_alg_to_string(bank->algorithm)),
- JSON_BUILD_PAIR_HEX("digest", bank->hash.buffer, bank->hash.size)));
+ r = sd_json_variant_append_arrayb(
+ &ja, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("hashAlg", tpm2_hash_alg_to_string(bank->algorithm)),
+ SD_JSON_BUILD_PAIR_HEX("digest", bank->hash.buffer, bank->hash.size)));
if (r < 0)
return log_error_errno(r, "Failed to append CEL digest entry: %m");
}
if (!ja) {
- r = json_variant_new_array(&ja, NULL, 0);
+ r = sd_json_variant_new_array(&ja, NULL, 0);
if (r < 0)
return log_error_errno(r, "Failed to allocate JSON array: %m");
}
} else if (asprintf(&et, "%" PRIu32, record->firmware_event_type) < 0)
return log_oom();
- r = json_build(&fj, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("event_type", et),
- JSON_BUILD_PAIR_HEX("event_data", record->firmware_payload, record->firmware_payload_size)));
+ r = sd_json_build(&fj, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("event_type", et),
+ SD_JSON_BUILD_PAIR_HEX("event_data", record->firmware_payload, record->firmware_payload_size)));
if (r < 0)
return log_error_errno(r, "Failed to build firmware event data: %m");
ct = "systemd";
}
- r = json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("pcr", record->pcr),
- JSON_BUILD_PAIR_UNSIGNED("recnum", ++(*recnum)),
- JSON_BUILD_PAIR_VARIANT("digests", ja),
- JSON_BUILD_PAIR_CONDITION(ct, "content_type", JSON_BUILD_STRING(ct)),
- JSON_BUILD_PAIR_CONDITION(cd, "content", JSON_BUILD_VARIANT(cd))));
+ r = sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("pcr", record->pcr),
+ SD_JSON_BUILD_PAIR_UNSIGNED("recnum", ++(*recnum)),
+ SD_JSON_BUILD_PAIR_VARIANT("digests", ja),
+ SD_JSON_BUILD_PAIR_CONDITION(!!ct, "content_type", SD_JSON_BUILD_STRING(ct)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!cd, "content", SD_JSON_BUILD_VARIANT(cd))));
if (r < 0)
return log_error_errno(r, "Failed to make CEL record: %m");
}
static int verb_show_cel(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_(event_log_freep) EventLog *el = NULL;
uint64_t recnum = 0;
int r;
/* Output the event log in TCG CEL-JSON. */
FOREACH_ARRAY(rr, el->records, el->n_records) {
- _cleanup_(json_variant_unrefp) JsonVariant *cel = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *cel = NULL;
r = event_log_record_to_cel(*rr, &recnum, &cel);
if (r < 0)
return r;
- r = json_variant_append_array(&array, cel);
+ r = sd_json_variant_append_array(&array, cel);
if (r < 0)
return log_error_errno(r, "Failed to append CEL record: %m");
}
- if (arg_json_format_flags & (JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ if (arg_json_format_flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
pager_open(arg_pager_flags);
- json_variant_dump(array, arg_json_format_flags|JSON_FORMAT_EMPTY_ARRAY, stdout, NULL);
+ sd_json_variant_dump(array, arg_json_format_flags|SD_JSON_FORMAT_EMPTY_ARRAY, stdout, NULL);
return 0;
}
FOREACH_ARRAY(c, el->components, el->n_components) {
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
_cleanup_free_ char *marker = NULL;
switch (loc) {
}
}
- if (!table_isempty(table) || !FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ if (!table_isempty(table) || !FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
r = table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, /* show_header= */ true);
if (r < 0)
return log_error_errno(r, "Failed to output table: %m");
}
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
if (table_isempty(table))
printf("No components defined.\n");
else
uint32_t pcr,
const void *data,
size_t data_size,
- JsonVariant **ret_record) {
+ sd_json_variant **ret_record) {
- _cleanup_(json_variant_unrefp) JsonVariant *digests = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *digests = NULL;
int r;
assert(data || data_size == 0);
if (EVP_Digest(data, data_size, hash, &hash_usize, md, NULL) != 1)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "Failed to hash data with algorithm '%s'.", a);
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&digests,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(a)),
- JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(hash, hash_usize))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("hashAlg", SD_JSON_BUILD_STRING(a)),
+ SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(hash, hash_usize))));
if (r < 0)
return log_error_errno(r, "Failed to build JSON digest object: %m");
}
- r = json_build(ret_record,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(pcr)),
- JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(digests))));
+ r = sd_json_build(ret_record,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_UNSIGNED(pcr)),
+ SD_JSON_BUILD_PAIR("digests", SD_JSON_BUILD_VARIANT(digests))));
if (r < 0)
return log_error_errno(r, "Failed to build record object: %m");
static int make_pcrlock_record_from_stream(
uint32_t pcr_mask,
FILE *f,
- JsonVariant **ret_records) {
+ sd_json_variant **ret_records) {
- _cleanup_(json_variant_unrefp) JsonVariant *digests = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *digests = NULL;
_cleanup_(evp_md_ctx_free_all) EVP_MD_CTX *mdctx[TPM2_N_HASH_ALGORITHMS] = {};
int r;
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"Failed to finalize hash context for algorithn '%s'.", a);
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&digests,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(a)),
- JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(hash, hash_usize))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("hashAlg", SD_JSON_BUILD_STRING(a)),
+ SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(hash, hash_usize))));
if (r < 0)
return log_error_errno(r, "Failed to build JSON digest object: %m");
}
for (uint32_t i = 0; i < TPM2_PCRS_MAX; i++) {
- _cleanup_(json_variant_unrefp) JsonVariant *record = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *record = NULL;
if (!FLAGS_SET(pcr_mask, UINT32_C(1) << i))
continue;
- r = json_build(&record,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(i)),
- JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(digests))));
+ r = sd_json_build(&record,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_UNSIGNED(i)),
+ SD_JSON_BUILD_PAIR("digests", SD_JSON_BUILD_VARIANT(digests))));
if (r < 0)
return log_error_errno(r, "Failed to build record object: %m");
- r = json_variant_append_array(ret_records, record);
+ r = sd_json_variant_append_array(ret_records, record);
if (r < 0)
return log_error_errno(r, "Failed to append to JSON array: %m");
}
return arg_pcrlock_path ?: arg_pcrlock_auto ? default_pcrlock_path : NULL;
}
-static int write_pcrlock(JsonVariant *array, const char *default_pcrlock_path) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *a = NULL;
+static int write_pcrlock(sd_json_variant *array, const char *default_pcrlock_path) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *a = NULL;
_cleanup_fclose_ FILE *f = NULL;
const char *p;
int r;
if (!array) {
- r = json_variant_new_array(&a, NULL, 0);
+ r = sd_json_variant_new_array(&a, NULL, 0);
if (r < 0)
return log_error_errno(r, "Failed to allocate empty array: %m");
array = a;
}
- r = json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("records", JSON_BUILD_VARIANT(array))));
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("records", SD_JSON_BUILD_VARIANT(array))));
if (r < 0)
return log_error_errno(r, "Failed to build JSON object: %m");
return log_error_errno(errno, "Failed to open %s for writing: %m", p);
}
- r = json_variant_dump(v, arg_json_format_flags, f ?: stdout, /* prefix= */ NULL);
+ r = sd_json_variant_dump(v, arg_json_format_flags, f ?: stdout, /* prefix= */ NULL);
if (r < 0)
return log_error_errno(r, "Failed to output JSON object: %m");
}
static int verb_lock_raw(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *records = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *records = NULL;
_cleanup_fclose_ FILE *f = NULL;
int r;
{ EFI_VENDOR_DATABASE, "dbr", -1 },
};
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
int r;
/* Generates expected records from the current SecureBoot state, as readable in the EFI variables
* right now. */
FOREACH_ELEMENT(vv, variables) {
- _cleanup_(json_variant_unrefp) JsonVariant *record = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *record = NULL;
_cleanup_free_ char *name = NULL;
if (asprintf(&name, "%s-" SD_ID128_UUID_FORMAT_STR, vv->name, SD_ID128_FORMAT_VAL(vv->id)) < 0)
if (r < 0)
return r;
- r = json_variant_append_array(&array, record);
+ r = sd_json_variant_append_array(&array, record);
if (r < 0)
return log_error_errno(r, "Failed to append to JSON array: %m");
}
}
static int verb_lock_secureboot_authority(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_(event_log_freep) EventLog *el = NULL;
int r;
return r;
FOREACH_ARRAY(rr, el->records, el->n_records) {
- _cleanup_(json_variant_unrefp) JsonVariant *digests = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *digests = NULL;
EventLogRecord *rec = *rr;
if (!event_log_record_is_secureboot_authority(rec))
log_debug("Locking down authority '%s'.", strna(rec->description));
LIST_FOREACH(banks, bank, rec->banks) {
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&digests,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(tpm2_hash_alg_to_string(bank->algorithm))),
- JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(bank->hash.buffer, bank->hash.size))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("hashAlg", SD_JSON_BUILD_STRING(tpm2_hash_alg_to_string(bank->algorithm))),
+ SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(bank->hash.buffer, bank->hash.size))));
if (r < 0)
return log_error_errno(r, "Failed to build digests array: %m");
}
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(rec->pcr)),
- JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(digests))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_UNSIGNED(rec->pcr)),
+ SD_JSON_BUILD_PAIR("digests", SD_JSON_BUILD_VARIANT(digests))));
if (r < 0)
return log_error_errno(r, "Failed to build record array: %m");
}
}
static int verb_lock_gpt(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL, *record = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL, *record = NULL;
_cleanup_(sd_device_unrefp) sd_device *d = NULL;
uint8_t h[2 * 4096]; /* space for at least two 4K sectors. GPT header should definitely be in here */
uint64_t start, n_members, member_size;
if (r < 0)
return r;
- r = json_variant_new_array(&array, &record, 1);
+ r = sd_json_variant_new_array(&array, &record, 1);
if (r < 0)
return log_error_errno(r, "Failed to append to JSON array: %m");
if (!arg_pcrlock_path && arg_pcrlock_auto)
return;
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_SSE))
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_SSE))
return;
log_notice("Enabling JSON_SEQ mode, since writing two .pcrlock files to single output.");
- arg_json_format_flags |= JSON_FORMAT_SSE;
+ arg_json_format_flags |= SD_JSON_FORMAT_SSE;
}
static int verb_lock_firmware(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *array_early = NULL, *array_late = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array_early = NULL, *array_late = NULL;
_cleanup_(event_log_freep) EventLog *el = NULL;
uint32_t always_mask, separator_mask, separator_seen_mask = 0, action_seen_mask = 0;
const char *default_pcrlock_early_path, *default_pcrlock_late_path;
// and exactly once
FOREACH_ARRAY(rr, el->records, el->n_records) {
- _cleanup_(json_variant_unrefp) JsonVariant *digests = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *digests = NULL;
EventLogRecord *rec = *rr;
uint32_t bit = UINT32_C(1) << rec->pcr;
}
LIST_FOREACH(banks, bank, rec->banks) {
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&digests,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(tpm2_hash_alg_to_string(bank->algorithm))),
- JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(bank->hash.buffer, bank->hash.size))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("hashAlg", SD_JSON_BUILD_STRING(tpm2_hash_alg_to_string(bank->algorithm))),
+ SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(bank->hash.buffer, bank->hash.size))));
if (r < 0)
return log_error_errno(r, "Failed to build digests array: %m");
}
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
FLAGS_SET(separator_seen_mask, bit) ? &array_late : &array_early,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(rec->pcr)),
- JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(digests))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_UNSIGNED(rec->pcr)),
+ SD_JSON_BUILD_PAIR("digests", SD_JSON_BUILD_VARIANT(digests))));
if (r < 0)
return log_error_errno(r, "Failed to build record array: %m");
}
}
static int verb_lock_machine_id(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *record = NULL, *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *record = NULL, *array = NULL;
_cleanup_free_ char *word = NULL;
int r;
if (r < 0)
return r;
- r = json_variant_new_array(&array, &record, 1);
+ r = sd_json_variant_new_array(&array, &record, 1);
if (r < 0)
return log_error_errno(r, "Failed to create record array: %m");
STRV_FOREACH(p, paths) {
_cleanup_free_ char *word = NULL, *normalized_path = NULL, *pcrlock_file = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *record = NULL, *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *record = NULL, *array = NULL;
r = pcrextend_file_system_word(*p, &word, &normalized_path);
if (r < 0)
if (r < 0)
return r;
- r = json_variant_new_array(&array, &record, 1);
+ r = sd_json_variant_new_array(&array, &record, 1);
if (r < 0)
return log_error_errno(r, "Failed to create record array: %m");
}
static int verb_lock_pe(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_close_ int fd = -EBADF;
int r;
arg_pcr_mask = UINT32_C(1) << TPM2_PCR_BOOT_LOADER_CODE;
for (uint32_t i = 0; i < TPM2_PCRS_MAX; i++) {
- _cleanup_(json_variant_unrefp) JsonVariant *digests = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *digests = NULL;
if (!FLAGS_SET(arg_pcr_mask, UINT32_C(1) << i))
continue;
if (r < 0)
return log_error_errno(r, "Failed to hash PE binary: %m");
- r = json_variant_append_arrayb(&digests,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(a)),
- JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(hash, hash_size))));
+ r = sd_json_variant_append_arrayb(&digests,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("hashAlg", SD_JSON_BUILD_STRING(a)),
+ SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(hash, hash_size))));
if (r < 0)
return log_error_errno(r, "Failed to build JSON digest object: %m");
}
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(i)),
- JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(digests))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_UNSIGNED(i)),
+ SD_JSON_BUILD_PAIR("digests", SD_JSON_BUILD_VARIANT(digests))));
if (r < 0)
return log_error_errno(r, "Failed to append record object: %m");
}
}
static int verb_lock_uki(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL, *pe_digests = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL, *pe_digests = NULL;
_cleanup_(section_hashes_array_done) SectionHashArray section_hashes = {};
size_t hash_sizes[TPM2_N_HASH_ALGORITHMS];
_cleanup_close_ int fd = -EBADF;
if (r < 0)
return log_error_errno(r, "Failed to hash PE binary: %m");
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&pe_digests,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(a)),
- JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(peh, hash_sizes[i]))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("hashAlg", SD_JSON_BUILD_STRING(a)),
+ SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(peh, hash_sizes[i]))));
if (r < 0)
return log_error_errno(r, "Failed to build JSON digest object: %m");
return log_error_errno(r, "Failed to UKI hash PE binary: %m");
}
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(TPM2_PCR_BOOT_LOADER_CODE)),
- JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(pe_digests))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_UNSIGNED(TPM2_PCR_BOOT_LOADER_CODE)),
+ SD_JSON_BUILD_PAIR("digests", SD_JSON_BUILD_VARIANT(pe_digests))));
if (r < 0)
return log_error_errno(r, "Failed to append record object: %m");
for (UnifiedSection section = 0; section < _UNIFIED_SECTION_MAX; section++) {
- _cleanup_(json_variant_unrefp) JsonVariant *section_digests = NULL, *record = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *section_digests = NULL, *record = NULL;
if (!unified_section_measure(section))
continue;
assert_se(a = tpm2_hash_alg_to_string(tpm2_hash_algorithms[i]));
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
§ion_digests,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("hashAlg", JSON_BUILD_STRING(a)),
- JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(hash, hash_sizes[i]))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("hashAlg", SD_JSON_BUILD_STRING(a)),
+ SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(hash, hash_sizes[i]))));
if (r < 0)
return log_error_errno(r, "Failed to build JSON digest object: %m");
}
if (r < 0)
return r;
- r = json_variant_append_array(&array, record);
+ r = sd_json_variant_append_array(&array, record);
if (r < 0)
return log_error_errno(r, "Failed to append JSON record array: %m");
/* And then append a record for the section contents digests as well */
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(TPM2_PCR_KERNEL_BOOT /* =11 */)),
- JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(section_digests))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_UNSIGNED(TPM2_PCR_KERNEL_BOOT /* =11 */)),
+ SD_JSON_BUILD_PAIR("digests", SD_JSON_BUILD_VARIANT(section_digests))));
if (r < 0)
return log_error_errno(r, "Failed to append record object: %m");
}
}
static int verb_lock_kernel_cmdline(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *record = NULL, *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *record = NULL, *array = NULL;
_cleanup_free_ char *cmdline = NULL;
int r;
if (r < 0)
return r;
- r = json_variant_new_array(&array, &record, 1);
+ r = sd_json_variant_new_array(&array, &record, 1);
if (r < 0)
return log_error_errno(r, "Failed to create record array: %m");
}
static int verb_lock_kernel_initrd(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *records = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *records = NULL;
_cleanup_fclose_ FILE *f = NULL;
uint32_t pcr_mask = UINT32_C(1) << TPM2_PCR_KERNEL_INITRD;
int r;
pager_open(arg_pager_flags);
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
for (size_t i = 0; i < TPM2_N_HASH_ALGORITHMS; i++) {
- _cleanup_(json_variant_unrefp) JsonVariant *aj = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *aj = NULL;
r = tpm2_pcr_prediction_to_json(
context,
if (r < 0)
return r;
- if (json_variant_elements(aj) == 0)
+ if (sd_json_variant_elements(aj) == 0)
continue;
- r = json_variant_set_field(
+ r = sd_json_variant_set_field(
&j,
tpm2_hash_alg_to_string(tpm2_hash_algorithms[i]),
aj);
}
if (!j) {
- r = json_variant_new_object(&j, NULL, 0);
+ r = sd_json_variant_new_object(&j, NULL, 0);
if (r < 0)
return log_error_errno(r, "Failed to allocated empty object: %m");
}
- json_variant_dump(j, arg_json_format_flags, /* f= */ NULL, /* prefix= */ NULL);
+ sd_json_variant_dump(j, arg_json_format_flags, /* f= */ NULL, /* prefix= */ NULL);
return 0;
}
log_info("Predicted future PCRs in %s.", FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), predict_start_usec), 1));
- _cleanup_(json_variant_unrefp) JsonVariant *new_prediction_json = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *new_prediction_json = NULL;
r = tpm2_pcr_prediction_to_json(&new_prediction, el->primary_algorithm, &new_prediction_json);
if (r < 0)
return r;
if (DEBUG_LOGGING)
- (void) json_variant_dump(new_prediction_json, JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO, stderr, NULL);
+ (void) sd_json_variant_dump(new_prediction_json, SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO, stderr, NULL);
_cleanup_(tpm2_pcrlock_policy_done) Tpm2PCRLockPolicy old_policy = {};
return log_error_errno(r, "Failed to marshal NV public area: %m");
}
- _cleanup_(json_variant_unrefp) JsonVariant *new_configuration_json = NULL;
- r = json_build(&new_configuration_json,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("pcrBank", tpm2_hash_alg_to_string(el->primary_algorithm)),
- JSON_BUILD_PAIR_VARIANT("pcrValues", new_prediction_json),
- JSON_BUILD_PAIR_INTEGER("nvIndex", nv_index),
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *new_configuration_json = NULL;
+ r = sd_json_build(&new_configuration_json,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("pcrBank", tpm2_hash_alg_to_string(el->primary_algorithm)),
+ SD_JSON_BUILD_PAIR_VARIANT("pcrValues", new_prediction_json),
+ SD_JSON_BUILD_PAIR_INTEGER("nvIndex", nv_index),
JSON_BUILD_PAIR_IOVEC_BASE64("nvHandle", &nv_blob),
JSON_BUILD_PAIR_IOVEC_BASE64("nvPublic", &nv_public_blob),
JSON_BUILD_PAIR_IOVEC_BASE64("srkHandle", &srk_blob),
return log_error_errno(r, "Failed to generate JSON: %m");
_cleanup_free_ char *text = NULL;
- r = json_variant_format(new_configuration_json, 0, &text);
+ r = sd_json_variant_format(new_configuration_json, 0, &text);
if (r < 0)
return log_error_errno(r, "Failed to format new configuration to JSON: %m");
return dispatch_verb(argc, argv, verbs, NULL);
}
-static int vl_method_read_event_log(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_read_event_log(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
_cleanup_(event_log_freep) EventLog *el = NULL;
uint64_t recnum = 0;
int r;
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
el = event_log_new();
if (r < 0)
return r;
- _cleanup_(json_variant_unrefp) JsonVariant *rec_cel = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *rec_cel = NULL;
FOREACH_ARRAY(rr, el->records, el->n_records) {
if (rec_cel) {
r = varlink_notifyb(link,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR_VARIANT("record", rec_cel)));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_VARIANT("record", rec_cel)));
if (r < 0)
return r;
- rec_cel = json_variant_unref(rec_cel);
+ rec_cel = sd_json_variant_unref(rec_cel);
}
r = event_log_record_to_cel(*rr, &recnum, &rec_cel);
}
return varlink_replyb(link,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR_CONDITION(rec_cel, "record", JSON_BUILD_VARIANT(rec_cel))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_CONDITION(!!rec_cel, "record", SD_JSON_BUILD_VARIANT(rec_cel))));
}
typedef struct MethodMakePolicyParameters {
bool force;
} MethodMakePolicyParameters;
-static int vl_method_make_policy(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "force", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(MethodMakePolicyParameters, force), 0 },
+static int vl_method_make_policy(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "force", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(MethodMakePolicyParameters, force), 0 },
{}
};
MethodMakePolicyParameters p = {};
return varlink_reply(link, NULL);
}
-static int vl_method_remove_policy(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_remove_policy(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
int r;
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
r = remove_policy();
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL, *copy = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(memstream_done) MemStream m = {};
FILE *f;
(void) fprintf(f, "%s", strna(dns_resource_record_to_string(rr)));
assert_se(dns_resource_record_to_json(rr, &v) >= 0);
- assert_se(json_variant_dump(v, JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR|JSON_FORMAT_SOURCE, f, NULL) >= 0);
+ assert_se(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_SOURCE, f, NULL) >= 0);
assert_se(dns_resource_record_to_wire_format(rr, false) >= 0);
assert_se(dns_resource_record_to_wire_format(rr, true) >= 0);
#include <net/if.h>
#include "sd-bus.h"
+#include "sd-json.h"
#include "sd-netlink.h"
#include "af-list.h"
#include "format-util.h"
#include "gcrypt-util.h"
#include "hostname-util.h"
-#include "json.h"
+#include "json-util.h"
#include "main-func.h"
#include "missing_network.h"
#include "netlink-util.h"
static uint16_t arg_class = 0;
static bool arg_legend = true;
static uint64_t arg_flags = 0;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
bool arg_ifindex_permissive = false; /* If true, don't generate an error if the specified interface index doesn't exist */
static const char *arg_service_family = NULL;
if (!arg_legend)
return;
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
return;
if (flags == 0)
assert(name);
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type=A or --type=AAAA to acquire address record information in JSON format.");
log_debug("Resolving %s (family %s, interface %s).", name, af_to_name(arg_family) ?: "*", isempty(arg_ifname) ? "*" : arg_ifname);
assert(IN_SET(family, AF_INET, AF_INET6));
assert(address);
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type= to acquire resource record information in JSON format.");
if (ifindex <= 0)
if (r < 0)
return log_error_errno(r, "Failed to parse RR: %m");
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
r = dns_resource_record_to_json(rr, &j);
if (r < 0)
return log_error_errno(r, "Failed to convert RR to JSON: %m");
if (!j)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "JSON formatting for records of type %s (%u) not available.", dns_type_to_string(rr->key->type), rr->key->type);
- r = json_variant_dump(j, arg_json_format_flags, NULL, NULL);
+ r = sd_json_variant_dump(j, arg_json_format_flags, NULL, NULL);
if (r < 0)
return r;
static int verb_service(int argc, char **argv, void *userdata) {
sd_bus *bus = userdata;
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type= to acquire resource record information in JSON format.");
if (argc == 2)
sd_bus *bus = userdata;
int q, r = 0;
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type= to acquire resource record information in JSON format.");
STRV_FOREACH(p, argv + 1) {
const char *family = "tcp";
int q, r = 0;
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Use --json=pretty with --type= to acquire resource record information in JSON format.");
if (service_family_is_valid(argv[1])) {
static int show_statistics(int argc, char **argv, void *userdata) {
_cleanup_(table_unrefp) Table *table = NULL;
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
_cleanup_(varlink_unrefp) Varlink *vl = NULL;
int r;
if (r < 0)
return r;
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
- return json_variant_dump(reply, arg_json_format_flags, NULL, NULL);
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
+ return sd_json_variant_dump(reply, arg_json_format_flags, NULL, NULL);
struct statistics {
- JsonVariant *transactions;
- JsonVariant *cache;
- JsonVariant *dnssec;
+ sd_json_variant *transactions;
+ sd_json_variant *cache;
+ sd_json_variant *dnssec;
} statistics;
- static const JsonDispatch statistics_dispatch_table[] = {
- { "transactions", JSON_VARIANT_OBJECT, json_dispatch_variant_noref, offsetof(struct statistics, transactions), JSON_MANDATORY },
- { "cache", JSON_VARIANT_OBJECT, json_dispatch_variant_noref, offsetof(struct statistics, cache), JSON_MANDATORY },
- { "dnssec", JSON_VARIANT_OBJECT, json_dispatch_variant_noref, offsetof(struct statistics, dnssec), JSON_MANDATORY },
+ static const sd_json_dispatch_field statistics_dispatch_table[] = {
+ { "transactions", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_variant_noref, offsetof(struct statistics, transactions), SD_JSON_MANDATORY },
+ { "cache", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_variant_noref, offsetof(struct statistics, cache), SD_JSON_MANDATORY },
+ { "dnssec", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_variant_noref, offsetof(struct statistics, dnssec), SD_JSON_MANDATORY },
{},
};
- r = json_dispatch(reply, statistics_dispatch_table, JSON_LOG, &statistics);
+ r = sd_json_dispatch(reply, statistics_dispatch_table, SD_JSON_LOG, &statistics);
if (r < 0)
return r;
uint64_t n_failure_responses_served_stale_total;
} transactions;
- static const JsonDispatch transactions_dispatch_table[] = {
- { "currentTransactions", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct transactions, n_current_transactions), JSON_MANDATORY },
- { "totalTransactions", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct transactions, n_transactions_total), JSON_MANDATORY },
- { "totalTimeouts", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct transactions, n_timeouts_total), JSON_MANDATORY },
- { "totalTimeoutsServedStale", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct transactions, n_timeouts_served_stale_total), JSON_MANDATORY },
- { "totalFailedResponses", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct transactions, n_failure_responses_total), JSON_MANDATORY },
- { "totalFailedResponsesServedStale", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct transactions, n_failure_responses_served_stale_total), JSON_MANDATORY },
+ static const sd_json_dispatch_field transactions_dispatch_table[] = {
+ { "currentTransactions", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_current_transactions), SD_JSON_MANDATORY },
+ { "totalTransactions", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_transactions_total), SD_JSON_MANDATORY },
+ { "totalTimeouts", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_timeouts_total), SD_JSON_MANDATORY },
+ { "totalTimeoutsServedStale", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_timeouts_served_stale_total), SD_JSON_MANDATORY },
+ { "totalFailedResponses", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_failure_responses_total), SD_JSON_MANDATORY },
+ { "totalFailedResponsesServedStale", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct transactions, n_failure_responses_served_stale_total), SD_JSON_MANDATORY },
{},
};
- r = json_dispatch(statistics.transactions, transactions_dispatch_table, JSON_LOG, &transactions);
+ r = sd_json_dispatch(statistics.transactions, transactions_dispatch_table, SD_JSON_LOG, &transactions);
if (r < 0)
return r;
uint64_t n_cache_miss;
} cache;
- static const JsonDispatch cache_dispatch_table[] = {
- { "size", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct cache, cache_size), JSON_MANDATORY },
- { "hits", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct cache, n_cache_hit), JSON_MANDATORY },
- { "misses", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct cache, n_cache_miss), JSON_MANDATORY },
+ static const sd_json_dispatch_field cache_dispatch_table[] = {
+ { "size", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct cache, cache_size), SD_JSON_MANDATORY },
+ { "hits", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct cache, n_cache_hit), SD_JSON_MANDATORY },
+ { "misses", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct cache, n_cache_miss), SD_JSON_MANDATORY },
{},
};
- r = json_dispatch(statistics.cache, cache_dispatch_table, JSON_LOG, &cache);
+ r = sd_json_dispatch(statistics.cache, cache_dispatch_table, SD_JSON_LOG, &cache);
if (r < 0)
return r;
uint64_t n_dnssec_indeterminate;
} dnsssec;
- static const JsonDispatch dnssec_dispatch_table[] = {
- { "secure", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_secure), JSON_MANDATORY },
- { "insecure", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_insecure), JSON_MANDATORY },
- { "bogus", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_bogus), JSON_MANDATORY },
- { "indeterminate", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_indeterminate), JSON_MANDATORY },
+ static const sd_json_dispatch_field dnssec_dispatch_table[] = {
+ { "secure", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_secure), SD_JSON_MANDATORY },
+ { "insecure", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_insecure), SD_JSON_MANDATORY },
+ { "bogus", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_bogus), SD_JSON_MANDATORY },
+ { "indeterminate", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct dnsssec, n_dnssec_indeterminate), SD_JSON_MANDATORY },
{},
};
- r = json_dispatch(statistics.dnssec, dnssec_dispatch_table, JSON_LOG, &dnsssec);
+ r = sd_json_dispatch(statistics.dnssec, dnssec_dispatch_table, SD_JSON_LOG, &dnsssec);
if (r < 0)
return r;
}
static int reset_statistics(int argc, char **argv, void *userdata) {
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
_cleanup_(varlink_unrefp) Varlink *vl = NULL;
int r;
if (r < 0)
return r;
- if (!FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
- return json_variant_dump(reply, arg_json_format_flags, NULL, NULL);
+ if (!FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
+ return sd_json_variant_dump(reply, arg_json_format_flags, NULL, NULL);
return 0;
}
return verb_log_control_common(bus, "org.freedesktop.resolve1", argv[0], argc == 2 ? argv[1] : NULL);
}
-static int print_question(char prefix, const char *color, JsonVariant *question) {
- JsonVariant *q = NULL;
+static int print_question(char prefix, const char *color, sd_json_variant *question) {
+ sd_json_variant *q = NULL;
int r;
assert(color);
return 0;
}
-static int print_answer(JsonVariant *answer) {
- JsonVariant *a;
+static int print_answer(sd_json_variant *answer) {
+ sd_json_variant *a;
int r;
JSON_VARIANT_ARRAY_FOREACH(a, answer) {
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
_cleanup_free_ void *d = NULL;
- JsonVariant *jraw;
+ sd_json_variant *jraw;
const char *s;
size_t l;
- jraw = json_variant_by_key(a, "raw");
+ jraw = sd_json_variant_by_key(a, "raw");
if (!jraw) {
log_warning("Received monitor answer lacking valid raw data, ignoring.");
continue;
}
- r = json_variant_unbase64(jraw, &d, &l);
+ r = sd_json_variant_unbase64(jraw, &d, &l);
if (r < 0) {
log_warning_errno(r, "Failed to undo base64 encoding of monitor answer raw data, ignoring.");
continue;
return 0;
}
-static void monitor_query_dump(JsonVariant *v) {
- _cleanup_(json_variant_unrefp) JsonVariant *question = NULL, *answer = NULL, *collected_questions = NULL;
+static void monitor_query_dump(sd_json_variant *v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *question = NULL, *answer = NULL, *collected_questions = NULL;
int rcode = -1, error = 0, ede_code = -1;
const char *state = NULL, *result = NULL, *ede_msg = NULL;
assert(v);
- JsonDispatch dispatch_table[] = {
- { "question", JSON_VARIANT_ARRAY, json_dispatch_variant, PTR_TO_SIZE(&question), JSON_MANDATORY },
- { "answer", JSON_VARIANT_ARRAY, json_dispatch_variant, PTR_TO_SIZE(&answer), 0 },
- { "collectedQuestions", JSON_VARIANT_ARRAY, json_dispatch_variant, PTR_TO_SIZE(&collected_questions), 0 },
- { "state", JSON_VARIANT_STRING, json_dispatch_const_string, PTR_TO_SIZE(&state), JSON_MANDATORY },
- { "result", JSON_VARIANT_STRING, json_dispatch_const_string, PTR_TO_SIZE(&result), 0 },
- { "rcode", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, PTR_TO_SIZE(&rcode), 0 },
- { "errno", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, PTR_TO_SIZE(&error), 0 },
- { "extendedDNSErrorCode", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, PTR_TO_SIZE(&ede_code), 0 },
- { "extendedDNSErrorMessage", JSON_VARIANT_STRING, json_dispatch_const_string, PTR_TO_SIZE(&ede_msg), 0 },
+ sd_json_dispatch_field dispatch_table[] = {
+ { "question", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, PTR_TO_SIZE(&question), SD_JSON_MANDATORY },
+ { "answer", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, PTR_TO_SIZE(&answer), 0 },
+ { "collectedQuestions", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, PTR_TO_SIZE(&collected_questions), 0 },
+ { "state", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, PTR_TO_SIZE(&state), SD_JSON_MANDATORY },
+ { "result", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, PTR_TO_SIZE(&result), 0 },
+ { "rcode", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, PTR_TO_SIZE(&rcode), 0 },
+ { "errno", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, PTR_TO_SIZE(&error), 0 },
+ { "extendedDNSErrorCode", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, PTR_TO_SIZE(&ede_code), 0 },
+ { "extendedDNSErrorMessage", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, PTR_TO_SIZE(&ede_msg), 0 },
{}
};
- if (json_dispatch(v, dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, NULL) < 0)
+ if (sd_json_dispatch(v, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, NULL) < 0)
return;
/* First show the current question */
static int monitor_reply(
Varlink *link,
- JsonVariant *parameters,
+ sd_json_variant *parameters,
const char *error_id,
VarlinkReplyFlags flags,
void *userdata) {
return 0;
}
- if (json_variant_by_key(parameters, "ready")) {
+ if (sd_json_variant_by_key(parameters, "ready")) {
/* The first message coming in will just indicate that we are now subscribed. We let our
* caller know if they asked for it. Once the caller sees this they should know that we are
* not going to miss any queries anymore. */
return 0;
}
- if (arg_json_format_flags & JSON_FORMAT_OFF) {
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF) {
monitor_query_dump(parameters);
printf("\n");
} else
- json_variant_dump(parameters, arg_json_format_flags, NULL, NULL);
+ sd_json_variant_dump(parameters, arg_json_format_flags, NULL, NULL);
fflush(stdout);
return c;
}
-static int dump_cache_item(JsonVariant *item) {
+static int dump_cache_item(sd_json_variant *item) {
struct item_info {
- JsonVariant *key;
- JsonVariant *rrs;
+ sd_json_variant *key;
+ sd_json_variant *rrs;
const char *type;
uint64_t until;
} item_info = {};
- static const JsonDispatch dispatch_table[] = {
- { "key", JSON_VARIANT_OBJECT, json_dispatch_variant_noref, offsetof(struct item_info, key), JSON_MANDATORY },
- { "rrs", JSON_VARIANT_ARRAY, json_dispatch_variant_noref, offsetof(struct item_info, rrs), 0 },
- { "type", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(struct item_info, type), 0 },
- { "until", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct item_info, until), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "key", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_variant_noref, offsetof(struct item_info, key), SD_JSON_MANDATORY },
+ { "rrs", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant_noref, offsetof(struct item_info, rrs), 0 },
+ { "type", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct item_info, type), 0 },
+ { "until", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct item_info, until), 0 },
{},
};
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *k = NULL;
int r, c = 0;
- r = json_dispatch(item, dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, &item_info);
+ r = sd_json_dispatch(item, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &item_info);
if (r < 0)
return r;
if (item_info.type)
printf("%s %s%s%s\n", DNS_RESOURCE_KEY_TO_STRING(k), ansi_highlight_red(), item_info.type, ansi_normal());
else {
- JsonVariant *i;
+ sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, item_info.rrs) {
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
_cleanup_free_ void *data = NULL;
- JsonVariant *raw;
+ sd_json_variant *raw;
size_t size;
- raw = json_variant_by_key(i, "raw");
+ raw = sd_json_variant_by_key(i, "raw");
if (!raw)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "raw field missing from RR JSON data.");
- r = json_variant_unbase64(raw, &data, &size);
+ r = sd_json_variant_unbase64(raw, &data, &size);
if (r < 0)
return log_error_errno(r, "Unable to decode raw RR JSON data: %m");
return c;
}
-static int dump_cache_scope(JsonVariant *scope) {
+static int dump_cache_scope(sd_json_variant *scope) {
struct scope_info {
const char *protocol;
int family;
int ifindex;
const char *ifname;
- JsonVariant *cache;
+ sd_json_variant *cache;
} scope_info = {
.family = AF_UNSPEC,
};
- JsonVariant *i;
+ sd_json_variant *i;
int r, c = 0;
- static const JsonDispatch dispatch_table[] = {
- { "protocol", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(struct scope_info, protocol), JSON_MANDATORY },
- { "family", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(struct scope_info, family), 0 },
- { "ifindex", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(struct scope_info, ifindex), 0 },
- { "ifname", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(struct scope_info, ifname), 0 },
- { "cache", JSON_VARIANT_ARRAY, json_dispatch_variant_noref, offsetof(struct scope_info, cache), JSON_MANDATORY },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "protocol", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, protocol), SD_JSON_MANDATORY },
+ { "family", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(struct scope_info, family), 0 },
+ { "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(struct scope_info, ifindex), 0 },
+ { "ifname", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct scope_info, ifname), 0 },
+ { "cache", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant_noref, offsetof(struct scope_info, cache), SD_JSON_MANDATORY },
{},
};
- r = json_dispatch(scope, dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, &scope_info);
+ r = sd_json_dispatch(scope, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &scope_info);
if (r < 0)
return r;
}
static int verb_show_cache(int argc, char *argv[], void *userdata) {
- JsonVariant *reply = NULL, *d = NULL;
+ sd_json_variant *reply = NULL, *d = NULL;
_cleanup_(varlink_unrefp) Varlink *vl = NULL;
int r;
if (r < 0)
return r;
- d = json_variant_by_key(reply, "dump");
+ d = sd_json_variant_by_key(reply, "dump");
if (!d)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"DumpCache() response is missing 'dump' key.");
- if (!json_variant_is_array(d))
+ if (!sd_json_variant_is_array(d))
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"DumpCache() response 'dump' field not an array");
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
- JsonVariant *i;
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
+ sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, d) {
r = dump_cache_scope(i);
return 0;
}
- return json_variant_dump(d, arg_json_format_flags, NULL, NULL);
+ return sd_json_variant_dump(d, arg_json_format_flags, NULL, NULL);
}
-static int dump_server_state(JsonVariant *server) {
+static int dump_server_state(sd_json_variant *server) {
_cleanup_(table_unrefp) Table *table = NULL;
TableCell *cell;
int r;
- static const JsonDispatch dispatch_table[] = {
- { "Server", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(struct server_state, server_name), JSON_MANDATORY },
- { "Type", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(struct server_state, type), JSON_MANDATORY },
- { "Interface", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(struct server_state, ifname), 0 },
- { "InterfaceIndex", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(struct server_state, ifindex), 0 },
- { "VerifiedFeatureLevel", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(struct server_state, verified_feature_level), 0 },
- { "PossibleFeatureLevel", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(struct server_state, possible_feature_level), 0 },
- { "DNSSECMode", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(struct server_state, dnssec_mode), JSON_MANDATORY },
- { "DNSSECSupported", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct server_state, dnssec_supported), JSON_MANDATORY },
- { "ReceivedUDPFragmentMax", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct server_state, received_udp_fragment_max), JSON_MANDATORY },
- { "FailedUDPAttempts", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct server_state, n_failed_udp), JSON_MANDATORY },
- { "FailedTCPAttempts", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct server_state, n_failed_tcp), JSON_MANDATORY },
- { "PacketTruncated", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct server_state, packet_truncated), JSON_MANDATORY },
- { "PacketBadOpt", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct server_state, packet_bad_opt), JSON_MANDATORY },
- { "PacketRRSIGMissing", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct server_state, packet_rrsig_missing), JSON_MANDATORY },
- { "PacketInvalid", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct server_state, packet_invalid), JSON_MANDATORY },
- { "PacketDoOff", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct server_state, packet_do_off), JSON_MANDATORY },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "Server", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, server_name), SD_JSON_MANDATORY },
+ { "Type", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, type), SD_JSON_MANDATORY },
+ { "Interface", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, ifname), 0 },
+ { "InterfaceIndex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(struct server_state, ifindex), 0 },
+ { "VerifiedFeatureLevel", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, verified_feature_level), 0 },
+ { "PossibleFeatureLevel", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, possible_feature_level), 0 },
+ { "DNSSECMode", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct server_state, dnssec_mode), SD_JSON_MANDATORY },
+ { "DNSSECSupported", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, dnssec_supported), SD_JSON_MANDATORY },
+ { "ReceivedUDPFragmentMax", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct server_state, received_udp_fragment_max), SD_JSON_MANDATORY },
+ { "FailedUDPAttempts", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct server_state, n_failed_udp), SD_JSON_MANDATORY },
+ { "FailedTCPAttempts", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct server_state, n_failed_tcp), SD_JSON_MANDATORY },
+ { "PacketTruncated", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_truncated), SD_JSON_MANDATORY },
+ { "PacketBadOpt", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_bad_opt), SD_JSON_MANDATORY },
+ { "PacketRRSIGMissing", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_rrsig_missing), SD_JSON_MANDATORY },
+ { "PacketInvalid", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_invalid), SD_JSON_MANDATORY },
+ { "PacketDoOff", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct server_state, packet_do_off), SD_JSON_MANDATORY },
{},
};
- r = json_dispatch(server, dispatch_table, JSON_LOG|JSON_ALLOW_EXTENSIONS, &server_state);
+ r = sd_json_dispatch(server, dispatch_table, SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS, &server_state);
if (r < 0)
return r;
}
static int verb_show_server_state(int argc, char *argv[], void *userdata) {
- JsonVariant *reply = NULL, *d = NULL;
+ sd_json_variant *reply = NULL, *d = NULL;
_cleanup_(varlink_unrefp) Varlink *vl = NULL;
int r;
if (r < 0)
return r;
- d = json_variant_by_key(reply, "dump");
+ d = sd_json_variant_by_key(reply, "dump");
if (!d)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"DumpCache() response is missing 'dump' key.");
- if (!json_variant_is_array(d))
+ if (!sd_json_variant_is_array(d))
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"DumpCache() response 'dump' field not an array");
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
- JsonVariant *i;
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
+ sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, d) {
r = dump_server_state(i);
return 0;
}
- return json_variant_dump(d, arg_json_format_flags, NULL, NULL);
+ return sd_json_variant_dump(d, arg_json_format_flags, NULL, NULL);
}
static void help_protocol_types(void) {
break;
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
break;
case '?':
}
}
-int dns_cache_dump_to_json(DnsCache *cache, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *c = NULL;
+int dns_cache_dump_to_json(DnsCache *cache, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *c = NULL;
DnsCacheItem *i;
int r;
assert(ret);
HASHMAP_FOREACH(i, cache->by_key) {
- _cleanup_(json_variant_unrefp) JsonVariant *d = NULL, *k = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *d = NULL, *k = NULL;
r = dns_resource_key_to_json(i->key, &k);
if (r < 0)
return r;
if (i->rr) {
- _cleanup_(json_variant_unrefp) JsonVariant *l = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
LIST_FOREACH(by_key, j, i) {
- _cleanup_(json_variant_unrefp) JsonVariant *rj = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *rj = NULL;
assert(j->rr);
if (r < 0)
return r;
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&l,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("rr", rj),
- JSON_BUILD_PAIR_BASE64("raw", j->rr->wire_format, j->rr->wire_format_size)));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("rr", rj),
+ SD_JSON_BUILD_PAIR_BASE64("raw", j->rr->wire_format, j->rr->wire_format_size)));
if (r < 0)
return r;
}
if (!l) {
- r = json_variant_new_array(&l, NULL, 0);
+ r = sd_json_variant_new_array(&l, NULL, 0);
if (r < 0)
return r;
}
- r = json_build(&d,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("key", k),
- JSON_BUILD_PAIR_VARIANT("rrs", l),
- JSON_BUILD_PAIR_UNSIGNED("until", i->until)));
+ r = sd_json_build(&d,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("key", k),
+ SD_JSON_BUILD_PAIR_VARIANT("rrs", l),
+ SD_JSON_BUILD_PAIR_UNSIGNED("until", i->until)));
} else if (i->type == DNS_CACHE_NODATA) {
- r = json_build(&d,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("key", k),
- JSON_BUILD_PAIR_EMPTY_ARRAY("rrs"),
- JSON_BUILD_PAIR_UNSIGNED("until", i->until)));
+ r = sd_json_build(&d,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("key", k),
+ SD_JSON_BUILD_PAIR_EMPTY_ARRAY("rrs"),
+ SD_JSON_BUILD_PAIR_UNSIGNED("until", i->until)));
} else
- r = json_build(&d,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("key", k),
- JSON_BUILD_PAIR_STRING("type", dns_cache_item_type_to_string(i)),
- JSON_BUILD_PAIR_UNSIGNED("until", i->until)));
+ r = sd_json_build(&d,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("key", k),
+ SD_JSON_BUILD_PAIR_STRING("type", dns_cache_item_type_to_string(i)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("until", i->until)));
if (r < 0)
return r;
- r = json_variant_append_array(&c, d);
+ r = sd_json_variant_append_array(&c, d);
if (r < 0)
return r;
}
if (!c)
- return json_variant_new_array(ret, NULL, 0);
+ return sd_json_variant_new_array(ret, NULL, 0);
*ret = TAKE_PTR(c);
return 0;
int dns_cache_check_conflicts(DnsCache *cache, DnsResourceRecord *rr, int owner_family, const union in_addr_union *owner_address);
void dns_cache_dump(DnsCache *cache, FILE *f);
-int dns_cache_dump_to_json(DnsCache *cache, JsonVariant **ret);
+int dns_cache_dump_to_json(DnsCache *cache, sd_json_variant **ret);
bool dns_cache_is_empty(DnsCache *cache);
#include "dns-type.h"
#include "escape.h"
#include "hexdecoct.h"
+#include "json-util.h"
#include "memory-util.h"
#include "resolved-dns-dnssec.h"
#include "resolved-dns-packet.h"
return dns_packet_read_rr(p, ret, NULL, NULL);
}
-int dns_resource_key_to_json(DnsResourceKey *key, JsonVariant **ret) {
+int dns_resource_key_to_json(DnsResourceKey *key, sd_json_variant **ret) {
assert(key);
assert(ret);
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("class", JSON_BUILD_INTEGER(key->class)),
- JSON_BUILD_PAIR("type", JSON_BUILD_INTEGER(key->type)),
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(dns_resource_key_name(key)))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("class", SD_JSON_BUILD_INTEGER(key->class)),
+ SD_JSON_BUILD_PAIR("type", SD_JSON_BUILD_INTEGER(key->type)),
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(dns_resource_key_name(key)))));
}
-int dns_resource_key_from_json(JsonVariant *v, DnsResourceKey **ret) {
+int dns_resource_key_from_json(sd_json_variant *v, DnsResourceKey **ret) {
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
uint16_t type = 0, class = 0;
const char *name = NULL;
int r;
- JsonDispatch dispatch_table[] = {
- { "class", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint16, PTR_TO_SIZE(&class), JSON_MANDATORY },
- { "type", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint16, PTR_TO_SIZE(&type), JSON_MANDATORY },
- { "name", JSON_VARIANT_STRING, json_dispatch_const_string, PTR_TO_SIZE(&name), JSON_MANDATORY },
+ sd_json_dispatch_field dispatch_table[] = {
+ { "class", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, PTR_TO_SIZE(&class), SD_JSON_MANDATORY },
+ { "type", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, PTR_TO_SIZE(&type), SD_JSON_MANDATORY },
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, PTR_TO_SIZE(&name), SD_JSON_MANDATORY },
{}
};
assert(v);
assert(ret);
- r = json_dispatch(v, dispatch_table, 0, NULL);
+ r = sd_json_dispatch(v, dispatch_table, 0, NULL);
if (r < 0)
return r;
return 0;
}
-static int type_bitmap_to_json(Bitmap *b, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *l = NULL;
+static int type_bitmap_to_json(Bitmap *b, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
unsigned t;
int r;
assert(ret);
BITMAP_FOREACH(t, b) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
- r = json_variant_new_unsigned(&v, t);
+ r = sd_json_variant_new_unsigned(&v, t);
if (r < 0)
return r;
- r = json_variant_append_array(&l, v);
+ r = sd_json_variant_append_array(&l, v);
if (r < 0)
return r;
}
if (!l)
- return json_variant_new_array(ret, NULL, 0);
+ return sd_json_variant_new_array(ret, NULL, 0);
*ret = TAKE_PTR(l);
return 0;
}
-static int txt_to_json(DnsTxtItem *items, JsonVariant **ret) {
- JsonVariant **elements = NULL;
+static int txt_to_json(DnsTxtItem *items, sd_json_variant **ret) {
+ sd_json_variant **elements = NULL;
size_t n = 0;
int r;
goto finalize;
}
- r = json_variant_new_octescape(elements + n, i->data, i->length);
+ r = sd_json_variant_new_octescape(elements + n, i->data, i->length);
if (r < 0)
goto finalize;
n++;
}
- r = json_variant_new_array(ret, elements, n);
+ r = sd_json_variant_new_array(ret, elements, n);
finalize:
- json_variant_unref_many(elements, n);
+ sd_json_variant_unref_many(elements, n);
return r;
}
-static int svc_params_to_json(DnsSvcParam *params, JsonVariant **ret) {
- JsonVariant **elements = NULL;
+static int svc_params_to_json(DnsSvcParam *params, sd_json_variant **ret) {
+ sd_json_variant **elements = NULL;
size_t n = 0;
int r;
goto finalize;
}
- r = json_variant_new_base64(elements + n, i->value, i->length);
+ r = sd_json_variant_new_base64(elements + n, i->value, i->length);
if (r < 0)
goto finalize;
n++;
}
- r = json_variant_new_array(ret, elements, n);
+ r = sd_json_variant_new_array(ret, elements, n);
finalize:
- json_variant_unref_many(elements, n);
+ sd_json_variant_unref_many(elements, n);
return r;
}
-int dns_resource_record_to_json(DnsResourceRecord *rr, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *k = NULL;
+int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *k = NULL;
int r;
assert(rr);
switch (rr->unparsable ? _DNS_TYPE_INVALID : rr->key->type) {
case DNS_TYPE_SRV:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("priority", JSON_BUILD_UNSIGNED(rr->srv.priority)),
- JSON_BUILD_PAIR("weight", JSON_BUILD_UNSIGNED(rr->srv.weight)),
- JSON_BUILD_PAIR("port", JSON_BUILD_UNSIGNED(rr->srv.port)),
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(rr->srv.name))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("priority", SD_JSON_BUILD_UNSIGNED(rr->srv.priority)),
+ SD_JSON_BUILD_PAIR("weight", SD_JSON_BUILD_UNSIGNED(rr->srv.weight)),
+ SD_JSON_BUILD_PAIR("port", SD_JSON_BUILD_UNSIGNED(rr->srv.port)),
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(rr->srv.name))));
case DNS_TYPE_PTR:
case DNS_TYPE_NS:
case DNS_TYPE_CNAME:
case DNS_TYPE_DNAME:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(rr->ptr.name))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(rr->ptr.name))));
case DNS_TYPE_HINFO:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("cpu", JSON_BUILD_STRING(rr->hinfo.cpu)),
- JSON_BUILD_PAIR("os", JSON_BUILD_STRING(rr->hinfo.os))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("cpu", SD_JSON_BUILD_STRING(rr->hinfo.cpu)),
+ SD_JSON_BUILD_PAIR("os", SD_JSON_BUILD_STRING(rr->hinfo.os))));
case DNS_TYPE_SPF:
case DNS_TYPE_TXT: {
- _cleanup_(json_variant_unrefp) JsonVariant *l = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
r = txt_to_json(rr->txt.items, &l);
if (r < 0)
return r;
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("items", JSON_BUILD_VARIANT(l))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("items", SD_JSON_BUILD_VARIANT(l))));
}
case DNS_TYPE_A:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("address", JSON_BUILD_IN4_ADDR(&rr->a.in_addr))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("address", JSON_BUILD_IN4_ADDR(&rr->a.in_addr))));
case DNS_TYPE_AAAA:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("address", JSON_BUILD_IN6_ADDR(&rr->aaaa.in6_addr))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("address", JSON_BUILD_IN6_ADDR(&rr->aaaa.in6_addr))));
case DNS_TYPE_SOA:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("mname", JSON_BUILD_STRING(rr->soa.mname)),
- JSON_BUILD_PAIR("rname", JSON_BUILD_STRING(rr->soa.rname)),
- JSON_BUILD_PAIR("serial", JSON_BUILD_UNSIGNED(rr->soa.serial)),
- JSON_BUILD_PAIR("refresh", JSON_BUILD_UNSIGNED(rr->soa.refresh)),
- JSON_BUILD_PAIR("expire", JSON_BUILD_UNSIGNED(rr->soa.retry)),
- JSON_BUILD_PAIR("minimum", JSON_BUILD_UNSIGNED(rr->soa.minimum))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("mname", SD_JSON_BUILD_STRING(rr->soa.mname)),
+ SD_JSON_BUILD_PAIR("rname", SD_JSON_BUILD_STRING(rr->soa.rname)),
+ SD_JSON_BUILD_PAIR("serial", SD_JSON_BUILD_UNSIGNED(rr->soa.serial)),
+ SD_JSON_BUILD_PAIR("refresh", SD_JSON_BUILD_UNSIGNED(rr->soa.refresh)),
+ SD_JSON_BUILD_PAIR("expire", SD_JSON_BUILD_UNSIGNED(rr->soa.retry)),
+ SD_JSON_BUILD_PAIR("minimum", SD_JSON_BUILD_UNSIGNED(rr->soa.minimum))));
case DNS_TYPE_MX:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("priority", JSON_BUILD_UNSIGNED(rr->mx.priority)),
- JSON_BUILD_PAIR("exchange", JSON_BUILD_STRING(rr->mx.exchange))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("priority", SD_JSON_BUILD_UNSIGNED(rr->mx.priority)),
+ SD_JSON_BUILD_PAIR("exchange", SD_JSON_BUILD_STRING(rr->mx.exchange))));
case DNS_TYPE_LOC:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("version", JSON_BUILD_UNSIGNED(rr->loc.version)),
- JSON_BUILD_PAIR("size", JSON_BUILD_UNSIGNED(rr->loc.size)),
- JSON_BUILD_PAIR("horiz_pre", JSON_BUILD_UNSIGNED(rr->loc.horiz_pre)),
- JSON_BUILD_PAIR("vert_pre", JSON_BUILD_UNSIGNED(rr->loc.vert_pre)),
- JSON_BUILD_PAIR("latitude", JSON_BUILD_UNSIGNED(rr->loc.latitude)),
- JSON_BUILD_PAIR("longitude", JSON_BUILD_UNSIGNED(rr->loc.longitude)),
- JSON_BUILD_PAIR("altitude", JSON_BUILD_UNSIGNED(rr->loc.altitude))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("version", SD_JSON_BUILD_UNSIGNED(rr->loc.version)),
+ SD_JSON_BUILD_PAIR("size", SD_JSON_BUILD_UNSIGNED(rr->loc.size)),
+ SD_JSON_BUILD_PAIR("horiz_pre", SD_JSON_BUILD_UNSIGNED(rr->loc.horiz_pre)),
+ SD_JSON_BUILD_PAIR("vert_pre", SD_JSON_BUILD_UNSIGNED(rr->loc.vert_pre)),
+ SD_JSON_BUILD_PAIR("latitude", SD_JSON_BUILD_UNSIGNED(rr->loc.latitude)),
+ SD_JSON_BUILD_PAIR("longitude", SD_JSON_BUILD_UNSIGNED(rr->loc.longitude)),
+ SD_JSON_BUILD_PAIR("altitude", SD_JSON_BUILD_UNSIGNED(rr->loc.altitude))));
case DNS_TYPE_DS:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("keyTag", JSON_BUILD_UNSIGNED(rr->ds.key_tag)),
- JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr->ds.algorithm)),
- JSON_BUILD_PAIR("digestType", JSON_BUILD_UNSIGNED(rr->ds.digest_type)),
- JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(rr->ds.digest, rr->ds.digest_size))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("keyTag", SD_JSON_BUILD_UNSIGNED(rr->ds.key_tag)),
+ SD_JSON_BUILD_PAIR("algorithm", SD_JSON_BUILD_UNSIGNED(rr->ds.algorithm)),
+ SD_JSON_BUILD_PAIR("digestType", SD_JSON_BUILD_UNSIGNED(rr->ds.digest_type)),
+ SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(rr->ds.digest, rr->ds.digest_size))));
case DNS_TYPE_SSHFP:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr->sshfp.algorithm)),
- JSON_BUILD_PAIR("fptype", JSON_BUILD_UNSIGNED(rr->sshfp.fptype)),
- JSON_BUILD_PAIR("fingerprint", JSON_BUILD_HEX(rr->sshfp.fingerprint, rr->sshfp.fingerprint_size))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("algorithm", SD_JSON_BUILD_UNSIGNED(rr->sshfp.algorithm)),
+ SD_JSON_BUILD_PAIR("fptype", SD_JSON_BUILD_UNSIGNED(rr->sshfp.fptype)),
+ SD_JSON_BUILD_PAIR("fingerprint", SD_JSON_BUILD_HEX(rr->sshfp.fingerprint, rr->sshfp.fingerprint_size))));
case DNS_TYPE_DNSKEY:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(rr->dnskey.flags)),
- JSON_BUILD_PAIR("protocol", JSON_BUILD_UNSIGNED(rr->dnskey.protocol)),
- JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr->dnskey.algorithm)),
- JSON_BUILD_PAIR("dnskey", JSON_BUILD_BASE64(rr->dnskey.key, rr->dnskey.key_size))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_UNSIGNED(rr->dnskey.flags)),
+ SD_JSON_BUILD_PAIR("protocol", SD_JSON_BUILD_UNSIGNED(rr->dnskey.protocol)),
+ SD_JSON_BUILD_PAIR("algorithm", SD_JSON_BUILD_UNSIGNED(rr->dnskey.algorithm)),
+ SD_JSON_BUILD_PAIR("dnskey", SD_JSON_BUILD_BASE64(rr->dnskey.key, rr->dnskey.key_size))));
case DNS_TYPE_RRSIG:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("signer", JSON_BUILD_STRING(rr->rrsig.signer)),
- JSON_BUILD_PAIR("typeCovered", JSON_BUILD_UNSIGNED(rr->rrsig.type_covered)),
- JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr->rrsig.algorithm)),
- JSON_BUILD_PAIR("labels", JSON_BUILD_UNSIGNED(rr->rrsig.labels)),
- JSON_BUILD_PAIR("originalTtl", JSON_BUILD_UNSIGNED(rr->rrsig.original_ttl)),
- JSON_BUILD_PAIR("expiration", JSON_BUILD_UNSIGNED(rr->rrsig.expiration)),
- JSON_BUILD_PAIR("inception", JSON_BUILD_UNSIGNED(rr->rrsig.inception)),
- JSON_BUILD_PAIR("keyTag", JSON_BUILD_UNSIGNED(rr->rrsig.key_tag)),
- JSON_BUILD_PAIR("signature", JSON_BUILD_BASE64(rr->rrsig.signature, rr->rrsig.signature_size))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("signer", SD_JSON_BUILD_STRING(rr->rrsig.signer)),
+ SD_JSON_BUILD_PAIR("typeCovered", SD_JSON_BUILD_UNSIGNED(rr->rrsig.type_covered)),
+ SD_JSON_BUILD_PAIR("algorithm", SD_JSON_BUILD_UNSIGNED(rr->rrsig.algorithm)),
+ SD_JSON_BUILD_PAIR("labels", SD_JSON_BUILD_UNSIGNED(rr->rrsig.labels)),
+ SD_JSON_BUILD_PAIR("originalTtl", SD_JSON_BUILD_UNSIGNED(rr->rrsig.original_ttl)),
+ SD_JSON_BUILD_PAIR("expiration", SD_JSON_BUILD_UNSIGNED(rr->rrsig.expiration)),
+ SD_JSON_BUILD_PAIR("inception", SD_JSON_BUILD_UNSIGNED(rr->rrsig.inception)),
+ SD_JSON_BUILD_PAIR("keyTag", SD_JSON_BUILD_UNSIGNED(rr->rrsig.key_tag)),
+ SD_JSON_BUILD_PAIR("signature", SD_JSON_BUILD_BASE64(rr->rrsig.signature, rr->rrsig.signature_size))));
case DNS_TYPE_NSEC: {
- _cleanup_(json_variant_unrefp) JsonVariant *bm = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *bm = NULL;
r = type_bitmap_to_json(rr->nsec.types, &bm);
if (r < 0)
return r;
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("nextDomain", JSON_BUILD_STRING(rr->nsec.next_domain_name)),
- JSON_BUILD_PAIR("types", JSON_BUILD_VARIANT(bm))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("nextDomain", SD_JSON_BUILD_STRING(rr->nsec.next_domain_name)),
+ SD_JSON_BUILD_PAIR("types", SD_JSON_BUILD_VARIANT(bm))));
}
case DNS_TYPE_NSEC3: {
- _cleanup_(json_variant_unrefp) JsonVariant *bm = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *bm = NULL;
r = type_bitmap_to_json(rr->nsec3.types, &bm);
if (r < 0)
return r;
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr->nsec3.algorithm)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(rr->nsec3.flags)),
- JSON_BUILD_PAIR("iterations", JSON_BUILD_UNSIGNED(rr->nsec3.iterations)),
- JSON_BUILD_PAIR("salt", JSON_BUILD_HEX(rr->nsec3.salt, rr->nsec3.salt_size)),
- JSON_BUILD_PAIR("hash", JSON_BUILD_BASE32HEX(rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size)),
- JSON_BUILD_PAIR("types", JSON_BUILD_VARIANT(bm))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("algorithm", SD_JSON_BUILD_UNSIGNED(rr->nsec3.algorithm)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_UNSIGNED(rr->nsec3.flags)),
+ SD_JSON_BUILD_PAIR("iterations", SD_JSON_BUILD_UNSIGNED(rr->nsec3.iterations)),
+ SD_JSON_BUILD_PAIR("salt", SD_JSON_BUILD_HEX(rr->nsec3.salt, rr->nsec3.salt_size)),
+ SD_JSON_BUILD_PAIR("hash", SD_JSON_BUILD_BASE32HEX(rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size)),
+ SD_JSON_BUILD_PAIR("types", SD_JSON_BUILD_VARIANT(bm))));
}
case DNS_TYPE_TLSA:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("certUsage", JSON_BUILD_UNSIGNED(rr->tlsa.cert_usage)),
- JSON_BUILD_PAIR("selector", JSON_BUILD_UNSIGNED(rr->tlsa.selector)),
- JSON_BUILD_PAIR("matchingType", JSON_BUILD_UNSIGNED(rr->tlsa.matching_type)),
- JSON_BUILD_PAIR("data", JSON_BUILD_HEX(rr->tlsa.data, rr->tlsa.data_size))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("certUsage", SD_JSON_BUILD_UNSIGNED(rr->tlsa.cert_usage)),
+ SD_JSON_BUILD_PAIR("selector", SD_JSON_BUILD_UNSIGNED(rr->tlsa.selector)),
+ SD_JSON_BUILD_PAIR("matchingType", SD_JSON_BUILD_UNSIGNED(rr->tlsa.matching_type)),
+ SD_JSON_BUILD_PAIR("data", SD_JSON_BUILD_HEX(rr->tlsa.data, rr->tlsa.data_size))));
case DNS_TYPE_SVCB:
case DNS_TYPE_HTTPS: {
- _cleanup_(json_variant_unrefp) JsonVariant *p = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *p = NULL;
r = svc_params_to_json(rr->svcb.params, &p);
if (r < 0)
return r;
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("priority", JSON_BUILD_UNSIGNED(rr->svcb.priority)),
- JSON_BUILD_PAIR("target", JSON_BUILD_STRING(rr->svcb.target_name)),
- JSON_BUILD_PAIR("params", JSON_BUILD_VARIANT(p))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("priority", SD_JSON_BUILD_UNSIGNED(rr->svcb.priority)),
+ SD_JSON_BUILD_PAIR("target", SD_JSON_BUILD_STRING(rr->svcb.target_name)),
+ SD_JSON_BUILD_PAIR("params", SD_JSON_BUILD_VARIANT(p))));
}
case DNS_TYPE_CAA:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(rr->caa.flags)),
- JSON_BUILD_PAIR("tag", JSON_BUILD_STRING(rr->caa.tag)),
- JSON_BUILD_PAIR("value", JSON_BUILD_OCTESCAPE(rr->caa.value, rr->caa.value_size))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_UNSIGNED(rr->caa.flags)),
+ SD_JSON_BUILD_PAIR("tag", SD_JSON_BUILD_STRING(rr->caa.tag)),
+ SD_JSON_BUILD_PAIR("value", SD_JSON_BUILD_OCTESCAPE(rr->caa.value, rr->caa.value_size))));
case DNS_TYPE_NAPTR:
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k)),
- JSON_BUILD_PAIR("order", JSON_BUILD_UNSIGNED(rr->naptr.order)),
- JSON_BUILD_PAIR("preference", JSON_BUILD_UNSIGNED(rr->naptr.preference)),
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+ SD_JSON_BUILD_PAIR("order", SD_JSON_BUILD_UNSIGNED(rr->naptr.order)),
+ SD_JSON_BUILD_PAIR("preference", SD_JSON_BUILD_UNSIGNED(rr->naptr.preference)),
/* NB: we name this flags field here naptrFlags, because there's already another "flags" field (for example in CAA) which has a different type */
- JSON_BUILD_PAIR("naptrFlags", JSON_BUILD_STRING(rr->naptr.flags)),
- JSON_BUILD_PAIR("services", JSON_BUILD_STRING(rr->naptr.services)),
- JSON_BUILD_PAIR("regexp", JSON_BUILD_STRING(rr->naptr.regexp)),
- JSON_BUILD_PAIR("replacement", JSON_BUILD_STRING(rr->naptr.replacement))));
+ SD_JSON_BUILD_PAIR("naptrFlags", SD_JSON_BUILD_STRING(rr->naptr.flags)),
+ SD_JSON_BUILD_PAIR("services", SD_JSON_BUILD_STRING(rr->naptr.services)),
+ SD_JSON_BUILD_PAIR("regexp", SD_JSON_BUILD_STRING(rr->naptr.regexp)),
+ SD_JSON_BUILD_PAIR("replacement", SD_JSON_BUILD_STRING(rr->naptr.replacement))));
default:
/* Can't provide broken-down format */
#include <netinet/in.h>
+#include "sd-json.h"
+
#include "bitmap.h"
#include "dns-def.h"
#include "dns-type.h"
#include "hashmap.h"
#include "in-addr-util.h"
-#include "json.h"
#include "list.h"
#include "string-util.h"
#include "time-util.h"
int dns_resource_record_new_from_raw(DnsResourceRecord **ret, const void *data, size_t size);
-int dns_resource_key_to_json(DnsResourceKey *key, JsonVariant **ret);
-int dns_resource_key_from_json(JsonVariant *v, DnsResourceKey **ret);
-int dns_resource_record_to_json(DnsResourceRecord *rr, JsonVariant **ret);
+int dns_resource_key_to_json(DnsResourceKey *key, sd_json_variant **ret);
+int dns_resource_key_from_json(sd_json_variant *v, DnsResourceKey **ret);
+int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret);
void dns_resource_record_hash_func(const DnsResourceRecord *i, struct siphash *state);
int dns_resource_record_compare_func(const DnsResourceRecord *x, const DnsResourceRecord *y);
return !dns_scope_has_route_only_domains(scope);
}
-int dns_scope_dump_cache_to_json(DnsScope *scope, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *cache = NULL;
+int dns_scope_dump_cache_to_json(DnsScope *scope, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *cache = NULL;
int r;
assert(scope);
if (r < 0)
return r;
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("protocol", dns_protocol_to_string(scope->protocol)),
- JSON_BUILD_PAIR_CONDITION(scope->family != AF_UNSPEC, "family", JSON_BUILD_INTEGER(scope->family)),
- JSON_BUILD_PAIR_CONDITION(scope->link, "ifindex", JSON_BUILD_INTEGER(scope->link ? scope->link->ifindex : 0)),
- JSON_BUILD_PAIR_CONDITION(scope->link, "ifname", JSON_BUILD_STRING(scope->link ? scope->link->ifname : NULL)),
- JSON_BUILD_PAIR_VARIANT("cache", cache)));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("protocol", dns_protocol_to_string(scope->protocol)),
+ SD_JSON_BUILD_PAIR_CONDITION(scope->family != AF_UNSPEC, "family", SD_JSON_BUILD_INTEGER(scope->family)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!scope->link, "ifindex", SD_JSON_BUILD_INTEGER(scope->link ? scope->link->ifindex : 0)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!scope->link, "ifname", SD_JSON_BUILD_STRING(scope->link ? scope->link->ifname : NULL)),
+ SD_JSON_BUILD_PAIR_VARIANT("cache", cache)));
}
int dns_type_suitable_for_protocol(uint16_t type, DnsProtocol protocol) {
bool dns_scope_is_default_route(DnsScope *scope);
-int dns_scope_dump_cache_to_json(DnsScope *scope, JsonVariant **ret);
+int dns_scope_dump_cache_to_json(DnsScope *scope, sd_json_variant **ret);
int dns_type_suitable_for_protocol(uint16_t type, DnsProtocol protocol);
int dns_question_types_suitable_for_protocol(DnsQuestion *q, DnsProtocol protocol);
};
DEFINE_STRING_TABLE_LOOKUP(dns_server_feature_level, DnsServerFeatureLevel);
-int dns_server_dump_state_to_json(DnsServer *server, JsonVariant **ret) {
+int dns_server_dump_state_to_json(DnsServer *server, sd_json_variant **ret) {
assert(server);
assert(ret);
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("Server", strna(dns_server_string_full(server))),
- JSON_BUILD_PAIR_STRING("Type", strna(dns_server_type_to_string(server->type))),
- JSON_BUILD_PAIR_CONDITION(server->type == DNS_SERVER_LINK, "Interface", JSON_BUILD_STRING(server->link ? server->link->ifname : NULL)),
- JSON_BUILD_PAIR_CONDITION(server->type == DNS_SERVER_LINK, "InterfaceIndex", JSON_BUILD_UNSIGNED(server->link ? server->link->ifindex : 0)),
- JSON_BUILD_PAIR_STRING("VerifiedFeatureLevel", strna(dns_server_feature_level_to_string(server->verified_feature_level))),
- JSON_BUILD_PAIR_STRING("PossibleFeatureLevel", strna(dns_server_feature_level_to_string(server->possible_feature_level))),
- JSON_BUILD_PAIR_STRING("DNSSECMode", strna(dnssec_mode_to_string(dns_server_get_dnssec_mode(server)))),
- JSON_BUILD_PAIR_BOOLEAN("DNSSECSupported", dns_server_dnssec_supported(server)),
- JSON_BUILD_PAIR_UNSIGNED("ReceivedUDPFragmentMax", server->received_udp_fragment_max),
- JSON_BUILD_PAIR_UNSIGNED("FailedUDPAttempts", server->n_failed_udp),
- JSON_BUILD_PAIR_UNSIGNED("FailedTCPAttempts", server->n_failed_tcp),
- JSON_BUILD_PAIR_BOOLEAN("PacketTruncated", server->packet_truncated),
- JSON_BUILD_PAIR_BOOLEAN("PacketBadOpt", server->packet_bad_opt),
- JSON_BUILD_PAIR_BOOLEAN("PacketRRSIGMissing", server->packet_rrsig_missing),
- JSON_BUILD_PAIR_BOOLEAN("PacketInvalid", server->packet_invalid),
- JSON_BUILD_PAIR_BOOLEAN("PacketDoOff", server->packet_do_off)));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("Server", strna(dns_server_string_full(server))),
+ SD_JSON_BUILD_PAIR_STRING("Type", strna(dns_server_type_to_string(server->type))),
+ SD_JSON_BUILD_PAIR_CONDITION(server->type == DNS_SERVER_LINK, "Interface", SD_JSON_BUILD_STRING(server->link ? server->link->ifname : NULL)),
+ SD_JSON_BUILD_PAIR_CONDITION(server->type == DNS_SERVER_LINK, "InterfaceIndex", SD_JSON_BUILD_UNSIGNED(server->link ? server->link->ifindex : 0)),
+ SD_JSON_BUILD_PAIR_STRING("VerifiedFeatureLevel", strna(dns_server_feature_level_to_string(server->verified_feature_level))),
+ SD_JSON_BUILD_PAIR_STRING("PossibleFeatureLevel", strna(dns_server_feature_level_to_string(server->possible_feature_level))),
+ SD_JSON_BUILD_PAIR_STRING("DNSSECMode", strna(dnssec_mode_to_string(dns_server_get_dnssec_mode(server)))),
+ SD_JSON_BUILD_PAIR_BOOLEAN("DNSSECSupported", dns_server_dnssec_supported(server)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("ReceivedUDPFragmentMax", server->received_udp_fragment_max),
+ SD_JSON_BUILD_PAIR_UNSIGNED("FailedUDPAttempts", server->n_failed_udp),
+ SD_JSON_BUILD_PAIR_UNSIGNED("FailedTCPAttempts", server->n_failed_tcp),
+ SD_JSON_BUILD_PAIR_BOOLEAN("PacketTruncated", server->packet_truncated),
+ SD_JSON_BUILD_PAIR_BOOLEAN("PacketBadOpt", server->packet_bad_opt),
+ SD_JSON_BUILD_PAIR_BOOLEAN("PacketRRSIGMissing", server->packet_rrsig_missing),
+ SD_JSON_BUILD_PAIR_BOOLEAN("PacketInvalid", server->packet_invalid),
+ SD_JSON_BUILD_PAIR_BOOLEAN("PacketDoOff", server->packet_do_off)));
}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "sd-json.h"
+
#include "in-addr-util.h"
-#include "json.h"
#include "list.h"
#include "resolve-util.h"
#include "time-util.h"
DnsScope *dns_server_scope(DnsServer *s);
-int dns_server_dump_state_to_json(DnsServer *server, JsonVariant **ret);
+int dns_server_dump_state_to_json(DnsServer *server, sd_json_variant **ret);
return sendmsg_loop(fd, &mh, 0);
}
-static int dns_question_to_json(DnsQuestion *q, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *l = NULL;
+static int dns_question_to_json(DnsQuestion *q, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
DnsResourceKey *key;
int r;
assert(ret);
DNS_QUESTION_FOREACH(key, q) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = dns_resource_key_to_json(key, &v);
if (r < 0)
return r;
- r = json_variant_append_array(&l, v);
+ r = sd_json_variant_append_array(&l, v);
if (r < 0)
return r;
}
}
int manager_monitor_send(Manager *m, DnsQuery *q) {
- _cleanup_(json_variant_unrefp) JsonVariant *jquestion = NULL, *jcollected_questions = NULL, *janswer = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *jquestion = NULL, *jcollected_questions = NULL, *janswer = NULL;
_cleanup_(dns_question_unrefp) DnsQuestion *merged = NULL;
Varlink *connection;
DnsAnswerItem *rri;
return log_error_errno(r, "Failed to convert question to JSON: %m");
DNS_ANSWER_FOREACH_ITEM(rri, q->answer) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = dns_resource_record_to_json(rri->rr, &v);
if (r < 0)
if (r < 0)
return log_error_errno(r, "Failed to generate RR wire format: %m");
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&janswer,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(v, "rr", JSON_BUILD_VARIANT(v)),
- JSON_BUILD_PAIR("raw", JSON_BUILD_BASE64(rri->rr->wire_format, rri->rr->wire_format_size)),
- JSON_BUILD_PAIR_CONDITION(rri->ifindex > 0, "ifindex", JSON_BUILD_INTEGER(rri->ifindex))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(!!v, "rr", SD_JSON_BUILD_VARIANT(v)),
+ SD_JSON_BUILD_PAIR("raw", SD_JSON_BUILD_BASE64(rri->rr->wire_format, rri->rr->wire_format_size)),
+ SD_JSON_BUILD_PAIR_CONDITION(rri->ifindex > 0, "ifindex", SD_JSON_BUILD_INTEGER(rri->ifindex))));
if (r < 0)
return log_debug_errno(r, "Failed to append notification entry to array: %m");
}
SET_FOREACH(connection, m->varlink_subscription) {
r = varlink_notifyb(connection,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("state", JSON_BUILD_STRING(dns_transaction_state_to_string(q->state))),
- JSON_BUILD_PAIR_CONDITION(q->state == DNS_TRANSACTION_DNSSEC_FAILED,
- "result", JSON_BUILD_STRING(dnssec_result_to_string(q->answer_dnssec_result))),
- JSON_BUILD_PAIR_CONDITION(q->state == DNS_TRANSACTION_RCODE_FAILURE,
- "rcode", JSON_BUILD_INTEGER(q->answer_rcode)),
- JSON_BUILD_PAIR_CONDITION(q->state == DNS_TRANSACTION_ERRNO,
- "errno", JSON_BUILD_INTEGER(q->answer_errno)),
- JSON_BUILD_PAIR_CONDITION(IN_SET(q->state,
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("state", SD_JSON_BUILD_STRING(dns_transaction_state_to_string(q->state))),
+ SD_JSON_BUILD_PAIR_CONDITION(q->state == DNS_TRANSACTION_DNSSEC_FAILED,
+ "result", SD_JSON_BUILD_STRING(dnssec_result_to_string(q->answer_dnssec_result))),
+ SD_JSON_BUILD_PAIR_CONDITION(q->state == DNS_TRANSACTION_RCODE_FAILURE,
+ "rcode", SD_JSON_BUILD_INTEGER(q->answer_rcode)),
+ SD_JSON_BUILD_PAIR_CONDITION(q->state == DNS_TRANSACTION_ERRNO,
+ "errno", SD_JSON_BUILD_INTEGER(q->answer_errno)),
+ SD_JSON_BUILD_PAIR_CONDITION(IN_SET(q->state,
DNS_TRANSACTION_DNSSEC_FAILED,
DNS_TRANSACTION_RCODE_FAILURE) &&
q->answer_ede_rcode >= 0,
- "extendedDNSErrorCode", JSON_BUILD_INTEGER(q->answer_ede_rcode)),
- JSON_BUILD_PAIR_CONDITION(IN_SET(q->state,
+ "extendedDNSErrorCode", SD_JSON_BUILD_INTEGER(q->answer_ede_rcode)),
+ SD_JSON_BUILD_PAIR_CONDITION(IN_SET(q->state,
DNS_TRANSACTION_DNSSEC_FAILED,
DNS_TRANSACTION_RCODE_FAILURE) &&
q->answer_ede_rcode >= 0 && !isempty(q->answer_ede_msg),
- "extendedDNSErrorMessage", JSON_BUILD_STRING(q->answer_ede_msg)),
- JSON_BUILD_PAIR("question", JSON_BUILD_VARIANT(jquestion)),
- JSON_BUILD_PAIR_CONDITION(jcollected_questions,
- "collectedQuestions", JSON_BUILD_VARIANT(jcollected_questions)),
- JSON_BUILD_PAIR_CONDITION(janswer,
- "answer", JSON_BUILD_VARIANT(janswer))));
+ "extendedDNSErrorMessage", SD_JSON_BUILD_STRING(q->answer_ede_msg)),
+ SD_JSON_BUILD_PAIR("question", SD_JSON_BUILD_VARIANT(jquestion)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!jcollected_questions,
+ "collectedQuestions", SD_JSON_BUILD_VARIANT(jcollected_questions)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!janswer,
+ "answer", SD_JSON_BUILD_VARIANT(janswer))));
if (r < 0)
log_debug_errno(r, "Failed to send monitor event, ignoring: %m");
}
}
}
-int dns_manager_dump_statistics_json(Manager *m, JsonVariant **ret) {
+int dns_manager_dump_statistics_json(Manager *m, sd_json_variant **ret) {
uint64_t size = 0, hit = 0, miss = 0;
assert(m);
miss += s->cache.n_miss;
}
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("transactions", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("currentTransactions", hashmap_size(m->dns_transactions)),
- JSON_BUILD_PAIR_UNSIGNED("totalTransactions", m->n_transactions_total),
- JSON_BUILD_PAIR_UNSIGNED("totalTimeouts", m->n_timeouts_total),
- JSON_BUILD_PAIR_UNSIGNED("totalTimeoutsServedStale", m->n_timeouts_served_stale_total),
- JSON_BUILD_PAIR_UNSIGNED("totalFailedResponses", m->n_failure_responses_total),
- JSON_BUILD_PAIR_UNSIGNED("totalFailedResponsesServedStale", m->n_failure_responses_served_stale_total)
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("transactions", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("currentTransactions", hashmap_size(m->dns_transactions)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("totalTransactions", m->n_transactions_total),
+ SD_JSON_BUILD_PAIR_UNSIGNED("totalTimeouts", m->n_timeouts_total),
+ SD_JSON_BUILD_PAIR_UNSIGNED("totalTimeoutsServedStale", m->n_timeouts_served_stale_total),
+ SD_JSON_BUILD_PAIR_UNSIGNED("totalFailedResponses", m->n_failure_responses_total),
+ SD_JSON_BUILD_PAIR_UNSIGNED("totalFailedResponsesServedStale", m->n_failure_responses_served_stale_total)
)),
- JSON_BUILD_PAIR("cache", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("size", size),
- JSON_BUILD_PAIR_UNSIGNED("hits", hit),
- JSON_BUILD_PAIR_UNSIGNED("misses", miss)
+ SD_JSON_BUILD_PAIR("cache", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("size", size),
+ SD_JSON_BUILD_PAIR_UNSIGNED("hits", hit),
+ SD_JSON_BUILD_PAIR_UNSIGNED("misses", miss)
)),
- JSON_BUILD_PAIR("dnssec", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("secure", m->n_dnssec_verdict[DNSSEC_SECURE]),
- JSON_BUILD_PAIR_UNSIGNED("insecure", m->n_dnssec_verdict[DNSSEC_INSECURE]),
- JSON_BUILD_PAIR_UNSIGNED("bogus", m->n_dnssec_verdict[DNSSEC_BOGUS]),
- JSON_BUILD_PAIR_UNSIGNED("indeterminate", m->n_dnssec_verdict[DNSSEC_INDETERMINATE])
+ SD_JSON_BUILD_PAIR("dnssec", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("secure", m->n_dnssec_verdict[DNSSEC_SECURE]),
+ SD_JSON_BUILD_PAIR_UNSIGNED("insecure", m->n_dnssec_verdict[DNSSEC_INSECURE]),
+ SD_JSON_BUILD_PAIR_UNSIGNED("bogus", m->n_dnssec_verdict[DNSSEC_BOGUS]),
+ SD_JSON_BUILD_PAIR_UNSIGNED("indeterminate", m->n_dnssec_verdict[DNSSEC_INDETERMINATE])
))));
}
int socket_disable_pmtud(int fd, int af);
-int dns_manager_dump_statistics_json(Manager *m, JsonVariant **ret);
+int dns_manager_dump_statistics_json(Manager *m, sd_json_variant **ret);
void dns_manager_reset_statistics(Manager *m);
#include "glyph-util.h"
#include "in-addr-util.h"
+#include "json-util.h"
#include "resolved-dns-synthesize.h"
#include "resolved-varlink.h"
#include "socket-netlink.h"
case DNS_TRANSACTION_DNSSEC_FAILED:
return varlink_errorb(q->varlink_request, "io.systemd.Resolve.DNSSECValidationFailed",
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("result", JSON_BUILD_STRING(dnssec_result_to_string(q->answer_dnssec_result))),
- JSON_BUILD_PAIR_CONDITION(q->answer_ede_rcode >= 0,
- "extendedDNSErrorCode", JSON_BUILD_INTEGER(q->answer_ede_rcode)),
- JSON_BUILD_PAIR_CONDITION(q->answer_ede_rcode >= 0 && !isempty(q->answer_ede_msg),
- "extendedDNSErrorMessage", JSON_BUILD_STRING(q->answer_ede_msg))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("result", SD_JSON_BUILD_STRING(dnssec_result_to_string(q->answer_dnssec_result))),
+ SD_JSON_BUILD_PAIR_CONDITION(q->answer_ede_rcode >= 0,
+ "extendedDNSErrorCode", SD_JSON_BUILD_INTEGER(q->answer_ede_rcode)),
+ SD_JSON_BUILD_PAIR_CONDITION(q->answer_ede_rcode >= 0 && !isempty(q->answer_ede_msg),
+ "extendedDNSErrorMessage", SD_JSON_BUILD_STRING(q->answer_ede_msg))));
case DNS_TRANSACTION_NO_TRUST_ANCHOR:
return varlink_error(q->varlink_request, "io.systemd.Resolve.NoTrustAnchor", NULL);
/* We return this as NXDOMAIN. This is only generated when a host doesn't implement LLMNR/TCP, and we
* thus quickly know that we cannot resolve an in-addr.arpa or ip6.arpa address. */
return varlink_errorb(q->varlink_request, "io.systemd.Resolve.DNSError",
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("rcode", JSON_BUILD_INTEGER(DNS_RCODE_NXDOMAIN))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("rcode", SD_JSON_BUILD_INTEGER(DNS_RCODE_NXDOMAIN))));
case DNS_TRANSACTION_RCODE_FAILURE:
return varlink_errorb(q->varlink_request, "io.systemd.Resolve.DNSError",
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("rcode", JSON_BUILD_INTEGER(q->answer_rcode)),
- JSON_BUILD_PAIR_CONDITION(q->answer_ede_rcode >= 0,
- "extendedDNSErrorCode", JSON_BUILD_INTEGER(q->answer_ede_rcode)),
- JSON_BUILD_PAIR_CONDITION(q->answer_ede_rcode >= 0 && !isempty(q->answer_ede_msg),
- "extendedDNSErrorMessage", JSON_BUILD_STRING(q->answer_ede_msg))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("rcode", SD_JSON_BUILD_INTEGER(q->answer_rcode)),
+ SD_JSON_BUILD_PAIR_CONDITION(q->answer_ede_rcode >= 0,
+ "extendedDNSErrorCode", SD_JSON_BUILD_INTEGER(q->answer_ede_rcode)),
+ SD_JSON_BUILD_PAIR_CONDITION(q->answer_ede_rcode >= 0 && !isempty(q->answer_ede_msg),
+ "extendedDNSErrorMessage", SD_JSON_BUILD_STRING(q->answer_ede_msg))));
case DNS_TRANSACTION_NULL:
case DNS_TRANSACTION_PENDING:
}
static int find_addr_records(
- JsonVariant **array,
+ sd_json_variant **array,
DnsQuestion *question,
DnsQuery *q,
DnsResourceRecord **canonical,
int ifindex, r;
DNS_ANSWER_FOREACH_IFINDEX(rr, ifindex, q->answer) {
- _cleanup_(json_variant_unrefp) JsonVariant *entry = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *entry = NULL;
int family;
const void *p;
return -EAFNOSUPPORT;
}
- r = json_build(&entry,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", JSON_BUILD_INTEGER(ifindex)),
- JSON_BUILD_PAIR("family", JSON_BUILD_INTEGER(family)),
- JSON_BUILD_PAIR("address", JSON_BUILD_BYTE_ARRAY(p, FAMILY_ADDRESS_SIZE(family)))));
+ r = sd_json_build(&entry,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", SD_JSON_BUILD_INTEGER(ifindex)),
+ SD_JSON_BUILD_PAIR("family", SD_JSON_BUILD_INTEGER(family)),
+ SD_JSON_BUILD_PAIR("address", SD_JSON_BUILD_BYTE_ARRAY(p, FAMILY_ADDRESS_SIZE(family)))));
if (r < 0)
return r;
- r = json_variant_append_array(array, entry);
+ r = sd_json_variant_append_array(array, entry);
if (r < 0)
return r;
static void vl_method_resolve_hostname_complete(DnsQuery *query) {
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *canonical = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_(dns_query_freep) DnsQuery *q = query;
_cleanup_free_ char *normalized = NULL;
DnsQuestion *question;
if (r < 0)
goto finish;
- if (json_variant_is_blank_object(array)) {
+ if (sd_json_variant_is_blank_object(array)) {
r = varlink_error(q->varlink_request, "io.systemd.Resolve.NoSuchResourceRecord", NULL);
goto finish;
}
goto finish;
r = varlink_replyb(q->varlink_request,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("addresses", JSON_BUILD_VARIANT(array)),
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(normalized)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_INTEGER(dns_query_reply_flags_make(q)))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("addresses", SD_JSON_BUILD_VARIANT(array)),
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(normalized)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_INTEGER(dns_query_reply_flags_make(q)))));
finish:
if (r < 0) {
log_full_errno(ERRNO_IS_DISCONNECT(r) ? LOG_DEBUG : LOG_ERR, r, "Failed to send hostname reply: %m");
return varlink_replyb(
link,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("addresses",
- JSON_BUILD_ARRAY(
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", JSON_BUILD_INTEGER(ifindex)),
- JSON_BUILD_PAIR("family", JSON_BUILD_INTEGER(ff)),
- JSON_BUILD_PAIR("address", JSON_BUILD_BYTE_ARRAY(&parsed, FAMILY_ADDRESS_SIZE(ff)))))),
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(canonical)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_INTEGER(SD_RESOLVED_FLAGS_MAKE(dns_synthesize_protocol(p->flags), ff, true, true)|
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("addresses",
+ SD_JSON_BUILD_ARRAY(
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", SD_JSON_BUILD_INTEGER(ifindex)),
+ SD_JSON_BUILD_PAIR("family", SD_JSON_BUILD_INTEGER(ff)),
+ SD_JSON_BUILD_PAIR("address", SD_JSON_BUILD_BYTE_ARRAY(&parsed, FAMILY_ADDRESS_SIZE(ff)))))),
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(canonical)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_INTEGER(SD_RESOLVED_FLAGS_MAKE(dns_synthesize_protocol(p->flags), ff, true, true)|
SD_RESOLVED_SYNTHETIC))));
}
-static int vl_method_resolve_hostname(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "ifindex", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(LookupParameters, ifindex), 0 },
- { "name", JSON_VARIANT_STRING, json_dispatch_string, offsetof(LookupParameters, name), JSON_MANDATORY },
- { "family", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(LookupParameters, family), 0 },
- { "flags", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(LookupParameters, flags), 0 },
+static int vl_method_resolve_hostname(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(LookupParameters, ifindex), 0 },
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(LookupParameters, name), SD_JSON_MANDATORY },
+ { "family", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(LookupParameters, family), 0 },
+ { "flags", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(LookupParameters, flags), 0 },
{}
};
return 1;
}
-static int json_dispatch_address(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_address(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
LookupParameters *p = ASSERT_PTR(userdata);
union in_addr_union buf = {};
- JsonVariant *i;
+ sd_json_variant *i;
size_t n, k = 0;
assert(variant);
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
- n = json_variant_elements(variant);
+ n = sd_json_variant_elements(variant);
if (!IN_SET(n, 4, 16))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is array of unexpected size.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(i, variant) {
int64_t b;
- if (!json_variant_is_integer(i))
+ if (!sd_json_variant_is_integer(i))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Element %zu of JSON field '%s' is not an integer.", k, strna(name));
- b = json_variant_integer(i);
+ b = sd_json_variant_integer(i);
if (b < 0 || b > 0xff)
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL),
"Element %zu of JSON field '%s' is out of range 0%s255.",
}
static void vl_method_resolve_address_complete(DnsQuery *query) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_(dns_query_freep) DnsQuery *q = query;
DnsQuestion *question;
DnsResourceRecord *rr;
if (r < 0)
goto finish;
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", JSON_BUILD_INTEGER(ifindex)),
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(normalized))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", SD_JSON_BUILD_INTEGER(ifindex)),
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(normalized))));
if (r < 0)
goto finish;
}
- if (json_variant_is_blank_object(array)) {
+ if (sd_json_variant_is_blank_object(array)) {
r = varlink_error(q->varlink_request, "io.systemd.Resolve.NoSuchResourceRecord", NULL);
goto finish;
}
r = varlink_replyb(q->varlink_request,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("names", JSON_BUILD_VARIANT(array)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_INTEGER(dns_query_reply_flags_make(q)))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("names", SD_JSON_BUILD_VARIANT(array)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_INTEGER(dns_query_reply_flags_make(q)))));
finish:
if (r < 0) {
log_full_errno(ERRNO_IS_DISCONNECT(r) ? LOG_DEBUG : LOG_ERR, r, "Failed to send address reply: %m");
}
}
-static int vl_method_resolve_address(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "ifindex", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(LookupParameters, ifindex), 0 },
- { "family", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(LookupParameters, family), JSON_MANDATORY },
- { "address", JSON_VARIANT_ARRAY, json_dispatch_address, 0, JSON_MANDATORY },
- { "flags", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(LookupParameters, flags), 0 },
+static int vl_method_resolve_address(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(LookupParameters, ifindex), 0 },
+ { "family", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(LookupParameters, family), SD_JSON_MANDATORY },
+ { "address", SD_JSON_VARIANT_ARRAY, json_dispatch_address, 0, SD_JSON_MANDATORY },
+ { "flags", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(LookupParameters, flags), 0 },
{}
};
return 1;
}
-static int append_txt(JsonVariant **txt, DnsResourceRecord *rr) {
+static int append_txt(sd_json_variant **txt, DnsResourceRecord *rr) {
int r;
assert(txt);
return 0;
LIST_FOREACH(items, i, rr->txt.items) {
- _cleanup_(json_variant_unrefp) JsonVariant *entry = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *entry = NULL;
if (i->length <= 0)
continue;
- r = json_variant_new_octescape(&entry, i->data, i->length);
+ r = sd_json_variant_new_octescape(&entry, i->data, i->length);
if (r < 0)
return r;
- r = json_variant_append_array(txt, entry);
+ r = sd_json_variant_append_array(txt, entry);
if (r < 0)
return r;
}
static int append_srv(
DnsQuery *q,
DnsResourceRecord *rr,
- JsonVariant **array) {
+ sd_json_variant **array) {
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *canonical = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *normalized = NULL;
int r;
if (r < 0)
return r;
- r = json_build(&v,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("priority", JSON_BUILD_UNSIGNED(rr->srv.priority)),
- JSON_BUILD_PAIR("weight", JSON_BUILD_UNSIGNED(rr->srv.weight)),
- JSON_BUILD_PAIR("port", JSON_BUILD_UNSIGNED(rr->srv.port)),
- JSON_BUILD_PAIR("hostname", JSON_BUILD_STRING(normalized))));
+ r = sd_json_build(&v,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("priority", SD_JSON_BUILD_UNSIGNED(rr->srv.priority)),
+ SD_JSON_BUILD_PAIR("weight", SD_JSON_BUILD_UNSIGNED(rr->srv.weight)),
+ SD_JSON_BUILD_PAIR("port", SD_JSON_BUILD_UNSIGNED(rr->srv.port)),
+ SD_JSON_BUILD_PAIR("hostname", SD_JSON_BUILD_STRING(normalized))));
if (r < 0)
return r;
if (r < 0)
return r;
- r = json_variant_set_field_string(&v, "canonicalName", normalized);
+ r = sd_json_variant_set_field_string(&v, "canonicalName", normalized);
if (r < 0)
return r;
}
if ((q->flags & SD_RESOLVED_NO_ADDRESS) == 0) {
- _cleanup_(json_variant_unrefp) JsonVariant *addresses = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *addresses = NULL;
LIST_FOREACH(auxiliary_queries, aux, q->auxiliary_queries) {
DnsQuestion *question;
return r;
}
- r = json_variant_set_field(&v, "addresses", addresses);
+ r = sd_json_variant_set_field(&v, "addresses", addresses);
if (r < 0)
return r;
}
- r = json_variant_append_array(array, v);
+ r = sd_json_variant_append_array(array, v);
if (r < 0)
return r;
static void resolve_service_all_complete(DnsQuery *query) {
_cleanup_(dns_query_freep) DnsQuery *q = query;
- _cleanup_(json_variant_unrefp) JsonVariant *srv = NULL, *txt = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *srv = NULL, *txt = NULL;
_cleanup_free_ char *name = NULL, *type = NULL, *domain = NULL;
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *canonical = NULL;
DnsQuestion *question;
canonical = dns_resource_record_ref(rr);
}
- if (json_variant_is_blank_object(srv)) {
+ if (sd_json_variant_is_blank_object(srv)) {
r = varlink_error(query->varlink_request, "io.systemd.Resolve.NoSuchResourceRecord", NULL);
goto finish;
}
if (r < 0)
goto finish;
- r = varlink_replyb(query->varlink_request, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("services", JSON_BUILD_VARIANT(srv)),
- JSON_BUILD_PAIR_CONDITION(!json_variant_is_blank_object(txt), "txt", JSON_BUILD_VARIANT(txt)),
- JSON_BUILD_PAIR("canonical", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(name)),
- JSON_BUILD_PAIR("type", JSON_BUILD_STRING(type)),
- JSON_BUILD_PAIR("domain", JSON_BUILD_STRING(domain)))),
- JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(dns_query_reply_flags_make(query)))));
+ r = varlink_replyb(query->varlink_request, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("services", SD_JSON_BUILD_VARIANT(srv)),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_json_variant_is_blank_object(txt), "txt", SD_JSON_BUILD_VARIANT(txt)),
+ SD_JSON_BUILD_PAIR("canonical", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(name)),
+ SD_JSON_BUILD_PAIR("type", SD_JSON_BUILD_STRING(type)),
+ SD_JSON_BUILD_PAIR("domain", SD_JSON_BUILD_STRING(domain)))),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_UNSIGNED(dns_query_reply_flags_make(query)))));
finish:
if (r < 0) {
}
}
-static int vl_method_resolve_service(Varlink* link, JsonVariant* parameters, VarlinkMethodFlags flags, void* userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "name", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParametersResolveService, name), 0 },
- { "type", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParametersResolveService, type), 0 },
- { "domain", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParametersResolveService, domain), JSON_MANDATORY },
- { "ifindex", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(LookupParametersResolveService, ifindex), 0 },
- { "family", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(LookupParametersResolveService, family), 0 },
- { "flags", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(LookupParametersResolveService, flags), 0 },
+static int vl_method_resolve_service(Varlink* link, sd_json_variant* parameters, VarlinkMethodFlags flags, void* userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParametersResolveService, name), 0 },
+ { "type", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParametersResolveService, type), 0 },
+ { "domain", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParametersResolveService, domain), SD_JSON_MANDATORY },
+ { "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(LookupParametersResolveService, ifindex), 0 },
+ { "family", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(LookupParametersResolveService, family), 0 },
+ { "flags", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(LookupParametersResolveService, flags), 0 },
{}
};
}
static void vl_method_resolve_record_complete(DnsQuery *query) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
_cleanup_(dns_query_freep) DnsQuery *q = query;
DnsQuestion *question;
int r;
int ifindex;
DnsResourceRecord *rr;
DNS_ANSWER_FOREACH_IFINDEX(rr, ifindex, q->answer) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = dns_question_matches_rr(question, rr, NULL);
if (r < 0)
if (r < 0)
goto finish;
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&array,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", JSON_BUILD_INTEGER(ifindex)),
- JSON_BUILD_PAIR_CONDITION(v, "rr", JSON_BUILD_VARIANT(v)),
- JSON_BUILD_PAIR("raw", JSON_BUILD_BASE64(rr->wire_format, rr->wire_format_size))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", SD_JSON_BUILD_INTEGER(ifindex)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!v, "rr", SD_JSON_BUILD_VARIANT(v)),
+ SD_JSON_BUILD_PAIR("raw", SD_JSON_BUILD_BASE64(rr->wire_format, rr->wire_format_size))));
if (r < 0)
goto finish;
}
r = varlink_replyb(q->varlink_request,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("rrs", JSON_BUILD_VARIANT(array)),
- JSON_BUILD_PAIR("flags", JSON_BUILD_INTEGER(dns_query_reply_flags_make(q)))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("rrs", SD_JSON_BUILD_VARIANT(array)),
+ SD_JSON_BUILD_PAIR("flags", SD_JSON_BUILD_INTEGER(dns_query_reply_flags_make(q)))));
finish:
if (r < 0) {
log_full_errno(ERRNO_IS_DISCONNECT(r) ? LOG_DEBUG : LOG_ERR, r, "Failed to send record reply: %m");
}
}
-static int vl_method_resolve_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "ifindex", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int, offsetof(LookupParameters, ifindex), 0 },
- { "name", JSON_VARIANT_STRING, json_dispatch_string, offsetof(LookupParameters, name), JSON_MANDATORY },
- { "class", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint16, offsetof(LookupParameters, class), 0 },
- { "type", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint16, offsetof(LookupParameters, type), JSON_MANDATORY },
- { "flags", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(LookupParameters, flags), 0 },
+static int vl_method_resolve_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int, offsetof(LookupParameters, ifindex), 0 },
+ { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(LookupParameters, name), SD_JSON_MANDATORY },
+ { "class", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(LookupParameters, class), 0 },
+ { "type", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(LookupParameters, type), SD_JSON_MANDATORY },
+ { "flags", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(LookupParameters, flags), 0 },
{}
};
return 1;
}
-static int vl_method_subscribe_query_results(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_subscribe_query_results(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
Manager *m;
int r;
if (!FLAGS_SET(flags, VARLINK_METHOD_MORE))
return varlink_error(link, VARLINK_ERROR_EXPECTED_MORE, NULL);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
/* Send a ready message to the connecting client, to indicate that we are now listinening, and all
* queries issued after the point the client sees this will also be reported to the client. */
r = varlink_notifyb(link,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("ready", JSON_BUILD_BOOLEAN(true))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("ready", SD_JSON_BUILD_BOOLEAN(true))));
if (r < 0)
return log_error_errno(r, "Failed to report monitor to be established: %m");
return 1;
}
-static int vl_method_dump_cache(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *list = NULL;
+static int vl_method_dump_cache(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *list = NULL;
Manager *m;
int r;
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
m = ASSERT_PTR(varlink_server_get_userdata(varlink_get_server(link)));
LIST_FOREACH(scopes, s, m->dns_scopes) {
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
r = dns_scope_dump_cache_to_json(s, &j);
if (r < 0)
return r;
- r = json_variant_append_array(&list, j);
+ r = sd_json_variant_append_array(&list, j);
if (r < 0)
return r;
}
if (!list) {
- r = json_variant_new_array(&list, NULL, 0);
+ r = sd_json_variant_new_array(&list, NULL, 0);
if (r < 0)
return r;
}
- return varlink_replyb(link, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("dump", JSON_BUILD_VARIANT(list))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("dump", SD_JSON_BUILD_VARIANT(list))));
}
-static int dns_server_dump_state_to_json_list(DnsServer *server, JsonVariant **list) {
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+static int dns_server_dump_state_to_json_list(DnsServer *server, sd_json_variant **list) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
int r;
assert(list);
if (r < 0)
return r;
- return json_variant_append_array(list, j);
+ return sd_json_variant_append_array(list, j);
}
-static int vl_method_dump_server_state(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *list = NULL;
+static int vl_method_dump_server_state(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *list = NULL;
Manager *m;
int r;
Link *l;
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
m = ASSERT_PTR(varlink_server_get_userdata(varlink_get_server(link)));
}
if (!list) {
- r = json_variant_new_array(&list, NULL, 0);
+ r = sd_json_variant_new_array(&list, NULL, 0);
if (r < 0)
return r;
}
- return varlink_replyb(link, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("dump", JSON_BUILD_VARIANT(list))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("dump", SD_JSON_BUILD_VARIANT(list))));
}
-static int vl_method_dump_statistics(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+static int vl_method_dump_statistics(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
Manager *m;
int r;
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
m = ASSERT_PTR(varlink_server_get_userdata(varlink_get_server(link)));
if (r < 0)
return r;
- return varlink_replyb(link, JSON_BUILD_VARIANT(j));
+ return varlink_replyb(link, SD_JSON_BUILD_VARIANT(j));
}
-static int vl_method_reset_statistics(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_reset_statistics(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
Manager *m;
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
m = ASSERT_PTR(varlink_server_get_userdata(varlink_get_server(link)));
dns_manager_reset_statistics(m);
- return varlink_replyb(link, JSON_BUILD_EMPTY_OBJECT);
+ return varlink_replyb(link, SD_JSON_BUILD_EMPTY_OBJECT);
}
static int varlink_monitor_server_init(Manager *m) {
assert_se(dns_packet_extract(p) >= 0);
- _cleanup_(json_variant_unrefp) JsonVariant *a = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *a = NULL;
_cleanup_free_ char *joined = NULL;
DnsResourceRecord *rr;
DNS_ANSWER_FOREACH(rr, p->answer) {
assert_se(strextend(&joined, s, "\n"));
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
assert_se(dns_resource_record_to_json(rr, &v) >= 0);
- assert_se(json_variant_append_array(&a, v) >= 0);
+ assert_se(sd_json_variant_append_array(&a, v) >= 0);
}
assert(streq(joined, twilio_reply_string));
- _cleanup_(json_variant_unrefp) JsonVariant *parsed = NULL;
- assert_se(json_parse(twilio_reply_json, /* flags= */ 0, &parsed, /* ret_line= */ NULL, /* ret_column= */ NULL) >= 0);
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parsed = NULL;
+ assert_se(sd_json_parse(twilio_reply_json, /* flags= */ 0, &parsed, /* ret_line= */ NULL, /* ret_column= */ NULL) >= 0);
- assert_se(json_variant_equal(parsed, a));
+ assert_se(sd_json_variant_equal(parsed, a));
}
DEFINE_TEST_MAIN(LOG_DEBUG);
static int json_addon(
BootEntryAddon *addon,
const char *addon_str,
- JsonVariant **array) {
+ sd_json_variant **array) {
int r;
assert(addon);
assert(addon_str);
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
array,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR(addon_str, JSON_BUILD_STRING(addon->location)),
- JSON_BUILD_PAIR("options", JSON_BUILD_STRING(addon->cmdline))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR(addon_str, SD_JSON_BUILD_STRING(addon->location)),
+ SD_JSON_BUILD_PAIR("options", SD_JSON_BUILD_STRING(addon->cmdline))));
if (r < 0)
return log_oom();
const BootEntry *e,
const BootEntryAddons *global_arr,
const char *def_cmdline,
- JsonVariant **v) {
+ sd_json_variant **v) {
_cleanup_free_ char *combined_cmdline = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *addons_array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *addons_array = NULL;
int r;
assert(e);
return log_oom();
}
- r = json_variant_merge_objectb(
- v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("addons", JSON_BUILD_VARIANT(addons_array)),
- JSON_BUILD_PAIR_CONDITION(combined_cmdline, "cmdline", JSON_BUILD_STRING(combined_cmdline))));
+ r = sd_json_variant_merge_objectb(
+ v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("addons", SD_JSON_BUILD_VARIANT(addons_array)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!combined_cmdline, "cmdline", SD_JSON_BUILD_STRING(combined_cmdline))));
if (r < 0)
return log_oom();
return 0;
return -status;
}
-int boot_entry_to_json(const BootConfig *c, size_t i, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+int boot_entry_to_json(const BootConfig *c, size_t i, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *opts = NULL;
const BootEntry *e;
int r;
return log_oom();
}
- r = json_variant_merge_objectb(
- &v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("type", JSON_BUILD_STRING(boot_entry_type_json_to_string(e->type))),
- JSON_BUILD_PAIR_CONDITION(e->id, "id", JSON_BUILD_STRING(e->id)),
- JSON_BUILD_PAIR_CONDITION(e->path, "path", JSON_BUILD_STRING(e->path)),
- JSON_BUILD_PAIR_CONDITION(e->root, "root", JSON_BUILD_STRING(e->root)),
- JSON_BUILD_PAIR_CONDITION(e->title, "title", JSON_BUILD_STRING(e->title)),
- JSON_BUILD_PAIR_CONDITION(boot_entry_title(e), "showTitle", JSON_BUILD_STRING(boot_entry_title(e))),
- JSON_BUILD_PAIR_CONDITION(e->sort_key, "sortKey", JSON_BUILD_STRING(e->sort_key)),
- JSON_BUILD_PAIR_CONDITION(e->version, "version", JSON_BUILD_STRING(e->version)),
- JSON_BUILD_PAIR_CONDITION(e->machine_id, "machineId", JSON_BUILD_STRING(e->machine_id)),
- JSON_BUILD_PAIR_CONDITION(e->architecture, "architecture", JSON_BUILD_STRING(e->architecture)),
- JSON_BUILD_PAIR_CONDITION(opts, "options", JSON_BUILD_STRING(opts)),
- JSON_BUILD_PAIR_CONDITION(e->kernel, "linux", JSON_BUILD_STRING(e->kernel)),
- JSON_BUILD_PAIR_CONDITION(e->efi, "efi", JSON_BUILD_STRING(e->efi)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(e->initrd), "initrd", JSON_BUILD_STRV(e->initrd)),
- JSON_BUILD_PAIR_CONDITION(e->device_tree, "devicetree", JSON_BUILD_STRING(e->device_tree)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(e->device_tree_overlay), "devicetreeOverlay", JSON_BUILD_STRV(e->device_tree_overlay))));
+ r = sd_json_variant_merge_objectb(
+ &v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("type", SD_JSON_BUILD_STRING(boot_entry_type_json_to_string(e->type))),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->id, "id", SD_JSON_BUILD_STRING(e->id)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->path, "path", SD_JSON_BUILD_STRING(e->path)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->root, "root", SD_JSON_BUILD_STRING(e->root)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->title, "title", SD_JSON_BUILD_STRING(e->title)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!boot_entry_title(e), "showTitle", SD_JSON_BUILD_STRING(boot_entry_title(e))),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->sort_key, "sortKey", SD_JSON_BUILD_STRING(e->sort_key)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->version, "version", SD_JSON_BUILD_STRING(e->version)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->machine_id, "machineId", SD_JSON_BUILD_STRING(e->machine_id)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->architecture, "architecture", SD_JSON_BUILD_STRING(e->architecture)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!opts, "options", SD_JSON_BUILD_STRING(opts)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->kernel, "linux", SD_JSON_BUILD_STRING(e->kernel)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->efi, "efi", SD_JSON_BUILD_STRING(e->efi)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(e->initrd), "initrd", SD_JSON_BUILD_STRV(e->initrd)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!e->device_tree, "devicetree", SD_JSON_BUILD_STRING(e->device_tree)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(e->device_tree_overlay), "devicetreeOverlay", SD_JSON_BUILD_STRV(e->device_tree_overlay))));
if (r < 0)
return log_oom();
/* Sanitizers (only memory sanitizer?) do not like function call with too many
* arguments and trigger false positive warnings. Let's not add too many json objects
* at once. */
- r = json_variant_merge_objectb(
- &v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("isReported", JSON_BUILD_BOOLEAN(e->reported_by_loader)),
- JSON_BUILD_PAIR_CONDITION(e->tries_left != UINT_MAX, "triesLeft", JSON_BUILD_UNSIGNED(e->tries_left)),
- JSON_BUILD_PAIR_CONDITION(e->tries_done != UINT_MAX, "triesDone", JSON_BUILD_UNSIGNED(e->tries_done)),
- JSON_BUILD_PAIR_CONDITION(c->default_entry >= 0, "isDefault", JSON_BUILD_BOOLEAN(i == (size_t) c->default_entry)),
- JSON_BUILD_PAIR_CONDITION(c->selected_entry >= 0, "isSelected", JSON_BUILD_BOOLEAN(i == (size_t) c->selected_entry))));
+ r = sd_json_variant_merge_objectb(
+ &v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("isReported", SD_JSON_BUILD_BOOLEAN(e->reported_by_loader)),
+ SD_JSON_BUILD_PAIR_CONDITION(e->tries_left != UINT_MAX, "triesLeft", SD_JSON_BUILD_UNSIGNED(e->tries_left)),
+ SD_JSON_BUILD_PAIR_CONDITION(e->tries_done != UINT_MAX, "triesDone", SD_JSON_BUILD_UNSIGNED(e->tries_done)),
+ SD_JSON_BUILD_PAIR_CONDITION(c->default_entry >= 0, "isDefault", SD_JSON_BUILD_BOOLEAN(i == (size_t) c->default_entry)),
+ SD_JSON_BUILD_PAIR_CONDITION(c->selected_entry >= 0, "isSelected", SD_JSON_BUILD_BOOLEAN(i == (size_t) c->selected_entry))));
if (r < 0)
return log_oom();
return 1;
}
-int show_boot_entries(const BootConfig *config, JsonFormatFlags json_format) {
+int show_boot_entries(const BootConfig *config, sd_json_format_flags_t json_format) {
int r;
assert(config);
- if (!FLAGS_SET(json_format, JSON_FORMAT_OFF)) {
- _cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
+ if (!FLAGS_SET(json_format, SD_JSON_FORMAT_OFF)) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
for (size_t i = 0; i < config->n_entries; i++) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = boot_entry_to_json(config, i, &v);
if (r < 0)
return log_oom();
- r = json_variant_append_array(&array, v);
+ r = sd_json_variant_append_array(&array, v);
if (r < 0)
return log_oom();
}
- return json_variant_dump(array, json_format | JSON_FORMAT_EMPTY_ARRAY, NULL, NULL);
+ return sd_json_variant_dump(array, json_format | SD_JSON_FORMAT_EMPTY_ARRAY, NULL, NULL);
} else
for (size_t n = 0; n < config->n_entries; n++) {
r = show_boot_entry(
#include <stdbool.h>
#include <sys/types.h>
-#include "json.h"
+#include "sd-json.h"
+
#include "set.h"
#include "string-util.h"
bool show_reported);
int show_boot_entries(
const BootConfig *config,
- JsonFormatFlags json_format);
+ sd_json_format_flags_t json_format);
int boot_filename_extract_tries(const char *fname, char **ret_stripped, unsigned *ret_tries_left, unsigned *ret_tries_done);
-int boot_entry_to_json(const BootConfig *c, size_t i, JsonVariant **ret);
+int boot_entry_to_json(const BootConfig *c, size_t i, sd_json_variant **ret);
}
static bool varlink_allow_interactive_authentication(Varlink *link) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(link);
return false;
}
- JsonVariant *b;
- b = json_variant_by_key(v, "allowInteractiveAuthentication");
+ sd_json_variant *b;
+ b = sd_json_variant_by_key(v, "allowInteractiveAuthentication");
if (b) {
- if (json_variant_is_boolean(b))
- return json_variant_boolean(b);
+ if (sd_json_variant_is_boolean(b))
+ return sd_json_variant_boolean(b);
log_debug("Incoming 'allowInteractiveAuthentication' field is not a boolean, ignoring.");
}
return varlink_verify_polkit_async_full(link, bus, action, details, UID_INVALID, 0, registry);
}
-/* A JsonDispatch initializer that makes sure the allowInteractiveAuthentication boolean field we want for
+/* A sd_json_dispatch_field initializer that makes sure the allowInteractiveAuthentication boolean field we want for
* polkit support in Varlink calls is ignored while regular dispatching (and does not result in errors
* regarding unexpected fields) */
#define VARLINK_DISPATCH_POLKIT_FIELD { \
.name = "allowInteractiveAuthentication", \
- .type = JSON_VARIANT_BOOLEAN, \
+ .type = SD_JSON_VARIANT_BOOLEAN, \
}
bool varlink_has_polkit_action(Varlink *link, const char *action, const char **details, Hashmap **registry);
#endif
#include "sd-id128.h"
+#include "sd-json.h"
#include "blockdev-util.h"
#include "capability-util.h"
#include "format-util.h"
#include "fs-util.h"
#include "io-util.h"
+#include "json-util.h"
#include "memory-util.h"
#include "mkdir-label.h"
#include "openssl-util.h"
struct iovec *ret) {
_cleanup_(iovec_done_erase) struct iovec host_key = {}, plaintext = {}, tpm2_key = {};
- _cleanup_(json_variant_unrefp) JsonVariant *signature_json = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *signature_json = NULL;
_cleanup_(EVP_CIPHER_CTX_freep) EVP_CIPHER_CTX *context = NULL;
struct encrypted_credential_header *h;
struct metadata_credential_header *m;
return log_error_errno(r, "Failed to enable sensitive Varlink input: %m");
/* Create the input data blob object separately, so that we can mark it as sensitive */
- _cleanup_(json_variant_unrefp) JsonVariant *jinput = NULL;
- r = json_build(&jinput, JSON_BUILD_IOVEC_BASE64(input));
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *jinput = NULL;
+ r = sd_json_build(&jinput, JSON_BUILD_IOVEC_BASE64(input));
if (r < 0)
return log_error_errno(r, "Failed to create input object: %m");
- json_variant_sensitive(jinput);
+ sd_json_variant_sensitive(jinput);
- _cleanup_(json_variant_unrefp) JsonVariant *reply = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *reply = NULL;
const char *error_id = NULL;
r = varlink_callb(vl,
"io.systemd.Credentials.Encrypt",
&reply,
&error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(name, "name", JSON_BUILD_STRING(name)),
- JSON_BUILD_PAIR("data", JSON_BUILD_VARIANT(jinput)),
- JSON_BUILD_PAIR_CONDITION(timestamp != USEC_INFINITY, "timestamp", JSON_BUILD_UNSIGNED(timestamp)),
- JSON_BUILD_PAIR_CONDITION(not_after != USEC_INFINITY, "notAfter", JSON_BUILD_UNSIGNED(not_after)),
- JSON_BUILD_PAIR_CONDITION(!FLAGS_SET(flags, CREDENTIAL_ANY_SCOPE), "scope", JSON_BUILD_STRING(uid_is_valid(uid) ? "user" : "system")),
- JSON_BUILD_PAIR_CONDITION(uid_is_valid(uid), "uid", JSON_BUILD_UNSIGNED(uid))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(!!name, "name", SD_JSON_BUILD_STRING(name)),
+ SD_JSON_BUILD_PAIR("data", SD_JSON_BUILD_VARIANT(jinput)),
+ SD_JSON_BUILD_PAIR_CONDITION(timestamp != USEC_INFINITY, "timestamp", SD_JSON_BUILD_UNSIGNED(timestamp)),
+ SD_JSON_BUILD_PAIR_CONDITION(not_after != USEC_INFINITY, "notAfter", SD_JSON_BUILD_UNSIGNED(not_after)),
+ SD_JSON_BUILD_PAIR_CONDITION(!FLAGS_SET(flags, CREDENTIAL_ANY_SCOPE), "scope", SD_JSON_BUILD_STRING(uid_is_valid(uid) ? "user" : "system")),
+ SD_JSON_BUILD_PAIR_CONDITION(uid_is_valid(uid), "uid", SD_JSON_BUILD_UNSIGNED(uid))));
if (r < 0)
return log_error_errno(r, "Failed to call Encrypt() varlink call.");
if (!isempty(error_id)) {
return log_error_errno(varlink_error_to_errno(error_id, reply), "Failed to encrypt: %s", error_id);
}
- r = json_dispatch(
+ r = sd_json_dispatch(
reply,
- (const JsonDispatch[]) {
- { "blob", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, PTR_TO_SIZE(ret), JSON_MANDATORY },
+ (const sd_json_dispatch_field[]) {
+ { "blob", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, PTR_TO_SIZE(ret), SD_JSON_MANDATORY },
{},
},
- JSON_LOG|JSON_ALLOW_EXTENSIONS,
+ SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS,
/* userdata= */ NULL);
if (r < 0)
return r;
/* Create the input data blob object separately, so that we can mark it as sensitive (it's supposed
* to be encrypted, but who knows maybe it uses the NULL cypher). */
- _cleanup_(json_variant_unrefp) JsonVariant *jinput = NULL;
- r = json_build(&jinput, JSON_BUILD_IOVEC_BASE64(input));
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *jinput = NULL;
+ r = sd_json_build(&jinput, JSON_BUILD_IOVEC_BASE64(input));
if (r < 0)
return log_error_errno(r, "Failed to create input object: %m");
- json_variant_sensitive(jinput);
+ sd_json_variant_sensitive(jinput);
- _cleanup_(json_variant_unrefp) JsonVariant *reply = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *reply = NULL;
const char *error_id = NULL;
r = varlink_callb(vl,
"io.systemd.Credentials.Decrypt",
&reply,
&error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(validate_name, "name", JSON_BUILD_STRING(validate_name)),
- JSON_BUILD_PAIR("blob", JSON_BUILD_VARIANT(jinput)),
- JSON_BUILD_PAIR_CONDITION(validate_timestamp != USEC_INFINITY, "timestamp", JSON_BUILD_UNSIGNED(validate_timestamp)),
- JSON_BUILD_PAIR_CONDITION(!FLAGS_SET(flags, CREDENTIAL_ANY_SCOPE), "scope", JSON_BUILD_STRING(uid_is_valid(uid) ? "user" : "system")),
- JSON_BUILD_PAIR_CONDITION(uid_is_valid(uid), "uid", JSON_BUILD_UNSIGNED(uid))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(!!validate_name, "name", SD_JSON_BUILD_STRING(validate_name)),
+ SD_JSON_BUILD_PAIR("blob", SD_JSON_BUILD_VARIANT(jinput)),
+ SD_JSON_BUILD_PAIR_CONDITION(validate_timestamp != USEC_INFINITY, "timestamp", SD_JSON_BUILD_UNSIGNED(validate_timestamp)),
+ SD_JSON_BUILD_PAIR_CONDITION(!FLAGS_SET(flags, CREDENTIAL_ANY_SCOPE), "scope", SD_JSON_BUILD_STRING(uid_is_valid(uid) ? "user" : "system")),
+ SD_JSON_BUILD_PAIR_CONDITION(uid_is_valid(uid), "uid", SD_JSON_BUILD_UNSIGNED(uid))));
if (r < 0)
return log_error_errno(r, "Failed to call Decrypt() varlink call.");
if (!isempty(error_id)) {
return log_error_errno(varlink_error_to_errno(error_id, reply), "Failed to decrypt: %s", error_id);
}
- r = json_dispatch(
+ r = sd_json_dispatch(
reply,
- (const JsonDispatch[]) {
- { "data", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, PTR_TO_SIZE(ret), JSON_MANDATORY },
+ (const sd_json_dispatch_field[]) {
+ { "data", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, PTR_TO_SIZE(ret), SD_JSON_MANDATORY },
{},
},
- JSON_LOG|JSON_ALLOW_EXTENSIONS,
+ SD_JSON_LOG|SD_JSON_ALLOW_EXTENSIONS,
/* userdata= */ NULL);
if (r < 0)
return r;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "ask-password-api.h"
#include "cryptsetup-fido2.h"
#include "env-util.h"
#include "fileio.h"
#include "hexdecoct.h"
-#include "json.h"
#include "libfido2-util.h"
#include "parse-util.h"
#include "random-util.h"
/* Loads FIDO2 metadata from LUKS2 JSON token headers. */
for (int token = 0; token < sym_crypt_token_max(CRYPT_LUKS2); token++) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- JsonVariant *w;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+ sd_json_variant *w;
_cleanup_free_ void *salt = NULL;
_cleanup_free_ char *rp = NULL;
size_t salt_size = 0;
continue;
}
- w = json_variant_by_key(v, "fido2-credential");
- if (!w || !json_variant_is_string(w))
+ w = sd_json_variant_by_key(v, "fido2-credential");
+ if (!w || !sd_json_variant_is_string(w))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"FIDO2 token data lacks 'fido2-credential' field.");
- r = unbase64mem(json_variant_string(w), &cid, &cid_size);
+ r = unbase64mem(sd_json_variant_string(w), &cid, &cid_size);
if (r < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid base64 data in 'fido2-credential' field.");
- w = json_variant_by_key(v, "fido2-salt");
- if (!w || !json_variant_is_string(w))
+ w = sd_json_variant_by_key(v, "fido2-salt");
+ if (!w || !sd_json_variant_is_string(w))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"FIDO2 token data lacks 'fido2-salt' field.");
assert(!salt);
assert(salt_size == 0);
- r = unbase64mem(json_variant_string(w), &salt, &salt_size);
+ r = unbase64mem(sd_json_variant_string(w), &salt, &salt_size);
if (r < 0)
return log_error_errno(r, "Failed to decode base64 encoded salt.");
- w = json_variant_by_key(v, "fido2-rp");
+ w = sd_json_variant_by_key(v, "fido2-rp");
if (w) {
/* The "rp" field is optional. */
- if (!json_variant_is_string(w))
+ if (!sd_json_variant_is_string(w))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"FIDO2 token data's 'fido2-rp' field is not a string.");
assert(!rp);
- rp = strdup(json_variant_string(w));
+ rp = strdup(sd_json_variant_string(w));
if (!rp)
return log_oom();
}
- w = json_variant_by_key(v, "fido2-clientPin-required");
+ w = sd_json_variant_by_key(v, "fido2-clientPin-required");
if (w) {
/* The "fido2-clientPin-required" field is optional. */
- if (!json_variant_is_boolean(w))
+ if (!sd_json_variant_is_boolean(w))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"FIDO2 token data's 'fido2-clientPin-required' field is not a boolean.");
- SET_FLAG(required, FIDO2ENROLL_PIN, json_variant_boolean(w));
+ SET_FLAG(required, FIDO2ENROLL_PIN, sd_json_variant_boolean(w));
} else
required |= FIDO2ENROLL_PIN_IF_NEEDED; /* compat with 248, where the field was unset */
- w = json_variant_by_key(v, "fido2-up-required");
+ w = sd_json_variant_by_key(v, "fido2-up-required");
if (w) {
/* The "fido2-up-required" field is optional. */
- if (!json_variant_is_boolean(w))
+ if (!sd_json_variant_is_boolean(w))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"FIDO2 token data's 'fido2-up-required' field is not a boolean.");
- SET_FLAG(required, FIDO2ENROLL_UP, json_variant_boolean(w));
+ SET_FLAG(required, FIDO2ENROLL_UP, sd_json_variant_boolean(w));
} else
required |= FIDO2ENROLL_UP_IF_NEEDED; /* compat with 248 */
- w = json_variant_by_key(v, "fido2-uv-required");
+ w = sd_json_variant_by_key(v, "fido2-uv-required");
if (w) {
/* The "fido2-uv-required" field is optional. */
- if (!json_variant_is_boolean(w))
+ if (!sd_json_variant_is_boolean(w))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"FIDO2 token data's 'fido2-uv-required' field is not a boolean.");
- SET_FLAG(required, FIDO2ENROLL_UV, json_variant_boolean(w));
+ SET_FLAG(required, FIDO2ENROLL_UV, sd_json_variant_boolean(w));
} else
required |= FIDO2ENROLL_UV_OMIT; /* compat with 248 */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "ask-password-api.h"
#include "cryptsetup-tpm2.h"
#include "env-util.h"
#include "fileio.h"
#include "hexdecoct.h"
-#include "json.h"
#include "parse-util.h"
#include "random-util.h"
#include "sha256.h"
AskPasswordFlags askpw_flags,
struct iovec *ret_decrypted_key) {
- _cleanup_(json_variant_unrefp) JsonVariant *signature_json = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *signature_json = NULL;
_cleanup_free_ void *loaded_blob = NULL;
_cleanup_free_ char *auto_device = NULL;
struct iovec blob;
for (token = start_token; token < sym_crypt_token_max(CRYPT_LUKS2); token++) {
_cleanup_(iovec_done) struct iovec blob = {}, policy_hash = {}, pubkey = {}, salt = {}, srk = {}, pcrlock_nv = {};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
uint32_t hash_pcr_mask, pubkey_pcr_mask;
uint16_t pcr_bank, primary_alg;
TPM2Flags flags;
struct crypt_device *cd,
int idx,
const char *verify_type,
- JsonVariant **ret) {
+ sd_json_variant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
const char *text;
int r;
if (r < 0)
return r;
- r = json_parse(text, 0, &v, NULL, NULL);
+ r = sd_json_parse(text, 0, &v, NULL, NULL);
if (r < 0)
return r;
if (verify_type) {
- JsonVariant *w;
+ sd_json_variant *w;
- w = json_variant_by_key(v, "type");
+ w = sd_json_variant_by_key(v, "type");
if (!w)
return -EINVAL;
- if (!streq_ptr(json_variant_string(w), verify_type))
+ if (!streq_ptr(sd_json_variant_string(w), verify_type))
return -EMEDIUMTYPE;
}
return 0;
}
-int cryptsetup_add_token_json(struct crypt_device *cd, JsonVariant *v) {
+int cryptsetup_add_token_json(struct crypt_device *cd, sd_json_variant *v) {
_cleanup_free_ char *text = NULL;
int r;
if (r < 0)
return r;
- r = json_variant_format(v, 0, &text);
+ r = sd_json_variant_format(v, 0, &text);
if (r < 0)
return log_debug_errno(r, "Failed to format token data for LUKS: %m");
#endif
}
-int cryptsetup_get_keyslot_from_token(JsonVariant *v) {
+int cryptsetup_get_keyslot_from_token(sd_json_variant *v) {
int keyslot, r;
- JsonVariant *w;
+ sd_json_variant *w;
/* Parses the "keyslots" field of a LUKS2 token object. The field can be an array, but here we assume
* that it contains a single element only, since that's the only way we ever generate it
* ourselves. */
- w = json_variant_by_key(v, "keyslots");
+ w = sd_json_variant_by_key(v, "keyslots");
if (!w)
return -ENOENT;
- if (!json_variant_is_array(w) || json_variant_elements(w) != 1)
+ if (!sd_json_variant_is_array(w) || sd_json_variant_elements(w) != 1)
return -EMEDIUMTYPE;
- w = json_variant_by_index(w, 0);
+ w = sd_json_variant_by_index(w, 0);
if (!w)
return -ENOENT;
- if (!json_variant_is_string(w))
+ if (!sd_json_variant_is_string(w))
return -EMEDIUMTYPE;
- r = safe_atoi(json_variant_string(w), &keyslot);
+ r = safe_atoi(sd_json_variant_string(w), &keyslot);
if (r < 0)
return r;
if (keyslot < 0)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "dlfcn-util.h"
-#include "json.h"
#include "macro.h"
+#include "string-util.h"
+#include "strv.h"
#if HAVE_LIBCRYPTSETUP
#include <libcryptsetup.h>
int cryptsetup_set_minimal_pbkdf(struct crypt_device *cd);
-int cryptsetup_get_token_as_json(struct crypt_device *cd, int idx, const char *verify_type, JsonVariant **ret);
-int cryptsetup_add_token_json(struct crypt_device *cd, JsonVariant *v);
+int cryptsetup_get_token_as_json(struct crypt_device *cd, int idx, const char *verify_type, sd_json_variant **ret);
+int cryptsetup_add_token_json(struct crypt_device *cd, sd_json_variant *v);
#else
int dlopen_cryptsetup(void);
-int cryptsetup_get_keyslot_from_token(JsonVariant *v);
+int cryptsetup_get_keyslot_from_token(sd_json_variant *v);
static inline const char *mangle_none(const char *s) {
/* A helper that turns cryptsetup/integritysetup/veritysetup "options" strings into NULL if they are effectively empty */
return false;
}
-int image_to_json(const struct Image *img, JsonVariant **ret) {
+int image_to_json(const struct Image *img, sd_json_variant **ret) {
assert(img);
- return json_build(ret,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("Type", image_type_to_string(img->type)),
- JSON_BUILD_PAIR_STRING("Class", image_class_to_string(img->class)),
- JSON_BUILD_PAIR_STRING("Name", img->name),
- JSON_BUILD_PAIR_CONDITION(img->path, "Path", JSON_BUILD_STRING(img->path)),
- JSON_BUILD_PAIR_BOOLEAN("ReadOnly", img->read_only),
- JSON_BUILD_PAIR_CONDITION(img->crtime != 0, "CreationTimestamp", JSON_BUILD_UNSIGNED(img->crtime)),
- JSON_BUILD_PAIR_CONDITION(img->mtime != 0, "ModificationTimestamp", JSON_BUILD_UNSIGNED(img->mtime)),
- JSON_BUILD_PAIR_CONDITION(img->usage != UINT64_MAX, "Usage", JSON_BUILD_UNSIGNED(img->usage)),
- JSON_BUILD_PAIR_CONDITION(img->usage_exclusive != UINT64_MAX, "UsageExclusive", JSON_BUILD_UNSIGNED(img->usage_exclusive)),
- JSON_BUILD_PAIR_CONDITION(img->limit != UINT64_MAX, "Limit", JSON_BUILD_UNSIGNED(img->limit)),
- JSON_BUILD_PAIR_CONDITION(img->limit_exclusive != UINT64_MAX, "LimitExclusive", JSON_BUILD_UNSIGNED(img->limit_exclusive))));
+ return sd_json_build(ret,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("Type", image_type_to_string(img->type)),
+ SD_JSON_BUILD_PAIR_STRING("Class", image_class_to_string(img->class)),
+ SD_JSON_BUILD_PAIR_STRING("Name", img->name),
+ SD_JSON_BUILD_PAIR_CONDITION(!!img->path, "Path", SD_JSON_BUILD_STRING(img->path)),
+ SD_JSON_BUILD_PAIR_BOOLEAN("ReadOnly", img->read_only),
+ SD_JSON_BUILD_PAIR_CONDITION(img->crtime != 0, "CreationTimestamp", SD_JSON_BUILD_UNSIGNED(img->crtime)),
+ SD_JSON_BUILD_PAIR_CONDITION(img->mtime != 0, "ModificationTimestamp", SD_JSON_BUILD_UNSIGNED(img->mtime)),
+ SD_JSON_BUILD_PAIR_CONDITION(img->usage != UINT64_MAX, "Usage", SD_JSON_BUILD_UNSIGNED(img->usage)),
+ SD_JSON_BUILD_PAIR_CONDITION(img->usage_exclusive != UINT64_MAX, "UsageExclusive", SD_JSON_BUILD_UNSIGNED(img->usage_exclusive)),
+ SD_JSON_BUILD_PAIR_CONDITION(img->limit != UINT64_MAX, "Limit", SD_JSON_BUILD_UNSIGNED(img->limit)),
+ SD_JSON_BUILD_PAIR_CONDITION(img->limit_exclusive != UINT64_MAX, "LimitExclusive", SD_JSON_BUILD_UNSIGNED(img->limit_exclusive))));
}
static const char* const image_type_table[_IMAGE_TYPE_MAX] = {
#include <stdint.h>
#include "sd-id128.h"
+#include "sd-json.h"
#include "hashmap.h"
#include "image-policy.h"
-#include "json.h"
#include "lock-util.h"
#include "macro.h"
#include "os-util.h"
return false;
}
-int image_to_json(const struct Image *i, JsonVariant **ret);
+int image_to_json(const struct Image *i, sd_json_variant **ret);
const char *image_root_to_string(ImageClass c) _const_;
#include "sd-device.h"
#include "sd-id128.h"
+#include "sd-json.h"
#include "architecture.h"
#include "ask-password-api.h"
#include "id128-util.h"
#include "import-util.h"
#include "io-util.h"
+#include "json-util.h"
#include "missing_mount.h"
#include "missing_syscall.h"
#include "mkdir-label.h"
VeritySettings *verity) {
_cleanup_free_ void *root_hash = NULL, *root_hash_sig = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
size_t root_hash_size, root_hash_sig_size;
_cleanup_free_ char *buf = NULL;
PartitionDesignator d;
DissectedPartition *p;
- JsonVariant *rh, *sig;
+ sd_json_variant *rh, *sig;
ssize_t n;
char *e;
int r;
} else
buf[p->size] = 0;
- r = json_parse(buf, 0, &v, NULL, NULL);
+ r = sd_json_parse(buf, 0, &v, NULL, NULL);
if (r < 0)
return log_debug_errno(r, "Failed to parse signature JSON data: %m");
- rh = json_variant_by_key(v, "rootHash");
+ rh = sd_json_variant_by_key(v, "rootHash");
if (!rh)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Signature JSON object lacks 'rootHash' field.");
- if (!json_variant_is_string(rh))
+ if (!sd_json_variant_is_string(rh))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "'rootHash' field of signature JSON object is not a string.");
- r = unhexmem(json_variant_string(rh), &root_hash, &root_hash_size);
+ r = unhexmem(sd_json_variant_string(rh), &root_hash, &root_hash_size);
if (r < 0)
return log_debug_errno(r, "Failed to parse root hash field: %m");
return log_debug_errno(r, "Root hash in signature JSON data (%s) doesn't match configured hash (%s).", strna(a), strna(b));
}
- sig = json_variant_by_key(v, "signature");
+ sig = sd_json_variant_by_key(v, "signature");
if (!sig)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Signature JSON object lacks 'signature' field.");
- if (!json_variant_is_string(sig))
+ if (!sd_json_variant_is_string(sig))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "'signature' field of signature JSON object is not a string.");
- r = unbase64mem(json_variant_string(sig), &root_hash_sig, &root_hash_sig_size);
+ r = unbase64mem(sd_json_variant_string(sig), &root_hash_sig, &root_hash_sig_size);
if (r < 0)
return log_debug_errno(r, "Failed to parse signature field: %m");
}
typedef struct ReplyParameters {
- JsonVariant *partitions;
+ sd_json_variant *partitions;
char *image_policy;
uint64_t image_size;
uint32_t sector_size;
assert(p);
p->image_policy = mfree(p->image_policy);
- p->partitions = json_variant_unref(p->partitions);
+ p->partitions = sd_json_variant_unref(p->partitions);
}
#endif
#if HAVE_BLKID
_cleanup_(reply_parameters_done) ReplyParameters p = {};
- static const JsonDispatch dispatch_table[] = {
- { "partitions", JSON_VARIANT_ARRAY, json_dispatch_variant, offsetof(struct ReplyParameters, partitions), JSON_MANDATORY },
- { "imagePolicy", JSON_VARIANT_STRING, json_dispatch_string, offsetof(struct ReplyParameters, image_policy), 0 },
- { "imageSize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct ReplyParameters, image_size), JSON_MANDATORY },
- { "sectorSize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint32, offsetof(struct ReplyParameters, sector_size), JSON_MANDATORY },
- { "imageUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(struct ReplyParameters, image_uuid), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "partitions", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(struct ReplyParameters, partitions), SD_JSON_MANDATORY },
+ { "imagePolicy", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(struct ReplyParameters, image_policy), 0 },
+ { "imageSize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct ReplyParameters, image_size), SD_JSON_MANDATORY },
+ { "sectorSize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint32, offsetof(struct ReplyParameters, sector_size), SD_JSON_MANDATORY },
+ { "imageUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(struct ReplyParameters, image_uuid), 0 },
{}
};
return log_error_errno(r, "Failed format image policy to string: %m");
}
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
r = varlink_callb(
vl,
"io.systemd.MountFileSystem.MountImage",
&reply,
&error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("imageFileDescriptor", JSON_BUILD_UNSIGNED(0)),
- JSON_BUILD_PAIR_CONDITION(userns_fd >= 0, "userNamespaceFileDescriptor", JSON_BUILD_UNSIGNED(1)),
- JSON_BUILD_PAIR("readOnly", JSON_BUILD_BOOLEAN(FLAGS_SET(flags, DISSECT_IMAGE_MOUNT_READ_ONLY))),
- JSON_BUILD_PAIR("growFileSystems", JSON_BUILD_BOOLEAN(FLAGS_SET(flags, DISSECT_IMAGE_GROWFS))),
- JSON_BUILD_PAIR_CONDITION(ps, "imagePolicy", JSON_BUILD_STRING(ps)),
- JSON_BUILD_PAIR("allowInteractiveAuthentication", JSON_BUILD_BOOLEAN(FLAGS_SET(flags, DISSECT_IMAGE_ALLOW_INTERACTIVE_AUTH)))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("imageFileDescriptor", SD_JSON_BUILD_UNSIGNED(0)),
+ SD_JSON_BUILD_PAIR_CONDITION(userns_fd >= 0, "userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(1)),
+ SD_JSON_BUILD_PAIR("readOnly", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(flags, DISSECT_IMAGE_MOUNT_READ_ONLY))),
+ SD_JSON_BUILD_PAIR("growFileSystems", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(flags, DISSECT_IMAGE_GROWFS))),
+ SD_JSON_BUILD_PAIR_CONDITION(!!ps, "imagePolicy", SD_JSON_BUILD_STRING(ps)),
+ SD_JSON_BUILD_PAIR("allowInteractiveAuthentication", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(flags, DISSECT_IMAGE_ALLOW_INTERACTIVE_AUTH)))));
if (r < 0)
return log_error_errno(r, "Failed to call MountImage() varlink call: %m");
if (!isempty(error_id))
return log_error_errno(varlink_error_to_errno(error_id, reply), "Failed to call MountImage() varlink call: %s", error_id);
- r = json_dispatch(reply, dispatch_table, JSON_ALLOW_EXTENSIONS, &p);
+ r = sd_json_dispatch(reply, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &p);
if (r < 0)
return log_error_errno(r, "Failed to parse MountImage() reply: %m");
log_debug("Effective image policy: %s", p.image_policy);
- JsonVariant *i;
+ sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, p.partitions) {
_cleanup_close_ int fsmount_fd = -EBADF;
.fsmount_fd_idx = UINT_MAX,
};
- static const JsonDispatch partition_dispatch_table[] = {
- { "designator", JSON_VARIANT_STRING, dispatch_partition_designator, offsetof(struct PartitionFields, designator), JSON_MANDATORY },
- { "writable", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct PartitionFields, rw), JSON_MANDATORY },
- { "growFileSystem", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct PartitionFields, growfs), JSON_MANDATORY },
- { "partitionNumber", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(struct PartitionFields, partno), 0 },
- { "architecture", JSON_VARIANT_STRING, dispatch_architecture, offsetof(struct PartitionFields, architecture), 0 },
- { "partitionUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(struct PartitionFields, uuid), 0 },
- { "fileSystemType", JSON_VARIANT_STRING, json_dispatch_string, offsetof(struct PartitionFields, fstype), JSON_MANDATORY },
- { "partitionLabel", JSON_VARIANT_STRING, json_dispatch_string, offsetof(struct PartitionFields, label), 0 },
- { "size", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct PartitionFields, size), JSON_MANDATORY },
- { "offset", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct PartitionFields, offset), JSON_MANDATORY },
- { "mountFileDescriptor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint, offsetof(struct PartitionFields, fsmount_fd_idx), JSON_MANDATORY },
+ static const sd_json_dispatch_field partition_dispatch_table[] = {
+ { "designator", SD_JSON_VARIANT_STRING, dispatch_partition_designator, offsetof(struct PartitionFields, designator), SD_JSON_MANDATORY },
+ { "writable", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct PartitionFields, rw), SD_JSON_MANDATORY },
+ { "growFileSystem", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct PartitionFields, growfs), SD_JSON_MANDATORY },
+ { "partitionNumber", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(struct PartitionFields, partno), 0 },
+ { "architecture", SD_JSON_VARIANT_STRING, dispatch_architecture, offsetof(struct PartitionFields, architecture), 0 },
+ { "partitionUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(struct PartitionFields, uuid), 0 },
+ { "fileSystemType", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(struct PartitionFields, fstype), SD_JSON_MANDATORY },
+ { "partitionLabel", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(struct PartitionFields, label), 0 },
+ { "size", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct PartitionFields, size), SD_JSON_MANDATORY },
+ { "offset", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct PartitionFields, offset), SD_JSON_MANDATORY },
+ { "mountFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint, offsetof(struct PartitionFields, fsmount_fd_idx), SD_JSON_MANDATORY },
{}
};
- r = json_dispatch(i, partition_dispatch_table, JSON_ALLOW_EXTENSIONS, &pp);
+ r = sd_json_dispatch(i, partition_dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &pp);
if (r < 0)
return log_error_errno(r, "Failed to parse partition data: %m");
Elf *elf;
unsigned n_thread;
unsigned n_frame;
- JsonVariant **package_metadata;
+ sd_json_variant **package_metadata;
Set **modules;
} StackContext;
strempty(arch));
}
-static void report_module_metadata(StackContext *c, const char *name, JsonVariant *metadata) {
+static void report_module_metadata(StackContext *c, const char *name, sd_json_variant *metadata) {
assert(c);
assert(name);
if (metadata) {
const char
- *build_id = json_variant_string(json_variant_by_key(metadata, "buildId")),
- *type = json_variant_string(json_variant_by_key(metadata, "type")),
- *package = json_variant_string(json_variant_by_key(metadata, "name")),
- *version = json_variant_string(json_variant_by_key(metadata, "version")),
- *arch = json_variant_string(json_variant_by_key(metadata, "architecture"));
+ *build_id = sd_json_variant_string(sd_json_variant_by_key(metadata, "buildId")),
+ *type = sd_json_variant_string(sd_json_variant_by_key(metadata, "type")),
+ *package = sd_json_variant_string(sd_json_variant_by_key(metadata, "name")),
+ *version = sd_json_variant_string(sd_json_variant_by_key(metadata, "version")),
+ *arch = sd_json_variant_string(sd_json_variant_by_key(metadata, "architecture"));
if (package) {
/* Version/architecture is only meaningful with a package name.
fputs("\n", c->m.f);
}
-static int parse_package_metadata(const char *name, JsonVariant *id_json, Elf *elf, bool *ret_interpreter_found, StackContext *c) {
+static int parse_package_metadata(const char *name, sd_json_variant *id_json, Elf *elf, bool *ret_interpreter_found, StackContext *c) {
bool interpreter_found = false;
size_t n_program_headers;
int r;
note_offset < data->d_size &&
(note_offset = sym_gelf_getnote(data, note_offset, ¬e_header, &name_offset, &desc_offset)) > 0;) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL;
const char *payload = (const char *)data->d_buf + desc_offset;
if (note_header.n_namesz == 0 || note_header.n_descsz == 0)
payload = payload_0suffixed;
}
- r = json_parse(payload, 0, &v, NULL, NULL);
+ r = sd_json_parse(payload, 0, &v, NULL, NULL);
if (r < 0) {
_cleanup_free_ char *esc = cescape(payload);
return log_error_errno(r, "json_parse on \"%s\" failed: %m", strnull(esc));
/* If we have a build-id, merge it in the same JSON object so that it appears all
* nicely together in the logs/metadata. */
if (id_json) {
- r = json_variant_merge_object(&v, id_json);
+ r = sd_json_variant_merge_object(&v, id_json);
if (r < 0)
- return log_error_errno(r, "json_variant_merge of package meta with buildId failed: %m");
+ return log_error_errno(r, "sd_json_variant_merge of package meta with buildId failed: %m");
}
/* Pretty-print to the buffer, so that the metadata goes as plaintext in the
/* Then we build a new object using the module name as the key, and merge it
* with the previous parses, so that in the end it all fits together in a single
* JSON blob. */
- r = json_build(&w, JSON_BUILD_OBJECT(JSON_BUILD_PAIR(name, JSON_BUILD_VARIANT(v))));
+ r = sd_json_build(&w, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_VARIANT(v))));
if (r < 0)
return log_error_errno(r, "Failed to build JSON object: %m");
- r = json_variant_merge_object(c->package_metadata, w);
+ r = sd_json_variant_merge_object(c->package_metadata, w);
if (r < 0)
- return log_error_errno(r, "json_variant_merge of package meta with buildId failed: %m");
+ return log_error_errno(r, "sd_json_variant_merge of package meta with buildId failed: %m");
/* Finally stash the name, so we avoid double visits. */
r = set_put_strdup(c->modules, name);
}
/* Get the build-id out of an ELF object or a dwarf core module. */
-static int parse_buildid(Dwfl_Module *mod, Elf *elf, const char *name, StackContext *c, JsonVariant **ret_id_json) {
- _cleanup_(json_variant_unrefp) JsonVariant *id_json = NULL;
+static int parse_buildid(Dwfl_Module *mod, Elf *elf, const char *name, StackContext *c, sd_json_variant **ret_id_json) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *id_json = NULL;
const unsigned char *id;
GElf_Addr id_vaddr;
ssize_t id_len;
/* We will later parse package metadata json and pass it to our caller. Prepare the
* build-id in json format too, so that it can be appended and parsed cleanly. It
* will then be added as metadata to the journal message with the stack trace. */
- r = json_build(&id_json, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("buildId", JSON_BUILD_HEX(id, id_len))));
+ r = sd_json_build(&id_json, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("buildId", SD_JSON_BUILD_HEX(id, id_len))));
if (r < 0)
return log_error_errno(r, "json_build on buildId failed: %m");
}
}
static int module_callback(Dwfl_Module *mod, void **userdata, const char *name, Dwarf_Addr start, void *arg) {
- _cleanup_(json_variant_unrefp) JsonVariant *id_json = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *id_json = NULL;
StackContext *c = ASSERT_PTR(arg);
size_t n_program_headers;
GElf_Addr bias;
return DWARF_CB_OK;
}
-static int parse_core(int fd, const char *executable, char **ret, JsonVariant **ret_package_metadata) {
+static int parse_core(int fd, const char *executable, char **ret, sd_json_variant **ret_package_metadata) {
const Dwfl_Callbacks callbacks = {
.find_elf = sym_dwfl_build_id_find_elf,
.find_debuginfo = sym_dwfl_standard_find_debuginfo,
};
- _cleanup_(json_variant_unrefp) JsonVariant *package_metadata = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *package_metadata = NULL;
_cleanup_set_free_ Set *modules = NULL;
_cleanup_(stack_context_done) StackContext c = {
.package_metadata = &package_metadata,
return 0;
}
-static int parse_elf(int fd, const char *executable, char **ret, JsonVariant **ret_package_metadata) {
- _cleanup_(json_variant_unrefp) JsonVariant *package_metadata = NULL, *elf_metadata = NULL;
+static int parse_elf(int fd, const char *executable, char **ret, sd_json_variant **ret_package_metadata) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *package_metadata = NULL, *elf_metadata = NULL;
_cleanup_set_free_ Set *modules = NULL;
_cleanup_(stack_context_done) StackContext c = {
.package_metadata = &package_metadata,
elf_type = "coredump";
} else {
- _cleanup_(json_variant_unrefp) JsonVariant *id_json = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *id_json = NULL;
const char *e = executable ?: "(unnamed)";
bool interpreter_found = false;
/* If we found a build-id and nothing else, return at least that. */
if (!package_metadata && id_json) {
- r = json_build(&package_metadata, JSON_BUILD_OBJECT(JSON_BUILD_PAIR(e, JSON_BUILD_VARIANT(id_json))));
+ r = sd_json_build(&package_metadata, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR(e, SD_JSON_BUILD_VARIANT(id_json))));
if (r < 0)
return log_warning_errno(r, "Failed to build JSON object: %m");
}
/* Note that e_type is always DYN for both executables and libraries, so we can't tell them apart from the header,
* but we will search for the PT_INTERP section when parsing the metadata. */
- r = json_build(&elf_metadata, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("elfType", JSON_BUILD_STRING(elf_type))));
+ r = sd_json_build(&elf_metadata, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("elfType", SD_JSON_BUILD_STRING(elf_type))));
if (r < 0)
return log_warning_errno(r, "Failed to build JSON object: %m");
#if HAVE_DWELF_ELF_E_MACHINE_STRING
const char *elf_architecture = sym_dwelf_elf_e_machine_string(elf_header.e_machine);
if (elf_architecture) {
- _cleanup_(json_variant_unrefp) JsonVariant *json_architecture = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *json_architecture = NULL;
- r = json_build(&json_architecture,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("elfArchitecture", JSON_BUILD_STRING(elf_architecture))));
+ r = sd_json_build(&json_architecture,
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("elfArchitecture", SD_JSON_BUILD_STRING(elf_architecture))));
if (r < 0)
return log_warning_errno(r, "Failed to build JSON object: %m");
- r = json_variant_merge_object(&elf_metadata, json_architecture);
+ r = sd_json_variant_merge_object(&elf_metadata, json_architecture);
if (r < 0)
return log_warning_errno(r, "Failed to merge JSON objects: %m");
#endif
/* We always at least have the ELF type, so merge that (and possibly the arch). */
- r = json_variant_merge_object(&elf_metadata, package_metadata);
+ r = sd_json_variant_merge_object(&elf_metadata, package_metadata);
if (r < 0)
return log_warning_errno(r, "Failed to merge JSON objects: %m");
return 0;
}
-int parse_elf_object(int fd, const char *executable, bool fork_disable_dump, char **ret, JsonVariant **ret_package_metadata) {
+int parse_elf_object(int fd, const char *executable, bool fork_disable_dump, char **ret, sd_json_variant **ret_package_metadata) {
_cleanup_close_pair_ int error_pipe[2] = EBADF_PAIR,
return_pipe[2] = EBADF_PAIR,
json_pipe[2] = EBADF_PAIR;
- _cleanup_(json_variant_unrefp) JsonVariant *package_metadata = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *package_metadata = NULL;
_cleanup_free_ char *buf = NULL;
int r;
goto child_fail;
}
- r = json_variant_dump(package_metadata, JSON_FORMAT_FLUSH, json_out, NULL);
+ r = sd_json_variant_dump(package_metadata, SD_JSON_FORMAT_FLUSH, json_out, NULL);
if (r < 0)
log_warning_errno(r, "Failed to write JSON package metadata, ignoring: %m");
}
if (!json_in)
return -errno;
- r = json_parse_file(json_in, NULL, 0, &package_metadata, NULL, NULL);
+ r = sd_json_parse_file(json_in, NULL, 0, &package_metadata, NULL, NULL);
if (r < 0 && r != -ENODATA) /* ENODATA: json was empty, so we got nothing, but that's ok */
log_warning_errno(r, "Failed to read or parse json metadata, ignoring: %m");
}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "json.h"
+#include "sd-json.h"
#if HAVE_ELFUTILS
int dlopen_dw(void);
/* Parse an ELF object in a forked process, so that errors while iterating over
* untrusted and potentially malicious data do not propagate to the main caller's process.
* If fork_disable_dump, the child process will not dump core if it crashes. */
-int parse_elf_object(int fd, const char *executable, bool fork_disable_dump, char **ret, JsonVariant **ret_package_metadata);
+int parse_elf_object(int fd, const char *executable, bool fork_disable_dump, char **ret, sd_json_variant **ret_package_metadata);
#else
-static inline int parse_elf_object(int fd, const char *executable, bool fork_disable_dump, char **ret, JsonVariant **ret_package_metadata) {
+static inline int parse_elf_object(int fd, const char *executable, bool fork_disable_dump, char **ret, sd_json_variant **ret_package_metadata) {
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "elfutils disabled, parsing ELF objects not supported");
}
#endif
return table_get(t, cell);
}
-static int table_data_to_json(TableData *d, JsonVariant **ret) {
+static int table_data_to_json(TableData *d, sd_json_variant **ret) {
switch (d->type) {
case TABLE_EMPTY:
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
case TABLE_STRING:
case TABLE_PATH:
case TABLE_PATH_BASENAME:
case TABLE_FIELD:
case TABLE_HEADER:
- return json_variant_new_string(ret, d->string);
+ return sd_json_variant_new_string(ret, d->string);
case TABLE_STRV:
case TABLE_STRV_WRAPPED:
- return json_variant_new_array_strv(ret, d->strv);
+ return sd_json_variant_new_array_strv(ret, d->strv);
case TABLE_BOOLEAN_CHECKMARK:
case TABLE_BOOLEAN:
- return json_variant_new_boolean(ret, d->boolean);
+ return sd_json_variant_new_boolean(ret, d->boolean);
case TABLE_TIMESTAMP:
case TABLE_TIMESTAMP_UTC:
case TABLE_TIMESTAMP_LEFT:
case TABLE_TIMESTAMP_DATE:
if (d->timestamp == USEC_INFINITY)
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_variant_new_unsigned(ret, d->timestamp);
+ return sd_json_variant_new_unsigned(ret, d->timestamp);
case TABLE_TIMESPAN:
case TABLE_TIMESPAN_MSEC:
case TABLE_TIMESPAN_DAY:
if (d->timespan == USEC_INFINITY)
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_variant_new_unsigned(ret, d->timespan);
+ return sd_json_variant_new_unsigned(ret, d->timespan);
case TABLE_SIZE:
case TABLE_BPS:
if (d->size == UINT64_MAX)
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_variant_new_unsigned(ret, d->size);
+ return sd_json_variant_new_unsigned(ret, d->size);
case TABLE_INT:
- return json_variant_new_integer(ret, d->int_val);
+ return sd_json_variant_new_integer(ret, d->int_val);
case TABLE_INT8:
- return json_variant_new_integer(ret, d->int8);
+ return sd_json_variant_new_integer(ret, d->int8);
case TABLE_INT16:
- return json_variant_new_integer(ret, d->int16);
+ return sd_json_variant_new_integer(ret, d->int16);
case TABLE_INT32:
- return json_variant_new_integer(ret, d->int32);
+ return sd_json_variant_new_integer(ret, d->int32);
case TABLE_INT64:
- return json_variant_new_integer(ret, d->int64);
+ return sd_json_variant_new_integer(ret, d->int64);
case TABLE_UINT:
- return json_variant_new_unsigned(ret, d->uint_val);
+ return sd_json_variant_new_unsigned(ret, d->uint_val);
case TABLE_UINT8:
- return json_variant_new_unsigned(ret, d->uint8);
+ return sd_json_variant_new_unsigned(ret, d->uint8);
case TABLE_UINT16:
- return json_variant_new_unsigned(ret, d->uint16);
+ return sd_json_variant_new_unsigned(ret, d->uint16);
case TABLE_UINT32:
case TABLE_UINT32_HEX:
- return json_variant_new_unsigned(ret, d->uint32);
+ return sd_json_variant_new_unsigned(ret, d->uint32);
case TABLE_UINT64:
case TABLE_UINT64_HEX:
- return json_variant_new_unsigned(ret, d->uint64);
+ return sd_json_variant_new_unsigned(ret, d->uint64);
case TABLE_PERCENT:
- return json_variant_new_integer(ret, d->percent);
+ return sd_json_variant_new_integer(ret, d->percent);
case TABLE_IFINDEX:
if (d->ifindex <= 0)
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_variant_new_integer(ret, d->ifindex);
+ return sd_json_variant_new_integer(ret, d->ifindex);
case TABLE_IN_ADDR:
- return json_variant_new_array_bytes(ret, &d->address, FAMILY_ADDRESS_SIZE(AF_INET));
+ return sd_json_variant_new_array_bytes(ret, &d->address, FAMILY_ADDRESS_SIZE(AF_INET));
case TABLE_IN6_ADDR:
- return json_variant_new_array_bytes(ret, &d->address, FAMILY_ADDRESS_SIZE(AF_INET6));
+ return sd_json_variant_new_array_bytes(ret, &d->address, FAMILY_ADDRESS_SIZE(AF_INET6));
case TABLE_ID128:
- return json_variant_new_id128(ret, d->id128);
+ return sd_json_variant_new_id128(ret, d->id128);
case TABLE_UUID:
- return json_variant_new_uuid(ret, d->id128);
+ return sd_json_variant_new_uuid(ret, d->id128);
case TABLE_UID:
if (!uid_is_valid(d->uid))
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_variant_new_integer(ret, d->uid);
+ return sd_json_variant_new_integer(ret, d->uid);
case TABLE_GID:
if (!gid_is_valid(d->gid))
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_variant_new_integer(ret, d->gid);
+ return sd_json_variant_new_integer(ret, d->gid);
case TABLE_PID:
if (!pid_is_valid(d->pid))
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_variant_new_integer(ret, d->pid);
+ return sd_json_variant_new_integer(ret, d->pid);
case TABLE_SIGNAL:
if (!SIGNAL_VALID(d->int_val))
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_variant_new_integer(ret, d->int_val);
+ return sd_json_variant_new_integer(ret, d->int_val);
case TABLE_MODE:
case TABLE_MODE_INODE_TYPE:
if (d->mode == MODE_INVALID)
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_variant_new_unsigned(ret, d->mode);
+ return sd_json_variant_new_unsigned(ret, d->mode);
case TABLE_DEVNUM:
if (devnum_is_zero(d->devnum))
- return json_variant_new_null(ret);
+ return sd_json_variant_new_null(ret);
- return json_build(ret, JSON_BUILD_ARRAY(
- JSON_BUILD_UNSIGNED(major(d->devnum)),
- JSON_BUILD_UNSIGNED(minor(d->devnum))));
+ return sd_json_build(ret, SD_JSON_BUILD_ARRAY(
+ SD_JSON_BUILD_UNSIGNED(major(d->devnum)),
+ SD_JSON_BUILD_UNSIGNED(minor(d->devnum))));
default:
return -EINVAL;
return idx < t->n_json_fields ? t->json_fields[idx] : NULL;
}
-static int table_to_json_regular(Table *t, JsonVariant **ret) {
- JsonVariant **rows = NULL, **elements = NULL;
+static int table_to_json_regular(Table *t, sd_json_variant **ret) {
+ sd_json_variant **rows = NULL, **elements = NULL;
_cleanup_free_ size_t *sorted = NULL;
size_t n_rows, display_columns;
int r;
display_columns = t->n_columns;
assert(display_columns > 0);
- elements = new0(JsonVariant*, display_columns * 2);
+ elements = new0(sd_json_variant*, display_columns * 2);
if (!elements)
return -ENOMEM;
- CLEANUP_ARRAY(elements, (size_t) { display_columns * 2 }, json_variant_unref_many);
+ CLEANUP_ARRAY(elements, (size_t) { display_columns * 2 }, sd_json_variant_unref_many);
for (size_t j = 0; j < display_columns; j++) {
_cleanup_free_ char *mangled = NULL;
n = mangled;
}
- r = json_variant_new_string(elements + j*2, n);
+ r = sd_json_variant_new_string(elements + j*2, n);
if (r < 0)
return r;
}
- rows = new0(JsonVariant*, n_rows-1);
+ rows = new0(sd_json_variant*, n_rows-1);
if (!rows)
return -ENOMEM;
- CLEANUP_ARRAY(rows, (size_t) { n_rows - 1 }, json_variant_unref_many);
+ CLEANUP_ARRAY(rows, (size_t) { n_rows - 1 }, sd_json_variant_unref_many);
for (size_t i = 1; i < n_rows; i++) {
TableData **row;
assert_se(d = row[t->display_map ? t->display_map[j] : j]);
k = j*2+1;
- elements[k] = json_variant_unref(elements[k]);
+ elements[k] = sd_json_variant_unref(elements[k]);
r = table_data_to_json(d, elements + k);
if (r < 0)
return r;
}
- r = json_variant_new_object(rows + i - 1, elements, display_columns * 2);
+ r = sd_json_variant_new_object(rows + i - 1, elements, display_columns * 2);
if (r < 0)
return r;
}
- return json_variant_new_array(ret, rows, n_rows - 1);
+ return sd_json_variant_new_array(ret, rows, n_rows - 1);
}
-static int table_to_json_vertical(Table *t, JsonVariant **ret) {
- JsonVariant **elements = NULL;
+static int table_to_json_vertical(Table *t, sd_json_variant **ret) {
+ sd_json_variant **elements = NULL;
size_t n_elements = 0;
int r;
/* Ensure we have no incomplete rows */
assert(t->n_cells % t->n_columns == 0);
- elements = new0(JsonVariant *, t->n_cells);
+ elements = new0(sd_json_variant *, t->n_cells);
if (!elements)
return -ENOMEM;
- CLEANUP_ARRAY(elements, n_elements, json_variant_unref_many);
+ CLEANUP_ARRAY(elements, n_elements, sd_json_variant_unref_many);
for (size_t i = t->n_columns; i < t->n_cells; i++) {
n = mangled;
}
- r = json_variant_new_string(elements + n_elements, n);
+ r = sd_json_variant_new_string(elements + n_elements, n);
} else
r = table_data_to_json(t->data[i], elements + n_elements);
if (r < 0)
n_elements++;
}
- return json_variant_new_object(ret, elements, n_elements);
+ return sd_json_variant_new_object(ret, elements, n_elements);
}
-int table_to_json(Table *t, JsonVariant **ret) {
+int table_to_json(Table *t, sd_json_variant **ret) {
assert(t);
if (t->vertical)
return table_to_json_regular(t, ret);
}
-int table_print_json(Table *t, FILE *f, JsonFormatFlags flags) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+int table_print_json(Table *t, FILE *f, sd_json_format_flags_t flags) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(t);
- if (flags & JSON_FORMAT_OFF) /* If JSON output is turned off, use regular output */
+ if (flags & SD_JSON_FORMAT_OFF) /* If JSON output is turned off, use regular output */
return table_print(t, f);
if (!f)
if (r < 0)
return r;
- json_variant_dump(v, flags, f, NULL);
+ sd_json_variant_dump(v, flags, f, NULL);
return fflush_and_check(f);
}
int table_print_with_pager(
Table *t,
- JsonFormatFlags json_format_flags,
+ sd_json_format_flags_t json_format_flags,
PagerFlags pager_flags,
bool show_header) {
/* An all-in-one solution for showing tables, and turning on a pager first. Also optionally suppresses
* the table header and logs about any error. */
- if (json_format_flags & (JSON_FORMAT_OFF|JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ if (json_format_flags & (SD_JSON_FORMAT_OFF|SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
pager_open(pager_flags);
saved_header = t->header;
#include <stdio.h>
#include <sys/types.h>
-#include "json.h"
+#include "sd-json.h"
+
#include "macro.h"
#include "pager.h"
const void *table_get(Table *t, TableCell *cell);
const void *table_get_at(Table *t, size_t row, size_t column);
-int table_to_json(Table *t, JsonVariant **ret);
-int table_print_json(Table *t, FILE *f, JsonFormatFlags json_flags);
+int table_to_json(Table *t, sd_json_variant **ret);
+int table_print_json(Table *t, FILE *f, sd_json_format_flags_t json_flags);
-int table_print_with_pager(Table *t, JsonFormatFlags json_format_flags, PagerFlags pager_flags, bool show_header);
+int table_print_with_pager(Table *t, sd_json_format_flags_t json_format_flags, PagerFlags pager_flags, bool show_header);
int table_set_json_field_name(Table *t, size_t idx, const char *name);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "group-record.h"
+#include "json-util.h"
#include "strv.h"
#include "uid-classification.h"
#include "user-util.h"
strv_free(g->administrators);
strv_free_erase(g->hashed_password);
- json_variant_unref(g->json);
+ sd_json_variant_unref(g->json);
return mfree(g);
}
DEFINE_TRIVIAL_REF_UNREF_FUNC(GroupRecord, group_record, group_record_free);
-static int dispatch_privileged(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_privileged(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch privileged_dispatch_table[] = {
- { "hashedPassword", _JSON_VARIANT_TYPE_INVALID, json_dispatch_strv, offsetof(GroupRecord, hashed_password), JSON_SAFE },
+ static const sd_json_dispatch_field privileged_dispatch_table[] = {
+ { "hashedPassword", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_strv, offsetof(GroupRecord, hashed_password), SD_JSON_SAFE },
{},
};
- return json_dispatch(variant, privileged_dispatch_table, flags, userdata);
+ return sd_json_dispatch(variant, privileged_dispatch_table, flags, userdata);
}
-static int dispatch_binding(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_binding(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch binding_dispatch_table[] = {
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(GroupRecord, gid), 0 },
+ static const sd_json_dispatch_field binding_dispatch_table[] = {
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(GroupRecord, gid), 0 },
{},
};
- JsonVariant *m;
+ sd_json_variant *m;
sd_id128_t mid;
int r;
if (!variant)
return 0;
- if (!json_variant_is_object(variant))
+ if (!sd_json_variant_is_object(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an object.", strna(name));
r = sd_id128_get_machine(&mid);
if (r < 0)
return json_log(variant, flags, r, "Failed to determine machine ID: %m");
- m = json_variant_by_key(variant, SD_ID128_TO_STRING(mid));
+ m = sd_json_variant_by_key(variant, SD_ID128_TO_STRING(mid));
if (!m)
return 0;
- return json_dispatch(m, binding_dispatch_table, flags, userdata);
+ return sd_json_dispatch(m, binding_dispatch_table, flags, userdata);
}
-static int dispatch_per_machine(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_per_machine(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch per_machine_dispatch_table[] = {
- { "matchMachineId", _JSON_VARIANT_TYPE_INVALID, NULL, 0, 0 },
- { "matchHostname", _JSON_VARIANT_TYPE_INVALID, NULL, 0, 0 },
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(GroupRecord, gid), 0 },
- { "members", JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(GroupRecord, members), JSON_RELAX},
- { "administrators", JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(GroupRecord, administrators), JSON_RELAX},
+ static const sd_json_dispatch_field per_machine_dispatch_table[] = {
+ { "matchMachineId", _SD_JSON_VARIANT_TYPE_INVALID, NULL, 0, 0 },
+ { "matchHostname", _SD_JSON_VARIANT_TYPE_INVALID, NULL, 0, 0 },
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(GroupRecord, gid), 0 },
+ { "members", SD_JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(GroupRecord, members), SD_JSON_RELAX },
+ { "administrators", SD_JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(GroupRecord, administrators), SD_JSON_RELAX },
{},
};
- JsonVariant *e;
+ sd_json_variant *e;
int r;
if (!variant)
return 0;
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
- if (!json_variant_is_object(e))
+ if (!sd_json_variant_is_object(e))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of objects.", strna(name));
r = per_machine_match(e, flags);
if (r == 0)
continue;
- r = json_dispatch(e, per_machine_dispatch_table, flags, userdata);
+ r = sd_json_dispatch(e, per_machine_dispatch_table, flags, userdata);
if (r < 0)
return r;
}
return 0;
}
-static int dispatch_status(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_status(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch status_dispatch_table[] = {
- { "service", JSON_VARIANT_STRING, json_dispatch_string, offsetof(GroupRecord, service), JSON_SAFE },
+ static const sd_json_dispatch_field status_dispatch_table[] = {
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(GroupRecord, service), SD_JSON_SAFE },
{},
};
- JsonVariant *m;
+ sd_json_variant *m;
sd_id128_t mid;
int r;
if (!variant)
return 0;
- if (!json_variant_is_object(variant))
+ if (!sd_json_variant_is_object(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an object.", strna(name));
r = sd_id128_get_machine(&mid);
if (r < 0)
return json_log(variant, flags, r, "Failed to determine machine ID: %m");
- m = json_variant_by_key(variant, SD_ID128_TO_STRING(mid));
+ m = sd_json_variant_by_key(variant, SD_ID128_TO_STRING(mid));
if (!m)
return 0;
- return json_dispatch(m, status_dispatch_table, flags, userdata);
+ return sd_json_dispatch(m, status_dispatch_table, flags, userdata);
}
-static int group_record_augment(GroupRecord *h, JsonDispatchFlags json_flags) {
+static int group_record_augment(GroupRecord *h, sd_json_dispatch_flags_t json_flags) {
assert(h);
if (!FLAGS_SET(h->mask, USER_RECORD_REGULAR))
int group_record_load(
GroupRecord *h,
- JsonVariant *v,
+ sd_json_variant *v,
UserRecordLoadFlags load_flags) {
- static const JsonDispatch group_dispatch_table[] = {
- { "groupName", JSON_VARIANT_STRING, json_dispatch_user_group_name, offsetof(GroupRecord, group_name), JSON_RELAX},
- { "realm", JSON_VARIANT_STRING, json_dispatch_realm, offsetof(GroupRecord, realm), 0 },
- { "description", JSON_VARIANT_STRING, json_dispatch_gecos, offsetof(GroupRecord, description), 0 },
- { "disposition", JSON_VARIANT_STRING, json_dispatch_user_disposition, offsetof(GroupRecord, disposition), 0 },
- { "service", JSON_VARIANT_STRING, json_dispatch_string, offsetof(GroupRecord, service), JSON_SAFE },
- { "lastChangeUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(GroupRecord, last_change_usec), 0 },
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(GroupRecord, gid), 0 },
- { "members", JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(GroupRecord, members), JSON_RELAX},
- { "administrators", JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(GroupRecord, administrators), JSON_RELAX},
+ static const sd_json_dispatch_field group_dispatch_table[] = {
+ { "groupName", SD_JSON_VARIANT_STRING, json_dispatch_user_group_name, offsetof(GroupRecord, group_name), SD_JSON_RELAX },
+ { "realm", SD_JSON_VARIANT_STRING, json_dispatch_realm, offsetof(GroupRecord, realm), 0 },
+ { "description", SD_JSON_VARIANT_STRING, json_dispatch_gecos, offsetof(GroupRecord, description), 0 },
+ { "disposition", SD_JSON_VARIANT_STRING, json_dispatch_user_disposition, offsetof(GroupRecord, disposition), 0 },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(GroupRecord, service), SD_JSON_SAFE },
+ { "lastChangeUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(GroupRecord, last_change_usec), 0 },
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(GroupRecord, gid), 0 },
+ { "members", SD_JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(GroupRecord, members), SD_JSON_RELAX },
+ { "administrators", SD_JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(GroupRecord, administrators), SD_JSON_RELAX },
- { "privileged", JSON_VARIANT_OBJECT, dispatch_privileged, 0, 0 },
+ { "privileged", SD_JSON_VARIANT_OBJECT, dispatch_privileged, 0, 0 },
/* Not defined for now, for groups, but let's at least generate sensible errors about it */
- { "secret", JSON_VARIANT_OBJECT, json_dispatch_unsupported, 0, 0 },
+ { "secret", SD_JSON_VARIANT_OBJECT, sd_json_dispatch_unsupported, 0, 0 },
/* Ignore the perMachine, binding and status stuff here, and process it later, so that it overrides whatever is set above */
- { "perMachine", JSON_VARIANT_ARRAY, NULL, 0, 0 },
- { "binding", JSON_VARIANT_OBJECT, NULL, 0, 0 },
- { "status", JSON_VARIANT_OBJECT, NULL, 0, 0 },
+ { "perMachine", SD_JSON_VARIANT_ARRAY, NULL, 0, 0 },
+ { "binding", SD_JSON_VARIANT_OBJECT, NULL, 0, 0 },
+ { "status", SD_JSON_VARIANT_OBJECT, NULL, 0, 0 },
/* Ignore 'signature', we check it with explicit accessors instead */
- { "signature", JSON_VARIANT_ARRAY, NULL, 0, 0 },
+ { "signature", SD_JSON_VARIANT_ARRAY, NULL, 0, 0 },
{},
};
- JsonDispatchFlags json_flags = USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(load_flags);
+ sd_json_dispatch_flags_t json_flags = USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(load_flags);
int r;
assert(h);
if (r < 0)
return r;
- r = json_dispatch(h->json, group_dispatch_table, json_flags | JSON_ALLOW_EXTENSIONS, h);
+ r = sd_json_dispatch(h->json, group_dispatch_table, json_flags | SD_JSON_ALLOW_EXTENSIONS, h);
if (r < 0)
return r;
/* During the parsing operation above we ignored the 'perMachine', 'binding' and 'status' fields, since we want
* them to override the global options. Let's process them now. */
- r = dispatch_per_machine("perMachine", json_variant_by_key(h->json, "perMachine"), json_flags, h);
+ r = dispatch_per_machine("perMachine", sd_json_variant_by_key(h->json, "perMachine"), json_flags, h);
if (r < 0)
return r;
- r = dispatch_binding("binding", json_variant_by_key(h->json, "binding"), json_flags, h);
+ r = dispatch_binding("binding", sd_json_variant_by_key(h->json, "binding"), json_flags, h);
if (r < 0)
return r;
- r = dispatch_status("status", json_variant_by_key(h->json, "status"), json_flags, h);
+ r = dispatch_status("status", sd_json_variant_by_key(h->json, "status"), json_flags, h);
if (r < 0)
return r;
}
int group_record_build(GroupRecord **ret, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(group_record_unrefp) GroupRecord *g = NULL;
va_list ap;
int r;
assert(ret);
va_start(ap, ret);
- r = json_buildv(&v, ap);
+ r = sd_json_buildv(&v, ap);
va_end(ap);
if (r < 0)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "json.h"
+#include "sd-json.h"
+
#include "user-record.h"
typedef struct GroupRecord {
char **administrators; /* maps to 'struct sgrp' .sg_adm field */
char **hashed_password; /* maps to 'struct sgrp' .sg_passwd field */
- JsonVariant *json;
+ sd_json_variant *json;
} GroupRecord;
GroupRecord* group_record_new(void);
DEFINE_TRIVIAL_CLEANUP_FUNC(GroupRecord*, group_record_unref);
-int group_record_load(GroupRecord *h, JsonVariant *v, UserRecordLoadFlags flags);
+int group_record_load(GroupRecord *h, sd_json_variant *v, UserRecordLoadFlags flags);
int group_record_build(GroupRecord **ret, ...);
int group_record_clone(GroupRecord *g, UserRecordLoadFlags flags, GroupRecord **ret);
+++ /dev/null
-/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#pragma once
-
-#include <fcntl.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include "sd-id128.h"
-
-#include "ether-addr-util.h"
-#include "in-addr-util.h"
-#include "log.h"
-#include "macro.h"
-#include "string-util.h"
-#include "strv.h"
-#include "time-util.h"
-
-/*
- In case you wonder why we have our own JSON implementation, here are a couple of reasons why this implementation has
- benefits over various other implementations:
-
- - We need support for 64-bit signed and unsigned integers, i.e. the full 64,5bit range of -9223372036854775808…18446744073709551615
- - All our variants are immutable after creation
- - Special values such as true, false, zero, null, empty strings, empty array, empty objects require zero dynamic memory
- - Progressive parsing
- - Our integer/real type implicitly converts, but only if that's safe and loss-lessly possible
- - There's a "builder" for putting together objects easily in varargs function calls
- - There's a "dispatcher" for mapping objects to C data structures
- - Every variant optionally carries parsing location information, which simplifies debugging and parse log error generation
- - Formatter has color, line, column support
-
- Limitations:
- - Doesn't allow embedded NUL in strings
- - Can't store integers outside of the -9223372036854775808…18446744073709551615 range (it will use 'double' for
- values outside this range, which is lossy)
- - Can't store negative zero (will be treated identical to positive zero, and not retained across serialization)
- - Can't store non-integer numbers that can't be stored in "double" losslessly
- - Allows creation and parsing of objects with duplicate keys. The "dispatcher" will refuse them however. This means
- we can parse and pass around such objects, but will carefully refuse them when we convert them into our own data.
-
- (These limitations should be pretty much in line with those of other JSON implementations, in fact might be less
- limiting in most cases even.)
-*/
-
-typedef struct JsonVariant JsonVariant;
-
-typedef enum JsonVariantType {
- JSON_VARIANT_STRING,
- JSON_VARIANT_INTEGER,
- JSON_VARIANT_UNSIGNED,
- JSON_VARIANT_REAL,
- JSON_VARIANT_NUMBER, /* This a pseudo-type: we can never create variants of this type, but we use it as wildcard check for the above three types */
- JSON_VARIANT_BOOLEAN,
- JSON_VARIANT_ARRAY,
- JSON_VARIANT_OBJECT,
- JSON_VARIANT_NULL,
- _JSON_VARIANT_TYPE_MAX,
- _JSON_VARIANT_TYPE_INVALID = -EINVAL,
-} JsonVariantType;
-
-int json_variant_new_stringn(JsonVariant **ret, const char *s, size_t n);
-int json_variant_new_base64(JsonVariant **ret, const void *p, size_t n);
-int json_variant_new_base32hex(JsonVariant **ret, const void *p, size_t n);
-int json_variant_new_hex(JsonVariant **ret, const void *p, size_t n);
-int json_variant_new_octescape(JsonVariant **ret, const void *p, size_t n);
-int json_variant_new_integer(JsonVariant **ret, int64_t i);
-int json_variant_new_unsigned(JsonVariant **ret, uint64_t u);
-int json_variant_new_real(JsonVariant **ret, double d);
-int json_variant_new_boolean(JsonVariant **ret, bool b);
-int json_variant_new_array(JsonVariant **ret, JsonVariant **array, size_t n);
-int json_variant_new_array_bytes(JsonVariant **ret, const void *p, size_t n);
-int json_variant_new_array_strv(JsonVariant **ret, char **l);
-int json_variant_new_object(JsonVariant **ret, JsonVariant **array, size_t n);
-int json_variant_new_null(JsonVariant **ret);
-int json_variant_new_id128(JsonVariant **ret, sd_id128_t id);
-int json_variant_new_uuid(JsonVariant **ret, sd_id128_t id);
-
-static inline int json_variant_new_string(JsonVariant **ret, const char *s) {
- return json_variant_new_stringn(ret, s, SIZE_MAX);
-}
-
-JsonVariant *json_variant_ref(JsonVariant *v);
-JsonVariant *json_variant_unref(JsonVariant *v);
-void json_variant_unref_many(JsonVariant **array, size_t n);
-
-#define JSON_VARIANT_REPLACE(v, q) \
- do { \
- typeof(v)* _v = &(v); \
- typeof(q) _q = (q); \
- json_variant_unref(*_v); \
- *_v = _q; \
- } while(0)
-
-DEFINE_TRIVIAL_CLEANUP_FUNC(JsonVariant *, json_variant_unref);
-
-const char *json_variant_string(JsonVariant *v);
-int64_t json_variant_integer(JsonVariant *v);
-uint64_t json_variant_unsigned(JsonVariant *v);
-double json_variant_real(JsonVariant *v);
-bool json_variant_boolean(JsonVariant *v);
-
-JsonVariantType json_variant_type(JsonVariant *v);
-bool json_variant_has_type(JsonVariant *v, JsonVariantType type);
-
-static inline bool json_variant_is_string(JsonVariant *v) {
- return json_variant_has_type(v, JSON_VARIANT_STRING);
-}
-
-static inline bool json_variant_is_integer(JsonVariant *v) {
- return json_variant_has_type(v, JSON_VARIANT_INTEGER);
-}
-
-static inline bool json_variant_is_unsigned(JsonVariant *v) {
- return json_variant_has_type(v, JSON_VARIANT_UNSIGNED);
-}
-
-static inline bool json_variant_is_real(JsonVariant *v) {
- return json_variant_has_type(v, JSON_VARIANT_REAL);
-}
-
-static inline bool json_variant_is_number(JsonVariant *v) {
- return json_variant_has_type(v, JSON_VARIANT_NUMBER);
-}
-
-static inline bool json_variant_is_boolean(JsonVariant *v) {
- return json_variant_has_type(v, JSON_VARIANT_BOOLEAN);
-}
-
-static inline bool json_variant_is_array(JsonVariant *v) {
- return json_variant_has_type(v, JSON_VARIANT_ARRAY);
-}
-
-static inline bool json_variant_is_object(JsonVariant *v) {
- return json_variant_has_type(v, JSON_VARIANT_OBJECT);
-}
-
-static inline bool json_variant_is_null(JsonVariant *v) {
- return json_variant_has_type(v, JSON_VARIANT_NULL);
-}
-
-bool json_variant_is_negative(JsonVariant *v);
-bool json_variant_is_blank_object(JsonVariant *v);
-bool json_variant_is_blank_array(JsonVariant *v);
-bool json_variant_is_normalized(JsonVariant *v);
-bool json_variant_is_sorted(JsonVariant *v);
-
-size_t json_variant_elements(JsonVariant *v);
-JsonVariant *json_variant_by_index(JsonVariant *v, size_t index);
-JsonVariant *json_variant_by_key(JsonVariant *v, const char *key);
-JsonVariant *json_variant_by_key_full(JsonVariant *v, const char *key, JsonVariant **ret_key);
-
-bool json_variant_equal(JsonVariant *a, JsonVariant *b);
-
-void json_variant_sensitive(JsonVariant *v);
-bool json_variant_is_sensitive(JsonVariant *v);
-bool json_variant_is_sensitive_recursive(JsonVariant *v);
-
-struct json_variant_foreach_state {
- JsonVariant *variant;
- size_t idx;
-};
-
-#define _JSON_VARIANT_ARRAY_FOREACH(i, v, state) \
- for (struct json_variant_foreach_state state = { (v), 0 }; \
- json_variant_is_array(state.variant) && \
- state.idx < json_variant_elements(state.variant) && \
- ({ i = json_variant_by_index(state.variant, state.idx); \
- true; }); \
- state.idx++)
-#define JSON_VARIANT_ARRAY_FOREACH(i, v) \
- _JSON_VARIANT_ARRAY_FOREACH(i, v, UNIQ_T(state, UNIQ))
-
-#define _JSON_VARIANT_OBJECT_FOREACH(k, e, v, state) \
- for (struct json_variant_foreach_state state = { (v), 0 }; \
- json_variant_is_object(state.variant) && \
- state.idx < json_variant_elements(state.variant) && \
- ({ k = json_variant_string(json_variant_by_index(state.variant, state.idx)); \
- e = json_variant_by_index(state.variant, state.idx + 1); \
- true; }); \
- state.idx += 2)
-#define JSON_VARIANT_OBJECT_FOREACH(k, e, v) \
- _JSON_VARIANT_OBJECT_FOREACH(k, e, v, UNIQ_T(state, UNIQ))
-
-int json_variant_get_source(JsonVariant *v, const char **ret_source, unsigned *ret_line, unsigned *ret_column);
-
-typedef enum JsonFormatFlags {
- JSON_FORMAT_NEWLINE = 1 << 0, /* suffix with newline */
- JSON_FORMAT_PRETTY = 1 << 1, /* add internal whitespace to appeal to human readers */
- JSON_FORMAT_PRETTY_AUTO = 1 << 2, /* same, but only if connected to a tty (and JSON_FORMAT_NEWLINE otherwise) */
- JSON_FORMAT_COLOR = 1 << 3, /* insert ANSI color sequences */
- JSON_FORMAT_COLOR_AUTO = 1 << 4, /* insert ANSI color sequences if colors_enabled() says so */
- JSON_FORMAT_SOURCE = 1 << 5, /* prefix with source filename/line/column */
- JSON_FORMAT_SSE = 1 << 6, /* prefix/suffix with W3C server-sent events */
- JSON_FORMAT_SEQ = 1 << 7, /* prefix/suffix with RFC 7464 application/json-seq */
- JSON_FORMAT_FLUSH = 1 << 8, /* call fflush() after dumping JSON */
- JSON_FORMAT_EMPTY_ARRAY = 1 << 9, /* output "[]" for empty input */
- JSON_FORMAT_OFF = 1 << 10, /* make json_variant_format() fail with -ENOEXEC */
- JSON_FORMAT_CENSOR_SENSITIVE = 1 << 11, /* Replace all sensitive elements with the string "<sensitive data>" */
-} JsonFormatFlags;
-
-int json_variant_format(JsonVariant *v, JsonFormatFlags flags, char **ret);
-int json_variant_dump(JsonVariant *v, JsonFormatFlags flags, FILE *f, const char *prefix);
-
-int json_variant_filter(JsonVariant **v, char **to_remove);
-
-int json_variant_set_field(JsonVariant **v, const char *field, JsonVariant *value);
-int json_variant_set_fieldb(JsonVariant **v, const char *field, ...);
-int json_variant_set_field_string(JsonVariant **v, const char *field, const char *value);
-int json_variant_set_field_integer(JsonVariant **v, const char *field, int64_t value);
-int json_variant_set_field_unsigned(JsonVariant **v, const char *field, uint64_t value);
-int json_variant_set_field_boolean(JsonVariant **v, const char *field, bool b);
-int json_variant_set_field_strv(JsonVariant **v, const char *field, char **l);
-
-static inline int json_variant_set_field_non_null(JsonVariant **v, const char *field, JsonVariant *value) {
- return value && !json_variant_is_null(value) ? json_variant_set_field(v, field, value) : 0;
-}
-
-JsonVariant *json_variant_find(JsonVariant *haystack, JsonVariant *needle);
-
-int json_variant_append_array(JsonVariant **v, JsonVariant *element);
-int json_variant_append_arrayb(JsonVariant **v, ...);
-int json_variant_append_array_nodup(JsonVariant **v, JsonVariant *element);
-
-int json_variant_merge_object(JsonVariant **v, JsonVariant *m);
-int json_variant_merge_objectb(JsonVariant **v, ...);
-
-int json_variant_strv(JsonVariant *v, char ***ret);
-
-int json_variant_sort(JsonVariant **v);
-int json_variant_normalize(JsonVariant **v);
-
-typedef enum JsonParseFlags {
- JSON_PARSE_SENSITIVE = 1 << 0, /* mark variant as "sensitive", i.e. something containing secret key material or such */
-} JsonParseFlags;
-
-int json_parse_with_source(const char *string, const char *source, JsonParseFlags flags, JsonVariant **ret, unsigned *ret_line, unsigned *ret_column);
-int json_parse_with_source_continue(const char **p, const char *source, JsonParseFlags flags, JsonVariant **ret, unsigned *ret_line, unsigned *ret_column);
-
-static inline int json_parse(const char *string, JsonParseFlags flags, JsonVariant **ret, unsigned *ret_line, unsigned *ret_column) {
- return json_parse_with_source(string, NULL, flags, ret, ret_line, ret_column);
-}
-static inline int json_parse_continue(const char **p, JsonParseFlags flags, JsonVariant **ret, unsigned *ret_line, unsigned *ret_column) {
- return json_parse_with_source_continue(p, NULL, flags, ret, ret_line, ret_column);
-}
-
-int json_parse_file_at(FILE *f, int dir_fd, const char *path, JsonParseFlags flags, JsonVariant **ret, unsigned *ret_line, unsigned *ret_column);
-
-static inline int json_parse_file(FILE *f, const char *path, JsonParseFlags flags, JsonVariant **ret, unsigned *ret_line, unsigned *ret_column) {
- return json_parse_file_at(f, AT_FDCWD, path, flags, ret, ret_line, ret_column);
-}
-
-enum {
- _JSON_BUILD_STRING,
- _JSON_BUILD_INTEGER,
- _JSON_BUILD_UNSIGNED,
- _JSON_BUILD_REAL,
- _JSON_BUILD_BOOLEAN,
- _JSON_BUILD_ARRAY_BEGIN,
- _JSON_BUILD_ARRAY_END,
- _JSON_BUILD_OBJECT_BEGIN,
- _JSON_BUILD_OBJECT_END,
- _JSON_BUILD_PAIR,
- _JSON_BUILD_PAIR_CONDITION,
- _JSON_BUILD_NULL,
- _JSON_BUILD_VARIANT,
- _JSON_BUILD_VARIANT_ARRAY,
- _JSON_BUILD_LITERAL,
- _JSON_BUILD_STRV,
- _JSON_BUILD_STRV_ENV_PAIR,
- _JSON_BUILD_BASE64,
- _JSON_BUILD_IOVEC_BASE64,
- _JSON_BUILD_BASE32HEX,
- _JSON_BUILD_HEX,
- _JSON_BUILD_IOVEC_HEX,
- _JSON_BUILD_OCTESCAPE,
- _JSON_BUILD_ID128,
- _JSON_BUILD_UUID,
- _JSON_BUILD_BYTE_ARRAY,
- _JSON_BUILD_HW_ADDR,
- _JSON_BUILD_STRING_SET,
- _JSON_BUILD_CALLBACK,
- _JSON_BUILD_PAIR_UNSIGNED_NON_ZERO,
- _JSON_BUILD_PAIR_FINITE_USEC,
- _JSON_BUILD_PAIR_STRING_NON_EMPTY,
- _JSON_BUILD_PAIR_STRV_NON_EMPTY,
- _JSON_BUILD_PAIR_VARIANT_NON_NULL,
- _JSON_BUILD_PAIR_VARIANT_ARRAY_NON_EMPTY,
- _JSON_BUILD_PAIR_IN4_ADDR_NON_NULL,
- _JSON_BUILD_PAIR_IN6_ADDR_NON_NULL,
- _JSON_BUILD_PAIR_IN_ADDR_NON_NULL,
- _JSON_BUILD_PAIR_ETHER_ADDR_NON_NULL,
- _JSON_BUILD_PAIR_HW_ADDR_NON_NULL,
- _JSON_BUILD_MAX,
-};
-
-typedef int (*JsonBuildCallback)(JsonVariant **ret, const char *name, void *userdata);
-
-#define JSON_BUILD_STRING(s) _JSON_BUILD_STRING, (const char*) { s }
-#define JSON_BUILD_INTEGER(i) _JSON_BUILD_INTEGER, (int64_t) { i }
-#define JSON_BUILD_UNSIGNED(u) _JSON_BUILD_UNSIGNED, (uint64_t) { u }
-#define JSON_BUILD_REAL(d) _JSON_BUILD_REAL, (double) { d }
-#define JSON_BUILD_BOOLEAN(b) _JSON_BUILD_BOOLEAN, (bool) { b }
-#define JSON_BUILD_ARRAY(...) _JSON_BUILD_ARRAY_BEGIN, __VA_ARGS__, _JSON_BUILD_ARRAY_END
-#define JSON_BUILD_EMPTY_ARRAY _JSON_BUILD_ARRAY_BEGIN, _JSON_BUILD_ARRAY_END
-#define JSON_BUILD_OBJECT(...) _JSON_BUILD_OBJECT_BEGIN, __VA_ARGS__, _JSON_BUILD_OBJECT_END
-#define JSON_BUILD_EMPTY_OBJECT _JSON_BUILD_OBJECT_BEGIN, _JSON_BUILD_OBJECT_END
-#define JSON_BUILD_PAIR(n, ...) _JSON_BUILD_PAIR, (const char*) { n }, __VA_ARGS__
-#define JSON_BUILD_PAIR_CONDITION(c, n, ...) _JSON_BUILD_PAIR_CONDITION, (bool) { c }, (const char*) { n }, __VA_ARGS__
-#define JSON_BUILD_NULL _JSON_BUILD_NULL
-#define JSON_BUILD_VARIANT(v) _JSON_BUILD_VARIANT, (JsonVariant*) { v }
-#define JSON_BUILD_VARIANT_ARRAY(v, n) _JSON_BUILD_VARIANT_ARRAY, (JsonVariant **) { v }, (size_t) { n }
-#define JSON_BUILD_LITERAL(l) _JSON_BUILD_LITERAL, (const char*) { l }
-#define JSON_BUILD_STRV(l) _JSON_BUILD_STRV, (char**) { l }
-#define JSON_BUILD_STRV_ENV_PAIR(l) _JSON_BUILD_STRV_ENV_PAIR, (char**) { l }
-#define JSON_BUILD_BASE64(p, n) _JSON_BUILD_BASE64, (const void*) { p }, (size_t) { n }
-#define JSON_BUILD_IOVEC_BASE64(iov) _JSON_BUILD_IOVEC_BASE64, (const struct iovec*) { iov }
-#define JSON_BUILD_BASE32HEX(p, n) _JSON_BUILD_BASE32HEX, (const void*) { p }, (size_t) { n }
-#define JSON_BUILD_HEX(p, n) _JSON_BUILD_HEX, (const void*) { p }, (size_t) { n }
-#define JSON_BUILD_IOVEC_HEX(iov) _JSON_BUILD_IOVEC_HEX, (const struct iovec*) { iov }
-#define JSON_BUILD_OCTESCAPE(p, n) _JSON_BUILD_OCTESCAPE, (const void*) { p }, (size_t) { n }
-#define JSON_BUILD_ID128(id) _JSON_BUILD_ID128, (const sd_id128_t*) { &(id) }
-#define JSON_BUILD_UUID(id) _JSON_BUILD_UUID, (const sd_id128_t*) { &(id) }
-#define JSON_BUILD_BYTE_ARRAY(v, n) _JSON_BUILD_BYTE_ARRAY, (const void*) { v }, (size_t) { n }
-#define JSON_BUILD_CONST_STRING(s) _JSON_BUILD_VARIANT, JSON_VARIANT_STRING_CONST(s)
-#define JSON_BUILD_IN4_ADDR(v) JSON_BUILD_BYTE_ARRAY((const struct in_addr*) { v }, sizeof(struct in_addr))
-#define JSON_BUILD_IN6_ADDR(v) JSON_BUILD_BYTE_ARRAY((const struct in6_addr*) { v }, sizeof(struct in6_addr))
-#define JSON_BUILD_IN_ADDR(v, f) JSON_BUILD_BYTE_ARRAY(((const union in_addr_union*) { v })->bytes, FAMILY_ADDRESS_SIZE_SAFE(f))
-#define JSON_BUILD_ETHER_ADDR(v) JSON_BUILD_BYTE_ARRAY(((const struct ether_addr*) { v })->ether_addr_octet, sizeof(struct ether_addr))
-#define JSON_BUILD_HW_ADDR(v) _JSON_BUILD_HW_ADDR, (const struct hw_addr_data*) { v }
-#define JSON_BUILD_STRING_SET(s) _JSON_BUILD_STRING_SET, (Set *) { s }
-#define JSON_BUILD_CALLBACK(c, u) _JSON_BUILD_CALLBACK, (JsonBuildCallback) { c }, (void*) { u }
-
-#define JSON_BUILD_PAIR_STRING(name, s) JSON_BUILD_PAIR(name, JSON_BUILD_STRING(s))
-#define JSON_BUILD_PAIR_INTEGER(name, i) JSON_BUILD_PAIR(name, JSON_BUILD_INTEGER(i))
-#define JSON_BUILD_PAIR_UNSIGNED(name, u) JSON_BUILD_PAIR(name, JSON_BUILD_UNSIGNED(u))
-#define JSON_BUILD_PAIR_REAL(name, d) JSON_BUILD_PAIR(name, JSON_BUILD_REAL(d))
-#define JSON_BUILD_PAIR_BOOLEAN(name, b) JSON_BUILD_PAIR(name, JSON_BUILD_BOOLEAN(b))
-#define JSON_BUILD_PAIR_ARRAY(name, ...) JSON_BUILD_PAIR(name, JSON_BUILD_ARRAY(__VA_ARGS__))
-#define JSON_BUILD_PAIR_EMPTY_ARRAY(name) JSON_BUILD_PAIR(name, JSON_BUILD_EMPTY_ARRAY)
-#define JSON_BUILD_PAIR_OBJECT(name, ...) JSON_BUILD_PAIR(name, JSON_BUILD_OBJECT(__VA_ARGS__))
-#define JSON_BUILD_PAIR_EMPTY_OBJECT(name) JSON_BUILD_PAIR(name, JSON_BUILD_EMPTY_OBJECT)
-#define JSON_BUILD_PAIR_NULL(name) JSON_BUILD_PAIR(name, JSON_BUILD_NULL)
-#define JSON_BUILD_PAIR_VARIANT(name, v) JSON_BUILD_PAIR(name, JSON_BUILD_VARIANT(v))
-#define JSON_BUILD_PAIR_VARIANT_ARRAY(name, v, n) JSON_BUILD_PAIR(name, JSON_BUILD_VARIANT_ARRAY(v, n))
-#define JSON_BUILD_PAIR_LITERAL(name, l) JSON_BUILD_PAIR(name, JSON_BUILD_LITERAL(l))
-#define JSON_BUILD_PAIR_STRV(name, l) JSON_BUILD_PAIR(name, JSON_BUILD_STRV(l))
-#define JSON_BUILD_PAIR_BASE64(name, p, n) JSON_BUILD_PAIR(name, JSON_BUILD_BASE64(p, n))
-#define JSON_BUILD_PAIR_IOVEC_BASE64(name, iov) JSON_BUILD_PAIR(name, JSON_BUILD_IOVEC_BASE64(iov))
-#define JSON_BUILD_PAIR_HEX(name, p, n) JSON_BUILD_PAIR(name, JSON_BUILD_HEX(p, n))
-#define JSON_BUILD_PAIR_IOVEC_HEX(name, iov) JSON_BUILD_PAIR(name, JSON_BUILD_IOVEC_HEX(iov))
-#define JSON_BUILD_PAIR_ID128(name, id) JSON_BUILD_PAIR(name, JSON_BUILD_ID128(id))
-#define JSON_BUILD_PAIR_UUID(name, id) JSON_BUILD_PAIR(name, JSON_BUILD_UUID(id))
-#define JSON_BUILD_PAIR_BYTE_ARRAY(name, v, n) JSON_BUILD_PAIR(name, JSON_BUILD_BYTE_ARRAY(v, n))
-#define JSON_BUILD_PAIR_IN4_ADDR(name, v) JSON_BUILD_PAIR(name, JSON_BUILD_IN4_ADDR(v))
-#define JSON_BUILD_PAIR_IN6_ADDR(name, v) JSON_BUILD_PAIR(name, JSON_BUILD_IN6_ADDR(v))
-#define JSON_BUILD_PAIR_IN_ADDR(name, v, f) JSON_BUILD_PAIR(name, JSON_BUILD_IN_ADDR(v, f))
-#define JSON_BUILD_PAIR_ETHER_ADDR(name, v) JSON_BUILD_PAIR(name, JSON_BUILD_ETHER_ADDR(v))
-#define JSON_BUILD_PAIR_HW_ADDR(name, v) JSON_BUILD_PAIR(name, JSON_BUILD_HW_ADDR(v))
-#define JSON_BUILD_PAIR_STRING_SET(name, s) JSON_BUILD_PAIR(name, JSON_BUILD_STRING_SET(s))
-#define JSON_BUILD_PAIR_CALLBACK(name, c, u) JSON_BUILD_PAIR(name, JSON_BUILD_CALLBACK(c, u))
-
-#define JSON_BUILD_PAIR_UNSIGNED_NON_ZERO(name, u) _JSON_BUILD_PAIR_UNSIGNED_NON_ZERO, (const char*) { name }, (uint64_t) { u }
-#define JSON_BUILD_PAIR_FINITE_USEC(name, u) _JSON_BUILD_PAIR_FINITE_USEC, (const char*) { name }, (usec_t) { u }
-#define JSON_BUILD_PAIR_STRING_NON_EMPTY(name, s) _JSON_BUILD_PAIR_STRING_NON_EMPTY, (const char*) { name }, (const char*) { s }
-#define JSON_BUILD_PAIR_STRV_NON_EMPTY(name, l) _JSON_BUILD_PAIR_STRV_NON_EMPTY, (const char*) { name }, (char**) { l }
-#define JSON_BUILD_PAIR_VARIANT_NON_NULL(name, v) _JSON_BUILD_PAIR_VARIANT_NON_NULL, (const char*) { name }, (JsonVariant*) { v }
-#define JSON_BUILD_PAIR_IN4_ADDR_NON_NULL(name, v) _JSON_BUILD_PAIR_IN4_ADDR_NON_NULL, (const char*) { name }, (const struct in_addr*) { v }
-#define JSON_BUILD_PAIR_IN6_ADDR_NON_NULL(name, v) _JSON_BUILD_PAIR_IN6_ADDR_NON_NULL, (const char*) { name }, (const struct in6_addr*) { v }
-#define JSON_BUILD_PAIR_IN_ADDR_NON_NULL(name, v, f) _JSON_BUILD_PAIR_IN_ADDR_NON_NULL, (const char*) { name }, (const union in_addr_union*) { v }, (int) { f }
-#define JSON_BUILD_PAIR_ETHER_ADDR_NON_NULL(name, v) _JSON_BUILD_PAIR_ETHER_ADDR_NON_NULL, (const char*) { name }, (const struct ether_addr*) { v }
-#define JSON_BUILD_PAIR_HW_ADDR_NON_NULL(name, v) _JSON_BUILD_PAIR_HW_ADDR_NON_NULL, (const char*) { name }, (const struct hw_addr_data*) { v }
-
-int json_build(JsonVariant **ret, ...);
-int json_buildv(JsonVariant **ret, va_list ap);
-
-/* A bitmask of flags used by the dispatch logic. Note that this is a combined bit mask, that is generated from the bit
- * mask originally passed into json_dispatch(), the individual bitmask associated with the static JsonDispatch callout
- * entry, as well the bitmask specified for json_log() calls */
-typedef enum JsonDispatchFlags {
- /* The following three may be set in JsonDispatch's .flags field or the json_dispatch() flags parameter */
- JSON_PERMISSIVE = 1 << 0, /* Shall parsing errors be considered fatal for this field or object? */
- JSON_MANDATORY = 1 << 1, /* Should existence of this property be mandatory? */
- JSON_LOG = 1 << 2, /* Should the parser log about errors? */
- JSON_SAFE = 1 << 3, /* Don't accept "unsafe" strings in json_dispatch_string() + json_dispatch_string() */
- JSON_RELAX = 1 << 4, /* Use relaxed user name checking in json_dispatch_user_group_name */
- JSON_ALLOW_EXTENSIONS = 1 << 5, /* Subset of JSON_PERMISSIVE: allow additional fields, but no other permissive handling */
-
- /* The following two may be passed into log_json() in addition to those above */
- JSON_DEBUG = 1 << 6, /* Indicates that this log message is a debug message */
- JSON_WARNING = 1 << 7, /* Indicates that this log message is a warning message */
-} JsonDispatchFlags;
-
-typedef int (*JsonDispatchCallback)(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-
-typedef struct JsonDispatch {
- const char *name;
- JsonVariantType type;
- JsonDispatchCallback callback;
- size_t offset;
- JsonDispatchFlags flags;
-} JsonDispatch;
-
-int json_dispatch_full(JsonVariant *v, const JsonDispatch table[], JsonDispatchCallback bad, JsonDispatchFlags flags, void *userdata, const char **reterr_bad_field);
-
-static inline int json_dispatch(JsonVariant *v, const JsonDispatch table[], JsonDispatchFlags flags, void *userdata) {
- return json_dispatch_full(v, table, NULL, flags, userdata, NULL);
-}
-
-int json_dispatch_string(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_const_string(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_strv(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_boolean(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_tristate(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_variant(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_variant_noref(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_int64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_uint64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_uint32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_int32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_uint16(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_int16(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_int8(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_uint8(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_uid_gid(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_user_group_name(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_path(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_id128(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_unsupported(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_unbase64_iovec(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_byte_array_iovec(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_in_addr(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-
-assert_cc(sizeof(uint32_t) == sizeof(unsigned));
-#define json_dispatch_uint json_dispatch_uint32
-
-assert_cc(sizeof(int32_t) == sizeof(int));
-#define json_dispatch_int json_dispatch_int32
-
-#define JSON_DISPATCH_ENUM_DEFINE(name, type, func) \
- int name(const char *n, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) { \
- type *c = ASSERT_PTR(userdata); \
- \
- assert(variant); \
- \
- if (json_variant_is_null(variant)) { \
- *c = (type) -EINVAL; \
- return 0; \
- } \
- \
- if (!json_variant_is_string(variant)) \
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(n)); \
- \
- type cc = func(json_variant_string(variant)); \
- if (cc < 0) \
- return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Value of JSON field '%s' not recognized.", strna(n)); \
- \
- *c = cc; \
- return 0; \
- }
-
-static inline int json_dispatch_level(JsonDispatchFlags flags) {
-
- /* Did the user request no logging? If so, then never log higher than LOG_DEBUG. Also, if this is marked as
- * debug message, then also log at debug level. */
-
- if (!(flags & JSON_LOG) ||
- (flags & JSON_DEBUG))
- return LOG_DEBUG;
-
- /* Are we invoked in permissive mode, or is this explicitly marked as warning message? Then this should be
- * printed at LOG_WARNING */
- if (flags & (JSON_PERMISSIVE|JSON_WARNING))
- return LOG_WARNING;
-
- /* Otherwise it's an error. */
- return LOG_ERR;
-}
-
-int json_log_internal(JsonVariant *variant, int level, int error, const char *file, int line, const char *func, const char *format, ...) _printf_(7, 8);
-
-#define json_log(variant, flags, error, ...) \
- ({ \
- int _level = json_dispatch_level(flags), _e = (error); \
- (log_get_max_level() >= LOG_PRI(_level)) \
- ? json_log_internal(variant, _level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \
- : -ERRNO_VALUE(_e); \
- })
-
-#define json_log_oom(variant, flags) \
- json_log(variant, flags, SYNTHETIC_ERRNO(ENOMEM), "Out of memory.")
-
-#define JSON_VARIANT_STRING_CONST(x) _JSON_VARIANT_STRING_CONST(UNIQ, (x))
-
-#define _JSON_VARIANT_STRING_CONST(xq, x) \
- ({ \
- _align_(2) static const char UNIQ_T(json_string_const, xq)[] = (x); \
- assert((((uintptr_t) UNIQ_T(json_string_const, xq)) & 1) == 0); \
- (JsonVariant*) ((uintptr_t) UNIQ_T(json_string_const, xq) + 1); \
- })
-
-int json_variant_unbase64(JsonVariant *v, void **ret, size_t *ret_size);
-int json_variant_unhex(JsonVariant *v, void **ret, size_t *ret_size);
-
-static inline int json_variant_unbase64_iovec(JsonVariant *v, struct iovec *ret) {
- return json_variant_unbase64(v, ret ? &ret->iov_base : NULL, ret ? &ret->iov_len : NULL);
-}
-
-static inline int json_variant_unhex_iovec(JsonVariant *v, struct iovec *ret) {
- return json_variant_unhex(v, ret ? &ret->iov_base : NULL, ret ? &ret->iov_len : NULL);
-}
-
-const char *json_variant_type_to_string(JsonVariantType t);
-JsonVariantType json_variant_type_from_string(const char *s);
#include "sd-id128.h"
#include "sd-journal.h"
+#include "sd-json.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "io-util.h"
#include "journal-internal.h"
#include "journal-util.h"
-#include "json.h"
#include "locale-util.h"
#include "log.h"
#include "logs-show.h"
}
typedef struct JsonData {
- JsonVariant* name;
- JsonVariant* values;
+ sd_json_variant* name;
+ sd_json_variant* values;
} JsonData;
static JsonData* json_data_free(JsonData *d) {
if (!d)
return NULL;
- json_variant_unref(d->name);
- json_variant_unref(d->values);
+ sd_json_variant_unref(d->name);
+ sd_json_variant_unref(d->values);
return mfree(d);
}
const void *value,
size_t size) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
JsonData *d;
int r;
size = strlen(value);
if (!(flags & OUTPUT_SHOW_ALL) && strlen(name) + 1 + size >= JSON_THRESHOLD)
- r = json_variant_new_null(&v);
+ r = sd_json_variant_new_null(&v);
else if (utf8_is_printable(value, size))
- r = json_variant_new_stringn(&v, value, size);
+ r = sd_json_variant_new_stringn(&v, value, size);
else
- r = json_variant_new_array_bytes(&v, value, size);
+ r = sd_json_variant_new_array_bytes(&v, value, size);
if (r < 0)
return log_error_errno(r, "Failed to allocate JSON data: %m");
d = hashmap_get(h, name);
if (d) {
- r = json_variant_append_array(&d->values, v);
+ r = sd_json_variant_append_array(&d->values, v);
if (r < 0)
return log_error_errno(r, "Failed to append JSON value into array: %m");
} else {
if (!e)
return log_oom();
- r = json_variant_new_string(&e->name, name);
+ r = sd_json_variant_new_string(&e->name, name);
if (r < 0)
return log_error_errno(r, "Failed to allocate JSON name variant: %m");
- r = json_variant_append_array(&e->values, v);
+ r = sd_json_variant_append_array(&e->values, v);
if (r < 0)
return log_error_errno(r, "Failed to create JSON value array: %m");
- r = hashmap_put(h, json_variant_string(e->name), e);
+ r = hashmap_put(h, sd_json_variant_string(e->name), e);
if (r < 0)
return log_error_errno(r, "Failed to insert JSON data into hashmap: %m");
sd_id128_t *previous_boot_id) { /* unused */
char usecbuf[CONST_MAX(DECIMAL_STR_MAX(usec_t), DECIMAL_STR_MAX(uint64_t))];
- _cleanup_(json_variant_unrefp) JsonVariant *object = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *object = NULL;
_cleanup_hashmap_free_ Hashmap *h = NULL;
sd_id128_t journal_boot_id, seqnum_id;
_cleanup_free_ char *cursor = NULL;
usec_t realtime, monotonic;
- JsonVariant **array = NULL;
+ sd_json_variant **array = NULL;
JsonData *d;
uint64_t seqnum;
size_t n = 0;
return r;
}
- array = new(JsonVariant*, hashmap_size(h)*2);
+ array = new(sd_json_variant*, hashmap_size(h)*2);
if (!array)
return log_oom();
- CLEANUP_ARRAY(array, n, json_variant_unref_many);
+ CLEANUP_ARRAY(array, n, sd_json_variant_unref_many);
HASHMAP_FOREACH(d, h) {
- assert(json_variant_elements(d->values) > 0);
+ assert(sd_json_variant_elements(d->values) > 0);
- array[n++] = json_variant_ref(d->name);
+ array[n++] = sd_json_variant_ref(d->name);
- if (json_variant_elements(d->values) == 1)
- array[n++] = json_variant_ref(json_variant_by_index(d->values, 0));
+ if (sd_json_variant_elements(d->values) == 1)
+ array[n++] = sd_json_variant_ref(sd_json_variant_by_index(d->values, 0));
else
- array[n++] = json_variant_ref(d->values);
+ array[n++] = sd_json_variant_ref(d->values);
}
- r = json_variant_new_object(&object, array, n);
+ r = sd_json_variant_new_object(&object, array, n);
if (r < 0)
return log_error_errno(r, "Failed to allocate JSON object: %m");
- return json_variant_dump(object,
+ return sd_json_variant_dump(object,
output_mode_to_json_format_flags(mode) |
- (FLAGS_SET(flags, OUTPUT_COLOR) ? JSON_FORMAT_COLOR : 0),
+ (FLAGS_SET(flags, OUTPUT_COLOR) ? SD_JSON_FORMAT_COLOR : 0),
f, NULL);
}
#include "macro.h"
#include "output-mode.h"
+#include "set.h"
#include "time-util.h"
typedef struct BootId {
'journal-file-util.c',
'journal-importer.c',
'journal-util.c',
- 'json.c',
'kbd-util.c',
'kernel-config.c',
'kernel-image.c',
#include "fd-util.h"
#include "format-util.h"
+#include "json-util.h"
#include "missing_sched.h"
#include "namespace-util.h"
#include "nsresource.h"
if (userns_fd_idx < 0)
return log_debug_errno(userns_fd_idx, "Failed to push userns fd into varlink connection: %m");
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
r = varlink_callb(vl,
"io.systemd.NamespaceResource.AllocateUserRange",
&reply,
&error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(name)),
- JSON_BUILD_PAIR("size", JSON_BUILD_UNSIGNED(size)),
- JSON_BUILD_PAIR("userNamespaceFileDescriptor", JSON_BUILD_UNSIGNED(userns_fd_idx))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(name)),
+ SD_JSON_BUILD_PAIR("size", SD_JSON_BUILD_UNSIGNED(size)),
+ SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx))));
if (r < 0)
return log_debug_errno(r, "Failed to call AllocateUserRange() varlink call: %m");
if (error_id)
if (userns_fd_idx < 0)
return log_debug_errno(userns_fd_idx, "Failed to push userns fd into varlink connection: %m");
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
r = varlink_callb(vl,
"io.systemd.NamespaceResource.RegisterUserNamespace",
&reply,
&error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("name", JSON_BUILD_STRING(name)),
- JSON_BUILD_PAIR("userNamespaceFileDescriptor", JSON_BUILD_UNSIGNED(userns_fd_idx))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(name)),
+ SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx))));
if (r < 0)
return log_debug_errno(r, "Failed to call RegisterUserNamespace() varlink call: %m");
if (error_id)
if (mount_fd_idx < 0)
return log_error_errno(mount_fd_idx, "Failed to push mount fd into varlink connection: %m");
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
r = varlink_callb(vl,
"io.systemd.NamespaceResource.AddMountToUserNamespace",
&reply,
&error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userNamespaceFileDescriptor", JSON_BUILD_UNSIGNED(userns_fd_idx)),
- JSON_BUILD_PAIR("mountFileDescriptor", JSON_BUILD_UNSIGNED(mount_fd_idx))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx)),
+ SD_JSON_BUILD_PAIR("mountFileDescriptor", SD_JSON_BUILD_UNSIGNED(mount_fd_idx))));
if (r < 0)
return log_error_errno(r, "Failed to call AddMountToUserNamespace() varlink call: %m");
if (streq_ptr(error_id, "io.systemd.NamespaceResource.UserNamespaceNotRegistered")) {
if (cgroup_fd_idx < 0)
return log_debug_errno(userns_fd_idx, "Failed to push cgroup fd into varlink connection: %m");
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
r = varlink_callb(vl,
"io.systemd.NamespaceResource.AddControlGroupToUserNamespace",
&reply,
&error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userNamespaceFileDescriptor", JSON_BUILD_UNSIGNED(userns_fd_idx)),
- JSON_BUILD_PAIR("controlGroupFileDescriptor", JSON_BUILD_UNSIGNED(cgroup_fd_idx))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx)),
+ SD_JSON_BUILD_PAIR("controlGroupFileDescriptor", SD_JSON_BUILD_UNSIGNED(cgroup_fd_idx))));
if (r < 0)
return log_debug_errno(r, "Failed to call AddControlGroupToUserNamespace() varlink call: %m");
if (streq_ptr(error_id, "io.systemd.NamespaceResource.UserNamespaceNotRegistered")) {
if (netns_fd_idx < 0)
return log_debug_errno(netns_fd_idx, "Failed to push netns fd into varlink connection: %m");
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
r = varlink_callb(vl,
"io.systemd.NamespaceResource.AddNetworkToUserNamespace",
&reply,
&error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userNamespaceFileDescriptor", JSON_BUILD_UNSIGNED(userns_fd_idx)),
- JSON_BUILD_PAIR("networkNamespaceFileDescriptor", JSON_BUILD_UNSIGNED(netns_fd_idx)),
- JSON_BUILD_PAIR("mode", JSON_BUILD_CONST_STRING("veth")),
- JSON_BUILD_PAIR_CONDITION(namespace_ifname, "namespaceInterfaceName", JSON_BUILD_STRING(namespace_ifname))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx)),
+ SD_JSON_BUILD_PAIR("networkNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(netns_fd_idx)),
+ SD_JSON_BUILD_PAIR("mode", JSON_BUILD_CONST_STRING("veth")),
+ SD_JSON_BUILD_PAIR_CONDITION(!!namespace_ifname, "namespaceInterfaceName", SD_JSON_BUILD_STRING(namespace_ifname))));
if (r < 0)
return log_debug_errno(r, "Failed to call AddNetworkToUserNamespace() varlink call: %m");
if (streq_ptr(error_id, "io.systemd.NamespaceResource.UserNamespaceNotRegistered")) {
return log_debug_errno(varlink_error_to_errno(error_id, reply), "Failed to add network to user namespace: %s", error_id);
_cleanup_free_ char *host_interface_name = NULL, *namespace_interface_name = NULL;
- r = json_dispatch(
+ r = sd_json_dispatch(
reply,
- (const JsonDispatch[]) {
- { "hostInterfaceName", JSON_VARIANT_STRING, json_dispatch_string, PTR_TO_SIZE(&host_interface_name) },
- { "namespaceInterfaceName", JSON_VARIANT_STRING, json_dispatch_string, PTR_TO_SIZE(&namespace_interface_name) },
+ (const sd_json_dispatch_field[]) {
+ { "hostInterfaceName", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, PTR_TO_SIZE(&host_interface_name) },
+ { "namespaceInterfaceName", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, PTR_TO_SIZE(&namespace_interface_name) },
},
- JSON_ALLOW_EXTENSIONS,
+ SD_JSON_ALLOW_EXTENSIONS,
/* userdata= */ NULL);
if (ret_host_ifname)
#include "output-mode.h"
#include "string-table.h"
-JsonFormatFlags output_mode_to_json_format_flags(OutputMode m) {
+sd_json_format_flags_t output_mode_to_json_format_flags(OutputMode m) {
switch (m) {
case OUTPUT_JSON_SSE:
- return JSON_FORMAT_SSE;
+ return SD_JSON_FORMAT_SSE;
case OUTPUT_JSON_SEQ:
- return JSON_FORMAT_SEQ;
+ return SD_JSON_FORMAT_SEQ;
case OUTPUT_JSON_PRETTY:
- return JSON_FORMAT_PRETTY;
+ return SD_JSON_FORMAT_PRETTY;
default:
- return JSON_FORMAT_NEWLINE;
+ return SD_JSON_FORMAT_NEWLINE;
}
}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "json.h"
+#include "sd-json.h"
#include "macro.h"
typedef enum OutputMode {
OUTPUT_CGROUP_ID = 1 << 11,
} OutputFlags;
-JsonFormatFlags output_mode_to_json_format_flags(OutputMode m);
+sd_json_format_flags_t output_mode_to_json_format_flags(OutputMode m);
const char* output_mode_to_string(OutputMode m) _const_;
OutputMode output_mode_from_string(const char *s) _pure_;
}
}
-int parse_json_argument(const char *s, JsonFormatFlags *ret) {
+int parse_json_argument(const char *s, sd_json_format_flags_t *ret) {
assert(s);
assert(ret);
if (streq(s, "pretty"))
- *ret = JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR_AUTO;
+ *ret = SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR_AUTO;
else if (streq(s, "short"))
- *ret = JSON_FORMAT_NEWLINE;
+ *ret = SD_JSON_FORMAT_NEWLINE;
else if (streq(s, "off"))
- *ret = JSON_FORMAT_OFF;
+ *ret = SD_JSON_FORMAT_OFF;
else if (streq(s, "help")) {
puts("pretty\n"
"short\n"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "json.h"
+#include <stdbool.h>
+
+#include "sd-json.h"
int parse_boolean_argument(const char *optname, const char *s, bool *ret);
-int parse_json_argument(const char *s, JsonFormatFlags *ret);
+int parse_json_argument(const char *s, sd_json_format_flags_t *ret);
int parse_path_argument(const char *path, bool suppress_root, char **arg);
int parse_signal_argument(const char *s, int *ret);
#include "hmac.h"
#include "initrd-util.h"
#include "io-util.h"
+#include "json-util.h"
#include "lock-util.h"
#include "log.h"
#include "logarithm.h"
}
static int find_signature(
- JsonVariant *v,
+ sd_json_variant *v,
const TPML_PCR_SELECTION *pcr_selection,
const void *fp,
size_t fp_size,
size_t *ret_signature_size) {
#if HAVE_OPENSSL
- JsonVariant *b, *i;
+ sd_json_variant *b, *i;
const char *k;
int r;
/* Searches for a signature blob in the specified JSON object. Search keys are PCR bank, PCR mask,
* public key, and policy digest. */
- if (!json_variant_is_object(v))
+ if (!sd_json_variant_is_object(v))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Signature is not a JSON object.");
uint16_t pcr_bank = pcr_selection->pcrSelections[0].hash;
return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Don't know PCR bank %" PRIu16, pcr_bank);
/* First, find field by bank */
- b = json_variant_by_key(v, k);
+ b = sd_json_variant_by_key(v, k);
if (!b)
return log_debug_errno(SYNTHETIC_ERRNO(ENXIO), "Signature lacks data for PCR bank '%s'.", k);
- if (!json_variant_is_array(b))
+ if (!sd_json_variant_is_array(b))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Bank data is not a JSON array.");
/* Now iterate through all signatures known for this bank */
JSON_VARIANT_ARRAY_FOREACH(i, b) {
_cleanup_free_ void *fpj_data = NULL, *polj_data = NULL;
- JsonVariant *maskj, *fpj, *sigj, *polj;
+ sd_json_variant *maskj, *fpj, *sigj, *polj;
size_t fpj_size, polj_size;
uint32_t parsed_mask;
- if (!json_variant_is_object(i))
+ if (!sd_json_variant_is_object(i))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Bank data element is not a JSON object");
/* Check if the PCR mask matches our expectations */
- maskj = json_variant_by_key(i, "pcrs");
+ maskj = sd_json_variant_by_key(i, "pcrs");
if (!maskj)
continue;
continue; /* Not for this PCR mask */
/* Then check if this is for the public key we operate with */
- fpj = json_variant_by_key(i, "pkfp");
+ fpj = sd_json_variant_by_key(i, "pkfp");
if (!fpj)
continue;
- r = json_variant_unhex(fpj, &fpj_data, &fpj_size);
+ r = sd_json_variant_unhex(fpj, &fpj_data, &fpj_size);
if (r < 0)
return log_debug_errno(r, "Failed to decode fingerprint in JSON data: %m");
continue; /* Not for this public key */
/* Finally, check if this is for the PCR policy we expect this to be */
- polj = json_variant_by_key(i, "pol");
+ polj = sd_json_variant_by_key(i, "pol");
if (!polj)
continue;
- r = json_variant_unhex(polj, &polj_data, &polj_size);
+ r = sd_json_variant_unhex(polj, &polj_data, &polj_size);
if (r < 0)
return log_debug_errno(r, "Failed to decode policy hash JSON data: %m");
continue;
/* This entry matches all our expectations, now return the signature included in it */
- sigj = json_variant_by_key(i, "sig");
+ sigj = sd_json_variant_by_key(i, "sig");
if (!sigj)
continue;
- return json_variant_unbase64(sigj, ret_signature, ret_signature_size);
+ return sd_json_variant_unbase64(sigj, ret_signature, ret_signature_size);
}
return log_debug_errno(SYNTHETIC_ERRNO(ENXIO), "Couldn't find signature for this PCR bank, PCR index and public key.");
const TPM2B_PUBLIC *public,
const void *fp,
size_t fp_size,
- JsonVariant *signature_json,
+ sd_json_variant *signature_json,
TPM2B_DIGEST **ret_policy_digest) {
TSS2_RC rc;
const void *fp,
size_t fp_size,
uint32_t pubkey_pcr_mask,
- JsonVariant *signature_json,
+ sd_json_variant *signature_json,
bool use_pin,
const Tpm2PCRLockPolicy *pcrlock_policy,
TPM2B_DIGEST **ret_policy_digest) {
uint16_t pcr_bank,
const struct iovec *pubkey,
uint32_t pubkey_pcr_mask,
- JsonVariant *signature,
+ sd_json_variant *signature,
const char *pin,
const Tpm2PCRLockPolicy *pcrlock_policy,
uint16_t primary_alg,
Tpm2UserspaceEventType event_type,
const char *description) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *array = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *array = NULL;
_cleanup_free_ char *f = NULL;
sd_id128_t boot_id;
int r;
assert_se(a = tpm2_hash_alg_to_string(values->digests[i].hashAlg));
assert_se(implementation = EVP_get_digestbyname(a));
- r = json_variant_append_arrayb(
- &array, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("hashAlg", a),
- JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(&values->digests[i].digest, EVP_MD_size(implementation)))));
+ r = sd_json_variant_append_arrayb(
+ &array, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("hashAlg", a),
+ SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(&values->digests[i].digest, EVP_MD_size(implementation)))));
if (r < 0)
return log_debug_errno(r, "Failed to append digest object to JSON array: %m");
}
if (r < 0)
return log_debug_errno(r, "Failed to acquire boot ID: %m");
- r = json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pcr", JSON_BUILD_UNSIGNED(pcr_index)),
- JSON_BUILD_PAIR("digests", JSON_BUILD_VARIANT(array)),
- JSON_BUILD_PAIR("content_type", JSON_BUILD_STRING("systemd")),
- JSON_BUILD_PAIR("content", JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_CONDITION(description, "string", JSON_BUILD_STRING(description)),
- JSON_BUILD_PAIR("bootId", JSON_BUILD_ID128(boot_id)),
- JSON_BUILD_PAIR("timestamp", JSON_BUILD_UNSIGNED(now(CLOCK_BOOTTIME))),
- JSON_BUILD_PAIR_CONDITION(event_type >= 0, "eventType", JSON_BUILD_STRING(tpm2_userspace_event_type_to_string(event_type)))))));
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pcr", SD_JSON_BUILD_UNSIGNED(pcr_index)),
+ SD_JSON_BUILD_PAIR("digests", SD_JSON_BUILD_VARIANT(array)),
+ SD_JSON_BUILD_PAIR("content_type", SD_JSON_BUILD_STRING("systemd")),
+ SD_JSON_BUILD_PAIR("content", SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_CONDITION(!!description, "string", SD_JSON_BUILD_STRING(description)),
+ SD_JSON_BUILD_PAIR("bootId", SD_JSON_BUILD_ID128(boot_id)),
+ SD_JSON_BUILD_PAIR("timestamp", SD_JSON_BUILD_UNSIGNED(now(CLOCK_BOOTTIME))),
+ SD_JSON_BUILD_PAIR_CONDITION(event_type >= 0, "eventType", SD_JSON_BUILD_STRING(tpm2_userspace_event_type_to_string(event_type)))))));
if (r < 0)
return log_debug_errno(r, "Failed to build log record JSON: %m");
- r = json_variant_format(v, JSON_FORMAT_SEQ, &f);
+ r = sd_json_variant_format(v, SD_JSON_FORMAT_SEQ, &f);
if (r < 0)
return log_debug_errno(r, "Failed to format JSON: %m");
int tpm2_pcr_prediction_to_json(
const Tpm2PCRPrediction *prediction,
uint16_t algorithm,
- JsonVariant **ret) {
+ sd_json_variant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *aj = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *aj = NULL;
int r;
assert(prediction);
assert(ret);
for (uint32_t pcr = 0; pcr < TPM2_PCRS_MAX; pcr++) {
- _cleanup_(json_variant_unrefp) JsonVariant *vj = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *vj = NULL;
Tpm2PCRPredictionResult *banks;
if (!FLAGS_SET(prediction->pcrs, UINT32_C(1) << pcr))
if (!hash)
continue;
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&vj,
- JSON_BUILD_HEX(hash->buffer, hash->size));
+ SD_JSON_BUILD_HEX(hash->buffer, hash->size));
if (r < 0)
return log_error_errno(r, "Failed to append hash variant to JSON array: %m");
}
if (!vj)
continue;
- r = json_variant_append_arrayb(
+ r = sd_json_variant_append_arrayb(
&aj,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_INTEGER("pcr", pcr),
- JSON_BUILD_PAIR_VARIANT("values", vj)));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_INTEGER("pcr", pcr),
+ SD_JSON_BUILD_PAIR_VARIANT("values", vj)));
if (r < 0)
return log_error_errno(r, "Failed to append PCR variants to JSON array: %m");
}
if (!aj) {
- r = json_variant_new_array(&aj, NULL, 0);
+ r = sd_json_variant_new_array(&aj, NULL, 0);
if (r < 0)
return r;
}
int tpm2_pcr_prediction_from_json(
Tpm2PCRPrediction *prediction,
uint16_t algorithm,
- JsonVariant *aj) {
+ sd_json_variant *aj) {
int r;
size_t alg_index = tpm2_hash_algorithm_index(algorithm);
assert(alg_index < TPM2_N_HASH_ALGORITHMS);
- if (!json_variant_is_array(aj))
+ if (!sd_json_variant_is_array(aj))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "PCR variant array is not an array.");
- JsonVariant *pcr;
+ sd_json_variant *pcr;
JSON_VARIANT_ARRAY_FOREACH(pcr, aj) {
- JsonVariant *nr, *values;
+ sd_json_variant *nr, *values;
- nr = json_variant_by_key(pcr, "pcr");
+ nr = sd_json_variant_by_key(pcr, "pcr");
if (!nr)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "PCR array entry lacks PCR index field");
- if (!json_variant_is_unsigned(nr) ||
- json_variant_unsigned(nr) >= TPM2_PCRS_MAX)
+ if (!sd_json_variant_is_unsigned(nr) ||
+ sd_json_variant_unsigned(nr) >= TPM2_PCRS_MAX)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "PCR array entry PCR index is not an integer in the range 0…23");
- values = json_variant_by_key(pcr, "values");
+ values = sd_json_variant_by_key(pcr, "values");
if (!values)
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "PCR array entry lacks values field");
- if (!json_variant_is_array(values))
+ if (!sd_json_variant_is_array(values))
return log_error_errno(SYNTHETIC_ERRNO(EBADMSG), "PCR array entry values field is not an array");
- prediction->pcrs |= UINT32_C(1) << json_variant_unsigned(nr);
+ prediction->pcrs |= UINT32_C(1) << sd_json_variant_unsigned(nr);
- JsonVariant *v;
+ sd_json_variant *v;
JSON_VARIANT_ARRAY_FOREACH(v, values) {
_cleanup_free_ void *buffer = NULL;
size_t size;
- r = json_variant_unhex(v, &buffer, &size);
+ r = sd_json_variant_unhex(v, &buffer, &size);
if (r < 0)
return log_error_errno(r, "Failed to decode PCR policy array hash value");
memcpy(banks->hash[alg_index].buffer, buffer, size);
banks->hash[alg_index].size = size;
- r = ordered_set_ensure_put(prediction->results + json_variant_unsigned(nr), &tpm2_pcr_prediction_result_hash_ops, banks);
+ r = ordered_set_ensure_put(prediction->results + sd_json_variant_unsigned(nr), &tpm2_pcr_prediction_result_hash_ops, banks);
if (r == -EEXIST) /* Let's allow duplicates */
continue;
if (r < 0)
void tpm2_pcrlock_policy_done(Tpm2PCRLockPolicy *data) {
assert(data);
- data->prediction_json = json_variant_unref(data->prediction_json);
+ data->prediction_json = sd_json_variant_unref(data->prediction_json);
tpm2_pcr_prediction_done(&data->prediction);
iovec_done(&data->nv_handle);
iovec_done(&data->nv_public);
iovec_done(&data->pin_private);
}
-static int json_dispatch_tpm2_algorithm(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_tpm2_algorithm(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
uint16_t *algorithm = ASSERT_PTR(userdata);
int r;
- r = tpm2_hash_alg_from_string(json_variant_string(variant));
+ r = tpm2_hash_alg_from_string(sd_json_variant_string(variant));
if (r < 0 || tpm2_hash_algorithm_index(r) == SIZE_MAX)
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid hash algorithm: %s", json_variant_string(variant));
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid hash algorithm: %s", sd_json_variant_string(variant));
*algorithm = r;
return 0;
}
int tpm2_pcrlock_policy_from_json(
- JsonVariant *v,
+ sd_json_variant *v,
Tpm2PCRLockPolicy *ret_policy) {
/* We use a type check of _JSON_VARIANT_TYPE_INVALID for the integer fields to allow
* json_dispatch_uint32() to parse strings as integers to work around the integer type weakness of
* JSON's design. */
- JsonDispatch policy_dispatch[] = {
- { "pcrBank", JSON_VARIANT_STRING, json_dispatch_tpm2_algorithm, offsetof(Tpm2PCRLockPolicy, algorithm), JSON_MANDATORY },
- { "pcrValues", JSON_VARIANT_ARRAY, json_dispatch_variant, offsetof(Tpm2PCRLockPolicy, prediction_json), JSON_MANDATORY },
- { "nvIndex", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint32, offsetof(Tpm2PCRLockPolicy, nv_index), JSON_MANDATORY },
- { "nvHandle", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, nv_handle), JSON_MANDATORY },
- { "nvPublic", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, nv_public), JSON_MANDATORY },
- { "srkHandle", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, srk_handle), JSON_MANDATORY },
- { "pinPublic", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, pin_public), JSON_MANDATORY },
- { "pinPrivate", JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, pin_private), JSON_MANDATORY },
+ sd_json_dispatch_field policy_dispatch[] = {
+ { "pcrBank", SD_JSON_VARIANT_STRING, json_dispatch_tpm2_algorithm, offsetof(Tpm2PCRLockPolicy, algorithm), SD_JSON_MANDATORY },
+ { "pcrValues", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_variant, offsetof(Tpm2PCRLockPolicy, prediction_json), SD_JSON_MANDATORY },
+ { "nvIndex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint32, offsetof(Tpm2PCRLockPolicy, nv_index), SD_JSON_MANDATORY },
+ { "nvHandle", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, nv_handle), SD_JSON_MANDATORY },
+ { "nvPublic", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, nv_public), SD_JSON_MANDATORY },
+ { "srkHandle", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, srk_handle), SD_JSON_MANDATORY },
+ { "pinPublic", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, pin_public), SD_JSON_MANDATORY },
+ { "pinPrivate", SD_JSON_VARIANT_STRING, json_dispatch_unbase64_iovec, offsetof(Tpm2PCRLockPolicy, pin_private), SD_JSON_MANDATORY },
{}
};
assert(v);
assert(ret_policy);
- r = json_dispatch(v, policy_dispatch, JSON_LOG, &policy);
+ r = sd_json_dispatch(v, policy_dispatch, SD_JSON_LOG, &policy);
if (r < 0)
return r;
if (r < 0)
return log_error_errno(r, "Failed to load TPM2 pcrlock policy file: %m");
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- r = json_parse_file(
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+ r = sd_json_parse_file(
f,
discovered_path,
/* flags = */ 0,
if (memchr(decoded.iov_base, 0, decoded.iov_len))
return log_error_errno(r, "Credential '%s' contains embedded NUL byte, refusing.", name);
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- r = json_parse(decoded.iov_base,
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+ r = sd_json_parse(decoded.iov_base,
/* flags= */ 0,
&v,
/* ret_line= */ NULL,
return TAKE_PTR(s);
}
-int tpm2_make_pcr_json_array(uint32_t pcr_mask, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *a = NULL;
+int tpm2_make_pcr_json_array(uint32_t pcr_mask, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *a = NULL;
int r;
assert(ret);
for (size_t i = 0; i < TPM2_PCRS_MAX; i++) {
- _cleanup_(json_variant_unrefp) JsonVariant *e = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *e = NULL;
if ((pcr_mask & (UINT32_C(1) << i)) == 0)
continue;
- r = json_variant_new_integer(&e, i);
+ r = sd_json_variant_new_integer(&e, i);
if (r < 0)
return r;
- r = json_variant_append_array(&a, e);
+ r = sd_json_variant_append_array(&a, e);
if (r < 0)
return r;
}
if (!a)
- return json_variant_new_array(ret, NULL, 0);
+ return sd_json_variant_new_array(ret, NULL, 0);
*ret = TAKE_PTR(a);
return 0;
}
-int tpm2_parse_pcr_json_array(JsonVariant *v, uint32_t *ret) {
- JsonVariant *e;
+int tpm2_parse_pcr_json_array(sd_json_variant *v, uint32_t *ret) {
+ sd_json_variant *e;
uint32_t mask = 0;
- if (!json_variant_is_array(v))
+ if (!sd_json_variant_is_array(v))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 PCR array is not a JSON array.");
JSON_VARIANT_ARRAY_FOREACH(e, v) {
uint64_t u;
- if (!json_variant_is_unsigned(e))
+ if (!sd_json_variant_is_unsigned(e))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 PCR is not an unsigned integer.");
- u = json_variant_unsigned(e);
+ u = sd_json_variant_unsigned(e);
if (u >= TPM2_PCRS_MAX)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 PCR number out of range: %" PRIu64, u);
const struct iovec *srk,
const struct iovec *pcrlock_nv,
TPM2Flags flags,
- JsonVariant **ret) {
+ sd_json_variant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *hmj = NULL, *pkmj = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *hmj = NULL, *pkmj = NULL;
_cleanup_free_ char *keyslot_as_string = NULL;
int r;
* other programming languages. Let's not make things worse though, i.e. future additions to the JSON
* object should use "_" rather than "-" in field names. */
- r = json_build(&v,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-tpm2")),
- JSON_BUILD_PAIR("keyslots", JSON_BUILD_ARRAY(JSON_BUILD_STRING(keyslot_as_string))),
- JSON_BUILD_PAIR("tpm2-blob", JSON_BUILD_IOVEC_BASE64(blob)),
- JSON_BUILD_PAIR("tpm2-pcrs", JSON_BUILD_VARIANT(hmj)),
- JSON_BUILD_PAIR_CONDITION(pcr_bank != 0 && tpm2_hash_alg_to_string(pcr_bank), "tpm2-pcr-bank", JSON_BUILD_STRING(tpm2_hash_alg_to_string(pcr_bank))),
- JSON_BUILD_PAIR_CONDITION(primary_alg != 0 && tpm2_asym_alg_to_string(primary_alg), "tpm2-primary-alg", JSON_BUILD_STRING(tpm2_asym_alg_to_string(primary_alg))),
- JSON_BUILD_PAIR("tpm2-policy-hash", JSON_BUILD_IOVEC_HEX(policy_hash)),
- JSON_BUILD_PAIR_CONDITION(FLAGS_SET(flags, TPM2_FLAGS_USE_PIN), "tpm2-pin", JSON_BUILD_BOOLEAN(true)),
- JSON_BUILD_PAIR_CONDITION(FLAGS_SET(flags, TPM2_FLAGS_USE_PCRLOCK), "tpm2_pcrlock", JSON_BUILD_BOOLEAN(true)),
- JSON_BUILD_PAIR_CONDITION(pubkey_pcr_mask != 0, "tpm2_pubkey_pcrs", JSON_BUILD_VARIANT(pkmj)),
- JSON_BUILD_PAIR_CONDITION(iovec_is_set(pubkey), "tpm2_pubkey", JSON_BUILD_IOVEC_BASE64(pubkey)),
- JSON_BUILD_PAIR_CONDITION(iovec_is_set(salt), "tpm2_salt", JSON_BUILD_IOVEC_BASE64(salt)),
- JSON_BUILD_PAIR_CONDITION(iovec_is_set(srk), "tpm2_srk", JSON_BUILD_IOVEC_BASE64(srk)),
- JSON_BUILD_PAIR_CONDITION(iovec_is_set(pcrlock_nv), "tpm2_pcrlock_nv", JSON_BUILD_IOVEC_BASE64(pcrlock_nv))));
+ r = sd_json_build(&v,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("type", JSON_BUILD_CONST_STRING("systemd-tpm2")),
+ SD_JSON_BUILD_PAIR("keyslots", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_STRING(keyslot_as_string))),
+ SD_JSON_BUILD_PAIR("tpm2-blob", JSON_BUILD_IOVEC_BASE64(blob)),
+ SD_JSON_BUILD_PAIR("tpm2-pcrs", SD_JSON_BUILD_VARIANT(hmj)),
+ SD_JSON_BUILD_PAIR_CONDITION(pcr_bank != 0 && tpm2_hash_alg_to_string(pcr_bank), "tpm2-pcr-bank", SD_JSON_BUILD_STRING(tpm2_hash_alg_to_string(pcr_bank))),
+ SD_JSON_BUILD_PAIR_CONDITION(primary_alg != 0 && tpm2_asym_alg_to_string(primary_alg), "tpm2-primary-alg", SD_JSON_BUILD_STRING(tpm2_asym_alg_to_string(primary_alg))),
+ SD_JSON_BUILD_PAIR("tpm2-policy-hash", JSON_BUILD_IOVEC_HEX(policy_hash)),
+ SD_JSON_BUILD_PAIR_CONDITION(FLAGS_SET(flags, TPM2_FLAGS_USE_PIN), "tpm2-pin", SD_JSON_BUILD_BOOLEAN(true)),
+ SD_JSON_BUILD_PAIR_CONDITION(FLAGS_SET(flags, TPM2_FLAGS_USE_PCRLOCK), "tpm2_pcrlock", SD_JSON_BUILD_BOOLEAN(true)),
+ SD_JSON_BUILD_PAIR_CONDITION(pubkey_pcr_mask != 0, "tpm2_pubkey_pcrs", SD_JSON_BUILD_VARIANT(pkmj)),
+ SD_JSON_BUILD_PAIR_CONDITION(iovec_is_set(pubkey), "tpm2_pubkey", JSON_BUILD_IOVEC_BASE64(pubkey)),
+ SD_JSON_BUILD_PAIR_CONDITION(iovec_is_set(salt), "tpm2_salt", JSON_BUILD_IOVEC_BASE64(salt)),
+ SD_JSON_BUILD_PAIR_CONDITION(iovec_is_set(srk), "tpm2_srk", JSON_BUILD_IOVEC_BASE64(srk)),
+ SD_JSON_BUILD_PAIR_CONDITION(iovec_is_set(pcrlock_nv), "tpm2_pcrlock_nv", JSON_BUILD_IOVEC_BASE64(pcrlock_nv))));
if (r < 0)
return r;
}
int tpm2_parse_luks2_json(
- JsonVariant *v,
+ sd_json_variant *v,
int *ret_keyslot,
uint32_t *ret_hash_pcr_mask,
uint16_t *ret_pcr_bank,
uint16_t pcr_bank = UINT16_MAX; /* default: pick automatically */
int r, keyslot = -1;
TPM2Flags flags = 0;
- JsonVariant *w;
+ sd_json_variant *w;
assert(v);
}
}
- w = json_variant_by_key(v, "tpm2-pcrs");
+ w = sd_json_variant_by_key(v, "tpm2-pcrs");
if (!w)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 token data lacks 'tpm2-pcrs' field.");
/* The bank field is optional, since it was added in systemd 250 only. Before the bank was hardcoded
* to SHA256. */
- w = json_variant_by_key(v, "tpm2-pcr-bank");
+ w = sd_json_variant_by_key(v, "tpm2-pcr-bank");
if (w) {
/* The PCR bank field is optional */
- if (!json_variant_is_string(w))
+ if (!sd_json_variant_is_string(w))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 PCR bank is not a string.");
- r = tpm2_hash_alg_from_string(json_variant_string(w));
+ r = tpm2_hash_alg_from_string(sd_json_variant_string(w));
if (r < 0)
- return log_debug_errno(r, "TPM2 PCR bank invalid or not supported: %s", json_variant_string(w));
+ return log_debug_errno(r, "TPM2 PCR bank invalid or not supported: %s", sd_json_variant_string(w));
pcr_bank = r;
}
/* The primary key algorithm field is optional, since it was also added in systemd 250 only. Before
* the algorithm was hardcoded to ECC. */
- w = json_variant_by_key(v, "tpm2-primary-alg");
+ w = sd_json_variant_by_key(v, "tpm2-primary-alg");
if (w) {
/* The primary key algorithm is optional */
- if (!json_variant_is_string(w))
+ if (!sd_json_variant_is_string(w))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 primary key algorithm is not a string.");
- r = tpm2_asym_alg_from_string(json_variant_string(w));
+ r = tpm2_asym_alg_from_string(sd_json_variant_string(w));
if (r < 0)
- return log_debug_errno(r, "TPM2 asymmetric algorithm invalid or not supported: %s", json_variant_string(w));
+ return log_debug_errno(r, "TPM2 asymmetric algorithm invalid or not supported: %s", sd_json_variant_string(w));
primary_alg = r;
}
- w = json_variant_by_key(v, "tpm2-blob");
+ w = sd_json_variant_by_key(v, "tpm2-blob");
if (!w)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 token data lacks 'tpm2-blob' field.");
if (r < 0)
return log_debug_errno(r, "Invalid base64 data in 'tpm2-blob' field.");
- w = json_variant_by_key(v, "tpm2-policy-hash");
+ w = sd_json_variant_by_key(v, "tpm2-policy-hash");
if (!w)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 token data lacks 'tpm2-policy-hash' field.");
if (r < 0)
return log_debug_errno(r, "Invalid base64 data in 'tpm2-policy-hash' field.");
- w = json_variant_by_key(v, "tpm2-pin");
+ w = sd_json_variant_by_key(v, "tpm2-pin");
if (w) {
- if (!json_variant_is_boolean(w))
+ if (!sd_json_variant_is_boolean(w))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 PIN policy is not a boolean.");
- SET_FLAG(flags, TPM2_FLAGS_USE_PIN, json_variant_boolean(w));
+ SET_FLAG(flags, TPM2_FLAGS_USE_PIN, sd_json_variant_boolean(w));
}
- w = json_variant_by_key(v, "tpm2_pcrlock");
+ w = sd_json_variant_by_key(v, "tpm2_pcrlock");
if (w) {
- if (!json_variant_is_boolean(w))
+ if (!sd_json_variant_is_boolean(w))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "TPM2 pclock policy is not a boolean.");
- SET_FLAG(flags, TPM2_FLAGS_USE_PCRLOCK, json_variant_boolean(w));
+ SET_FLAG(flags, TPM2_FLAGS_USE_PCRLOCK, sd_json_variant_boolean(w));
}
- w = json_variant_by_key(v, "tpm2_salt");
+ w = sd_json_variant_by_key(v, "tpm2_salt");
if (w) {
r = json_variant_unbase64_iovec(w, &salt);
if (r < 0)
return log_debug_errno(r, "Invalid base64 data in 'tpm2_salt' field.");
}
- w = json_variant_by_key(v, "tpm2_pubkey_pcrs");
+ w = sd_json_variant_by_key(v, "tpm2_pubkey_pcrs");
if (w) {
r = tpm2_parse_pcr_json_array(w, &pubkey_pcr_mask);
if (r < 0)
return r;
}
- w = json_variant_by_key(v, "tpm2_pubkey");
+ w = sd_json_variant_by_key(v, "tpm2_pubkey");
if (w) {
r = json_variant_unbase64_iovec(w, &pubkey);
if (r < 0)
} else if (pubkey_pcr_mask != 0)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Public key PCR mask set, but not public key included in JSON data, refusing.");
- w = json_variant_by_key(v, "tpm2_srk");
+ w = sd_json_variant_by_key(v, "tpm2_srk");
if (w) {
r = json_variant_unbase64_iovec(w, &srk);
if (r < 0)
return log_debug_errno(r, "Invalid base64 data in 'tpm2_srk' field.");
}
- w = json_variant_by_key(v, "tpm2_pcrlock_nv");
+ w = sd_json_variant_by_key(v, "tpm2_pcrlock_nv");
if (w) {
r = json_variant_unbase64_iovec(w, &pcrlock_nv);
if (r < 0)
#endif
}
-int tpm2_load_pcr_signature(const char *path, JsonVariant **ret) {
+int tpm2_load_pcr_signature(const char *path, sd_json_variant **ret) {
_cleanup_strv_free_ char **search = NULL;
_cleanup_free_ char *discovered_path = NULL;
_cleanup_fclose_ FILE *f = NULL;
if (r < 0)
return log_debug_errno(r, "Failed to find TPM PCR signature file '%s': %m", path);
- r = json_parse_file(f, discovered_path, 0, ret, NULL, NULL);
+ r = sd_json_parse_file(f, discovered_path, 0, ret, NULL, NULL);
if (r < 0)
return log_debug_errno(r, "Failed to parse TPM PCR signature JSON object '%s': %m", discovered_path);
#include "bitfield.h"
#include "io-util.h"
-#include "json.h"
+#include "sd-json.h"
#include "macro.h"
#include "openssl-util.h"
#include "ordered-set.h"
bool tpm2_pcr_prediction_equal(Tpm2PCRPrediction *a, Tpm2PCRPrediction *b, uint16_t algorithm);
-int tpm2_pcr_prediction_to_json(const Tpm2PCRPrediction *prediction, uint16_t algorithm, JsonVariant **ret);
-int tpm2_pcr_prediction_from_json(Tpm2PCRPrediction *prediction, uint16_t algorithm, JsonVariant *aj);
+int tpm2_pcr_prediction_to_json(const Tpm2PCRPrediction *prediction, uint16_t algorithm, sd_json_variant **ret);
+int tpm2_pcr_prediction_from_json(Tpm2PCRPrediction *prediction, uint16_t algorithm, sd_json_variant *aj);
/* As structure encapsulating all metadata stored for a pcrlock policy on disk */
typedef struct Tpm2PCRLockPolicy {
/* The below contains the current prediction whose resulting policy is stored in the NV
* index. Once in JSON and once in parsed form. When the policy is updated the fields below are
* changed, the fields above remain fixed. */
- JsonVariant *prediction_json;
+ sd_json_variant *prediction_json;
Tpm2PCRPrediction prediction;
} Tpm2PCRLockPolicy;
void tpm2_pcrlock_policy_done(Tpm2PCRLockPolicy *data);
-int tpm2_pcrlock_policy_from_json(JsonVariant *v, Tpm2PCRLockPolicy *ret_policy);
+int tpm2_pcrlock_policy_from_json(sd_json_variant *v, Tpm2PCRLockPolicy *ret_policy);
int tpm2_pcrlock_search_file(const char *path, FILE **ret_file, char **ret_path);
int tpm2_pcrlock_policy_load(const char *path, Tpm2PCRLockPolicy *ret_policy);
int tpm2_pcrlock_policy_from_credentials(const struct iovec *srk, const struct iovec *nv, Tpm2PCRLockPolicy *ret);
int tpm2_get_or_create_srk(Tpm2Context *c, const Tpm2Handle *session, TPM2B_PUBLIC **ret_public, TPM2B_NAME **ret_name, TPM2B_NAME **ret_qname, Tpm2Handle **ret_handle);
int tpm2_seal(Tpm2Context *c, uint32_t seal_key_handle, const TPM2B_DIGEST *policy, const char *pin, struct iovec *ret_secret, struct iovec *ret_blob, uint16_t *ret_primary_alg, struct iovec *ret_srk);
-int tpm2_unseal(Tpm2Context *c, uint32_t hash_pcr_mask, uint16_t pcr_bank, const struct iovec *pubkey, uint32_t pubkey_pcr_mask, JsonVariant *signature, const char *pin, const Tpm2PCRLockPolicy *pcrlock_policy, uint16_t primary_alg, const struct iovec *blob, const struct iovec *policy_hash, const struct iovec *srk, struct iovec *ret_secret);
+int tpm2_unseal(Tpm2Context *c, uint32_t hash_pcr_mask, uint16_t pcr_bank, const struct iovec *pubkey, uint32_t pubkey_pcr_mask, sd_json_variant *signature, const char *pin, const Tpm2PCRLockPolicy *pcrlock_policy, uint16_t primary_alg, const struct iovec *blob, const struct iovec *policy_hash, const struct iovec *srk, struct iovec *ret_secret);
#if HAVE_OPENSSL
int tpm2_tpm2b_public_to_openssl_pkey(const TPM2B_PUBLIC *public, EVP_PKEY **ret);
int tpm2_list_devices(void);
int tpm2_find_device_auto(char **ret);
-int tpm2_make_pcr_json_array(uint32_t pcr_mask, JsonVariant **ret);
-int tpm2_parse_pcr_json_array(JsonVariant *v, uint32_t *ret);
+int tpm2_make_pcr_json_array(uint32_t pcr_mask, sd_json_variant **ret);
+int tpm2_parse_pcr_json_array(sd_json_variant *v, uint32_t *ret);
-int tpm2_make_luks2_json(int keyslot, uint32_t hash_pcr_mask, uint16_t pcr_bank, const struct iovec *pubkey, uint32_t pubkey_pcr_mask, uint16_t primary_alg, const struct iovec *blob, const struct iovec *policy_hash, const struct iovec *salt, const struct iovec *srk, const struct iovec *pcrlock_nv, TPM2Flags flags, JsonVariant **ret);
-int tpm2_parse_luks2_json(JsonVariant *v, int *ret_keyslot, uint32_t *ret_hash_pcr_mask, uint16_t *ret_pcr_bank, struct iovec *ret_pubkey, uint32_t *ret_pubkey_pcr_mask, uint16_t *ret_primary_alg, struct iovec *ret_blob, struct iovec *ret_policy_hash, struct iovec *ret_salt, struct iovec *ret_srk, struct iovec *pcrlock_nv, TPM2Flags *ret_flags);
+int tpm2_make_luks2_json(int keyslot, uint32_t hash_pcr_mask, uint16_t pcr_bank, const struct iovec *pubkey, uint32_t pubkey_pcr_mask, uint16_t primary_alg, const struct iovec *blob, const struct iovec *policy_hash, const struct iovec *salt, const struct iovec *srk, const struct iovec *pcrlock_nv, TPM2Flags flags, sd_json_variant **ret);
+int tpm2_parse_luks2_json(sd_json_variant *v, int *ret_keyslot, uint32_t *ret_hash_pcr_mask, uint16_t *ret_pcr_bank, struct iovec *ret_pubkey, uint32_t *ret_pubkey_pcr_mask, uint16_t *ret_primary_alg, struct iovec *ret_blob, struct iovec *ret_policy_hash, struct iovec *ret_salt, struct iovec *ret_srk, struct iovec *pcrlock_nv, TPM2Flags *ret_flags);
/* Default to PCR 7 only */
#define TPM2_PCR_INDEX_DEFAULT UINT32_C(7)
int tpm2_parse_pcr_argument_append(const char *arg, Tpm2PCRValue **ret_pcr_values, size_t *ret_n_pcr_values);
int tpm2_parse_pcr_argument_to_mask(const char *arg, uint32_t *mask);
-int tpm2_load_pcr_signature(const char *path, JsonVariant **ret);
+int tpm2_load_pcr_signature(const char *path, sd_json_variant **ret);
int tpm2_load_pcr_public_key(const char *path, void **ret_pubkey, size_t *ret_pubkey_size);
int tpm2_util_pbkdf2_hmac_sha256(const void *pass,
spwd && spwd->sp_inact > 0 && (uint64_t) spwd->sp_inact <= (UINT64_MAX-1)/USEC_PER_DAY,
spwd->sp_inact * USEC_PER_DAY, UINT64_MAX);
- hr->json = json_variant_unref(hr->json);
- r = json_build(&hr->json, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(hr->user_name)),
- JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(hr->uid)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(hr->gid)),
- JSON_BUILD_PAIR_CONDITION(hr->real_name, "realName", JSON_BUILD_STRING(hr->real_name)),
- JSON_BUILD_PAIR_CONDITION(hr->home_directory, "homeDirectory", JSON_BUILD_STRING(hr->home_directory)),
- JSON_BUILD_PAIR_CONDITION(hr->shell, "shell", JSON_BUILD_STRING(hr->shell)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(hr->hashed_password), "privileged", JSON_BUILD_OBJECT(JSON_BUILD_PAIR("hashedPassword", JSON_BUILD_STRV(hr->hashed_password)))),
- JSON_BUILD_PAIR_CONDITION(hr->locked >= 0, "locked", JSON_BUILD_BOOLEAN(hr->locked)),
- JSON_BUILD_PAIR_CONDITION(hr->not_after_usec != UINT64_MAX, "notAfterUSec", JSON_BUILD_UNSIGNED(hr->not_after_usec)),
- JSON_BUILD_PAIR_CONDITION(hr->password_change_now >= 0, "passwordChangeNow", JSON_BUILD_BOOLEAN(hr->password_change_now)),
- JSON_BUILD_PAIR_CONDITION(hr->last_password_change_usec != UINT64_MAX, "lastPasswordChangeUSec", JSON_BUILD_UNSIGNED(hr->last_password_change_usec)),
- JSON_BUILD_PAIR_CONDITION(hr->password_change_min_usec != UINT64_MAX, "passwordChangeMinUSec", JSON_BUILD_UNSIGNED(hr->password_change_min_usec)),
- JSON_BUILD_PAIR_CONDITION(hr->password_change_max_usec != UINT64_MAX, "passwordChangeMaxUSec", JSON_BUILD_UNSIGNED(hr->password_change_max_usec)),
- JSON_BUILD_PAIR_CONDITION(hr->password_change_warn_usec != UINT64_MAX, "passwordChangeWarnUSec", JSON_BUILD_UNSIGNED(hr->password_change_warn_usec)),
- JSON_BUILD_PAIR_CONDITION(hr->password_change_inactive_usec != UINT64_MAX, "passwordChangeInactiveUSec", JSON_BUILD_UNSIGNED(hr->password_change_inactive_usec))));
+ hr->json = sd_json_variant_unref(hr->json);
+ r = sd_json_build(&hr->json, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(hr->user_name)),
+ SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(hr->uid)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(hr->gid)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!hr->real_name, "realName", SD_JSON_BUILD_STRING(hr->real_name)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!hr->home_directory, "homeDirectory", SD_JSON_BUILD_STRING(hr->home_directory)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!hr->shell, "shell", SD_JSON_BUILD_STRING(hr->shell)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(hr->hashed_password), "privileged", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("hashedPassword", SD_JSON_BUILD_STRV(hr->hashed_password)))),
+ SD_JSON_BUILD_PAIR_CONDITION(hr->locked >= 0, "locked", SD_JSON_BUILD_BOOLEAN(hr->locked)),
+ SD_JSON_BUILD_PAIR_CONDITION(hr->not_after_usec != UINT64_MAX, "notAfterUSec", SD_JSON_BUILD_UNSIGNED(hr->not_after_usec)),
+ SD_JSON_BUILD_PAIR_CONDITION(hr->password_change_now >= 0, "passwordChangeNow", SD_JSON_BUILD_BOOLEAN(hr->password_change_now)),
+ SD_JSON_BUILD_PAIR_CONDITION(hr->last_password_change_usec != UINT64_MAX, "lastPasswordChangeUSec", SD_JSON_BUILD_UNSIGNED(hr->last_password_change_usec)),
+ SD_JSON_BUILD_PAIR_CONDITION(hr->password_change_min_usec != UINT64_MAX, "passwordChangeMinUSec", SD_JSON_BUILD_UNSIGNED(hr->password_change_min_usec)),
+ SD_JSON_BUILD_PAIR_CONDITION(hr->password_change_max_usec != UINT64_MAX, "passwordChangeMaxUSec", SD_JSON_BUILD_UNSIGNED(hr->password_change_max_usec)),
+ SD_JSON_BUILD_PAIR_CONDITION(hr->password_change_warn_usec != UINT64_MAX, "passwordChangeWarnUSec", SD_JSON_BUILD_UNSIGNED(hr->password_change_warn_usec)),
+ SD_JSON_BUILD_PAIR_CONDITION(hr->password_change_inactive_usec != UINT64_MAX, "passwordChangeInactiveUSec", SD_JSON_BUILD_UNSIGNED(hr->password_change_inactive_usec))));
if (r < 0)
return r;
return r;
}
- r = json_build(&g->json, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(g->group_name)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(g->gid)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(g->members), "members", JSON_BUILD_STRV(g->members)),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(g->hashed_password), "privileged", JSON_BUILD_OBJECT(JSON_BUILD_PAIR("hashedPassword", JSON_BUILD_STRV(g->hashed_password)))),
- JSON_BUILD_PAIR_CONDITION(!strv_isempty(g->administrators), "administrators", JSON_BUILD_STRV(g->administrators))));
+ r = sd_json_build(&g->json, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(g->group_name)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(g->gid)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(g->members), "members", SD_JSON_BUILD_STRV(g->members)),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(g->hashed_password), "privileged", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("hashedPassword", SD_JSON_BUILD_STRV(g->hashed_password)))),
+ SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(g->administrators), "administrators", SD_JSON_BUILD_STRV(g->administrators))));
if (r < 0)
return r;
#include "glyph-util.h"
#include "hexdecoct.h"
#include "hostname-util.h"
+#include "json-util.h"
#include "locale-util.h"
#include "memory-util.h"
#include "path-util.h"
for (size_t i = 0; i < h->n_recovery_key; i++)
recovery_key_done(h->recovery_key + i);
- json_variant_unref(h->json);
+ sd_json_variant_unref(h->json);
return mfree(h);
}
DEFINE_TRIVIAL_REF_UNREF_FUNC(UserRecord, user_record, user_record_free);
-int json_dispatch_realm(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+int json_dispatch_realm(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
char **s = userdata;
const char *n;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*s = mfree(*s);
return 0;
}
- if (!json_variant_is_string(variant))
+ if (!sd_json_variant_is_string(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- n = json_variant_string(variant);
+ n = sd_json_variant_string(variant);
r = dns_name_is_valid(n);
if (r < 0)
return json_log(variant, flags, r, "Failed to check if JSON field '%s' is a valid DNS domain.", strna(name));
return 0;
}
-int json_dispatch_gecos(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+int json_dispatch_gecos(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
char **s = userdata;
const char *n;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*s = mfree(*s);
return 0;
}
- if (!json_variant_is_string(variant))
+ if (!sd_json_variant_is_string(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- n = json_variant_string(variant);
+ n = sd_json_variant_string(variant);
if (valid_gecos(n)) {
if (free_and_strdup(s, n) < 0)
return json_log_oom(variant, flags);
} else {
_cleanup_free_ char *m = NULL;
- json_log(variant, flags|JSON_DEBUG, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid GECOS compatible string, mangling.", strna(name));
+ json_log(variant, flags|SD_JSON_DEBUG, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid GECOS compatible string, mangling.", strna(name));
m = mangle_gecos(n);
if (!m)
return 0;
}
-static int json_dispatch_nice(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_nice(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
int *nl = userdata;
int64_t m;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*nl = INT_MAX;
return 0;
}
- if (!json_variant_is_integer(variant))
+ if (!sd_json_variant_is_integer(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- m = json_variant_integer(variant);
+ m = sd_json_variant_integer(variant);
if (m < PRIO_MIN || m >= PRIO_MAX)
return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "JSON field '%s' is not a valid nice level.", strna(name));
return 0;
}
-static int json_dispatch_rlimit_value(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_rlimit_value(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
rlim_t *ret = userdata;
- if (json_variant_is_null(variant))
+ if (sd_json_variant_is_null(variant))
*ret = RLIM_INFINITY;
- else if (json_variant_is_unsigned(variant)) {
+ else if (sd_json_variant_is_unsigned(variant)) {
uint64_t w;
- w = json_variant_unsigned(variant);
- if (w == RLIM_INFINITY || (uint64_t) w != json_variant_unsigned(variant))
+ w = sd_json_variant_unsigned(variant);
+ if (w == RLIM_INFINITY || (uint64_t) w != sd_json_variant_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "Resource limit value '%s' is out of range.", name);
*ret = (rlim_t) w;
return 0;
}
-static int json_dispatch_rlimits(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_rlimits(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
struct rlimit** limits = userdata;
- JsonVariant *value;
+ sd_json_variant *value;
const char *key;
int r;
assert_se(limits);
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
rlimit_free_all(limits);
return 0;
}
- if (!json_variant_is_object(variant))
+ if (!sd_json_variant_is_object(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an object.", strna(name));
JSON_VARIANT_OBJECT_FOREACH(key, value, variant) {
- JsonVariant *jcur, *jmax;
+ sd_json_variant *jcur, *jmax;
struct rlimit rl;
const char *p;
int l;
if (l < 0)
return json_log(variant, flags, l, "Resource limit '%s' not known.", key);
- if (!json_variant_is_object(value))
+ if (!sd_json_variant_is_object(value))
return json_log(value, flags, SYNTHETIC_ERRNO(EINVAL), "Resource limit '%s' has invalid value.", key);
- if (json_variant_elements(value) != 4)
+ if (sd_json_variant_elements(value) != 4)
return json_log(value, flags, SYNTHETIC_ERRNO(EINVAL), "Resource limit '%s' value is does not have two fields as expected.", key);
- jcur = json_variant_by_key(value, "cur");
+ jcur = sd_json_variant_by_key(value, "cur");
if (!jcur)
return json_log(value, flags, SYNTHETIC_ERRNO(EINVAL), "Resource limit '%s' lacks 'cur' field.", key);
r = json_dispatch_rlimit_value("cur", jcur, flags, &rl.rlim_cur);
if (r < 0)
return r;
- jmax = json_variant_by_key(value, "max");
+ jmax = sd_json_variant_by_key(value, "max");
if (!jmax)
return json_log(value, flags, SYNTHETIC_ERRNO(EINVAL), "Resource limit '%s' lacks 'max' field.", key);
r = json_dispatch_rlimit_value("max", jmax, flags, &rl.rlim_max);
return 0;
}
-static int json_dispatch_filename_or_path(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_filename_or_path(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
char **s = ASSERT_PTR(userdata);
const char *n;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*s = mfree(*s);
return 0;
}
- if (!json_variant_is_string(variant))
+ if (!sd_json_variant_is_string(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- n = json_variant_string(variant);
+ n = sd_json_variant_string(variant);
if (!filename_is_valid(n) && !path_is_normalized(n))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid file name or normalized path.", strna(name));
return 0;
}
-static int json_dispatch_home_directory(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_home_directory(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
char **s = userdata;
const char *n;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*s = mfree(*s);
return 0;
}
- if (!json_variant_is_string(variant))
+ if (!sd_json_variant_is_string(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- n = json_variant_string(variant);
+ n = sd_json_variant_string(variant);
if (!valid_home(n))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid home directory path.", strna(name));
return 0;
}
-static int json_dispatch_image_path(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_image_path(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
char **s = userdata;
const char *n;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*s = mfree(*s);
return 0;
}
- if (!json_variant_is_string(variant))
+ if (!sd_json_variant_is_string(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- n = json_variant_string(variant);
+ n = sd_json_variant_string(variant);
if (empty_or_root(n) || !path_is_valid(n) || !path_is_absolute(n))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid image path.", strna(name));
return 0;
}
-static int json_dispatch_umask(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_umask(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
mode_t *m = userdata;
uint64_t k;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*m = MODE_INVALID;
return 0;
}
- if (!json_variant_is_unsigned(variant))
+ if (!sd_json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a number.", strna(name));
- k = json_variant_unsigned(variant);
+ k = sd_json_variant_unsigned(variant);
if (k > 0777)
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL),
"JSON field '%s' outside of valid range 0%s0777.",
return 0;
}
-static int json_dispatch_access_mode(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_access_mode(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
mode_t *m = userdata;
uint64_t k;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*m = MODE_INVALID;
return 0;
}
- if (!json_variant_is_unsigned(variant))
+ if (!sd_json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a number.", strna(name));
- k = json_variant_unsigned(variant);
+ k = sd_json_variant_unsigned(variant);
if (k > 07777)
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL),
"JSON field '%s' outside of valid range 0%s07777.",
return 0;
}
-static int json_dispatch_environment(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_environment(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
_cleanup_strv_free_ char **n = NULL;
char ***l = userdata;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*l = strv_free(*l);
return 0;
}
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
- for (size_t i = 0; i < json_variant_elements(variant); i++) {
- JsonVariant *e;
+ for (size_t i = 0; i < sd_json_variant_elements(variant); i++) {
+ sd_json_variant *e;
const char *a;
- e = json_variant_by_index(variant, i);
- if (!json_variant_is_string(e))
+ e = sd_json_variant_by_index(variant, i);
+ if (!sd_json_variant_is_string(e))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of strings.", strna(name));
- assert_se(a = json_variant_string(e));
+ assert_se(a = sd_json_variant_string(e));
if (!env_assignment_is_valid(a))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of environment variables.", strna(name));
return strv_free_and_replace(*l, n);
}
-static int json_dispatch_locale(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_locale(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
char **s = userdata;
const char *n;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*s = mfree(*s);
return 0;
}
- if (!json_variant_is_string(variant))
+ if (!sd_json_variant_is_string(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- n = json_variant_string(variant);
+ n = sd_json_variant_string(variant);
if (!locale_is_valid(n))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid locale.", strna(name));
return 0;
}
-static int json_dispatch_locales(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_locales(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
_cleanup_strv_free_ char **n = NULL;
char ***l = userdata;
const char *locale;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*l = strv_free(*l);
return 0;
}
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of strings.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of strings.", strna(name));
- locale = json_variant_string(e);
+ locale = sd_json_variant_string(e);
if (!locale_is_valid(locale))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of valid locales.", strna(name));
JSON_DISPATCH_ENUM_DEFINE(json_dispatch_user_disposition, UserDisposition, user_disposition_from_string);
static JSON_DISPATCH_ENUM_DEFINE(json_dispatch_user_storage, UserStorage, user_storage_from_string);
-static int json_dispatch_tasks_or_memory_max(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_tasks_or_memory_max(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
uint64_t *limit = userdata, k;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*limit = UINT64_MAX;
return 0;
}
- if (!json_variant_is_unsigned(variant))
+ if (!sd_json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
- k = json_variant_unsigned(variant);
+ k = sd_json_variant_unsigned(variant);
if (k <= 0 || k >= UINT64_MAX)
return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE),
"JSON field '%s' is not in valid range %" PRIu64 "%s%" PRIu64 ".",
return 0;
}
-static int json_dispatch_weight(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int json_dispatch_weight(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
uint64_t *weight = userdata, k;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*weight = UINT64_MAX;
return 0;
}
- if (!json_variant_is_unsigned(variant))
+ if (!sd_json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
- k = json_variant_unsigned(variant);
+ k = sd_json_variant_unsigned(variant);
if (k <= CGROUP_WEIGHT_MIN || k >= CGROUP_WEIGHT_MAX)
return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE),
"JSON field '%s' is not in valid range %" PRIu64 "%s%" PRIu64 ".",
return 0;
}
-int json_dispatch_user_group_list(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+int json_dispatch_user_group_list(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
_cleanup_strv_free_ char **l = NULL;
char ***list = userdata;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of strings.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not a string.");
- if (!valid_user_group_name(json_variant_string(e), FLAGS_SET(flags, JSON_RELAX) ? VALID_USER_RELAX : 0))
- return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not a valid user/group name: %s", json_variant_string(e));
+ if (!valid_user_group_name(sd_json_variant_string(e), FLAGS_SET(flags, SD_JSON_RELAX) ? VALID_USER_RELAX : 0))
+ return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not a valid user/group name: %s", sd_json_variant_string(e));
- r = strv_extend(&l, json_variant_string(e));
+ r = strv_extend(&l, sd_json_variant_string(e));
if (r < 0)
return json_log(e, flags, r, "Failed to append array element: %m");
}
return 0;
}
-static int dispatch_secret(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_secret(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch secret_dispatch_table[] = {
- { "password", _JSON_VARIANT_TYPE_INVALID, json_dispatch_strv, offsetof(UserRecord, password), 0 },
- { "tokenPin", _JSON_VARIANT_TYPE_INVALID, json_dispatch_strv, offsetof(UserRecord, token_pin), 0 },
- { "pkcs11Pin", /* legacy alias */ _JSON_VARIANT_TYPE_INVALID, json_dispatch_strv, offsetof(UserRecord, token_pin), 0 },
- { "pkcs11ProtectedAuthenticationPathPermitted", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, pkcs11_protected_authentication_path_permitted), 0 },
- { "fido2UserPresencePermitted", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, fido2_user_presence_permitted), 0 },
- { "fido2UserVerificationPermitted", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, fido2_user_verification_permitted), 0 },
+ static const sd_json_dispatch_field secret_dispatch_table[] = {
+ { "password", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_strv, offsetof(UserRecord, password), 0 },
+ { "tokenPin", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_strv, offsetof(UserRecord, token_pin), 0 },
+ { "pkcs11Pin", /* legacy alias */ _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_strv, offsetof(UserRecord, token_pin), 0 },
+ { "pkcs11ProtectedAuthenticationPathPermitted", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, pkcs11_protected_authentication_path_permitted), 0 },
+ { "fido2UserPresencePermitted", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, fido2_user_presence_permitted), 0 },
+ { "fido2UserVerificationPermitted", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, fido2_user_verification_permitted), 0 },
{},
};
- return json_dispatch(variant, secret_dispatch_table, flags, userdata);
+ return sd_json_dispatch(variant, secret_dispatch_table, flags, userdata);
}
-static int dispatch_pkcs11_uri(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_pkcs11_uri(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
char **s = userdata;
const char *n;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*s = mfree(*s);
return 0;
}
- if (!json_variant_is_string(variant))
+ if (!sd_json_variant_is_string(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
- n = json_variant_string(variant);
+ n = sd_json_variant_string(variant);
if (!pkcs11_uri_valid(n))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid RFC7512 PKCS#11 URI.", strna(name));
return 0;
}
-static int dispatch_pkcs11_uri_array(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_pkcs11_uri_array(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
_cleanup_strv_free_ char **z = NULL;
char ***l = userdata;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*l = strv_free(*l);
return 0;
}
- if (json_variant_is_string(variant)) {
+ if (sd_json_variant_is_string(variant)) {
const char *n;
- n = json_variant_string(variant);
+ n = sd_json_variant_string(variant);
if (!pkcs11_uri_valid(n))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid RFC7512 PKCS#11 URI.", strna(name));
} else {
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string or array of strings.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
const char *n;
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not a string.");
- n = json_variant_string(e);
+ n = sd_json_variant_string(e);
if (!pkcs11_uri_valid(n))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element in '%s' is not a valid RFC7512 PKCS#11 URI: %s", strna(name), n);
return 0;
}
-static int dispatch_pkcs11_key_data(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_pkcs11_key_data(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
Pkcs11EncryptedKey *k = userdata;
size_t l;
void *b;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
k->data = erase_and_free(k->data);
k->size = 0;
return 0;
}
- if (!json_variant_is_string(variant))
+ 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 = unbase64mem(json_variant_string(variant), &b, &l);
+ r = unbase64mem(sd_json_variant_string(variant), &b, &l);
if (r < 0)
return json_log(variant, flags, r, "Failed to decode encrypted PKCS#11 key: %m");
return 0;
}
-static int dispatch_pkcs11_key(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_pkcs11_key(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
UserRecord *h = userdata;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of objects.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
Pkcs11EncryptedKey *array, *k;
- static const JsonDispatch pkcs11_key_dispatch_table[] = {
- { "uri", JSON_VARIANT_STRING, dispatch_pkcs11_uri, offsetof(Pkcs11EncryptedKey, uri), JSON_MANDATORY },
- { "data", JSON_VARIANT_STRING, dispatch_pkcs11_key_data, 0, JSON_MANDATORY },
- { "hashedPassword", JSON_VARIANT_STRING, json_dispatch_string, offsetof(Pkcs11EncryptedKey, hashed_password), JSON_MANDATORY },
+ static const sd_json_dispatch_field pkcs11_key_dispatch_table[] = {
+ { "uri", SD_JSON_VARIANT_STRING, dispatch_pkcs11_uri, offsetof(Pkcs11EncryptedKey, uri), SD_JSON_MANDATORY },
+ { "data", SD_JSON_VARIANT_STRING, dispatch_pkcs11_key_data, 0, SD_JSON_MANDATORY },
+ { "hashedPassword", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(Pkcs11EncryptedKey, hashed_password), SD_JSON_MANDATORY },
{},
};
- if (!json_variant_is_object(e))
+ if (!sd_json_variant_is_object(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not an object.");
array = reallocarray(h->pkcs11_encrypted_key, h->n_pkcs11_encrypted_key + 1, sizeof(Pkcs11EncryptedKey));
k = h->pkcs11_encrypted_key + h->n_pkcs11_encrypted_key;
*k = (Pkcs11EncryptedKey) {};
- r = json_dispatch(e, pkcs11_key_dispatch_table, flags, k);
+ r = sd_json_dispatch(e, pkcs11_key_dispatch_table, flags, k);
if (r < 0) {
pkcs11_encrypted_key_done(k);
return r;
return 0;
}
-static int dispatch_fido2_hmac_credential(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_fido2_hmac_credential(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
Fido2HmacCredential *k = userdata;
size_t l;
void *b;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
k->id = mfree(k->id);
k->size = 0;
return 0;
}
- if (!json_variant_is_string(variant))
+ 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 = unbase64mem(json_variant_string(variant), &b, &l);
+ r = unbase64mem(sd_json_variant_string(variant), &b, &l);
if (r < 0)
return json_log(variant, flags, r, "Failed to decode FIDO2 credential ID: %m");
return 0;
}
-static int dispatch_fido2_hmac_credential_array(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_fido2_hmac_credential_array(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
UserRecord *h = userdata;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of strings.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
size_t l;
void *b;
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not a string.");
array = reallocarray(h->fido2_hmac_credential, h->n_fido2_hmac_credential + 1, sizeof(Fido2HmacCredential));
if (!array)
return log_oom();
- r = unbase64mem(json_variant_string(e), &b, &l);
+ r = unbase64mem(sd_json_variant_string(e), &b, &l);
if (r < 0)
return json_log(variant, flags, r, "Failed to decode FIDO2 credential ID: %m");
return 0;
}
-static int dispatch_fido2_hmac_salt_value(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_fido2_hmac_salt_value(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
Fido2HmacSalt *k = userdata;
size_t l;
void *b;
int r;
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
k->salt = erase_and_free(k->salt);
k->salt_size = 0;
return 0;
}
- if (!json_variant_is_string(variant))
+ 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 = unbase64mem(json_variant_string(variant), &b, &l);
+ r = unbase64mem(sd_json_variant_string(variant), &b, &l);
if (r < 0)
return json_log(variant, flags, r, "Failed to decode FIDO2 salt: %m");
return 0;
}
-static int dispatch_fido2_hmac_salt(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_fido2_hmac_salt(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
UserRecord *h = userdata;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of objects.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
Fido2HmacSalt *array, *k;
- static const JsonDispatch fido2_hmac_salt_dispatch_table[] = {
- { "credential", JSON_VARIANT_STRING, dispatch_fido2_hmac_credential, offsetof(Fido2HmacSalt, credential), JSON_MANDATORY },
- { "salt", JSON_VARIANT_STRING, dispatch_fido2_hmac_salt_value, 0, JSON_MANDATORY },
- { "hashedPassword", JSON_VARIANT_STRING, json_dispatch_string, offsetof(Fido2HmacSalt, hashed_password), JSON_MANDATORY },
- { "up", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(Fido2HmacSalt, up), 0 },
- { "uv", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(Fido2HmacSalt, uv), 0 },
- { "clientPin", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(Fido2HmacSalt, client_pin), 0 },
+ static const sd_json_dispatch_field fido2_hmac_salt_dispatch_table[] = {
+ { "credential", SD_JSON_VARIANT_STRING, dispatch_fido2_hmac_credential, offsetof(Fido2HmacSalt, credential), SD_JSON_MANDATORY },
+ { "salt", SD_JSON_VARIANT_STRING, dispatch_fido2_hmac_salt_value, 0, SD_JSON_MANDATORY },
+ { "hashedPassword", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(Fido2HmacSalt, hashed_password), SD_JSON_MANDATORY },
+ { "up", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(Fido2HmacSalt, up), 0 },
+ { "uv", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(Fido2HmacSalt, uv), 0 },
+ { "clientPin", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(Fido2HmacSalt, client_pin), 0 },
{},
};
- if (!json_variant_is_object(e))
+ if (!sd_json_variant_is_object(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not an object.");
array = reallocarray(h->fido2_hmac_salt, h->n_fido2_hmac_salt + 1, sizeof(Fido2HmacSalt));
.client_pin = -1,
};
- r = json_dispatch(e, fido2_hmac_salt_dispatch_table, flags, k);
+ r = sd_json_dispatch(e, fido2_hmac_salt_dispatch_table, flags, k);
if (r < 0) {
fido2_hmac_salt_done(k);
return r;
return 0;
}
-static int dispatch_recovery_key(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_recovery_key(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
UserRecord *h = userdata;
- JsonVariant *e;
+ sd_json_variant *e;
int r;
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of objects.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
RecoveryKey *array, *k;
- static const JsonDispatch recovery_key_dispatch_table[] = {
- { "type", JSON_VARIANT_STRING, json_dispatch_string, 0, JSON_MANDATORY },
- { "hashedPassword", JSON_VARIANT_STRING, json_dispatch_string, offsetof(RecoveryKey, hashed_password), JSON_MANDATORY },
+ static const sd_json_dispatch_field recovery_key_dispatch_table[] = {
+ { "type", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, 0, SD_JSON_MANDATORY },
+ { "hashedPassword", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(RecoveryKey, hashed_password), SD_JSON_MANDATORY },
{},
};
- if (!json_variant_is_object(e))
+ if (!sd_json_variant_is_object(e))
return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not an object.");
array = reallocarray(h->recovery_key, h->n_recovery_key + 1, sizeof(RecoveryKey));
k = h->recovery_key + h->n_recovery_key;
*k = (RecoveryKey) {};
- r = json_dispatch(e, recovery_key_dispatch_table, flags, k);
+ r = sd_json_dispatch(e, recovery_key_dispatch_table, flags, k);
if (r < 0) {
recovery_key_done(k);
return r;
return 0;
}
-static int dispatch_auto_resize_mode(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_auto_resize_mode(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
AutoResizeMode *mode = userdata, m;
assert_se(mode);
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*mode = _AUTO_RESIZE_MODE_INVALID;
return 0;
}
- if (json_variant_is_boolean(variant)) {
- *mode = json_variant_boolean(variant) ? AUTO_RESIZE_SHRINK_AND_GROW : AUTO_RESIZE_OFF;
+ if (sd_json_variant_is_boolean(variant)) {
+ *mode = sd_json_variant_boolean(variant) ? AUTO_RESIZE_SHRINK_AND_GROW : AUTO_RESIZE_OFF;
return 0;
}
- if (!json_variant_is_string(variant))
+ if (!sd_json_variant_is_string(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string, boolean or null.", strna(name));
- m = auto_resize_mode_from_string(json_variant_string(variant));
+ m = auto_resize_mode_from_string(sd_json_variant_string(variant));
if (m < 0)
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid automatic resize mode.", strna(name));
return 0;
}
-static int dispatch_rebalance_weight(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_rebalance_weight(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
uint64_t *rebalance_weight = userdata;
uintmax_t u;
assert_se(rebalance_weight);
- if (json_variant_is_null(variant)) {
+ if (sd_json_variant_is_null(variant)) {
*rebalance_weight = REBALANCE_WEIGHT_UNSET;
return 0;
}
- if (json_variant_is_boolean(variant)) {
- *rebalance_weight = json_variant_boolean(variant) ? REBALANCE_WEIGHT_DEFAULT : REBALANCE_WEIGHT_OFF;
+ if (sd_json_variant_is_boolean(variant)) {
+ *rebalance_weight = sd_json_variant_boolean(variant) ? REBALANCE_WEIGHT_DEFAULT : REBALANCE_WEIGHT_OFF;
return 0;
}
- if (!json_variant_is_unsigned(variant))
+ if (!sd_json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an unsigned integer, boolean or null.", strna(name));
- u = json_variant_unsigned(variant);
+ u = sd_json_variant_unsigned(variant);
if (u >= REBALANCE_WEIGHT_MIN && u <= REBALANCE_WEIGHT_MAX)
*rebalance_weight = (uint64_t) u;
else if (u == 0)
return 0;
}
-static int dispatch_privileged(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_privileged(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
- static const JsonDispatch privileged_dispatch_table[] = {
- { "passwordHint", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, password_hint), 0 },
- { "hashedPassword", _JSON_VARIANT_TYPE_INVALID, json_dispatch_strv, offsetof(UserRecord, hashed_password), JSON_SAFE },
- { "sshAuthorizedKeys", _JSON_VARIANT_TYPE_INVALID, json_dispatch_strv, offsetof(UserRecord, ssh_authorized_keys), 0 },
- { "pkcs11EncryptedKey", JSON_VARIANT_ARRAY, dispatch_pkcs11_key, 0, 0 },
- { "fido2HmacSalt", JSON_VARIANT_ARRAY, dispatch_fido2_hmac_salt, 0, 0 },
- { "recoveryKey", JSON_VARIANT_ARRAY, dispatch_recovery_key, 0, 0 },
+ static const sd_json_dispatch_field privileged_dispatch_table[] = {
+ { "passwordHint", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, password_hint), 0 },
+ { "hashedPassword", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_strv, offsetof(UserRecord, hashed_password), SD_JSON_SAFE },
+ { "sshAuthorizedKeys", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_strv, offsetof(UserRecord, ssh_authorized_keys), 0 },
+ { "pkcs11EncryptedKey", SD_JSON_VARIANT_ARRAY, dispatch_pkcs11_key, 0, 0 },
+ { "fido2HmacSalt", SD_JSON_VARIANT_ARRAY, dispatch_fido2_hmac_salt, 0, 0 },
+ { "recoveryKey", SD_JSON_VARIANT_ARRAY, dispatch_recovery_key, 0, 0 },
{},
};
- return json_dispatch(variant, privileged_dispatch_table, flags, userdata);
-}
-
-static int dispatch_binding(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
-
- static const JsonDispatch binding_dispatch_table[] = {
- { "blobDirectory", JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, blob_directory), JSON_SAFE },
- { "imagePath", JSON_VARIANT_STRING, json_dispatch_image_path, offsetof(UserRecord, image_path), 0 },
- { "homeDirectory", JSON_VARIANT_STRING, json_dispatch_home_directory, offsetof(UserRecord, home_directory), 0 },
- { "partitionUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(UserRecord, partition_uuid), 0 },
- { "luksUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(UserRecord, luks_uuid), 0 },
- { "fileSystemUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(UserRecord, file_system_uuid), 0 },
- { "uid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(UserRecord, uid), 0 },
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(UserRecord, gid), 0 },
- { "storage", JSON_VARIANT_STRING, json_dispatch_user_storage, offsetof(UserRecord, storage), 0 },
- { "fileSystemType", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, file_system_type), JSON_SAFE },
- { "luksCipher", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_cipher), JSON_SAFE },
- { "luksCipherMode", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_cipher_mode), JSON_SAFE },
- { "luksVolumeKeySize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_volume_key_size), 0 },
+ return sd_json_dispatch(variant, privileged_dispatch_table, flags, userdata);
+}
+
+static int dispatch_binding(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
+
+ static const sd_json_dispatch_field binding_dispatch_table[] = {
+ { "blobDirectory", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, blob_directory), SD_JSON_SAFE },
+ { "imagePath", SD_JSON_VARIANT_STRING, json_dispatch_image_path, offsetof(UserRecord, image_path), 0 },
+ { "homeDirectory", SD_JSON_VARIANT_STRING, json_dispatch_home_directory, offsetof(UserRecord, home_directory), 0 },
+ { "partitionUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(UserRecord, partition_uuid), 0 },
+ { "luksUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(UserRecord, luks_uuid), 0 },
+ { "fileSystemUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(UserRecord, file_system_uuid), 0 },
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(UserRecord, uid), 0 },
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(UserRecord, gid), 0 },
+ { "storage", SD_JSON_VARIANT_STRING, json_dispatch_user_storage, offsetof(UserRecord, storage), 0 },
+ { "fileSystemType", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, file_system_type), SD_JSON_SAFE },
+ { "luksCipher", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_cipher), SD_JSON_SAFE },
+ { "luksCipherMode", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_cipher_mode), SD_JSON_SAFE },
+ { "luksVolumeKeySize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_volume_key_size), 0 },
{},
};
- JsonVariant *m;
+ sd_json_variant *m;
sd_id128_t mid;
int r;
if (!variant)
return 0;
- if (!json_variant_is_object(variant))
+ if (!sd_json_variant_is_object(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an object.", strna(name));
r = sd_id128_get_machine(&mid);
if (r < 0)
return json_log(variant, flags, r, "Failed to determine machine ID: %m");
- m = json_variant_by_key(variant, SD_ID128_TO_STRING(mid));
+ m = sd_json_variant_by_key(variant, SD_ID128_TO_STRING(mid));
if (!m)
return 0;
- return json_dispatch(m, binding_dispatch_table, flags, userdata);
+ return sd_json_dispatch(m, binding_dispatch_table, flags, userdata);
}
-static int dispatch_blob_manifest(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+static int dispatch_blob_manifest(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
_cleanup_hashmap_free_ Hashmap *manifest = NULL;
Hashmap **ret = ASSERT_PTR(userdata);
- JsonVariant *value;
+ sd_json_variant *value;
const char *key;
int r;
if (!variant)
return 0;
- if (!json_variant_is_object(variant))
+ if (!sd_json_variant_is_object(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an object.", strna(name));
JSON_VARIANT_OBJECT_FOREACH(key, value, variant) {
_cleanup_free_ char *filename = NULL;
_cleanup_free_ uint8_t *hash = NULL;
- if (!json_variant_is_string(value))
+ if (!sd_json_variant_is_string(value))
return json_log(value, flags, SYNTHETIC_ERRNO(EINVAL), "Blob entry '%s' has invalid hash.", key);
if (!suitable_blob_filename(key))
if (!hash)
return json_log_oom(value, flags);
- r = parse_sha256(json_variant_string(value), hash);
+ r = parse_sha256(sd_json_variant_string(value), hash);
if (r < 0)
- return json_log(value, flags, r, "Blob entry '%s' has invalid hash: %s", filename, json_variant_string(value));
+ return json_log(value, flags, r, "Blob entry '%s' has invalid hash: %s", filename, sd_json_variant_string(value));
r = hashmap_ensure_put(&manifest, &path_hash_ops_free_free, filename, hash);
if (r < 0)
return 0;
}
-int per_machine_id_match(JsonVariant *ids, JsonDispatchFlags flags) {
+int per_machine_id_match(sd_json_variant *ids, sd_json_dispatch_flags_t flags) {
sd_id128_t mid;
int r;
if (r < 0)
return json_log(ids, flags, r, "Failed to acquire machine ID: %m");
- if (json_variant_is_string(ids)) {
+ if (sd_json_variant_is_string(ids)) {
sd_id128_t k;
- r = sd_id128_from_string(json_variant_string(ids), &k);
+ r = sd_id128_from_string(sd_json_variant_string(ids), &k);
if (r < 0) {
- json_log(ids, flags, r, "%s is not a valid machine ID, ignoring: %m", json_variant_string(ids));
+ json_log(ids, flags, r, "%s is not a valid machine ID, ignoring: %m", sd_json_variant_string(ids));
return 0;
}
return sd_id128_equal(mid, k);
}
- if (json_variant_is_array(ids)) {
- JsonVariant *e;
+ if (sd_json_variant_is_array(ids)) {
+ sd_json_variant *e;
JSON_VARIANT_ARRAY_FOREACH(e, ids) {
sd_id128_t k;
- if (!json_variant_is_string(e)) {
+ if (!sd_json_variant_is_string(e)) {
json_log(e, flags, 0, "Machine ID is not a string, ignoring: %m");
continue;
}
- r = sd_id128_from_string(json_variant_string(e), &k);
+ r = sd_id128_from_string(sd_json_variant_string(e), &k);
if (r < 0) {
- json_log(e, flags, r, "%s is not a valid machine ID, ignoring: %m", json_variant_string(e));
+ json_log(e, flags, r, "%s is not a valid machine ID, ignoring: %m", sd_json_variant_string(e));
continue;
}
return false;
}
-int per_machine_hostname_match(JsonVariant *hns, JsonDispatchFlags flags) {
+int per_machine_hostname_match(sd_json_variant *hns, sd_json_dispatch_flags_t flags) {
_cleanup_free_ char *hn = NULL;
int r;
if (r < 0)
return json_log(hns, flags, r, "Failed to acquire hostname: %m");
- if (json_variant_is_string(hns))
- return streq(json_variant_string(hns), hn);
+ if (sd_json_variant_is_string(hns))
+ return streq(sd_json_variant_string(hns), hn);
- if (json_variant_is_array(hns)) {
- JsonVariant *e;
+ if (sd_json_variant_is_array(hns)) {
+ sd_json_variant *e;
JSON_VARIANT_ARRAY_FOREACH(e, hns) {
- if (!json_variant_is_string(e)) {
+ if (!sd_json_variant_is_string(e)) {
json_log(e, flags, 0, "Hostname is not a string, ignoring: %m");
continue;
}
- if (streq(json_variant_string(hns), hn))
+ if (streq(sd_json_variant_string(hns), hn))
return true;
}
return false;
}
-int per_machine_match(JsonVariant *entry, JsonDispatchFlags flags) {
- JsonVariant *m;
+int per_machine_match(sd_json_variant *entry, sd_json_dispatch_flags_t flags) {
+ sd_json_variant *m;
int r;
- assert(json_variant_is_object(entry));
+ assert(sd_json_variant_is_object(entry));
- m = json_variant_by_key(entry, "matchMachineId");
+ m = sd_json_variant_by_key(entry, "matchMachineId");
if (m) {
r = per_machine_id_match(m, flags);
if (r < 0)
return true;
}
- m = json_variant_by_key(entry, "matchHostname");
+ m = sd_json_variant_by_key(entry, "matchHostname");
if (m) {
r = per_machine_hostname_match(m, flags);
if (r < 0)
return false;
}
-static int dispatch_per_machine(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
-
- static const JsonDispatch per_machine_dispatch_table[] = {
- { "matchMachineId", _JSON_VARIANT_TYPE_INVALID, NULL, 0, 0 },
- { "matchHostname", _JSON_VARIANT_TYPE_INVALID, NULL, 0, 0 },
- { "blobDirectory", JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, blob_directory), JSON_SAFE },
- { "blobManifest", JSON_VARIANT_OBJECT, dispatch_blob_manifest, offsetof(UserRecord, blob_manifest), 0 },
- { "iconName", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, icon_name), JSON_SAFE },
- { "location", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, location), 0 },
- { "shell", JSON_VARIANT_STRING, json_dispatch_filename_or_path, offsetof(UserRecord, shell), 0 },
- { "umask", JSON_VARIANT_UNSIGNED, json_dispatch_umask, offsetof(UserRecord, umask), 0 },
- { "environment", JSON_VARIANT_ARRAY, json_dispatch_environment, offsetof(UserRecord, environment), 0 },
- { "timeZone", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, time_zone), JSON_SAFE },
- { "preferredLanguage", JSON_VARIANT_STRING, json_dispatch_locale, offsetof(UserRecord, preferred_language), 0 },
- { "additionalLanguages", JSON_VARIANT_ARRAY, json_dispatch_locales, offsetof(UserRecord, additional_languages), 0 },
- { "niceLevel", _JSON_VARIANT_TYPE_INVALID, json_dispatch_nice, offsetof(UserRecord, nice_level), 0 },
- { "resourceLimits", _JSON_VARIANT_TYPE_INVALID, json_dispatch_rlimits, offsetof(UserRecord, rlimits), 0 },
- { "locked", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, locked), 0 },
- { "notBeforeUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, not_before_usec), 0 },
- { "notAfterUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, not_after_usec), 0 },
- { "storage", JSON_VARIANT_STRING, json_dispatch_user_storage, offsetof(UserRecord, storage), 0 },
- { "diskSize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, disk_size), 0 },
- { "diskSizeRelative", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, disk_size_relative), 0 },
- { "skeletonDirectory", JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, skeleton_directory), JSON_SAFE },
- { "accessMode", JSON_VARIANT_UNSIGNED, json_dispatch_access_mode, offsetof(UserRecord, access_mode), 0 },
- { "tasksMax", JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, tasks_max), 0 },
- { "memoryHigh", JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, memory_high), 0 },
- { "memoryMax", JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, memory_max), 0 },
- { "cpuWeight", JSON_VARIANT_UNSIGNED, json_dispatch_weight, offsetof(UserRecord, cpu_weight), 0 },
- { "ioWeight", JSON_VARIANT_UNSIGNED, json_dispatch_weight, offsetof(UserRecord, io_weight), 0 },
- { "mountNoDevices", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(UserRecord, nodev), 0 },
- { "mountNoSuid", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(UserRecord, nosuid), 0 },
- { "mountNoExecute", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(UserRecord, noexec), 0 },
- { "cifsDomain", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, cifs_domain), JSON_SAFE },
- { "cifsUserName", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, cifs_user_name), JSON_SAFE },
- { "cifsService", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, cifs_service), JSON_SAFE },
- { "cifsExtraMountOptions", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, cifs_extra_mount_options), 0 },
- { "imagePath", JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, image_path), JSON_SAFE },
- { "uid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(UserRecord, uid), 0 },
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(UserRecord, gid), 0 },
- { "memberOf", JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(UserRecord, member_of), JSON_RELAX},
- { "capabilityBoundingSet", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(UserRecord, capability_bounding_set), JSON_SAFE },
- { "capabilityAmbientSet", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(UserRecord, capability_ambient_set), JSON_SAFE },
- { "fileSystemType", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, file_system_type), JSON_SAFE },
- { "partitionUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(UserRecord, partition_uuid), 0 },
- { "luksUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(UserRecord, luks_uuid), 0 },
- { "fileSystemUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(UserRecord, file_system_uuid), 0 },
- { "luksDiscard", _JSON_VARIANT_TYPE_INVALID, json_dispatch_tristate, offsetof(UserRecord, luks_discard), 0, },
- { "luksOfflineDiscard", _JSON_VARIANT_TYPE_INVALID, json_dispatch_tristate, offsetof(UserRecord, luks_offline_discard), 0, },
- { "luksCipher", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_cipher), JSON_SAFE },
- { "luksCipherMode", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_cipher_mode), JSON_SAFE },
- { "luksVolumeKeySize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_volume_key_size), 0 },
- { "luksPbkdfHashAlgorithm", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_pbkdf_hash_algorithm), JSON_SAFE },
- { "luksPbkdfType", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_pbkdf_type), JSON_SAFE },
- { "luksPbkdfForceIterations", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_force_iterations), 0 },
- { "luksPbkdfTimeCostUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_time_cost_usec), 0 },
- { "luksPbkdfMemoryCost", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_memory_cost), 0 },
- { "luksPbkdfParallelThreads", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_parallel_threads), 0 },
- { "luksSectorSize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_sector_size), 0 },
- { "luksExtraMountOptions", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_extra_mount_options), 0 },
- { "dropCaches", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, drop_caches), 0 },
- { "autoResizeMode", _JSON_VARIANT_TYPE_INVALID, dispatch_auto_resize_mode, offsetof(UserRecord, auto_resize_mode), 0 },
- { "rebalanceWeight", _JSON_VARIANT_TYPE_INVALID, dispatch_rebalance_weight, offsetof(UserRecord, rebalance_weight), 0 },
- { "rateLimitIntervalUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, ratelimit_interval_usec), 0 },
- { "rateLimitBurst", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, ratelimit_burst), 0 },
- { "enforcePasswordPolicy", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, enforce_password_policy), 0 },
- { "autoLogin", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, auto_login), 0 },
- { "preferredSessionType", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, preferred_session_type), JSON_SAFE },
- { "preferredSessionLauncher", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, preferred_session_launcher), JSON_SAFE },
- { "stopDelayUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, stop_delay_usec), 0 },
- { "killProcesses", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, kill_processes), 0 },
- { "passwordChangeMinUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, password_change_min_usec), 0 },
- { "passwordChangeMaxUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, password_change_max_usec), 0 },
- { "passwordChangeWarnUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, password_change_warn_usec), 0 },
- { "passwordChangeInactiveUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, password_change_inactive_usec), 0 },
- { "passwordChangeNow", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, password_change_now), 0 },
- { "pkcs11TokenUri", JSON_VARIANT_ARRAY, dispatch_pkcs11_uri_array, offsetof(UserRecord, pkcs11_token_uri), 0 },
- { "fido2HmacCredential", JSON_VARIANT_ARRAY, dispatch_fido2_hmac_credential_array, 0, 0 },
+static int dispatch_per_machine(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
+
+ static const sd_json_dispatch_field per_machine_dispatch_table[] = {
+ { "matchMachineId", _SD_JSON_VARIANT_TYPE_INVALID, NULL, 0, 0 },
+ { "matchHostname", _SD_JSON_VARIANT_TYPE_INVALID, NULL, 0, 0 },
+ { "blobDirectory", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, blob_directory), SD_JSON_SAFE },
+ { "blobManifest", SD_JSON_VARIANT_OBJECT, dispatch_blob_manifest, offsetof(UserRecord, blob_manifest), 0 },
+ { "iconName", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, icon_name), SD_JSON_SAFE },
+ { "location", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, location), 0 },
+ { "shell", SD_JSON_VARIANT_STRING, json_dispatch_filename_or_path, offsetof(UserRecord, shell), 0 },
+ { "umask", SD_JSON_VARIANT_UNSIGNED, json_dispatch_umask, offsetof(UserRecord, umask), 0 },
+ { "environment", SD_JSON_VARIANT_ARRAY, json_dispatch_environment, offsetof(UserRecord, environment), 0 },
+ { "timeZone", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, time_zone), SD_JSON_SAFE },
+ { "preferredLanguage", SD_JSON_VARIANT_STRING, json_dispatch_locale, offsetof(UserRecord, preferred_language), 0 },
+ { "additionalLanguages", SD_JSON_VARIANT_ARRAY, json_dispatch_locales, offsetof(UserRecord, additional_languages), 0 },
+ { "niceLevel", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_nice, offsetof(UserRecord, nice_level), 0 },
+ { "resourceLimits", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_rlimits, offsetof(UserRecord, rlimits), 0 },
+ { "locked", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, locked), 0 },
+ { "notBeforeUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, not_before_usec), 0 },
+ { "notAfterUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, not_after_usec), 0 },
+ { "storage", SD_JSON_VARIANT_STRING, json_dispatch_user_storage, offsetof(UserRecord, storage), 0 },
+ { "diskSize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, disk_size), 0 },
+ { "diskSizeRelative", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, disk_size_relative), 0 },
+ { "skeletonDirectory", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, skeleton_directory), SD_JSON_SAFE },
+ { "accessMode", SD_JSON_VARIANT_UNSIGNED, json_dispatch_access_mode, offsetof(UserRecord, access_mode), 0 },
+ { "tasksMax", SD_JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, tasks_max), 0 },
+ { "memoryHigh", SD_JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, memory_high), 0 },
+ { "memoryMax", SD_JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, memory_max), 0 },
+ { "cpuWeight", SD_JSON_VARIANT_UNSIGNED, json_dispatch_weight, offsetof(UserRecord, cpu_weight), 0 },
+ { "ioWeight", SD_JSON_VARIANT_UNSIGNED, json_dispatch_weight, offsetof(UserRecord, io_weight), 0 },
+ { "mountNoDevices", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(UserRecord, nodev), 0 },
+ { "mountNoSuid", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(UserRecord, nosuid), 0 },
+ { "mountNoExecute", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(UserRecord, noexec), 0 },
+ { "cifsDomain", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, cifs_domain), SD_JSON_SAFE },
+ { "cifsUserName", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, cifs_user_name), SD_JSON_SAFE },
+ { "cifsService", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, cifs_service), SD_JSON_SAFE },
+ { "cifsExtraMountOptions", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, cifs_extra_mount_options), 0 },
+ { "imagePath", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, image_path), SD_JSON_SAFE },
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(UserRecord, uid), 0 },
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(UserRecord, gid), 0 },
+ { "memberOf", SD_JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(UserRecord, member_of), SD_JSON_RELAX },
+ { "capabilityBoundingSet", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(UserRecord, capability_bounding_set), SD_JSON_SAFE },
+ { "capabilityAmbientSet", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(UserRecord, capability_ambient_set), SD_JSON_SAFE },
+ { "fileSystemType", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, file_system_type), SD_JSON_SAFE },
+ { "partitionUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(UserRecord, partition_uuid), 0 },
+ { "luksUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(UserRecord, luks_uuid), 0 },
+ { "fileSystemUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(UserRecord, file_system_uuid), 0 },
+ { "luksDiscard", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_tristate, offsetof(UserRecord, luks_discard), 0, },
+ { "luksOfflineDiscard", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_tristate, offsetof(UserRecord, luks_offline_discard), 0, },
+ { "luksCipher", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_cipher), SD_JSON_SAFE },
+ { "luksCipherMode", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_cipher_mode), SD_JSON_SAFE },
+ { "luksVolumeKeySize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_volume_key_size), 0 },
+ { "luksPbkdfHashAlgorithm", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_pbkdf_hash_algorithm), SD_JSON_SAFE },
+ { "luksPbkdfType", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_pbkdf_type), SD_JSON_SAFE },
+ { "luksPbkdfForceIterations", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_force_iterations), 0 },
+ { "luksPbkdfTimeCostUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_time_cost_usec), 0 },
+ { "luksPbkdfMemoryCost", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_memory_cost), 0 },
+ { "luksPbkdfParallelThreads", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_parallel_threads), 0 },
+ { "luksSectorSize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_sector_size), 0 },
+ { "luksExtraMountOptions", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_extra_mount_options), 0 },
+ { "dropCaches", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, drop_caches), 0 },
+ { "autoResizeMode", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_auto_resize_mode, offsetof(UserRecord, auto_resize_mode), 0 },
+ { "rebalanceWeight", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_rebalance_weight, offsetof(UserRecord, rebalance_weight), 0 },
+ { "rateLimitIntervalUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, ratelimit_interval_usec), 0 },
+ { "rateLimitBurst", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, ratelimit_burst), 0 },
+ { "enforcePasswordPolicy", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, enforce_password_policy), 0 },
+ { "autoLogin", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, auto_login), 0 },
+ { "preferredSessionType", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, preferred_session_type), SD_JSON_SAFE },
+ { "preferredSessionLauncher", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, preferred_session_launcher), SD_JSON_SAFE },
+ { "stopDelayUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, stop_delay_usec), 0 },
+ { "killProcesses", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, kill_processes), 0 },
+ { "passwordChangeMinUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, password_change_min_usec), 0 },
+ { "passwordChangeMaxUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, password_change_max_usec), 0 },
+ { "passwordChangeWarnUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, password_change_warn_usec), 0 },
+ { "passwordChangeInactiveUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, password_change_inactive_usec), 0 },
+ { "passwordChangeNow", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, password_change_now), 0 },
+ { "pkcs11TokenUri", SD_JSON_VARIANT_ARRAY, dispatch_pkcs11_uri_array, offsetof(UserRecord, pkcs11_token_uri), 0 },
+ { "fido2HmacCredential", SD_JSON_VARIANT_ARRAY, dispatch_fido2_hmac_credential_array, 0, 0 },
{},
};
- JsonVariant *e;
+ sd_json_variant *e;
int r;
if (!variant)
return 0;
- if (!json_variant_is_array(variant))
+ if (!sd_json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
JSON_VARIANT_ARRAY_FOREACH(e, variant) {
- if (!json_variant_is_object(e))
+ if (!sd_json_variant_is_object(e))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of objects.", strna(name));
r = per_machine_match(e, flags);
if (r == 0)
continue;
- r = json_dispatch(e, per_machine_dispatch_table, flags, userdata);
+ r = sd_json_dispatch(e, per_machine_dispatch_table, flags, userdata);
if (r < 0)
return r;
}
return 0;
}
-static int dispatch_status(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
-
- static const JsonDispatch status_dispatch_table[] = {
- { "diskUsage", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, disk_usage), 0 },
- { "diskFree", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, disk_free), 0 },
- { "diskSize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, disk_size), 0 },
- { "diskCeiling", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, disk_ceiling), 0 },
- { "diskFloor", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, disk_floor), 0 },
- { "state", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, state), JSON_SAFE },
- { "service", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, service), JSON_SAFE },
- { "signedLocally", _JSON_VARIANT_TYPE_INVALID, json_dispatch_tristate, offsetof(UserRecord, signed_locally), 0 },
- { "goodAuthenticationCounter", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, good_authentication_counter), 0 },
- { "badAuthenticationCounter", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, bad_authentication_counter), 0 },
- { "lastGoodAuthenticationUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, last_good_authentication_usec), 0 },
- { "lastBadAuthenticationUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, last_bad_authentication_usec), 0 },
- { "rateLimitBeginUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, ratelimit_begin_usec), 0 },
- { "rateLimitCount", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, ratelimit_count), 0 },
- { "removable", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, removable), 0 },
- { "accessMode", JSON_VARIANT_UNSIGNED, json_dispatch_access_mode, offsetof(UserRecord, access_mode), 0 },
- { "fileSystemType", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, file_system_type), JSON_SAFE },
- { "fallbackShell", JSON_VARIANT_STRING, json_dispatch_filename_or_path, offsetof(UserRecord, fallback_shell), 0 },
- { "fallbackHomeDirectory", JSON_VARIANT_STRING, json_dispatch_home_directory, offsetof(UserRecord, fallback_home_directory), 0 },
- { "useFallback", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(UserRecord, use_fallback), 0 },
+static int dispatch_status(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
+
+ static const sd_json_dispatch_field status_dispatch_table[] = {
+ { "diskUsage", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, disk_usage), 0 },
+ { "diskFree", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, disk_free), 0 },
+ { "diskSize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, disk_size), 0 },
+ { "diskCeiling", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, disk_ceiling), 0 },
+ { "diskFloor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, disk_floor), 0 },
+ { "state", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, state), SD_JSON_SAFE },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, service), SD_JSON_SAFE },
+ { "signedLocally", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_tristate, offsetof(UserRecord, signed_locally), 0 },
+ { "goodAuthenticationCounter", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, good_authentication_counter), 0 },
+ { "badAuthenticationCounter", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, bad_authentication_counter), 0 },
+ { "lastGoodAuthenticationUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, last_good_authentication_usec), 0 },
+ { "lastBadAuthenticationUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, last_bad_authentication_usec), 0 },
+ { "rateLimitBeginUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, ratelimit_begin_usec), 0 },
+ { "rateLimitCount", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, ratelimit_count), 0 },
+ { "removable", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, removable), 0 },
+ { "accessMode", SD_JSON_VARIANT_UNSIGNED, json_dispatch_access_mode, offsetof(UserRecord, access_mode), 0 },
+ { "fileSystemType", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, file_system_type), SD_JSON_SAFE },
+ { "fallbackShell", SD_JSON_VARIANT_STRING, json_dispatch_filename_or_path, offsetof(UserRecord, fallback_shell), 0 },
+ { "fallbackHomeDirectory", SD_JSON_VARIANT_STRING, json_dispatch_home_directory, offsetof(UserRecord, fallback_home_directory), 0 },
+ { "useFallback", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(UserRecord, use_fallback), 0 },
{},
};
- JsonVariant *m;
+ sd_json_variant *m;
sd_id128_t mid;
int r;
if (!variant)
return 0;
- if (!json_variant_is_object(variant))
+ if (!sd_json_variant_is_object(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an object.", strna(name));
r = sd_id128_get_machine(&mid);
if (r < 0)
return json_log(variant, flags, r, "Failed to determine machine ID: %m");
- m = json_variant_by_key(variant, SD_ID128_TO_STRING(mid));
+ m = sd_json_variant_by_key(variant, SD_ID128_TO_STRING(mid));
if (!m)
return 0;
- return json_dispatch(m, status_dispatch_table, flags, userdata);
+ return sd_json_dispatch(m, status_dispatch_table, flags, userdata);
}
int user_record_build_image_path(UserStorage storage, const char *user_name_and_realm, char **ret) {
return 1;
}
-static int user_record_augment(UserRecord *h, JsonDispatchFlags json_flags) {
+static int user_record_augment(UserRecord *h, sd_json_dispatch_flags_t json_flags) {
int r;
assert(h);
}
int user_group_record_mangle(
- JsonVariant *v,
+ sd_json_variant *v,
UserRecordLoadFlags load_flags,
- JsonVariant **ret_variant,
+ sd_json_variant **ret_variant,
UserRecordMask *ret_mask) {
static const struct {
{ USER_RECORD_SIGNATURE, "signature" },
};
- JsonDispatchFlags json_flags = USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(load_flags);
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
- JsonVariant *array[ELEMENTSOF(mask_field) * 2];
+ sd_json_dispatch_flags_t json_flags = USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(load_flags);
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
+ sd_json_variant *array[ELEMENTSOF(mask_field) * 2];
size_t n_retain = 0;
UserRecordMask m = 0;
int r;
/* Note that this function is shared with the group record parser, hence we try to be generic in our
* log message wording here, to cover both cases. */
- if (!json_variant_is_object(v))
+ if (!sd_json_variant_is_object(v))
return json_log(v, json_flags, SYNTHETIC_ERRNO(EBADMSG), "Record is not a JSON object, refusing.");
if (USER_RECORD_ALLOW_MASK(load_flags) == 0) /* allow nothing? */
/* Check if we have the special sections and if they match our flags set */
for (size_t i = 0; i < ELEMENTSOF(mask_field); i++) {
- JsonVariant *e, *k;
+ sd_json_variant *e, *k;
if (FLAGS_SET(USER_RECORD_STRIP_MASK(load_flags), mask_field[i].mask)) {
if (!w)
- w = json_variant_ref(v);
+ w = sd_json_variant_ref(v);
- r = json_variant_filter(&w, STRV_MAKE(mask_field[i].name));
+ r = sd_json_variant_filter(&w, STRV_MAKE(mask_field[i].name));
if (r < 0)
return json_log(w, json_flags, r, "Failed to remove field from variant: %m");
continue;
}
- e = json_variant_by_key_full(v, mask_field[i].name, &k);
+ e = sd_json_variant_by_key_full(v, mask_field[i].name, &k);
if (e) {
if (!FLAGS_SET(USER_RECORD_ALLOW_MASK(load_flags), mask_field[i].mask))
return json_log(e, json_flags, SYNTHETIC_ERRNO(EBADMSG), "Record contains '%s' field, which is not allowed.", mask_field[i].name);
/* If we are supposed to strip regular items, then let's instead just allocate a new object
* with just the stuff we need. */
- w = json_variant_unref(w);
- r = json_variant_new_object(&w, array, n_retain);
+ w = sd_json_variant_unref(w);
+ r = sd_json_variant_new_object(&w, array, n_retain);
if (r < 0)
return json_log(v, json_flags, r, "Failed to allocate new object: %m");
} else
/* And now check if there's anything else in the record */
- for (size_t i = 0; i < json_variant_elements(v); i += 2) {
+ for (size_t i = 0; i < sd_json_variant_elements(v); i += 2) {
const char *f;
bool special = false;
- assert_se(f = json_variant_string(json_variant_by_index(v, i)));
+ assert_se(f = sd_json_variant_string(sd_json_variant_by_index(v, i)));
for (size_t j = 0; j < ELEMENTSOF(mask_field); j++)
if (streq(f, mask_field[j].name)) { /* already covered in the loop above */
if (w)
*ret_variant = TAKE_PTR(w);
else
- *ret_variant = json_variant_ref(v);
+ *ret_variant = sd_json_variant_ref(v);
*ret_mask = m;
return 0;
}
-int user_record_load(UserRecord *h, JsonVariant *v, UserRecordLoadFlags load_flags) {
-
- static const JsonDispatch user_dispatch_table[] = {
- { "userName", JSON_VARIANT_STRING, json_dispatch_user_group_name, offsetof(UserRecord, user_name), JSON_RELAX},
- { "realm", JSON_VARIANT_STRING, json_dispatch_realm, offsetof(UserRecord, realm), 0 },
- { "blobDirectory", JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, blob_directory), JSON_SAFE },
- { "blobManifest", JSON_VARIANT_OBJECT, dispatch_blob_manifest, offsetof(UserRecord, blob_manifest), 0 },
- { "realName", JSON_VARIANT_STRING, json_dispatch_gecos, offsetof(UserRecord, real_name), 0 },
- { "emailAddress", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, email_address), JSON_SAFE },
- { "iconName", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, icon_name), JSON_SAFE },
- { "location", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, location), 0 },
- { "disposition", JSON_VARIANT_STRING, json_dispatch_user_disposition, offsetof(UserRecord, disposition), 0 },
- { "lastChangeUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, last_change_usec), 0 },
- { "lastPasswordChangeUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, last_password_change_usec), 0 },
- { "shell", JSON_VARIANT_STRING, json_dispatch_filename_or_path, offsetof(UserRecord, shell), 0 },
- { "umask", JSON_VARIANT_UNSIGNED, json_dispatch_umask, offsetof(UserRecord, umask), 0 },
- { "environment", JSON_VARIANT_ARRAY, json_dispatch_environment, offsetof(UserRecord, environment), 0 },
- { "timeZone", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, time_zone), JSON_SAFE },
- { "preferredLanguage", JSON_VARIANT_STRING, json_dispatch_locale, offsetof(UserRecord, preferred_language), 0 },
- { "additionalLanguages", JSON_VARIANT_ARRAY, json_dispatch_locales, offsetof(UserRecord, additional_languages), 0 },
- { "niceLevel", _JSON_VARIANT_TYPE_INVALID, json_dispatch_nice, offsetof(UserRecord, nice_level), 0 },
- { "resourceLimits", _JSON_VARIANT_TYPE_INVALID, json_dispatch_rlimits, offsetof(UserRecord, rlimits), 0 },
- { "locked", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, locked), 0 },
- { "notBeforeUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, not_before_usec), 0 },
- { "notAfterUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, not_after_usec), 0 },
- { "storage", JSON_VARIANT_STRING, json_dispatch_user_storage, offsetof(UserRecord, storage), 0 },
- { "diskSize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, disk_size), 0 },
- { "diskSizeRelative", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, disk_size_relative), 0 },
- { "skeletonDirectory", JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, skeleton_directory), JSON_SAFE },
- { "accessMode", JSON_VARIANT_UNSIGNED, json_dispatch_access_mode, offsetof(UserRecord, access_mode), 0 },
- { "tasksMax", JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, tasks_max), 0 },
- { "memoryHigh", JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, memory_high), 0 },
- { "memoryMax", JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, memory_max), 0 },
- { "cpuWeight", JSON_VARIANT_UNSIGNED, json_dispatch_weight, offsetof(UserRecord, cpu_weight), 0 },
- { "ioWeight", JSON_VARIANT_UNSIGNED, json_dispatch_weight, offsetof(UserRecord, io_weight), 0 },
- { "mountNoDevices", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(UserRecord, nodev), 0 },
- { "mountNoSuid", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(UserRecord, nosuid), 0 },
- { "mountNoExecute", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(UserRecord, noexec), 0 },
- { "cifsDomain", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, cifs_domain), JSON_SAFE },
- { "cifsUserName", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, cifs_user_name), JSON_SAFE },
- { "cifsService", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, cifs_service), JSON_SAFE },
- { "cifsExtraMountOptions", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, cifs_extra_mount_options), 0 },
- { "imagePath", JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, image_path), JSON_SAFE },
- { "homeDirectory", JSON_VARIANT_STRING, json_dispatch_home_directory, offsetof(UserRecord, home_directory), 0 },
- { "uid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(UserRecord, uid), 0 },
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(UserRecord, gid), 0 },
- { "memberOf", JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(UserRecord, member_of), JSON_RELAX},
- { "capabilityBoundingSet", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(UserRecord, capability_bounding_set), JSON_SAFE },
- { "capabilityAmbientSet", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(UserRecord, capability_ambient_set), JSON_SAFE },
- { "fileSystemType", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, file_system_type), JSON_SAFE },
- { "partitionUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(UserRecord, partition_uuid), 0 },
- { "luksUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(UserRecord, luks_uuid), 0 },
- { "fileSystemUuid", JSON_VARIANT_STRING, json_dispatch_id128, offsetof(UserRecord, file_system_uuid), 0 },
- { "luksDiscard", _JSON_VARIANT_TYPE_INVALID, json_dispatch_tristate, offsetof(UserRecord, luks_discard), 0 },
- { "luksOfflineDiscard", _JSON_VARIANT_TYPE_INVALID, json_dispatch_tristate, offsetof(UserRecord, luks_offline_discard), 0 },
- { "luksCipher", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_cipher), JSON_SAFE },
- { "luksCipherMode", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_cipher_mode), JSON_SAFE },
- { "luksVolumeKeySize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_volume_key_size), 0 },
- { "luksPbkdfHashAlgorithm", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_pbkdf_hash_algorithm), JSON_SAFE },
- { "luksPbkdfType", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_pbkdf_type), JSON_SAFE },
- { "luksPbkdfForceIterations", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_force_iterations), 0 },
- { "luksPbkdfTimeCostUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_time_cost_usec), 0 },
- { "luksPbkdfMemoryCost", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_memory_cost), 0 },
- { "luksPbkdfParallelThreads", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_parallel_threads), 0 },
- { "luksSectorSize", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, luks_sector_size), 0 },
- { "luksExtraMountOptions", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, luks_extra_mount_options), 0 },
- { "dropCaches", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, drop_caches), 0 },
- { "autoResizeMode", _JSON_VARIANT_TYPE_INVALID, dispatch_auto_resize_mode, offsetof(UserRecord, auto_resize_mode), 0 },
- { "rebalanceWeight", _JSON_VARIANT_TYPE_INVALID, dispatch_rebalance_weight, offsetof(UserRecord, rebalance_weight), 0 },
- { "service", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, service), JSON_SAFE },
- { "rateLimitIntervalUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, ratelimit_interval_usec), 0 },
- { "rateLimitBurst", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, ratelimit_burst), 0 },
- { "enforcePasswordPolicy", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, enforce_password_policy), 0 },
- { "autoLogin", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, auto_login), 0 },
- { "preferredSessionType", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, preferred_session_type), JSON_SAFE },
- { "preferredSessionLauncher", JSON_VARIANT_STRING, json_dispatch_string, offsetof(UserRecord, preferred_session_launcher), JSON_SAFE },
- { "stopDelayUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, stop_delay_usec), 0 },
- { "killProcesses", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, kill_processes), 0 },
- { "passwordChangeMinUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, password_change_min_usec), 0 },
- { "passwordChangeMaxUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, password_change_max_usec), 0 },
- { "passwordChangeWarnUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, password_change_warn_usec), 0 },
- { "passwordChangeInactiveUSec", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(UserRecord, password_change_inactive_usec), 0 },
- { "passwordChangeNow", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(UserRecord, password_change_now), 0 },
- { "pkcs11TokenUri", JSON_VARIANT_ARRAY, dispatch_pkcs11_uri_array, offsetof(UserRecord, pkcs11_token_uri), 0 },
- { "fido2HmacCredential", JSON_VARIANT_ARRAY, dispatch_fido2_hmac_credential_array, 0, 0 },
- { "recoveryKeyType", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(UserRecord, recovery_key_type), 0 },
-
- { "secret", JSON_VARIANT_OBJECT, dispatch_secret, 0, 0 },
- { "privileged", JSON_VARIANT_OBJECT, dispatch_privileged, 0, 0 },
+int user_record_load(UserRecord *h, sd_json_variant *v, UserRecordLoadFlags load_flags) {
+
+ static const sd_json_dispatch_field user_dispatch_table[] = {
+ { "userName", SD_JSON_VARIANT_STRING, json_dispatch_user_group_name, offsetof(UserRecord, user_name), SD_JSON_RELAX },
+ { "realm", SD_JSON_VARIANT_STRING, json_dispatch_realm, offsetof(UserRecord, realm), 0 },
+ { "blobDirectory", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, blob_directory), SD_JSON_SAFE },
+ { "blobManifest", SD_JSON_VARIANT_OBJECT, dispatch_blob_manifest, offsetof(UserRecord, blob_manifest), 0 },
+ { "realName", SD_JSON_VARIANT_STRING, json_dispatch_gecos, offsetof(UserRecord, real_name), 0 },
+ { "emailAddress", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, email_address), SD_JSON_SAFE },
+ { "iconName", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, icon_name), SD_JSON_SAFE },
+ { "location", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, location), 0 },
+ { "disposition", SD_JSON_VARIANT_STRING, json_dispatch_user_disposition, offsetof(UserRecord, disposition), 0 },
+ { "lastChangeUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, last_change_usec), 0 },
+ { "lastPasswordChangeUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, last_password_change_usec), 0 },
+ { "shell", SD_JSON_VARIANT_STRING, json_dispatch_filename_or_path, offsetof(UserRecord, shell), 0 },
+ { "umask", SD_JSON_VARIANT_UNSIGNED, json_dispatch_umask, offsetof(UserRecord, umask), 0 },
+ { "environment", SD_JSON_VARIANT_ARRAY, json_dispatch_environment, offsetof(UserRecord, environment), 0 },
+ { "timeZone", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, time_zone), SD_JSON_SAFE },
+ { "preferredLanguage", SD_JSON_VARIANT_STRING, json_dispatch_locale, offsetof(UserRecord, preferred_language), 0 },
+ { "additionalLanguages", SD_JSON_VARIANT_ARRAY, json_dispatch_locales, offsetof(UserRecord, additional_languages), 0 },
+ { "niceLevel", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_nice, offsetof(UserRecord, nice_level), 0 },
+ { "resourceLimits", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_rlimits, offsetof(UserRecord, rlimits), 0 },
+ { "locked", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, locked), 0 },
+ { "notBeforeUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, not_before_usec), 0 },
+ { "notAfterUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, not_after_usec), 0 },
+ { "storage", SD_JSON_VARIANT_STRING, json_dispatch_user_storage, offsetof(UserRecord, storage), 0 },
+ { "diskSize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, disk_size), 0 },
+ { "diskSizeRelative", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, disk_size_relative), 0 },
+ { "skeletonDirectory", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, skeleton_directory), SD_JSON_SAFE },
+ { "accessMode", SD_JSON_VARIANT_UNSIGNED, json_dispatch_access_mode, offsetof(UserRecord, access_mode), 0 },
+ { "tasksMax", SD_JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, tasks_max), 0 },
+ { "memoryHigh", SD_JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, memory_high), 0 },
+ { "memoryMax", SD_JSON_VARIANT_UNSIGNED, json_dispatch_tasks_or_memory_max, offsetof(UserRecord, memory_max), 0 },
+ { "cpuWeight", SD_JSON_VARIANT_UNSIGNED, json_dispatch_weight, offsetof(UserRecord, cpu_weight), 0 },
+ { "ioWeight", SD_JSON_VARIANT_UNSIGNED, json_dispatch_weight, offsetof(UserRecord, io_weight), 0 },
+ { "mountNoDevices", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(UserRecord, nodev), 0 },
+ { "mountNoSuid", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(UserRecord, nosuid), 0 },
+ { "mountNoExecute", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(UserRecord, noexec), 0 },
+ { "cifsDomain", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, cifs_domain), SD_JSON_SAFE },
+ { "cifsUserName", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, cifs_user_name), SD_JSON_SAFE },
+ { "cifsService", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, cifs_service), SD_JSON_SAFE },
+ { "cifsExtraMountOptions", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, cifs_extra_mount_options), 0 },
+ { "imagePath", SD_JSON_VARIANT_STRING, json_dispatch_path, offsetof(UserRecord, image_path), SD_JSON_SAFE },
+ { "homeDirectory", SD_JSON_VARIANT_STRING, json_dispatch_home_directory, offsetof(UserRecord, home_directory), 0 },
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(UserRecord, uid), 0 },
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(UserRecord, gid), 0 },
+ { "memberOf", SD_JSON_VARIANT_ARRAY, json_dispatch_user_group_list, offsetof(UserRecord, member_of), SD_JSON_RELAX },
+ { "capabilityBoundingSet", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(UserRecord, capability_bounding_set), SD_JSON_SAFE },
+ { "capabilityAmbientSet", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(UserRecord, capability_ambient_set), SD_JSON_SAFE },
+ { "fileSystemType", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, file_system_type), SD_JSON_SAFE },
+ { "partitionUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(UserRecord, partition_uuid), 0 },
+ { "luksUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(UserRecord, luks_uuid), 0 },
+ { "fileSystemUuid", SD_JSON_VARIANT_STRING, sd_json_dispatch_id128, offsetof(UserRecord, file_system_uuid), 0 },
+ { "luksDiscard", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_tristate, offsetof(UserRecord, luks_discard), 0 },
+ { "luksOfflineDiscard", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_tristate, offsetof(UserRecord, luks_offline_discard), 0 },
+ { "luksCipher", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_cipher), SD_JSON_SAFE },
+ { "luksCipherMode", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_cipher_mode), SD_JSON_SAFE },
+ { "luksVolumeKeySize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_volume_key_size), 0 },
+ { "luksPbkdfHashAlgorithm", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_pbkdf_hash_algorithm), SD_JSON_SAFE },
+ { "luksPbkdfType", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_pbkdf_type), SD_JSON_SAFE },
+ { "luksPbkdfForceIterations", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_force_iterations), 0 },
+ { "luksPbkdfTimeCostUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_time_cost_usec), 0 },
+ { "luksPbkdfMemoryCost", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_memory_cost), 0 },
+ { "luksPbkdfParallelThreads", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_pbkdf_parallel_threads), 0 },
+ { "luksSectorSize", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, luks_sector_size), 0 },
+ { "luksExtraMountOptions", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, luks_extra_mount_options), 0 },
+ { "dropCaches", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, drop_caches), 0 },
+ { "autoResizeMode", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_auto_resize_mode, offsetof(UserRecord, auto_resize_mode), 0 },
+ { "rebalanceWeight", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_rebalance_weight, offsetof(UserRecord, rebalance_weight), 0 },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, service), SD_JSON_SAFE },
+ { "rateLimitIntervalUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, ratelimit_interval_usec), 0 },
+ { "rateLimitBurst", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, ratelimit_burst), 0 },
+ { "enforcePasswordPolicy", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, enforce_password_policy), 0 },
+ { "autoLogin", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, auto_login), 0 },
+ { "preferredSessionType", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, preferred_session_type), SD_JSON_SAFE },
+ { "preferredSessionLauncher", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(UserRecord, preferred_session_launcher), SD_JSON_SAFE },
+ { "stopDelayUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, stop_delay_usec), 0 },
+ { "killProcesses", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, kill_processes), 0 },
+ { "passwordChangeMinUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, password_change_min_usec), 0 },
+ { "passwordChangeMaxUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, password_change_max_usec), 0 },
+ { "passwordChangeWarnUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, password_change_warn_usec), 0 },
+ { "passwordChangeInactiveUSec", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(UserRecord, password_change_inactive_usec), 0 },
+ { "passwordChangeNow", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(UserRecord, password_change_now), 0 },
+ { "pkcs11TokenUri", SD_JSON_VARIANT_ARRAY, dispatch_pkcs11_uri_array, offsetof(UserRecord, pkcs11_token_uri), 0 },
+ { "fido2HmacCredential", SD_JSON_VARIANT_ARRAY, dispatch_fido2_hmac_credential_array, 0, 0 },
+ { "recoveryKeyType", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(UserRecord, recovery_key_type), 0 },
+
+ { "secret", SD_JSON_VARIANT_OBJECT, dispatch_secret, 0, 0 },
+ { "privileged", SD_JSON_VARIANT_OBJECT, dispatch_privileged, 0, 0 },
/* Ignore the perMachine, binding, status stuff here, and process it later, so that it overrides whatever is set above */
- { "perMachine", JSON_VARIANT_ARRAY, NULL, 0, 0 },
- { "binding", JSON_VARIANT_OBJECT, NULL, 0, 0 },
- { "status", JSON_VARIANT_OBJECT, NULL, 0, 0 },
+ { "perMachine", SD_JSON_VARIANT_ARRAY, NULL, 0, 0 },
+ { "binding", SD_JSON_VARIANT_OBJECT, NULL, 0, 0 },
+ { "status", SD_JSON_VARIANT_OBJECT, NULL, 0, 0 },
/* Ignore 'signature', we check it with explicit accessors instead */
- { "signature", JSON_VARIANT_ARRAY, NULL, 0, 0 },
+ { "signature", SD_JSON_VARIANT_ARRAY, NULL, 0, 0 },
{},
};
- JsonDispatchFlags json_flags = USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(load_flags);
+ sd_json_dispatch_flags_t json_flags = USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(load_flags);
int r;
assert(h);
if (r < 0)
return r;
- r = json_dispatch(h->json, user_dispatch_table, json_flags | JSON_ALLOW_EXTENSIONS, h);
+ r = sd_json_dispatch(h->json, user_dispatch_table, json_flags | SD_JSON_ALLOW_EXTENSIONS, h);
if (r < 0)
return r;
/* During the parsing operation above we ignored the 'perMachine', 'binding' and 'status' fields,
* since we want them to override the global options. Let's process them now. */
- r = dispatch_per_machine("perMachine", json_variant_by_key(h->json, "perMachine"), json_flags, h);
+ r = dispatch_per_machine("perMachine", sd_json_variant_by_key(h->json, "perMachine"), json_flags, h);
if (r < 0)
return r;
- r = dispatch_binding("binding", json_variant_by_key(h->json, "binding"), json_flags, h);
+ r = dispatch_binding("binding", sd_json_variant_by_key(h->json, "binding"), json_flags, h);
if (r < 0)
return r;
- r = dispatch_status("status", json_variant_by_key(h->json, "status"), json_flags, h);
+ r = dispatch_status("status", sd_json_variant_by_key(h->json, "status"), json_flags, h);
if (r < 0)
return r;
}
int user_record_build(UserRecord **ret, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *u = NULL;
va_list ap;
int r;
assert(ret);
va_start(ap, ret);
- r = json_buildv(&v, ap);
+ r = sd_json_buildv(&v, ap);
va_end(ap);
if (r < 0)
/* We assume that when a record is modified its JSON data is updated at the same time, hence it's
* sufficient to compare the JSON data. */
- return json_variant_equal(a->json, b->json);
+ return sd_json_variant_equal(a->json, b->json);
}
bool user_record_compatible(UserRecord *a, UserRecord *b) {
#include <sys/types.h>
#include "sd-id128.h"
+#include "sd-json.h"
#include "hashmap.h"
-#include "json.h"
#include "missing_resource.h"
#include "time-util.h"
return (f >> 21) & _USER_RECORD_MASK_MAX;
}
-static inline JsonDispatchFlags USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(UserRecordLoadFlags flags) {
- return (FLAGS_SET(flags, USER_RECORD_LOG) ? JSON_LOG : 0) |
- (FLAGS_SET(flags, USER_RECORD_PERMISSIVE) ? JSON_PERMISSIVE : 0);
+static inline sd_json_dispatch_flags_t USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(UserRecordLoadFlags flags) {
+ return (FLAGS_SET(flags, USER_RECORD_LOG) ? SD_JSON_LOG : 0) |
+ (FLAGS_SET(flags, USER_RECORD_PERMISSIVE) ? SD_JSON_PERMISSIVE : 0);
}
typedef struct Pkcs11EncryptedKey {
char **capability_bounding_set;
char **capability_ambient_set;
- JsonVariant *json;
+ sd_json_variant *json;
} UserRecord;
UserRecord* user_record_new(void);
DEFINE_TRIVIAL_CLEANUP_FUNC(UserRecord*, user_record_unref);
-int user_record_load(UserRecord *h, JsonVariant *v, UserRecordLoadFlags flags);
+int user_record_load(UserRecord *h, sd_json_variant *v, UserRecordLoadFlags flags);
int user_record_build(UserRecord **ret, ...);
const char *user_record_user_name_and_realm(UserRecord *h);
int user_record_test_password_change_required(UserRecord *h);
/* The following six are user by group-record.c, that's why we export them here */
-int json_dispatch_realm(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_gecos(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_user_group_list(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_user_disposition(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-
-int per_machine_id_match(JsonVariant *ids, JsonDispatchFlags flags);
-int per_machine_hostname_match(JsonVariant *hns, JsonDispatchFlags flags);
-int per_machine_match(JsonVariant *entry, JsonDispatchFlags flags);
-int user_group_record_mangle(JsonVariant *v, UserRecordLoadFlags load_flags, JsonVariant **ret_variant, UserRecordMask *ret_mask);
+int json_dispatch_realm(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int json_dispatch_gecos(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int json_dispatch_user_group_list(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int json_dispatch_user_disposition(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+
+int per_machine_id_match(sd_json_variant *ids, sd_json_dispatch_flags_t flags);
+int per_machine_hostname_match(sd_json_variant *hns, sd_json_dispatch_flags_t flags);
+int per_machine_match(sd_json_variant *entry, sd_json_dispatch_flags_t flags);
+int user_group_record_mangle(sd_json_variant *v, UserRecordLoadFlags load_flags, sd_json_variant **ret_variant, UserRecordMask *ret_mask);
#define BLOB_DIR_MAX_SIZE (UINT64_C(64) * U64_MB)
int suitable_blob_filename(const char *name);
UserDBFlags flags,
UserRecord **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *u = NULL;
bool have_privileged;
int r;
assert(f);
- r = json_parse_file(f, path, 0, &v, NULL, NULL);
+ r = sd_json_parse_file(f, path, 0, &v, NULL, NULL);
if (r < 0)
return r;
if (FLAGS_SET(flags, USERDB_SUPPRESS_SHADOW) || !path || !(name || uid_is_valid(uid)))
have_privileged = false;
else {
- _cleanup_(json_variant_unrefp) JsonVariant *privileged_v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *privileged_v = NULL;
_cleanup_free_ char *d = NULL, *j = NULL;
/* Let's load the "privileged" section from a companion file. But only if USERDB_AVOID_SHADOW
return -ENOMEM;
}
- r = json_parse_file(NULL, j, JSON_PARSE_SENSITIVE, &privileged_v, NULL, NULL);
+ r = sd_json_parse_file(NULL, j, SD_JSON_PARSE_SENSITIVE, &privileged_v, NULL, NULL);
if (ERRNO_IS_NEG_PRIVILEGE(r))
have_privileged = false;
else if (r == -ENOENT)
else if (r < 0)
return r;
else {
- r = json_variant_merge_object(&v, privileged_v);
+ r = sd_json_variant_merge_object(&v, privileged_v);
if (r < 0)
return r;
UserDBFlags flags,
GroupRecord **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(group_record_unrefp) GroupRecord *g = NULL;
bool have_privileged;
int r;
assert(f);
- r = json_parse_file(f, path, 0, &v, NULL, NULL);
+ r = sd_json_parse_file(f, path, 0, &v, NULL, NULL);
if (r < 0)
return r;
if (FLAGS_SET(flags, USERDB_SUPPRESS_SHADOW) || !path || !(name || gid_is_valid(gid)))
have_privileged = false;
else {
- _cleanup_(json_variant_unrefp) JsonVariant *privileged_v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *privileged_v = NULL;
_cleanup_free_ char *d = NULL, *j = NULL;
r = path_extract_directory(path, &d);
return -ENOMEM;
}
- r = json_parse_file(NULL, j, JSON_PARSE_SENSITIVE, &privileged_v, NULL, NULL);
+ r = sd_json_parse_file(NULL, j, SD_JSON_PARSE_SENSITIVE, &privileged_v, NULL, NULL);
if (ERRNO_IS_NEG_PRIVILEGE(r))
have_privileged = false;
else if (r == -ENOENT)
else if (r < 0)
return r;
else {
- r = json_variant_merge_object(&v, privileged_v);
+ r = sd_json_variant_merge_object(&v, privileged_v);
if (r < 0)
return r;
#include "errno-util.h"
#include "fd-util.h"
#include "format-util.h"
+#include "json-util.h"
#include "missing_syscall.h"
#include "parse-util.h"
#include "set.h"
}
struct user_group_data {
- JsonVariant *record;
+ sd_json_variant *record;
bool incomplete;
};
static void user_group_data_done(struct user_group_data *d) {
- json_variant_unref(d->record);
+ sd_json_variant_unref(d->record);
}
struct membership_data {
static int userdb_on_query_reply(
Varlink *link,
- JsonVariant *parameters,
+ sd_json_variant *parameters,
const char *error_id,
VarlinkReplyFlags flags,
void *userdata) {
case LOOKUP_USER: {
_cleanup_(user_group_data_done) struct user_group_data user_data = {};
- static const JsonDispatch dispatch_table[] = {
- { "record", _JSON_VARIANT_TYPE_INVALID, json_dispatch_variant, offsetof(struct user_group_data, record), 0 },
- { "incomplete", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct user_group_data, incomplete), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "record", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_variant, offsetof(struct user_group_data, record), 0 },
+ { "incomplete", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct user_group_data, incomplete), 0 },
{}
};
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
assert_se(!iterator->found_user);
- r = json_dispatch(parameters, dispatch_table, JSON_ALLOW_EXTENSIONS, &user_data);
+ r = sd_json_dispatch(parameters, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &user_data);
if (r < 0)
goto finish;
case LOOKUP_GROUP: {
_cleanup_(user_group_data_done) struct user_group_data group_data = {};
- static const JsonDispatch dispatch_table[] = {
- { "record", _JSON_VARIANT_TYPE_INVALID, json_dispatch_variant, offsetof(struct user_group_data, record), 0 },
- { "incomplete", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(struct user_group_data, incomplete), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "record", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_variant, offsetof(struct user_group_data, record), 0 },
+ { "incomplete", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(struct user_group_data, incomplete), 0 },
{}
};
_cleanup_(group_record_unrefp) GroupRecord *g = NULL;
assert_se(!iterator->found_group);
- r = json_dispatch(parameters, dispatch_table, JSON_ALLOW_EXTENSIONS, &group_data);
+ r = sd_json_dispatch(parameters, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &group_data);
if (r < 0)
goto finish;
case LOOKUP_MEMBERSHIP: {
_cleanup_(membership_data_done) struct membership_data membership_data = {};
- static const JsonDispatch dispatch_table[] = {
- { "userName", JSON_VARIANT_STRING, json_dispatch_user_group_name, offsetof(struct membership_data, user_name), JSON_RELAX },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_user_group_name, offsetof(struct membership_data, group_name), JSON_RELAX },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "userName", SD_JSON_VARIANT_STRING, json_dispatch_user_group_name, offsetof(struct membership_data, user_name), SD_JSON_RELAX },
+ { "groupName", SD_JSON_VARIANT_STRING, json_dispatch_user_group_name, offsetof(struct membership_data, group_name), SD_JSON_RELAX },
{}
};
assert(!iterator->found_user_name);
assert(!iterator->found_group_name);
- r = json_dispatch(parameters, dispatch_table, JSON_ALLOW_EXTENSIONS, &membership_data);
+ r = sd_json_dispatch(parameters, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &membership_data);
if (r < 0)
goto finish;
const char *path,
const char *method,
bool more,
- JsonVariant *query) {
+ sd_json_variant *query) {
_cleanup_(varlink_unrefp) Varlink *vl = NULL;
int r;
UserDBIterator *iterator,
const char *method,
bool more,
- JsonVariant *query,
+ sd_json_variant *query,
UserDBFlags flags) {
_cleanup_strv_free_ char **except = NULL, **only = NULL;
if ((flags & (USERDB_AVOID_MULTIPLEXER|USERDB_EXCLUDE_DYNAMIC_USER|USERDB_EXCLUDE_NSS|USERDB_EXCLUDE_DROPIN|USERDB_DONT_SYNTHESIZE)) == 0 &&
!strv_contains(except, "io.systemd.Multiplexer") &&
(!only || strv_contains(only, "io.systemd.Multiplexer"))) {
- _cleanup_(json_variant_unrefp) JsonVariant *patched_query = json_variant_ref(query);
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *patched_query = sd_json_variant_ref(query);
- r = json_variant_set_field_string(&patched_query, "service", "io.systemd.Multiplexer");
+ r = sd_json_variant_set_field_string(&patched_query, "service", "io.systemd.Multiplexer");
if (r < 0)
return log_debug_errno(r, "Unable to set service JSON field: %m");
}
FOREACH_DIRENT(de, d, return -errno) {
- _cleanup_(json_variant_unrefp) JsonVariant *patched_query = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *patched_query = NULL;
_cleanup_free_ char *p = NULL;
bool is_nss, is_dropin;
if (!p)
return -ENOMEM;
- patched_query = json_variant_ref(query);
- r = json_variant_set_field_string(&patched_query, "service", de->d_name);
+ patched_query = sd_json_variant_ref(query);
+ r = sd_json_variant_set_field_string(&patched_query, "service", de->d_name);
if (r < 0)
return log_debug_errno(r, "Unable to set service JSON field: %m");
static int synthetic_root_user_build(UserRecord **ret) {
return user_record_build(
ret,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("userName", JSON_BUILD_CONST_STRING("root")),
- JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(0)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(0)),
- JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_CONST_STRING("/root")),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("intrinsic"))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("userName", JSON_BUILD_CONST_STRING("root")),
+ SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(0)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(0)),
+ SD_JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_CONST_STRING("/root")),
+ SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("intrinsic"))));
}
static int synthetic_nobody_user_build(UserRecord **ret) {
return user_record_build(
ret,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("userName", JSON_BUILD_CONST_STRING(NOBODY_USER_NAME)),
- JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(UID_NOBODY)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(GID_NOBODY)),
- JSON_BUILD_PAIR("shell", JSON_BUILD_CONST_STRING(NOLOGIN)),
- JSON_BUILD_PAIR("locked", JSON_BUILD_BOOLEAN(true)),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("intrinsic"))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("userName", JSON_BUILD_CONST_STRING(NOBODY_USER_NAME)),
+ SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(UID_NOBODY)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(GID_NOBODY)),
+ SD_JSON_BUILD_PAIR("shell", JSON_BUILD_CONST_STRING(NOLOGIN)),
+ SD_JSON_BUILD_PAIR("locked", SD_JSON_BUILD_BOOLEAN(true)),
+ SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("intrinsic"))));
}
int userdb_by_name(const char *name, UserDBFlags flags, UserRecord **ret) {
_cleanup_(userdb_iterator_freep) UserDBIterator *iterator = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *query = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *query = NULL;
int r;
if (!valid_user_group_name(name, VALID_USER_RELAX))
return -EINVAL;
- r = json_build(&query, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(name))));
+ r = sd_json_build(&query, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(name))));
if (r < 0)
return r;
int userdb_by_uid(uid_t uid, UserDBFlags flags, UserRecord **ret) {
_cleanup_(userdb_iterator_freep) UserDBIterator *iterator = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *query = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *query = NULL;
int r;
if (!uid_is_valid(uid))
return -EINVAL;
- r = json_build(&query, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(uid))));
+ r = sd_json_build(&query, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(uid))));
if (r < 0)
return r;
static int synthetic_root_group_build(GroupRecord **ret) {
return group_record_build(
ret,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("groupName", JSON_BUILD_CONST_STRING("root")),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(0)),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("intrinsic"))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("groupName", JSON_BUILD_CONST_STRING("root")),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(0)),
+ SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("intrinsic"))));
}
static int synthetic_nobody_group_build(GroupRecord **ret) {
return group_record_build(
ret,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("groupName", JSON_BUILD_CONST_STRING(NOBODY_GROUP_NAME)),
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(GID_NOBODY)),
- JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("intrinsic"))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("groupName", JSON_BUILD_CONST_STRING(NOBODY_GROUP_NAME)),
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(GID_NOBODY)),
+ SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("intrinsic"))));
}
int groupdb_by_name(const char *name, UserDBFlags flags, GroupRecord **ret) {
_cleanup_(userdb_iterator_freep) UserDBIterator *iterator = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *query = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *query = NULL;
int r;
if (!valid_user_group_name(name, VALID_USER_RELAX))
return -EINVAL;
- r = json_build(&query, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(name))));
+ r = sd_json_build(&query, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(name))));
if (r < 0)
return r;
int groupdb_by_gid(gid_t gid, UserDBFlags flags, GroupRecord **ret) {
_cleanup_(userdb_iterator_freep) UserDBIterator *iterator = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *query = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *query = NULL;
int r;
if (!gid_is_valid(gid))
return -EINVAL;
- r = json_build(&query, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(gid))));
+ r = sd_json_build(&query, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(gid))));
if (r < 0)
return r;
int membershipdb_by_user(const char *name, UserDBFlags flags, UserDBIterator **ret) {
_cleanup_(userdb_iterator_freep) UserDBIterator *iterator = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *query = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *query = NULL;
int r, qr;
assert(ret);
if (!valid_user_group_name(name, VALID_USER_RELAX))
return -EINVAL;
- r = json_build(&query, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(name))));
+ r = sd_json_build(&query, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(name))));
if (r < 0)
return r;
int membershipdb_by_group(const char *name, UserDBFlags flags, UserDBIterator **ret) {
_cleanup_(userdb_iterator_freep) UserDBIterator *iterator = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *query = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *query = NULL;
int r, qr;
assert(ret);
if (!valid_user_group_name(name, VALID_USER_RELAX))
return -EINVAL;
- r = json_build(&query, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(name))));
+ r = sd_json_build(&query, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(name))));
if (r < 0)
return r;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "json-util.h"
#include "memstream-util.h"
+#include "set.h"
#include "strv.h"
#include "terminal-util.h"
#include "varlink-idl.h"
-#include "set.h"
#define DEPTH_MAX 64U
return 0;
}
-static int varlink_idl_validate_symbol(const VarlinkSymbol *symbol, JsonVariant *v, VarlinkFieldDirection direction, const char **bad_field);
+static int varlink_idl_validate_symbol(const VarlinkSymbol *symbol, sd_json_variant *v, VarlinkFieldDirection direction, const char **bad_field);
-static int varlink_idl_validate_field_element_type(const VarlinkField *field, JsonVariant *v) {
+static int varlink_idl_validate_field_element_type(const VarlinkField *field, sd_json_variant *v) {
assert(field);
switch (field->field_type) {
return varlink_idl_validate_symbol(field->symbol, v, VARLINK_REGULAR, NULL);
case VARLINK_BOOL:
- if (!json_variant_is_boolean(v))
+ if (!sd_json_variant_is_boolean(v))
return varlink_idl_log(SYNTHETIC_ERRNO(EMEDIUMTYPE), "Field '%s' should be a bool, but it is not, refusing.", strna(field->name));
break;
case VARLINK_INT:
/* Allow strings here too, since integers with > 53 bits are often passed in as strings */
- if (!json_variant_is_integer(v) && !json_variant_is_unsigned(v) && !json_variant_is_string(v))
+ if (!sd_json_variant_is_integer(v) && !sd_json_variant_is_unsigned(v) && !sd_json_variant_is_string(v))
return varlink_idl_log(SYNTHETIC_ERRNO(EMEDIUMTYPE), "Field '%s' should be an int, but it is not, refusing.", strna(field->name));
break;
case VARLINK_FLOAT:
- if (!json_variant_is_number(v))
+ if (!sd_json_variant_is_number(v))
return varlink_idl_log(SYNTHETIC_ERRNO(EMEDIUMTYPE), "Field '%s' should be a float, but it is not, refusing.", strna(field->name));
break;
case VARLINK_STRING:
- if (!json_variant_is_string(v))
+ if (!sd_json_variant_is_string(v))
return varlink_idl_log(SYNTHETIC_ERRNO(EMEDIUMTYPE), "Field '%s' should be a string, but it is not, refusing.", strna(field->name));
break;
case VARLINK_OBJECT:
- if (!json_variant_is_object(v))
+ if (!sd_json_variant_is_object(v))
return varlink_idl_log(SYNTHETIC_ERRNO(EMEDIUMTYPE), "Field '%s' should be an object, but it is not, refusing.", strna(field->name));
break;
return 0;
}
-static int varlink_idl_validate_field(const VarlinkField *field, JsonVariant *v) {
+static int varlink_idl_validate_field(const VarlinkField *field, sd_json_variant *v) {
int r;
assert(field);
- if (!v || json_variant_is_null(v)) {
+ if (!v || sd_json_variant_is_null(v)) {
if (!FLAGS_SET(field->field_flags, VARLINK_NULLABLE))
return varlink_idl_log(SYNTHETIC_ERRNO(ENOANO), "Mandatory field '%s' is null or missing on object, refusing.", strna(field->name));
} else if (FLAGS_SET(field->field_flags, VARLINK_ARRAY)) {
- JsonVariant *i;
+ sd_json_variant *i;
- if (!json_variant_is_array(v))
+ if (!sd_json_variant_is_array(v))
return varlink_idl_log(SYNTHETIC_ERRNO(EMEDIUMTYPE), "Field '%s' should be an array, but it is not, refusing.", strna(field->name));
JSON_VARIANT_ARRAY_FOREACH(i, v) {
} else if (FLAGS_SET(field->field_flags, VARLINK_MAP)) {
_unused_ const char *k;
- JsonVariant *e;
+ sd_json_variant *e;
- if (!json_variant_is_object(v))
+ if (!sd_json_variant_is_object(v))
return varlink_idl_log(SYNTHETIC_ERRNO(EMEDIUMTYPE), "Field '%s' should be an object, but it is not, refusing.", strna(field->name));
JSON_VARIANT_OBJECT_FOREACH(k, e, v) {
return 0;
}
-static int varlink_idl_validate_symbol(const VarlinkSymbol *symbol, JsonVariant *v, VarlinkFieldDirection direction, const char **bad_field) {
+static int varlink_idl_validate_symbol(const VarlinkSymbol *symbol, sd_json_variant *v, VarlinkFieldDirection direction, const char **bad_field) {
int r;
assert(symbol);
bool found = false;
const char *s;
- if (!json_variant_is_string(v)) {
+ if (!sd_json_variant_is_string(v)) {
if (bad_field)
*bad_field = symbol->name;
return varlink_idl_log(SYNTHETIC_ERRNO(EMEDIUMTYPE), "Passed non-string to enum field '%s', refusing.", strna(symbol->name));
}
- assert_se(s = json_variant_string(v));
+ assert_se(s = sd_json_variant_string(v));
for (const VarlinkField *field = symbol->fields; field->field_type != _VARLINK_FIELD_TYPE_END_MARKER; field++) {
case VARLINK_STRUCT_TYPE:
case VARLINK_METHOD:
case VARLINK_ERROR: {
- if (!json_variant_is_object(v)) {
+ if (!sd_json_variant_is_object(v)) {
if (bad_field)
*bad_field = symbol->name;
return varlink_idl_log(SYNTHETIC_ERRNO(EMEDIUMTYPE), "Passed non-object to field '%s', refusing.", strna(symbol->name));
if (field->field_direction != direction)
continue;
- r = varlink_idl_validate_field(field, json_variant_by_key(v, field->name));
+ r = varlink_idl_validate_field(field, sd_json_variant_by_key(v, field->name));
if (r < 0) {
if (bad_field)
*bad_field = field->name;
}
}
- _unused_ JsonVariant *e;
+ _unused_ sd_json_variant *e;
const char *name;
JSON_VARIANT_OBJECT_FOREACH(name, e, v) {
if (!varlink_idl_find_field(symbol, name)) {
return 1; /* validated */
}
-static int varlink_idl_validate_method(const VarlinkSymbol *method, JsonVariant *v, VarlinkFieldDirection direction, const char **bad_field) {
+static int varlink_idl_validate_method(const VarlinkSymbol *method, sd_json_variant *v, VarlinkFieldDirection direction, const char **bad_field) {
assert(IN_SET(direction, VARLINK_INPUT, VARLINK_OUTPUT));
if (!method)
return varlink_idl_validate_symbol(method, v, direction, bad_field);
}
-int varlink_idl_validate_method_call(const VarlinkSymbol *method, JsonVariant *v, const char **bad_field) {
+int varlink_idl_validate_method_call(const VarlinkSymbol *method, sd_json_variant *v, const char **bad_field) {
return varlink_idl_validate_method(method, v, VARLINK_INPUT, bad_field);
}
-int varlink_idl_validate_method_reply(const VarlinkSymbol *method, JsonVariant *v, const char **bad_field) {
+int varlink_idl_validate_method_reply(const VarlinkSymbol *method, sd_json_variant *v, const char **bad_field) {
return varlink_idl_validate_method(method, v, VARLINK_OUTPUT, bad_field);
}
-int varlink_idl_validate_error(const VarlinkSymbol *error, JsonVariant *v, const char **bad_field) {
+int varlink_idl_validate_error(const VarlinkSymbol *error, sd_json_variant *v, const char **bad_field) {
if (!error)
return 0; /* Can't validate */
if (error->symbol_type != VARLINK_ERROR)
#include <stdbool.h>
#include <stdio.h>
-#include "json.h"
+#include "sd-json.h"
#include "macro.h"
/* This implements the Varlink Interface Definition Language ("Varlink IDL"),
const VarlinkSymbol* varlink_idl_find_symbol(const VarlinkInterface *interface, VarlinkSymbolType type, const char *name);
const VarlinkField* varlink_idl_find_field(const VarlinkSymbol *symbol, const char *name);
-int varlink_idl_validate_method_call(const VarlinkSymbol *method, JsonVariant *v, const char **bad_field);
-int varlink_idl_validate_method_reply(const VarlinkSymbol *method, JsonVariant *v, const char **bad_field);
-int varlink_idl_validate_error(const VarlinkSymbol *error, JsonVariant *v, const char **bad_field);
+int varlink_idl_validate_method_call(const VarlinkSymbol *method, sd_json_variant *v, const char **bad_field);
+int varlink_idl_validate_method_reply(const VarlinkSymbol *method, sd_json_variant *v, const char **bad_field);
+int varlink_idl_validate_error(const VarlinkSymbol *error, sd_json_variant *v, const char **bad_field);
&vl_method_Reload,
&vl_method_SetLogLevel);
-int varlink_method_ping(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+int varlink_method_ping(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
assert(link);
- if (json_variant_elements(parameters) > 0)
+ if (sd_json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
log_debug("Received io.systemd.service.Ping");
return varlink_reply(link, NULL);
}
-int varlink_method_set_log_level(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "level", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int64, 0, JSON_MANDATORY },
+int varlink_method_set_log_level(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "level", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int64, 0, SD_JSON_MANDATORY },
{}
};
assert(parameters);
/* NOTE: The method does have 1 parameter, but we must compare to 2 here, because
- * json_variant_elements() breaks abstraction and exposes internal structure of JsonObject. */
- if (json_variant_elements(parameters) != 2)
+ * sd_json_variant_elements() breaks abstraction and exposes internal structure of JsonObject. */
+ if (sd_json_variant_elements(parameters) != 2)
return varlink_error_invalid_parameter(link, parameters);
r = varlink_dispatch(link, parameters, dispatch_table, &level);
extern const VarlinkInterface vl_interface_io_systemd_service;
-int varlink_method_ping(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
-int varlink_method_set_log_level(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
+int varlink_method_ping(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
+int varlink_method_set_log_level(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
#include "hashmap.h"
#include "io-util.h"
#include "iovec-util.h"
+#include "json-util.h"
#include "list.h"
#include "path-util.h"
#include "process-util.h"
#include "user-util.h"
#include "varlink.h"
#include "varlink-internal.h"
-#include "varlink-org.varlink.service.h"
#include "varlink-io.systemd.h"
+#include "varlink-org.varlink.service.h"
#include "version.h"
#define VARLINK_DEFAULT_CONNECTIONS_MAX 4096U
* whole pipeline. */
struct VarlinkJsonQueueItem {
LIST_FIELDS(VarlinkJsonQueueItem, queue);
- JsonVariant *data;
+ sd_json_variant *data;
size_t n_fds;
int fds[];
};
VarlinkReply reply_callback;
- JsonVariant *current;
- JsonVariant *current_collected;
+ sd_json_variant *current;
+ sd_json_variant *current_collected;
VarlinkReplyFlags current_reply_flags;
VarlinkSymbol *current_method;
if (!q)
return NULL;
- json_variant_unref(q->data);
+ sd_json_variant_unref(q->data);
close_many(q->fds, q->n_fds);
return mfree(q);
}
-static VarlinkJsonQueueItem *varlink_json_queue_item_new(JsonVariant *m, const int fds[], size_t n_fds) {
+static VarlinkJsonQueueItem *varlink_json_queue_item_new(sd_json_variant *m, const int fds[], size_t n_fds) {
VarlinkJsonQueueItem *q;
assert(m);
return NULL;
*q = (VarlinkJsonQueueItem) {
- .data = json_variant_ref(m),
+ .data = sd_json_variant_ref(m),
.n_fds = n_fds,
};
assert(v);
/* Clears the currently processed incoming message */
- v->current = json_variant_unref(v->current);
- v->current_collected = json_variant_unref(v->current_collected);
+ v->current = sd_json_variant_unref(v->current);
+ v->current_collected = sd_json_variant_unref(v->current_collected);
v->current_method = NULL;
v->current_reply_flags = 0;
sz = e - begin + 1;
- r = json_parse(begin, 0, &v->current, NULL, NULL);
+ r = sd_json_parse(begin, 0, &v->current, NULL, NULL);
if (v->input_sensitive)
explicit_bzero_safe(begin, sz);
if (r < 0) {
if (v->input_sensitive) {
/* Mark the parameters subfield as sensitive right-away, if that's requested */
- JsonVariant *parameters = json_variant_by_key(v->current, "parameters");
+ sd_json_variant *parameters = sd_json_variant_by_key(v->current, "parameters");
if (parameters)
- json_variant_sensitive(parameters);
+ sd_json_variant_sensitive(parameters);
}
if (DEBUG_LOGGING) {
_cleanup_(erase_and_freep) char *censored_text = NULL;
/* Suppress sensitive fields in the debug output */
- r = json_variant_format(v->current, /* flags= */ JSON_FORMAT_CENSOR_SENSITIVE, &censored_text);
+ r = sd_json_variant_format(v->current, /* flags= */ SD_JSON_FORMAT_CENSOR_SENSITIVE, &censored_text);
if (r < 0)
return r;
return 1;
}
-static int varlink_sanitize_parameters(JsonVariant **v) {
+static int varlink_sanitize_parameters(sd_json_variant **v) {
int r;
assert(v);
/* Varlink always wants a parameters list, hence make one if the caller doesn't want any */
if (!*v)
- return json_variant_new_object(v, NULL, 0);
- if (json_variant_is_null(*v)) {
- JsonVariant *empty;
+ return sd_json_variant_new_object(v, NULL, 0);
+ if (sd_json_variant_is_null(*v)) {
+ sd_json_variant *empty;
- r = json_variant_new_object(&empty, NULL, 0);
+ r = sd_json_variant_new_object(&empty, NULL, 0);
if (r < 0)
return r;
- json_variant_unref(*v);
+ sd_json_variant_unref(*v);
*v = empty;
return 0;
}
- if (!json_variant_is_object(*v))
+ if (!sd_json_variant_is_object(*v))
return -EINVAL;
return 0;
}
static int varlink_dispatch_reply(Varlink *v) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
VarlinkReplyFlags flags = 0;
const char *error = NULL;
- JsonVariant *e;
+ sd_json_variant *e;
const char *k;
int r;
assert(v->n_pending > 0);
- if (!json_variant_is_object(v->current))
+ if (!sd_json_variant_is_object(v->current))
goto invalid;
JSON_VARIANT_OBJECT_FOREACH(k, e, v->current) {
if (streq(k, "error")) {
if (error)
goto invalid;
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
goto invalid;
- error = json_variant_string(e);
+ error = sd_json_variant_string(e);
flags |= VARLINK_REPLY_ERROR;
} else if (streq(k, "parameters")) {
if (parameters)
goto invalid;
- if (!json_variant_is_object(e) && !json_variant_is_null(e))
+ if (!sd_json_variant_is_object(e) && !sd_json_variant_is_null(e))
goto invalid;
- parameters = json_variant_ref(e);
+ parameters = sd_json_variant_ref(e);
} else if (streq(k, "continues")) {
if (FLAGS_SET(flags, VARLINK_REPLY_CONTINUES))
goto invalid;
- if (!json_variant_is_boolean(e))
+ if (!sd_json_variant_is_boolean(e))
goto invalid;
- if (json_variant_boolean(e))
+ if (sd_json_variant_boolean(e))
flags |= VARLINK_REPLY_CONTINUES;
} else
goto invalid;
static int generic_method_get_info(
Varlink *link,
- JsonVariant *parameters,
+ sd_json_variant *parameters,
VarlinkMethodFlags flags,
void *userdata) {
assert(link);
- if (json_variant_elements(parameters) != 0)
+ if (sd_json_variant_elements(parameters) != 0)
return varlink_error_invalid_parameter(link, parameters);
product = strjoin("systemd (", program_invocation_short_name, ")");
strv_sort(interfaces);
- return varlink_replyb(link, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("vendor", "The systemd Project"),
- JSON_BUILD_PAIR_STRING("product", product),
- JSON_BUILD_PAIR_STRING("version", PROJECT_VERSION_FULL " (" GIT_VERSION ")"),
- JSON_BUILD_PAIR_STRING("url", "https://systemd.io/"),
- JSON_BUILD_PAIR_STRV("interfaces", interfaces)));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("vendor", "The systemd Project"),
+ SD_JSON_BUILD_PAIR_STRING("product", product),
+ SD_JSON_BUILD_PAIR_STRING("version", PROJECT_VERSION_FULL " (" GIT_VERSION ")"),
+ SD_JSON_BUILD_PAIR_STRING("url", "https://systemd.io/"),
+ SD_JSON_BUILD_PAIR_STRV("interfaces", interfaces)));
}
static int generic_method_get_interface_description(
Varlink *link,
- JsonVariant *parameters,
+ sd_json_variant *parameters,
VarlinkMethodFlags flags,
void *userdata) {
- static const struct JsonDispatch dispatch_table[] = {
- { "interface", JSON_VARIANT_STRING, json_dispatch_const_string, 0, JSON_MANDATORY },
+ static const struct sd_json_dispatch_field dispatch_table[] = {
+ { "interface", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, 0, SD_JSON_MANDATORY },
{}
};
_cleanup_free_ char *text = NULL;
assert(link);
- r = json_dispatch(parameters, dispatch_table, 0, &name);
+ r = sd_json_dispatch(parameters, dispatch_table, 0, &name);
if (r < 0)
return r;
interface = hashmap_get(ASSERT_PTR(link->server)->interfaces, name);
if (!interface)
return varlink_errorb(link, VARLINK_ERROR_INTERFACE_NOT_FOUND,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("interface", name)));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("interface", name)));
r = varlink_idl_format(interface, &text);
if (r < 0)
return r;
return varlink_replyb(link,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("description", text)));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("description", text)));
}
static int varlink_dispatch_method(Varlink *v) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
VarlinkMethodFlags flags = 0;
const char *method = NULL;
- JsonVariant *e;
+ sd_json_variant *e;
VarlinkMethod callback;
const char *k;
int r;
if (!v->current)
return 0;
- if (!json_variant_is_object(v->current))
+ if (!sd_json_variant_is_object(v->current))
goto invalid;
JSON_VARIANT_OBJECT_FOREACH(k, e, v->current) {
if (streq(k, "method")) {
if (method)
goto invalid;
- if (!json_variant_is_string(e))
+ if (!sd_json_variant_is_string(e))
goto invalid;
- method = json_variant_string(e);
+ method = sd_json_variant_string(e);
} else if (streq(k, "parameters")) {
if (parameters)
goto invalid;
- if (!json_variant_is_object(e) && !json_variant_is_null(e))
+ if (!sd_json_variant_is_object(e) && !sd_json_variant_is_null(e))
goto invalid;
- parameters = json_variant_ref(e);
+ parameters = sd_json_variant_ref(e);
} else if (streq(k, "oneway")) {
if ((flags & (VARLINK_METHOD_ONEWAY|VARLINK_METHOD_MORE)) != 0)
goto invalid;
- if (!json_variant_is_boolean(e))
+ if (!sd_json_variant_is_boolean(e))
goto invalid;
- if (json_variant_boolean(e))
+ if (sd_json_variant_boolean(e))
flags |= VARLINK_METHOD_ONEWAY;
} else if (streq(k, "more")) {
if ((flags & (VARLINK_METHOD_ONEWAY|VARLINK_METHOD_MORE)) != 0)
goto invalid;
- if (!json_variant_is_boolean(e))
+ if (!sd_json_variant_is_boolean(e))
goto invalid;
- if (json_variant_boolean(e))
+ if (sd_json_variant_boolean(e))
flags |= VARLINK_METHOD_MORE;
} else
}
}
} else if (IN_SET(v->state, VARLINK_PROCESSING_METHOD, VARLINK_PROCESSING_METHOD_MORE)) {
- r = varlink_errorb(v, VARLINK_ERROR_METHOD_NOT_FOUND, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method))));
+ r = varlink_errorb(v, VARLINK_ERROR_METHOD_NOT_FOUND, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("method", SD_JSON_BUILD_STRING(method))));
if (r < 0)
return r;
}
return 0;
}
-int varlink_get_current_parameters(Varlink *v, JsonVariant **ret) {
- JsonVariant *p;
+int varlink_get_current_parameters(Varlink *v, sd_json_variant **ret) {
+ sd_json_variant *p;
assert_return(v, -EINVAL);
if (!v->current)
return -ENODATA;
- p = json_variant_by_key(v->current, "parameters");
+ p = sd_json_variant_by_key(v->current, "parameters");
if (!p)
return -ENODATA;
if (ret)
- *ret = json_variant_ref(p);
+ *ret = sd_json_variant_ref(p);
return 0;
}
return varlink_close_unref(v);
}
-static int varlink_format_json(Varlink *v, JsonVariant *m) {
+static int varlink_format_json(Varlink *v, sd_json_variant *m) {
_cleanup_(erase_and_freep) char *text = NULL;
int sz, r;
assert(v);
assert(m);
- sz = json_variant_format(m, /* flags= */ 0, &text);
+ sz = sd_json_variant_format(m, /* flags= */ 0, &text);
if (sz < 0)
return sz;
assert(text[sz] == '\0');
_cleanup_(erase_and_freep) char *censored_text = NULL;
/* Suppress sensitive fields in the debug output */
- r = json_variant_format(m, /* flags= */ JSON_FORMAT_CENSOR_SENSITIVE, &censored_text);
+ r = sd_json_variant_format(m, SD_JSON_FORMAT_CENSOR_SENSITIVE, &censored_text);
if (r < 0)
return r;
v->output_buffer_index = 0;
}
- if (json_variant_is_sensitive_recursive(m))
+ if (sd_json_variant_is_sensitive_recursive(m))
v->output_buffer_sensitive = true; /* Propagate sensitive flag */
else
text = mfree(text); /* No point in the erase_and_free() destructor declared above */
return 0;
}
-static int varlink_enqueue_json(Varlink *v, JsonVariant *m) {
+static int varlink_enqueue_json(Varlink *v, sd_json_variant *m) {
VarlinkJsonQueueItem *q;
assert(v);
return 0;
}
-int varlink_send(Varlink *v, const char *method, JsonVariant *parameters) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+int varlink_send(Varlink *v, const char *method, sd_json_variant *parameters) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
assert_return(v, -EINVAL);
if (r < 0)
return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
- r = json_build(&m, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method)),
- JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters)),
- JSON_BUILD_PAIR("oneway", JSON_BUILD_BOOLEAN(true))));
+ r = sd_json_build(&m, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("method", SD_JSON_BUILD_STRING(method)),
+ SD_JSON_BUILD_PAIR("parameters", SD_JSON_BUILD_VARIANT(parameters)),
+ SD_JSON_BUILD_PAIR("oneway", SD_JSON_BUILD_BOOLEAN(true))));
if (r < 0)
return varlink_log_errno(v, r, "Failed to build json message: %m");
}
int varlink_sendb(Varlink *v, const char *method, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
va_list ap;
int r;
assert_return(v, -EINVAL);
va_start(ap, method);
- r = json_buildv(¶meters, ap);
+ r = sd_json_buildv(¶meters, ap);
va_end(ap);
if (r < 0)
return varlink_send(v, method, parameters);
}
-int varlink_invoke(Varlink *v, const char *method, JsonVariant *parameters) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+int varlink_invoke(Varlink *v, const char *method, sd_json_variant *parameters) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
assert_return(v, -EINVAL);
if (r < 0)
return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
- r = json_build(&m, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method)),
- JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters))));
+ r = sd_json_build(&m, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("method", SD_JSON_BUILD_STRING(method)),
+ SD_JSON_BUILD_PAIR("parameters", SD_JSON_BUILD_VARIANT(parameters))));
if (r < 0)
return varlink_log_errno(v, r, "Failed to build json message: %m");
}
int varlink_invokeb(Varlink *v, const char *method, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
va_list ap;
int r;
assert_return(v, -EINVAL);
va_start(ap, method);
- r = json_buildv(¶meters, ap);
+ r = sd_json_buildv(¶meters, ap);
va_end(ap);
if (r < 0)
return varlink_invoke(v, method, parameters);
}
-int varlink_observe(Varlink *v, const char *method, JsonVariant *parameters) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+int varlink_observe(Varlink *v, const char *method, sd_json_variant *parameters) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
assert_return(v, -EINVAL);
if (r < 0)
return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
- r = json_build(&m, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method)),
- JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters)),
- JSON_BUILD_PAIR("more", JSON_BUILD_BOOLEAN(true))));
+ r = sd_json_build(&m, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("method", SD_JSON_BUILD_STRING(method)),
+ SD_JSON_BUILD_PAIR("parameters", SD_JSON_BUILD_VARIANT(parameters)),
+ SD_JSON_BUILD_PAIR("more", SD_JSON_BUILD_BOOLEAN(true))));
if (r < 0)
return varlink_log_errno(v, r, "Failed to build json message: %m");
}
int varlink_observeb(Varlink *v, const char *method, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
va_list ap;
int r;
assert_return(v, -EINVAL);
va_start(ap, method);
- r = json_buildv(¶meters, ap);
+ r = sd_json_buildv(¶meters, ap);
va_end(ap);
if (r < 0)
int varlink_call_full(
Varlink *v,
const char *method,
- JsonVariant *parameters,
- JsonVariant **ret_parameters,
+ sd_json_variant *parameters,
+ sd_json_variant **ret_parameters,
const char **ret_error_id,
VarlinkReplyFlags *ret_flags) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
assert_return(v, -EINVAL);
if (r < 0)
return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
- r = json_build(&m, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method)),
- JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters))));
+ r = sd_json_build(&m, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("method", SD_JSON_BUILD_STRING(method)),
+ SD_JSON_BUILD_PAIR("parameters", SD_JSON_BUILD_VARIANT(parameters))));
if (r < 0)
return varlink_log_errno(v, r, "Failed to build json message: %m");
assert(v->n_pending == 1);
v->n_pending--;
- JsonVariant *e = json_variant_by_key(v->current, "error"),
- *p = json_variant_by_key(v->current, "parameters");
+ sd_json_variant *e = sd_json_variant_by_key(v->current, "error"),
+ *p = sd_json_variant_by_key(v->current, "parameters");
/* If caller doesn't ask for the error string, then let's return an error code in case of failure */
if (!ret_error_id && e)
- return varlink_error_to_errno(json_variant_string(e), p);
+ return varlink_error_to_errno(sd_json_variant_string(e), p);
if (ret_parameters)
*ret_parameters = p;
if (ret_error_id)
- *ret_error_id = e ? json_variant_string(e) : NULL;
+ *ret_error_id = e ? sd_json_variant_string(e) : NULL;
if (ret_flags)
*ret_flags = v->current_reply_flags;
int varlink_callb_ap(
Varlink *v,
const char *method,
- JsonVariant **ret_parameters,
+ sd_json_variant **ret_parameters,
const char **ret_error_id,
VarlinkReplyFlags *ret_flags,
va_list ap) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
int r;
assert_return(v, -EINVAL);
assert_return(method, -EINVAL);
- r = json_buildv(¶meters, ap);
+ r = sd_json_buildv(¶meters, ap);
if (r < 0)
return varlink_log_errno(v, r, "Failed to build json message: %m");
int varlink_call_and_log(
Varlink *v,
const char *method,
- JsonVariant *parameters,
- JsonVariant **ret_parameters) {
+ sd_json_variant *parameters,
+ sd_json_variant **ret_parameters) {
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
const char *error_id = NULL;
int r;
int varlink_callb_and_log(
Varlink *v,
const char *method,
- JsonVariant **ret_parameters,
+ sd_json_variant **ret_parameters,
...) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
va_list ap;
int r;
assert_return(method, -EINVAL);
va_start(ap, ret_parameters);
- r = json_buildv(¶meters, ap);
+ r = sd_json_buildv(¶meters, ap);
va_end(ap);
if (r < 0)
return log_error_errno(r, "Failed to build JSON message: %m");
int varlink_collect_full(
Varlink *v,
const char *method,
- JsonVariant *parameters,
- JsonVariant **ret_parameters,
+ sd_json_variant *parameters,
+ sd_json_variant **ret_parameters,
const char **ret_error_id,
VarlinkReplyFlags *ret_flags) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL, *collected = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL, *collected = NULL;
int r;
assert_return(v, -EINVAL);
if (r < 0)
return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
- r = json_build(&m, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("method", JSON_BUILD_STRING(method)),
- JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters)),
- JSON_BUILD_PAIR("more", JSON_BUILD_BOOLEAN(true))));
+ r = sd_json_build(&m, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("method", SD_JSON_BUILD_STRING(method)),
+ SD_JSON_BUILD_PAIR("parameters", SD_JSON_BUILD_VARIANT(parameters)),
+ SD_JSON_BUILD_PAIR("more", SD_JSON_BUILD_BOOLEAN(true))));
if (r < 0)
return varlink_log_errno(v, r, "Failed to build json message: %m");
case VARLINK_COLLECTING_REPLY: {
assert(v->current);
- JsonVariant *e = json_variant_by_key(v->current, "error"),
- *p = json_variant_by_key(v->current, "parameters");
+ sd_json_variant *e = sd_json_variant_by_key(v->current, "error"),
+ *p = sd_json_variant_by_key(v->current, "parameters");
/* Unless there is more to collect we reset state to idle */
if (!FLAGS_SET(v->current_reply_flags, VARLINK_REPLY_CONTINUES)) {
if (e) {
if (!ret_error_id)
- return varlink_error_to_errno(json_variant_string(e), p);
+ return varlink_error_to_errno(sd_json_variant_string(e), p);
if (ret_parameters)
*ret_parameters = p;
if (ret_error_id)
- *ret_error_id = json_variant_string(e);
+ *ret_error_id = sd_json_variant_string(e);
if (ret_flags)
*ret_flags = v->current_reply_flags;
return 1;
}
- if (json_variant_elements(collected) >= VARLINK_COLLECT_MAX)
- return varlink_log_errno(v, SYNTHETIC_ERRNO(E2BIG), "Number of reply messages grew too large (%zu) while collecting.", json_variant_elements(collected));
+ if (sd_json_variant_elements(collected) >= VARLINK_COLLECT_MAX)
+ return varlink_log_errno(v, SYNTHETIC_ERRNO(E2BIG), "Number of reply messages grew too large (%zu) while collecting.", sd_json_variant_elements(collected));
- r = json_variant_append_array(&collected, p);
+ r = sd_json_variant_append_array(&collected, p);
if (r < 0)
return varlink_log_errno(v, r, "Failed to append JSON object to array: %m");
int varlink_collectb(
Varlink *v,
const char *method,
- JsonVariant **ret_parameters,
+ sd_json_variant **ret_parameters,
const char **ret_error_id,
...) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
va_list ap;
int r;
assert_return(v, -EINVAL);
va_start(ap, ret_error_id);
- r = json_buildv(¶meters, ap);
+ r = sd_json_buildv(¶meters, ap);
va_end(ap);
if (r < 0)
return varlink_collect_full(v, method, parameters, ret_parameters, ret_error_id, NULL);
}
-int varlink_reply(Varlink *v, JsonVariant *parameters) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+int varlink_reply(Varlink *v, sd_json_variant *parameters) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
assert_return(v, -EINVAL);
if (r < 0)
return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
- r = json_build(&m, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters))));
+ r = sd_json_build(&m, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("parameters", SD_JSON_BUILD_VARIANT(parameters))));
if (r < 0)
return varlink_log_errno(v, r, "Failed to build json message: %m");
}
int varlink_replyb(Varlink *v, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
va_list ap;
int r;
assert_return(v, -EINVAL);
va_start(ap, v);
- r = json_buildv(¶meters, ap);
+ r = sd_json_buildv(¶meters, ap);
va_end(ap);
if (r < 0)
return varlink_reply(v, parameters);
}
-int varlink_error(Varlink *v, const char *error_id, JsonVariant *parameters) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+int varlink_error(Varlink *v, const char *error_id, sd_json_variant *parameters) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
assert_return(v, -EINVAL);
if (r < 0)
return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
- r = json_build(&m, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("error", JSON_BUILD_STRING(error_id)),
- JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters))));
+ r = sd_json_build(&m, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("error", SD_JSON_BUILD_STRING(error_id)),
+ SD_JSON_BUILD_PAIR("parameters", SD_JSON_BUILD_VARIANT(parameters))));
if (r < 0)
return varlink_log_errno(v, r, "Failed to build json message: %m");
}
int varlink_errorb(Varlink *v, const char *error_id, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
va_list ap;
int r;
assert_return(error_id, -EINVAL);
va_start(ap, error_id);
- r = json_buildv(¶meters, ap);
+ r = sd_json_buildv(¶meters, ap);
va_end(ap);
if (r < 0)
return varlink_error(v, error_id, parameters);
}
-int varlink_error_invalid_parameter(Varlink *v, JsonVariant *parameters) {
+int varlink_error_invalid_parameter(Varlink *v, sd_json_variant *parameters) {
int r;
assert_return(v, -EINVAL);
/* varlink_error(...) expects a json object as the third parameter. Passing a string variant causes
* parameter sanitization to fail, and it returns -EINVAL. */
- if (json_variant_is_string(parameters)) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters_obj = NULL;
+ if (sd_json_variant_is_string(parameters)) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters_obj = NULL;
- r = json_build(¶meters_obj,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("parameter", JSON_BUILD_VARIANT(parameters))));
+ r = sd_json_build(¶meters_obj,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("parameter", SD_JSON_BUILD_VARIANT(parameters))));
if (r < 0)
return r;
return varlink_error(v, VARLINK_ERROR_INVALID_PARAMETER, parameters_obj);
}
- if (json_variant_is_object(parameters) &&
- json_variant_elements(parameters) > 0) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters_obj = NULL;
+ if (sd_json_variant_is_object(parameters) &&
+ sd_json_variant_elements(parameters) > 0) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters_obj = NULL;
- r = json_build(¶meters_obj,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("parameter", JSON_BUILD_VARIANT(json_variant_by_index(parameters, 0)))));
+ r = sd_json_build(¶meters_obj,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("parameter", SD_JSON_BUILD_VARIANT(sd_json_variant_by_index(parameters, 0)))));
if (r < 0)
return r;
return varlink_errorb(
v,
VARLINK_ERROR_INVALID_PARAMETER,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("parameter", JSON_BUILD_STRING(name))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("parameter", SD_JSON_BUILD_STRING(name))));
}
int varlink_error_errno(Varlink *v, int error) {
return varlink_errorb(
v,
VARLINK_ERROR_SYSTEM,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR("errno", JSON_BUILD_INTEGER(abs(error)))));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("errno", SD_JSON_BUILD_INTEGER(abs(error)))));
}
-int varlink_notify(Varlink *v, JsonVariant *parameters) {
- _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
+int varlink_notify(Varlink *v, sd_json_variant *parameters) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
int r;
assert_return(v, -EINVAL);
if (r < 0)
return varlink_log_errno(v, r, "Failed to sanitize parameters: %m");
- r = json_build(&m, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("parameters", JSON_BUILD_VARIANT(parameters)),
- JSON_BUILD_PAIR("continues", JSON_BUILD_BOOLEAN(true))));
+ r = sd_json_build(&m, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("parameters", SD_JSON_BUILD_VARIANT(parameters)),
+ SD_JSON_BUILD_PAIR("continues", SD_JSON_BUILD_BOOLEAN(true))));
if (r < 0)
return varlink_log_errno(v, r, "Failed to build json message: %m");
}
int varlink_notifyb(Varlink *v, ...) {
- _cleanup_(json_variant_unrefp) JsonVariant *parameters = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
va_list ap;
int r;
assert_return(v, -EINVAL);
va_start(ap, v);
- r = json_buildv(¶meters, ap);
+ r = sd_json_buildv(¶meters, ap);
va_end(ap);
if (r < 0)
return varlink_notify(v, parameters);
}
-int varlink_dispatch(Varlink *v, JsonVariant *parameters, const JsonDispatch table[], void *userdata) {
+int varlink_dispatch(Varlink *v, sd_json_variant *parameters, const sd_json_dispatch_field table[], void *userdata) {
const char *bad_field = NULL;
int r;
/* A wrapper around json_dispatch_full() that returns a nice InvalidParameter error if we hit a problem with some field. */
- r = json_dispatch_full(parameters, table, /* bad= */ NULL, /* flags= */ 0, userdata, &bad_field);
+ r = sd_json_dispatch_full(parameters, table, /* bad= */ NULL, /* flags= */ 0, userdata, &bad_field);
if (r < 0) {
if (bad_field)
return varlink_error_invalid_parameter_name(v, bad_field);
return true;
}
-int varlink_error_to_errno(const char *error, JsonVariant *parameters) {
+int varlink_error_to_errno(const char *error, sd_json_variant *parameters) {
static const struct {
const char *error;
int value;
return t->value;
if (streq(error, VARLINK_ERROR_SYSTEM) && parameters) {
- JsonVariant *e;
+ sd_json_variant *e;
- e = json_variant_by_key(parameters, "errno");
- if (json_variant_is_integer(e)) {
+ e = sd_json_variant_by_key(parameters, "errno");
+ if (sd_json_variant_is_integer(e)) {
int64_t i;
- i = json_variant_integer(e);
+ i = sd_json_variant_integer(e);
if (i > 0 && i < ERRNO_MAX)
return -i;
}
#include "sd-event.h"
-#include "json.h"
+#include "sd-json.h"
#include "pidref.h"
#include "time-util.h"
#include "varlink-idl.h"
_VARLINK_SERVER_FLAGS_ALL = (1 << 5) - 1,
} VarlinkServerFlags;
-typedef int (*VarlinkMethod)(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata);
-typedef int (*VarlinkReply)(Varlink *link, JsonVariant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata);
+typedef int (*VarlinkMethod)(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata);
+typedef int (*VarlinkReply)(Varlink *link, sd_json_variant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata);
typedef int (*VarlinkConnect)(VarlinkServer *server, Varlink *link, void *userdata);
typedef void (*VarlinkDisconnect)(VarlinkServer *server, Varlink *link, void *userdata);
Varlink* varlink_close_unref(Varlink *v);
/* Enqueue method call, not expecting a reply */
-int varlink_send(Varlink *v, const char *method, JsonVariant *parameters);
+int varlink_send(Varlink *v, const char *method, sd_json_variant *parameters);
int varlink_sendb(Varlink *v, const char *method, ...);
/* Send method call and wait for reply */
-int varlink_call_full(Varlink *v, const char *method, JsonVariant *parameters, JsonVariant **ret_parameters, const char **ret_error_id, VarlinkReplyFlags *ret_flags);
-static inline int varlink_call(Varlink *v, const char *method, JsonVariant *parameters, JsonVariant **ret_parameters, const char **ret_error_id) {
+int varlink_call_full(Varlink *v, const char *method, sd_json_variant *parameters, sd_json_variant **ret_parameters, const char **ret_error_id, VarlinkReplyFlags *ret_flags);
+static inline int varlink_call(Varlink *v, const char *method, sd_json_variant *parameters, sd_json_variant **ret_parameters, const char **ret_error_id) {
return varlink_call_full(v, method, parameters, ret_parameters, ret_error_id, NULL);
}
-int varlink_call_and_log(Varlink *v, const char *method, JsonVariant *parameters, JsonVariant **ret_parameters);
+int varlink_call_and_log(Varlink *v, const char *method, sd_json_variant *parameters, sd_json_variant **ret_parameters);
-int varlink_callb_ap(Varlink *v, const char *method, JsonVariant **ret_parameters, const char **ret_error_id, VarlinkReplyFlags *ret_flags, va_list ap);
-static inline int varlink_callb_full(Varlink *v, const char *method, JsonVariant **ret_parameters, const char **ret_error_id, VarlinkReplyFlags *ret_flags, ...) {
+int varlink_callb_ap(Varlink *v, const char *method, sd_json_variant **ret_parameters, const char **ret_error_id, VarlinkReplyFlags *ret_flags, va_list ap);
+static inline int varlink_callb_full(Varlink *v, const char *method, sd_json_variant **ret_parameters, const char **ret_error_id, VarlinkReplyFlags *ret_flags, ...) {
va_list ap;
int r;
va_end(ap);
return r;
}
-static inline int varlink_callb(Varlink *v, const char *method, JsonVariant **ret_parameters, const char **ret_error_id, ...) {
+static inline int varlink_callb(Varlink *v, const char *method, sd_json_variant **ret_parameters, const char **ret_error_id, ...) {
va_list ap;
int r;
va_end(ap);
return r;
}
-int varlink_callb_and_log(Varlink *v, const char *method, JsonVariant **ret_parameters, ...);
+int varlink_callb_and_log(Varlink *v, const char *method, sd_json_variant **ret_parameters, ...);
/* Send method call and begin collecting all 'more' replies into an array, finishing when a final reply is sent */
-int varlink_collect_full(Varlink *v, const char *method, JsonVariant *parameters, JsonVariant **ret_parameters, const char **ret_error_id, VarlinkReplyFlags *ret_flags);
-static inline int varlink_collect(Varlink *v, const char *method, JsonVariant *parameters, JsonVariant **ret_parameters, const char **ret_error_id) {
+int varlink_collect_full(Varlink *v, const char *method, sd_json_variant *parameters, sd_json_variant **ret_parameters, const char **ret_error_id, VarlinkReplyFlags *ret_flags);
+static inline int varlink_collect(Varlink *v, const char *method, sd_json_variant *parameters, sd_json_variant **ret_parameters, const char **ret_error_id) {
return varlink_collect_full(v, method, parameters, ret_parameters, ret_error_id, NULL);
}
-int varlink_collectb(Varlink *v, const char *method, JsonVariant **ret_parameters, const char **ret_error_id, ...);
+int varlink_collectb(Varlink *v, const char *method, sd_json_variant **ret_parameters, const char **ret_error_id, ...);
/* Enqueue method call, expect a reply, which is eventually delivered to the reply callback */
-int varlink_invoke(Varlink *v, const char *method, JsonVariant *parameters);
+int varlink_invoke(Varlink *v, const char *method, sd_json_variant *parameters);
int varlink_invokeb(Varlink *v, const char *method, ...);
/* Enqueue method call, expect a reply now, and possibly more later, which are all delivered to the reply callback */
-int varlink_observe(Varlink *v, const char *method, JsonVariant *parameters);
+int varlink_observe(Varlink *v, const char *method, sd_json_variant *parameters);
int varlink_observeb(Varlink *v, const char *method, ...);
/* Enqueue a final reply */
-int varlink_reply(Varlink *v, JsonVariant *parameters);
+int varlink_reply(Varlink *v, sd_json_variant *parameters);
int varlink_replyb(Varlink *v, ...);
/* Enqueue a (final) error */
-int varlink_error(Varlink *v, const char *error_id, JsonVariant *parameters);
+int varlink_error(Varlink *v, const char *error_id, sd_json_variant *parameters);
int varlink_errorb(Varlink *v, const char *error_id, ...);
-int varlink_error_invalid_parameter(Varlink *v, JsonVariant *parameters);
+int varlink_error_invalid_parameter(Varlink *v, sd_json_variant *parameters);
int varlink_error_invalid_parameter_name(Varlink *v, const char *name);
int varlink_error_errno(Varlink *v, int error);
/* Enqueue a "more" reply */
-int varlink_notify(Varlink *v, JsonVariant *parameters);
+int varlink_notify(Varlink *v, sd_json_variant *parameters);
int varlink_notifyb(Varlink *v, ...);
/* Ask for the current message to be dispatched again */
int varlink_dispatch_again(Varlink *v);
/* Get the currently processed incoming message */
-int varlink_get_current_parameters(Varlink *v, JsonVariant **ret);
+int varlink_get_current_parameters(Varlink *v, sd_json_variant **ret);
/* Parsing incoming data via json_dispatch() and generate a nice error on parse errors */
-int varlink_dispatch(Varlink *v, JsonVariant *parameters, const JsonDispatch table[], void *userdata);
+int varlink_dispatch(Varlink *v, sd_json_variant *parameters, const sd_json_dispatch_field table[], void *userdata);
/* Write outgoing fds into the socket (to be associated with the next enqueued message) */
int varlink_push_fd(Varlink *v, int fd);
int varlink_invocation(VarlinkInvocationFlags flags);
-int varlink_error_to_errno(const char *error, JsonVariant *parameters);
+int varlink_error_to_errno(const char *error, sd_json_variant *parameters);
DEFINE_TRIVIAL_CLEANUP_FUNC(Varlink *, varlink_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(Varlink *, varlink_close_unref);
#include "sd-bus.h"
#include "sd-device.h"
#include "sd-id128.h"
+#include "sd-json.h"
#include "sd-messages.h"
#include "battery-capacity.h"
#include "hibernate-util.h"
#include "id128-util.h"
#include "io-util.h"
-#include "json.h"
#include "log.h"
#include "main-func.h"
#include "os-util.h"
int log_level = required ? LOG_ERR : LOG_DEBUG;
#if ENABLE_EFI
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_free_ char *formatted = NULL, *id = NULL, *image_id = NULL,
*version_id = NULL, *image_version = NULL;
_cleanup_(sd_device_unrefp) sd_device *device = NULL;
if (r < 0)
log_full_errno(log_level_ignore, r, "Failed to parse os-release, ignoring: %m");
- r = json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UUID("uuid", uuid),
- JSON_BUILD_PAIR_UNSIGNED("offset", hibernation_device->offset),
- JSON_BUILD_PAIR_CONDITION(!isempty(uts.release), "kernelVersion", JSON_BUILD_STRING(uts.release)),
- JSON_BUILD_PAIR_CONDITION(id, "osReleaseId", JSON_BUILD_STRING(id)),
- JSON_BUILD_PAIR_CONDITION(image_id, "osReleaseImageId", JSON_BUILD_STRING(image_id)),
- JSON_BUILD_PAIR_CONDITION(version_id, "osReleaseVersionId", JSON_BUILD_STRING(version_id)),
- JSON_BUILD_PAIR_CONDITION(image_version, "osReleaseImageVersion", JSON_BUILD_STRING(image_version))));
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UUID("uuid", uuid),
+ SD_JSON_BUILD_PAIR_UNSIGNED("offset", hibernation_device->offset),
+ SD_JSON_BUILD_PAIR_CONDITION(!isempty(uts.release), "kernelVersion", SD_JSON_BUILD_STRING(uts.release)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!id, "osReleaseId", SD_JSON_BUILD_STRING(id)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!image_id, "osReleaseImageId", SD_JSON_BUILD_STRING(image_id)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!version_id, "osReleaseVersionId", SD_JSON_BUILD_STRING(version_id)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!image_version, "osReleaseImageVersion", SD_JSON_BUILD_STRING(image_version))));
if (r < 0)
return log_full_errno(log_level, r, "Failed to build JSON object: %m");
- r = json_variant_format(v, 0, &formatted);
+ r = sd_json_variant_format(v, 0, &formatted);
if (r < 0)
return log_full_errno(log_level, r, "Failed to format JSON object: %m");
static char **arg_hierarchies = NULL; /* "/usr" + "/opt" by default for sysext and /etc by default for confext */
static char *arg_root = NULL;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static bool arg_legend = true;
static bool arg_force = false;
int no_reload;
} MethodUnmergeParameters;
-static int vl_method_unmerge(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_unmerge(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "class", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(MethodUnmergeParameters, class), 0 },
- { "noReload", JSON_VARIANT_BOOLEAN, json_dispatch_boolean, offsetof(MethodUnmergeParameters, no_reload), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "class", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MethodUnmergeParameters, class), 0 },
+ { "noReload", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, offsetof(MethodUnmergeParameters, no_reload), 0 },
{}
};
MethodUnmergeParameters p = {
int noexec;
} MethodMergeParameters;
-static int parse_merge_parameters(Varlink *link, JsonVariant *parameters, MethodMergeParameters *p) {
+static int parse_merge_parameters(Varlink *link, sd_json_variant *parameters, MethodMergeParameters *p) {
- static const JsonDispatch dispatch_table[] = {
- { "class", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(MethodMergeParameters, class), 0 },
- { "force", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(MethodMergeParameters, force), 0 },
- { "noReload", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(MethodMergeParameters, no_reload), 0 },
- { "noexec", JSON_VARIANT_BOOLEAN, json_dispatch_tristate, offsetof(MethodMergeParameters, noexec), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "class", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MethodMergeParameters, class), 0 },
+ { "force", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(MethodMergeParameters, force), 0 },
+ { "noReload", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(MethodMergeParameters, no_reload), 0 },
+ { "noexec", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_tristate, offsetof(MethodMergeParameters, noexec), 0 },
{}
};
return varlink_dispatch(link, parameters, dispatch_table, p);
}
-static int vl_method_merge(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_merge(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
_cleanup_hashmap_free_ Hashmap *images = NULL;
MethodMergeParameters p = {
.force = -1,
if (r < 0)
return r;
if (r > 0)
- return varlink_errorb(link, "io.systemd.sysext.AlreadyMerged", JSON_BUILD_OBJECT(JSON_BUILD_PAIR_STRING("hierarchy", which)));
+ return varlink_errorb(link, "io.systemd.sysext.AlreadyMerged", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_STRING("hierarchy", which)));
r = merge(image_class,
hierarchies ?: arg_hierarchies,
arg_noexec);
}
-static int vl_method_refresh(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_refresh(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
MethodMergeParameters p = {
.force = -1,
if (r < 0)
return log_error_errno(r, "Failed to discover images: %m");
- if ((arg_json_format_flags & JSON_FORMAT_OFF) && hashmap_isempty(images)) {
+ if ((arg_json_format_flags & SD_JSON_FORMAT_OFF) && hashmap_isempty(images)) {
log_info("No OS extensions found.");
return 0;
}
const char *class;
} MethodListParameters;
-static int vl_method_list(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_list(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "class", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(MethodListParameters, class), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "class", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(MethodListParameters, class), 0 },
{}
};
MethodListParameters p = {
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_hashmap_free_ Hashmap *images = NULL;
ImageClass image_class = arg_image_class;
Image *img;
return r;
}
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
r = image_to_json(img, &v);
if (r < 0)
#include "systemctl-util.h"
#include "systemctl.h"
-static int json_transform_message(sd_bus_message *m, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+static int json_transform_message(sd_bus_message *m, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
const char *text;
int r;
sep++;
- r = json_variant_set_field_string(&v, n, sep);
+ r = sd_json_variant_set_field_string(&v, n, sep);
if (r < 0)
return log_error_errno(r, "Failed to set JSON field '%s' to '%s': %m", n, sep);
}
return bus_log_parse_error(r);
if (OUTPUT_MODE_IS_JSON(arg_output)) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = json_transform_message(reply, &v);
if (r < 0)
return r;
- json_variant_dump(v, output_mode_to_json_format_flags(arg_output), stdout, NULL);
+ sd_json_variant_dump(v, output_mode_to_json_format_flags(arg_output), stdout, NULL);
} else {
while ((r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &text)) > 0) {
r = print_variable(text);
assert(table);
if (OUTPUT_MODE_IS_JSON(arg_output))
- r = table_print_json(table, NULL, output_mode_to_json_format_flags(arg_output) | JSON_FORMAT_COLOR_AUTO);
+ r = table_print_json(table, NULL, output_mode_to_json_format_flags(arg_output) | SD_JSON_FORMAT_COLOR_AUTO);
else
r = table_print(table, NULL);
if (r < 0)
'sd-hwdb.h',
'sd-id128.h',
'sd-journal.h',
+ 'sd-json.h',
'sd-login.h',
'sd-messages.h',
'sd-path.h',
--- /dev/null
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#ifndef foosdjsonhfoo
+#define foosdjsonhfoo
+
+/***
+ systemd is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ systemd is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with systemd; If not, see <https://www.gnu.org/licenses/>.
+***/
+
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#include "sd-id128.h"
+
+#include "_sd-common.h"
+
+_SD_BEGIN_DECLARATIONS;
+
+/*
+ In case you wonder why we have our own JSON implementation, here are a couple of reasons why this implementation has
+ benefits over various other implementations:
+
+ - We need support for 64-bit signed and unsigned integers, i.e. the full 64,5bit range of -9223372036854775808…18446744073709551615
+ - All our variants are immutable after creation
+ - Special values such as true, false, zero, null, empty strings, empty array, empty objects require zero dynamic memory
+ - Progressive parsing
+ - Our integer/real type implicitly converts, but only if that's safe and loss-lessly possible
+ - There's a "builder" for putting together objects easily in varargs function calls
+ - There's a "dispatcher" for mapping objects to C data structures
+ - Every variant optionally carries parsing location information, which simplifies debugging and parse log error generation
+ - Formatter has color, line, column support
+
+ Limitations:
+ - Doesn't allow embedded NUL in strings
+ - Can't store integers outside of the -9223372036854775808…18446744073709551615 range (it will use 'double' for
+ values outside this range, which is lossy)
+ - Can't store negative zero (will be treated identical to positive zero, and not retained across serialization)
+ - Can't store non-integer numbers that can't be stored in "double" losslessly
+ - Allows creation and parsing of objects with duplicate keys. The "dispatcher" will refuse them however. This means
+ we can parse and pass around such objects, but will carefully refuse them when we convert them into our own data.
+
+ (These limitations should be pretty much in line with those of other JSON implementations, in fact might be less
+ limiting in most cases even.)
+*/
+
+typedef struct sd_json_variant sd_json_variant;
+
+__extension__ typedef enum sd_json_variant_type_t {
+ SD_JSON_VARIANT_STRING,
+ SD_JSON_VARIANT_INTEGER,
+ SD_JSON_VARIANT_UNSIGNED,
+ SD_JSON_VARIANT_REAL,
+ SD_JSON_VARIANT_NUMBER, /* This a pseudo-type: we can never create variants of this type, but we use it as wildcard check for the above three types */
+ SD_JSON_VARIANT_BOOLEAN,
+ SD_JSON_VARIANT_ARRAY,
+ SD_JSON_VARIANT_OBJECT,
+ SD_JSON_VARIANT_NULL,
+ _SD_JSON_VARIANT_TYPE_MAX,
+ _SD_JSON_VARIANT_TYPE_INVALID = -EINVAL,
+ _SD_ENUM_FORCE_S64(JSON_VARIANT_TYPE)
+} sd_json_variant_type_t;
+
+int sd_json_variant_new_string(sd_json_variant **ret, const char *s);
+int sd_json_variant_new_stringn(sd_json_variant **ret, const char *s, size_t n);
+int sd_json_variant_new_base64(sd_json_variant **ret, const void *p, size_t n);
+int sd_json_variant_new_base32hex(sd_json_variant **ret, const void *p, size_t n);
+int sd_json_variant_new_hex(sd_json_variant **ret, const void *p, size_t n);
+int sd_json_variant_new_octescape(sd_json_variant **ret, const void *p, size_t n);
+int sd_json_variant_new_integer(sd_json_variant **ret, int64_t i);
+int sd_json_variant_new_unsigned(sd_json_variant **ret, uint64_t u);
+int sd_json_variant_new_real(sd_json_variant **ret, double d);
+int sd_json_variant_new_boolean(sd_json_variant **ret, int b);
+int sd_json_variant_new_array(sd_json_variant **ret, sd_json_variant **array, size_t n);
+int sd_json_variant_new_array_bytes(sd_json_variant **ret, const void *p, size_t n);
+int sd_json_variant_new_array_strv(sd_json_variant **ret, char **l);
+int sd_json_variant_new_object(sd_json_variant **ret, sd_json_variant **array, size_t n);
+int sd_json_variant_new_null(sd_json_variant **ret);
+int sd_json_variant_new_id128(sd_json_variant **ret, sd_id128_t id);
+int sd_json_variant_new_uuid(sd_json_variant **ret, sd_id128_t id);
+
+sd_json_variant* sd_json_variant_ref(sd_json_variant *v);
+sd_json_variant* sd_json_variant_unref(sd_json_variant *v);
+void sd_json_variant_unref_many(sd_json_variant **array, size_t n);
+
+_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_json_variant, sd_json_variant_unref);
+
+const char *sd_json_variant_string(sd_json_variant *v);
+int64_t sd_json_variant_integer(sd_json_variant *v);
+uint64_t sd_json_variant_unsigned(sd_json_variant *v);
+double sd_json_variant_real(sd_json_variant *v);
+int sd_json_variant_boolean(sd_json_variant *v);
+
+sd_json_variant_type_t sd_json_variant_type(sd_json_variant *v);
+int sd_json_variant_has_type(sd_json_variant *v, sd_json_variant_type_t type);
+
+int sd_json_variant_is_string(sd_json_variant *v);
+int sd_json_variant_is_integer(sd_json_variant *v);
+int sd_json_variant_is_unsigned(sd_json_variant *v);
+int sd_json_variant_is_real(sd_json_variant *v);
+int sd_json_variant_is_number(sd_json_variant *v);
+int sd_json_variant_is_boolean(sd_json_variant *v);
+int sd_json_variant_is_array(sd_json_variant *v);
+int sd_json_variant_is_object(sd_json_variant *v);
+int sd_json_variant_is_null(sd_json_variant *v);
+
+int sd_json_variant_is_negative(sd_json_variant *v);
+int sd_json_variant_is_blank_object(sd_json_variant *v);
+int sd_json_variant_is_blank_array(sd_json_variant *v);
+int sd_json_variant_is_normalized(sd_json_variant *v);
+int sd_json_variant_is_sorted(sd_json_variant *v);
+
+size_t sd_json_variant_elements(sd_json_variant *v);
+sd_json_variant* sd_json_variant_by_index(sd_json_variant *v, size_t index);
+sd_json_variant* sd_json_variant_by_key(sd_json_variant *v, const char *key);
+sd_json_variant* sd_json_variant_by_key_full(sd_json_variant *v, const char *key, sd_json_variant **ret_key);
+
+int sd_json_variant_equal(sd_json_variant *a, sd_json_variant *b);
+
+void sd_json_variant_sensitive(sd_json_variant *v);
+int sd_json_variant_is_sensitive(sd_json_variant *v);
+int sd_json_variant_is_sensitive_recursive(sd_json_variant *v);
+
+int sd_json_variant_get_source(sd_json_variant *v, const char **ret_source, unsigned *ret_line, unsigned *reterr_column);
+
+__extension__ typedef enum sd_json_format_flags_t {
+ SD_JSON_FORMAT_NEWLINE = 1 << 0, /* suffix with newline */
+ SD_JSON_FORMAT_PRETTY = 1 << 1, /* add internal whitespace to appeal to human readers */
+ SD_JSON_FORMAT_PRETTY_AUTO = 1 << 2, /* same, but only if connected to a tty (and JSON_FORMAT_NEWLINE otherwise) */
+ SD_JSON_FORMAT_COLOR = 1 << 3, /* insert ANSI color sequences */
+ SD_JSON_FORMAT_COLOR_AUTO = 1 << 4, /* insert ANSI color sequences if colors_enabled() says so */
+ SD_JSON_FORMAT_SOURCE = 1 << 5, /* prefix with source filename/line/column */
+ SD_JSON_FORMAT_SSE = 1 << 6, /* prefix/suffix with W3C server-sent events */
+ SD_JSON_FORMAT_SEQ = 1 << 7, /* prefix/suffix with RFC 7464 application/json-seq */
+ SD_JSON_FORMAT_FLUSH = 1 << 8, /* call fflush() after dumping JSON */
+ SD_JSON_FORMAT_EMPTY_ARRAY = 1 << 9, /* output "[]" for empty input */
+ SD_JSON_FORMAT_OFF = 1 << 10, /* make json_variant_format() fail with -ENOEXEC */
+ SD_JSON_FORMAT_CENSOR_SENSITIVE = 1 << 11, /* Replace all sensitive elements with the string "<sensitive data>" */
+ _SD_ENUM_FORCE_S64(JSON_FORMAT_FLAGS)
+} sd_json_format_flags_t;
+
+int sd_json_variant_format(sd_json_variant *v, sd_json_format_flags_t flags, char **ret);
+int sd_json_variant_dump(sd_json_variant *v, sd_json_format_flags_t flags, FILE *f, const char *prefix);
+
+int sd_json_variant_filter(sd_json_variant **v, char **to_remove);
+
+int sd_json_variant_set_field(sd_json_variant **v, const char *field, sd_json_variant *value);
+int sd_json_variant_set_fieldb(sd_json_variant **v, const char *field, ...);
+int sd_json_variant_set_field_string(sd_json_variant **v, const char *field, const char *value);
+int sd_json_variant_set_field_integer(sd_json_variant **v, const char *field, int64_t value);
+int sd_json_variant_set_field_unsigned(sd_json_variant **v, const char *field, uint64_t value);
+int sd_json_variant_set_field_boolean(sd_json_variant **v, const char *field, int b);
+int sd_json_variant_set_field_strv(sd_json_variant **v, const char *field, char **l);
+
+sd_json_variant* sd_json_variant_find(sd_json_variant *haystack, sd_json_variant *needle);
+
+int sd_json_variant_append_array(sd_json_variant **v, sd_json_variant *element);
+int sd_json_variant_append_arrayb(sd_json_variant **v, ...);
+int sd_json_variant_append_array_nodup(sd_json_variant **v, sd_json_variant *element);
+
+int sd_json_variant_merge_object(sd_json_variant **v, sd_json_variant *m);
+int sd_json_variant_merge_objectb(sd_json_variant **v, ...);
+
+int sd_json_variant_sort(sd_json_variant **v);
+int sd_json_variant_normalize(sd_json_variant **v);
+
+__extension__ typedef enum sd_json_parse_flags_t {
+ SD_JSON_PARSE_SENSITIVE = 1 << 0, /* mark variant as "sensitive", i.e. something containing secret key material or such */
+ _SD_ENUM_FORCE_S64(JSON_PARSE_FLAGS)
+} sd_json_parse_flags_t;
+
+int sd_json_parse_with_source(const char *string, const char *source, sd_json_parse_flags_t flags, sd_json_variant **ret, unsigned *reterr_line, unsigned *reterr_column);
+int sd_json_parse_with_source_continue(const char **p, const char *source, sd_json_parse_flags_t flags, sd_json_variant **ret, unsigned *reterr_line, unsigned *reterr_column);
+int sd_json_parse(const char *string, sd_json_parse_flags_t flags, sd_json_variant **ret, unsigned *reterr_line, unsigned *reterr_column);
+int sd_json_parse_continue(const char **p, sd_json_parse_flags_t flags, sd_json_variant **ret, unsigned *reterr_line, unsigned *reterr_column);
+int sd_json_parse_file_at(FILE *f, int dir_fd, const char *path, sd_json_parse_flags_t flags, sd_json_variant **ret, unsigned *reterr_line, unsigned *reterr_column);
+int sd_json_parse_file(FILE *f, const char *path, sd_json_parse_flags_t flags, sd_json_variant **ret, unsigned *reterr_line, unsigned *reterr_column);
+
+enum {
+ _SD_JSON_BUILD_STRING,
+ _SD_JSON_BUILD_INTEGER,
+ _SD_JSON_BUILD_UNSIGNED,
+ _SD_JSON_BUILD_REAL,
+ _SD_JSON_BUILD_BOOLEAN,
+ _SD_JSON_BUILD_ARRAY_BEGIN,
+ _SD_JSON_BUILD_ARRAY_END,
+ _SD_JSON_BUILD_OBJECT_BEGIN,
+ _SD_JSON_BUILD_OBJECT_END,
+ _SD_JSON_BUILD_PAIR,
+ _SD_JSON_BUILD_PAIR_CONDITION,
+ _SD_JSON_BUILD_NULL,
+ _SD_JSON_BUILD_VARIANT,
+ _SD_JSON_BUILD_VARIANT_ARRAY,
+ _SD_JSON_BUILD_LITERAL,
+ _SD_JSON_BUILD_STRV,
+ _SD_JSON_BUILD_BASE64,
+ _SD_JSON_BUILD_BASE32HEX,
+ _SD_JSON_BUILD_HEX,
+ _SD_JSON_BUILD_OCTESCAPE,
+ _SD_JSON_BUILD_BYTE_ARRAY,
+ _SD_JSON_BUILD_ID128,
+ _SD_JSON_BUILD_UUID,
+ _SD_JSON_BUILD_CALLBACK,
+ _SD_JSON_BUILD_MAX
+};
+
+typedef int (*sd_json_build_callback_t)(sd_json_variant **ret, const char *name, void *userdata);
+
+#define SD_JSON_BUILD_STRING(s) _SD_JSON_BUILD_STRING, (const char*) { s }
+#define SD_JSON_BUILD_INTEGER(i) _SD_JSON_BUILD_INTEGER, (int64_t) { i }
+#define SD_JSON_BUILD_UNSIGNED(u) _SD_JSON_BUILD_UNSIGNED, (uint64_t) { u }
+#define SD_JSON_BUILD_REAL(d) _SD_JSON_BUILD_REAL, (double) { d }
+#define SD_JSON_BUILD_BOOLEAN(b) _SD_JSON_BUILD_BOOLEAN, (int) { b }
+#define SD_JSON_BUILD_ARRAY(...) _SD_JSON_BUILD_ARRAY_BEGIN, __VA_ARGS__, _SD_JSON_BUILD_ARRAY_END
+#define SD_JSON_BUILD_EMPTY_ARRAY _SD_JSON_BUILD_ARRAY_BEGIN, _SD_JSON_BUILD_ARRAY_END
+#define SD_JSON_BUILD_OBJECT(...) _SD_JSON_BUILD_OBJECT_BEGIN, __VA_ARGS__, _SD_JSON_BUILD_OBJECT_END
+#define SD_JSON_BUILD_EMPTY_OBJECT _SD_JSON_BUILD_OBJECT_BEGIN, _SD_JSON_BUILD_OBJECT_END
+#define SD_JSON_BUILD_PAIR(n, ...) _SD_JSON_BUILD_PAIR, (const char*) { n }, __VA_ARGS__
+#define SD_JSON_BUILD_PAIR_CONDITION(c, n, ...) _SD_JSON_BUILD_PAIR_CONDITION, (int) { c }, (const char*) { n }, __VA_ARGS__
+#define SD_JSON_BUILD_NULL _SD_JSON_BUILD_NULL
+#define SD_JSON_BUILD_VARIANT(v) _SD_JSON_BUILD_VARIANT, (sd_json_variant*) { v }
+#define SD_JSON_BUILD_VARIANT_ARRAY(v, n) _SD_JSON_BUILD_VARIANT_ARRAY, (sd_json_variant **) { v }, (size_t) { n }
+#define SD_JSON_BUILD_LITERAL(l) _SD_JSON_BUILD_LITERAL, (const char*) { l }
+#define SD_JSON_BUILD_STRV(l) _SD_JSON_BUILD_STRV, (char**) { l }
+#define SD_JSON_BUILD_BASE64(p, n) _SD_JSON_BUILD_BASE64, (const void*) { p }, (size_t) { n }
+#define SD_JSON_BUILD_BASE32HEX(p, n) _SD_JSON_BUILD_BASE32HEX, (const void*) { p }, (size_t) { n }
+#define SD_JSON_BUILD_HEX(p, n) _SD_JSON_BUILD_HEX, (const void*) { p }, (size_t) { n }
+#define SD_JSON_BUILD_OCTESCAPE(p, n) _SD_JSON_BUILD_OCTESCAPE, (const void*) { p }, (size_t) { n }
+#define SD_JSON_BUILD_BYTE_ARRAY(v, n) _SD_JSON_BUILD_BYTE_ARRAY, (const void*) { v }, (size_t) { n }
+#define SD_JSON_BUILD_ID128(id) _SD_JSON_BUILD_ID128, (const sd_id128_t*) { &(id) }
+#define SD_JSON_BUILD_UUID(id) _SD_JSON_BUILD_UUID, (const sd_id128_t*) { &(id) }
+#define SD_JSON_BUILD_CALLBACK(c, u) _SD_JSON_BUILD_CALLBACK, (sd_json_build_callback_t) { c }, (void*) { u }
+
+#define SD_JSON_BUILD_PAIR_STRING(name, s) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_STRING(s))
+#define SD_JSON_BUILD_PAIR_INTEGER(name, i) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_INTEGER(i))
+#define SD_JSON_BUILD_PAIR_UNSIGNED(name, u) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_UNSIGNED(u))
+#define SD_JSON_BUILD_PAIR_REAL(name, d) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_REAL(d))
+#define SD_JSON_BUILD_PAIR_BOOLEAN(name, b) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_BOOLEAN(b))
+#define SD_JSON_BUILD_PAIR_ARRAY(name, ...) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_ARRAY(__VA_ARGS__))
+#define SD_JSON_BUILD_PAIR_EMPTY_ARRAY(name) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_EMPTY_ARRAY)
+#define SD_JSON_BUILD_PAIR_OBJECT(name, ...) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_OBJECT(__VA_ARGS__))
+#define SD_JSON_BUILD_PAIR_EMPTY_OBJECT(name) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_EMPTY_OBJECT)
+#define SD_JSON_BUILD_PAIR_NULL(name) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_NULL)
+#define SD_JSON_BUILD_PAIR_VARIANT(name, v) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_VARIANT(v))
+#define SD_JSON_BUILD_PAIR_VARIANT_ARRAY(name, v, n) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_VARIANT_ARRAY(v, n))
+#define SD_JSON_BUILD_PAIR_LITERAL(name, l) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_LITERAL(l))
+#define SD_JSON_BUILD_PAIR_STRV(name, l) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_STRV(l))
+#define SD_JSON_BUILD_PAIR_BASE64(name, p, n) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_BASE64(p, n))
+#define SD_JSON_BUILD_PAIR_BASE32HEX(name, p, n) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_BASE32HEX(p, n))
+#define SD_JSON_BUILD_PAIR_HEX(name, p, n) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_HEX(p, n))
+#define SD_JSON_BUILD_PAIR_OCTESCAPE(name, p, n) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_OCTESCAPE(p, n))
+#define SD_JSON_BUILD_PAIR_BYTE_ARRAY(name, v, n) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_BYTE_ARRAY(v, n))
+#define SD_JSON_BUILD_PAIR_ID128(name, id) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_ID128(id))
+#define SD_JSON_BUILD_PAIR_UUID(name, id) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_UUID(id))
+#define SD_JSON_BUILD_PAIR_CALLBACK(name, c, u) SD_JSON_BUILD_PAIR(name, SD_JSON_BUILD_CALLBACK(c, u))
+
+int sd_json_build(sd_json_variant **ret, ...);
+int sd_json_buildv(sd_json_variant **ret, va_list ap);
+
+/* A bitmask of flags used by the dispatch logic. Note that this is a combined bit mask, that is generated from the bit
+ * mask originally passed into json_dispatch(), the individual bitmask associated with the static sd_json_dispatch callout
+ * entry, as well the bitmask specified for json_log() calls */
+typedef enum sd_json_dispatch_flags_t {
+ /* The following three may be set in sd_json_dispatch's .flags field or the json_dispatch() flags parameter */
+ SD_JSON_PERMISSIVE = 1 << 0, /* Shall parsing errors be considered fatal for this field or object? */
+ SD_JSON_MANDATORY = 1 << 1, /* Should existence of this property be mandatory? */
+ SD_JSON_LOG = 1 << 2, /* Should the parser log about errors? */
+ SD_JSON_SAFE = 1 << 3, /* Don't accept "unsafe" strings in json_dispatch_string() + json_dispatch_string() */
+ SD_JSON_RELAX = 1 << 4, /* Use relaxed user name checking in json_dispatch_user_group_name */
+ SD_JSON_ALLOW_EXTENSIONS = 1 << 5, /* Subset of JSON_PERMISSIVE: allow additional fields, but no other permissive handling */
+
+ /* The following two may be passed into log_json() in addition to those above */
+ SD_JSON_DEBUG = 1 << 6, /* Indicates that this log message is a debug message */
+ SD_JSON_WARNING = 1 << 7 /* Indicates that this log message is a warning message */
+} sd_json_dispatch_flags_t;
+
+typedef int (*sd_json_dispatch_callback_t)(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+
+typedef struct sd_json_dispatch_field {
+ const char *name;
+ sd_json_variant_type_t type;
+ sd_json_dispatch_callback_t callback;
+ size_t offset;
+ sd_json_dispatch_flags_t flags;
+} sd_json_dispatch_field;
+
+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);
+int sd_json_dispatch(sd_json_variant *v, const sd_json_dispatch_field table[], sd_json_dispatch_flags_t flags, void *userdata);
+
+int sd_json_dispatch_string(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_const_string(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_strv(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_stdbool(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_intbool(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_tristate(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_variant(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_variant_noref(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_int64(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_uint64(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_uint32(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_int32(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_uint16(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_int16(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_int8(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_uint8(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_uid_gid(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_id128(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+int sd_json_dispatch_unsupported(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata);
+
+#define sd_json_dispatch_uint sd_json_dispatch_uint32
+#define sd_json_dispatch_int sd_json_dispatch_int32
+
+int sd_json_variant_strv(sd_json_variant *v, char ***ret);
+int sd_json_variant_unbase64(sd_json_variant *v, void **ret, size_t *ret_size);
+int sd_json_variant_unhex(sd_json_variant *v, void **ret, size_t *ret_size);
+
+const char *sd_json_variant_type_to_string(sd_json_variant_type_t t);
+sd_json_variant_type_t sd_json_variant_type_from_string(const char *s);
+
+_SD_END_DECLARATIONS;
+
+#endif
static char *arg_definitions = NULL;
bool arg_sync = true;
uint64_t arg_instances_max = UINT64_MAX;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static bool arg_legend = true;
char *arg_root = NULL;
if (!us)
return log_error_errno(SYNTHETIC_ERRNO(ENOENT), "Update '%s' not found.", version);
- if (arg_json_format_flags & (JSON_FORMAT_OFF|JSON_FORMAT_PRETTY|JSON_FORMAT_PRETTY_AUTO))
+ if (arg_json_format_flags & (SD_JSON_FORMAT_OFF|SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
(void) pager_open(arg_pager_flags);
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
printf("%s%s%s Version: %s\n"
" State: %s%s%s\n"
"Installed: %s%s\n"
#include "alloc-util.h"
#include "format-table.h"
+#include "json-util.h"
#include "string-util.h"
#include "strv.h"
#include "tests.h"
}
TEST(json) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL;
_cleanup_(table_unrefp) Table *t = NULL;
assert_se(t = table_new("foo bar", "quux", "piep miau"));
assert_se(table_to_json(t, &v) >= 0);
- assert_se(json_build(&w,
- JSON_BUILD_ARRAY(
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("foo_bar", JSON_BUILD_CONST_STRING("v1")),
- JSON_BUILD_PAIR("quux", JSON_BUILD_UNSIGNED(4711)),
- JSON_BUILD_PAIR("zzz", JSON_BUILD_BOOLEAN(true))),
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("foo_bar", JSON_BUILD_STRV(STRV_MAKE("a", "b", "c"))),
- JSON_BUILD_PAIR("quux", JSON_BUILD_NULL),
- JSON_BUILD_PAIR("zzz", JSON_BUILD_UNSIGNED(0755))))) >= 0);
-
- assert_se(json_variant_equal(v, w));
+ assert_se(sd_json_build(&w,
+ SD_JSON_BUILD_ARRAY(
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("foo_bar", JSON_BUILD_CONST_STRING("v1")),
+ SD_JSON_BUILD_PAIR("quux", SD_JSON_BUILD_UNSIGNED(4711)),
+ SD_JSON_BUILD_PAIR("zzz", SD_JSON_BUILD_BOOLEAN(true))),
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("foo_bar", SD_JSON_BUILD_STRV(STRV_MAKE("a", "b", "c"))),
+ SD_JSON_BUILD_PAIR("quux", SD_JSON_BUILD_NULL),
+ SD_JSON_BUILD_PAIR("zzz", SD_JSON_BUILD_UNSIGNED(0755))))) >= 0);
+
+ assert_se(sd_json_variant_equal(v, w));
}
TEST(table) {
" uuu o: 1K\n"
"lllllllllllo: jjjjjjjjjjjjjjjjj\n"));
- _cleanup_(json_variant_unrefp) JsonVariant *a = NULL, *b = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *a = NULL, *b = NULL;
assert_se(table_to_json(t, &a) >= 0);
- assert_se(json_build(&b, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("pfft_aa", JSON_BUILD_STRING("foo")),
- JSON_BUILD_PAIR("dimpfelmoser", JSON_BUILD_UNSIGNED(1024)),
- JSON_BUILD_PAIR("lllllllllllo", JSON_BUILD_STRING("jjjjjjjjjjjjjjjjj")))) >= 0);
+ assert_se(sd_json_build(&b, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("pfft_aa", SD_JSON_BUILD_STRING("foo")),
+ SD_JSON_BUILD_PAIR("dimpfelmoser", SD_JSON_BUILD_UNSIGNED(1024)),
+ SD_JSON_BUILD_PAIR("lllllllllllo", SD_JSON_BUILD_STRING("jjjjjjjjjjjjjjjjj")))) >= 0);
- assert_se(json_variant_equal(a, b));
+ assert_se(sd_json_variant_equal(a, b));
}
TEST(path_basename) {
#include <float.h>
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "escape.h"
#include "fd-util.h"
#include "fileio.h"
#include "iovec-util.h"
#include "json-internal.h"
-#include "json.h"
+#include "json-util.h"
#include "math-util.h"
#include "string-table.h"
#include "string-util.h"
va_end(ap);
}
-typedef void (*Test)(JsonVariant *);
+typedef void (*Test)(sd_json_variant *);
static void test_variant_one(const char *data, Test test) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL;
_cleanup_free_ char *s = NULL;
int r;
assert_se(cdata = cescape(data));
log_info("/* %s data=\"%s\" */", __func__, cdata);
- r = json_parse(data, 0, &v, NULL, NULL);
+ r = sd_json_parse(data, 0, &v, NULL, NULL);
assert_se(r == 0);
assert_se(v);
- r = json_variant_format(v, 0, &s);
+ r = sd_json_variant_format(v, 0, &s);
assert_se(r >= 0);
assert_se(s);
assert_se((size_t) r == strlen(s));
log_info("formatted normally: %s", s);
- r = json_parse(data, JSON_PARSE_SENSITIVE, &w, NULL, NULL);
+ r = sd_json_parse(data, SD_JSON_PARSE_SENSITIVE, &w, NULL, NULL);
assert_se(r == 0);
assert_se(w);
- assert_se(json_variant_has_type(v, json_variant_type(w)));
- assert_se(json_variant_has_type(w, json_variant_type(v)));
- assert_se(json_variant_equal(v, w));
+ assert_se(sd_json_variant_has_type(v, sd_json_variant_type(w)));
+ assert_se(sd_json_variant_has_type(w, sd_json_variant_type(v)));
+ assert_se(sd_json_variant_equal(v, w));
s = mfree(s);
- r = json_variant_format(w, JSON_FORMAT_CENSOR_SENSITIVE, &s);
+ r = sd_json_variant_format(w, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s);
assert_se(s);
ASSERT_STREQ(s, "\"<sensitive data>\"");
s = mfree(s);
- r = json_variant_format(w, JSON_FORMAT_PRETTY, &s);
+ r = sd_json_variant_format(w, SD_JSON_FORMAT_PRETTY, &s);
assert_se(r >= 0);
assert_se(s);
assert_se((size_t) r == strlen(s));
s = mfree(s);
- w = json_variant_unref(w);
+ w = sd_json_variant_unref(w);
- r = json_variant_format(v, JSON_FORMAT_PRETTY, &s);
+ r = sd_json_variant_format(v, SD_JSON_FORMAT_PRETTY, &s);
assert_se(r >= 0);
assert_se(s);
assert_se((size_t) r == strlen(s));
log_info("formatted prettily:\n%s", s);
- r = json_parse(data, 0, &w, NULL, NULL);
+ r = sd_json_parse(data, 0, &w, NULL, NULL);
assert_se(r == 0);
assert_se(w);
- assert_se(json_variant_has_type(v, json_variant_type(w)));
- assert_se(json_variant_has_type(w, json_variant_type(v)));
- assert_se(json_variant_equal(v, w));
+ assert_se(sd_json_variant_has_type(v, sd_json_variant_type(w)));
+ assert_se(sd_json_variant_has_type(w, sd_json_variant_type(v)));
+ assert_se(sd_json_variant_equal(v, w));
s = mfree(s);
- r = json_variant_format(v, JSON_FORMAT_COLOR, &s);
+ r = sd_json_variant_format(v, SD_JSON_FORMAT_COLOR, &s);
assert_se(r >= 0);
assert_se(s);
assert_se((size_t) r == strlen(s));
printf("Normal with color: %s\n", s);
s = mfree(s);
- r = json_variant_format(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, &s);
+ r = sd_json_variant_format(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, &s);
assert_se(r >= 0);
assert_se(s);
assert_se((size_t) r == strlen(s));
test(v);
}
-static void test_1(JsonVariant *v) {
- JsonVariant *p, *q;
+static void test_1(sd_json_variant *v) {
+ sd_json_variant *p, *q;
unsigned i;
log_info("/* %s */", __func__);
/* 3 keys + 3 values */
- assert_se(json_variant_elements(v) == 6);
+ assert_se(sd_json_variant_elements(v) == 6);
/* has k */
- p = json_variant_by_key(v, "k");
- assert_se(p && json_variant_type(p) == JSON_VARIANT_STRING);
+ p = sd_json_variant_by_key(v, "k");
+ assert_se(p && sd_json_variant_type(p) == SD_JSON_VARIANT_STRING);
/* k equals v */
- ASSERT_STREQ(json_variant_string(p), "v");
+ ASSERT_STREQ(sd_json_variant_string(p), "v");
/* has foo */
- p = json_variant_by_key(v, "foo");
- assert_se(p && json_variant_type(p) == JSON_VARIANT_ARRAY && json_variant_elements(p) == 3);
+ p = sd_json_variant_by_key(v, "foo");
+ assert_se(p && sd_json_variant_type(p) == SD_JSON_VARIANT_ARRAY && sd_json_variant_elements(p) == 3);
/* check foo[0] = 1, foo[1] = 2, foo[2] = 3 */
for (i = 0; i < 3; ++i) {
- q = json_variant_by_index(p, i);
- assert_se(q && json_variant_type(q) == JSON_VARIANT_UNSIGNED && json_variant_unsigned(q) == (i+1));
- assert_se(q && json_variant_has_type(q, JSON_VARIANT_INTEGER) && json_variant_integer(q) == (i+1));
+ q = sd_json_variant_by_index(p, i);
+ assert_se(q && sd_json_variant_type(q) == SD_JSON_VARIANT_UNSIGNED && sd_json_variant_unsigned(q) == (i+1));
+ assert_se(q && sd_json_variant_has_type(q, SD_JSON_VARIANT_INTEGER) && sd_json_variant_integer(q) == (i+1));
}
/* has bar */
- p = json_variant_by_key(v, "bar");
- assert_se(p && json_variant_type(p) == JSON_VARIANT_OBJECT && json_variant_elements(p) == 2);
+ p = sd_json_variant_by_key(v, "bar");
+ assert_se(p && sd_json_variant_type(p) == SD_JSON_VARIANT_OBJECT && sd_json_variant_elements(p) == 2);
/* zap is null */
- q = json_variant_by_key(p, "zap");
- assert_se(q && json_variant_type(q) == JSON_VARIANT_NULL);
+ q = sd_json_variant_by_key(p, "zap");
+ assert_se(q && sd_json_variant_type(q) == SD_JSON_VARIANT_NULL);
}
-static void test_2(JsonVariant *v) {
- JsonVariant *p, *q;
+static void test_2(sd_json_variant *v) {
+ sd_json_variant *p, *q;
log_info("/* %s */", __func__);
/* 2 keys + 2 values */
- assert_se(json_variant_elements(v) == 4);
+ assert_se(sd_json_variant_elements(v) == 4);
/* has mutant */
- p = json_variant_by_key(v, "mutant");
- assert_se(p && json_variant_type(p) == JSON_VARIANT_ARRAY && json_variant_elements(p) == 4);
+ p = sd_json_variant_by_key(v, "mutant");
+ assert_se(p && sd_json_variant_type(p) == SD_JSON_VARIANT_ARRAY && sd_json_variant_elements(p) == 4);
/* mutant[0] == 1 */
- q = json_variant_by_index(p, 0);
- assert_se(q && json_variant_type(q) == JSON_VARIANT_UNSIGNED && json_variant_unsigned(q) == 1);
- assert_se(q && json_variant_has_type(q, JSON_VARIANT_INTEGER) && json_variant_integer(q) == 1);
+ q = sd_json_variant_by_index(p, 0);
+ assert_se(q && sd_json_variant_type(q) == SD_JSON_VARIANT_UNSIGNED && sd_json_variant_unsigned(q) == 1);
+ assert_se(q && sd_json_variant_has_type(q, SD_JSON_VARIANT_INTEGER) && sd_json_variant_integer(q) == 1);
/* mutant[1] == null */
- q = json_variant_by_index(p, 1);
- assert_se(q && json_variant_type(q) == JSON_VARIANT_NULL);
+ q = sd_json_variant_by_index(p, 1);
+ assert_se(q && sd_json_variant_type(q) == SD_JSON_VARIANT_NULL);
/* mutant[2] == "1" */
- q = json_variant_by_index(p, 2);
- assert_se(q && json_variant_type(q) == JSON_VARIANT_STRING && streq(json_variant_string(q), "1"));
+ q = sd_json_variant_by_index(p, 2);
+ assert_se(q && sd_json_variant_type(q) == SD_JSON_VARIANT_STRING && streq(sd_json_variant_string(q), "1"));
- /* mutant[3] == JSON_VARIANT_OBJECT */
- q = json_variant_by_index(p, 3);
- assert_se(q && json_variant_type(q) == JSON_VARIANT_OBJECT && json_variant_elements(q) == 2);
+ /* mutant[3] == SD_JSON_VARIANT_OBJECT */
+ q = sd_json_variant_by_index(p, 3);
+ assert_se(q && sd_json_variant_type(q) == SD_JSON_VARIANT_OBJECT && sd_json_variant_elements(q) == 2);
/* has 1 */
- p = json_variant_by_key(q, "1");
- assert_se(p && json_variant_type(p) == JSON_VARIANT_ARRAY && json_variant_elements(p) == 2);
+ p = sd_json_variant_by_key(q, "1");
+ assert_se(p && sd_json_variant_type(p) == SD_JSON_VARIANT_ARRAY && sd_json_variant_elements(p) == 2);
/* "1"[0] == 1 */
- q = json_variant_by_index(p, 0);
- assert_se(q && json_variant_type(q) == JSON_VARIANT_UNSIGNED && json_variant_unsigned(q) == 1);
- assert_se(q && json_variant_has_type(q, JSON_VARIANT_INTEGER) && json_variant_integer(q) == 1);
+ q = sd_json_variant_by_index(p, 0);
+ assert_se(q && sd_json_variant_type(q) == SD_JSON_VARIANT_UNSIGNED && sd_json_variant_unsigned(q) == 1);
+ assert_se(q && sd_json_variant_has_type(q, SD_JSON_VARIANT_INTEGER) && sd_json_variant_integer(q) == 1);
/* "1"[1] == "1" */
- q = json_variant_by_index(p, 1);
- assert_se(q && json_variant_type(q) == JSON_VARIANT_STRING && streq(json_variant_string(q), "1"));
+ q = sd_json_variant_by_index(p, 1);
+ assert_se(q && sd_json_variant_type(q) == SD_JSON_VARIANT_STRING && streq(sd_json_variant_string(q), "1"));
/* has thisisaverylongproperty */
- p = json_variant_by_key(v, "thisisaverylongproperty");
- assert_se(p && json_variant_type(p) == JSON_VARIANT_REAL && fabs(json_variant_real(p) - 1.27) < 0.001);
+ p = sd_json_variant_by_key(v, "thisisaverylongproperty");
+ assert_se(p && sd_json_variant_type(p) == SD_JSON_VARIANT_REAL && fabs(sd_json_variant_real(p) - 1.27) < 0.001);
}
-static void test_zeroes(JsonVariant *v) {
+static void test_zeroes(sd_json_variant *v) {
/* Make sure zero is how we expect it. */
log_info("/* %s */", __func__);
- assert_se(json_variant_elements(v) == 13);
+ assert_se(sd_json_variant_elements(v) == 13);
- for (size_t i = 0; i < json_variant_elements(v); i++) {
- JsonVariant *w;
+ for (size_t i = 0; i < sd_json_variant_elements(v); i++) {
+ sd_json_variant *w;
size_t j;
- assert_se(w = json_variant_by_index(v, i));
+ assert_se(w = sd_json_variant_by_index(v, i));
- assert_se(json_variant_integer(w) == 0);
- assert_se(json_variant_unsigned(w) == 0U);
+ assert_se(sd_json_variant_integer(w) == 0);
+ assert_se(sd_json_variant_unsigned(w) == 0U);
- assert_se(iszero_safe(json_variant_real(w)));
+ assert_se(iszero_safe(sd_json_variant_real(w)));
- assert_se(json_variant_is_integer(w));
- assert_se(json_variant_is_unsigned(w));
- assert_se(json_variant_is_real(w));
- assert_se(json_variant_is_number(w));
+ assert_se(sd_json_variant_is_integer(w));
+ assert_se(sd_json_variant_is_unsigned(w));
+ assert_se(sd_json_variant_is_real(w));
+ assert_se(sd_json_variant_is_number(w));
- assert_se(!json_variant_is_negative(w));
+ assert_se(!sd_json_variant_is_negative(w));
- assert_se(IN_SET(json_variant_type(w), JSON_VARIANT_INTEGER, JSON_VARIANT_UNSIGNED, JSON_VARIANT_REAL));
+ assert_se(IN_SET(sd_json_variant_type(w), SD_JSON_VARIANT_INTEGER, SD_JSON_VARIANT_UNSIGNED, SD_JSON_VARIANT_REAL));
- for (j = 0; j < json_variant_elements(v); j++) {
- JsonVariant *q;
+ for (j = 0; j < sd_json_variant_elements(v); j++) {
+ sd_json_variant *q;
- assert_se(q = json_variant_by_index(v, j));
+ assert_se(q = sd_json_variant_by_index(v, j));
- assert_se(json_variant_equal(w, q));
+ assert_se(sd_json_variant_equal(w, q));
}
}
}
TEST(build) {
- _cleanup_(json_variant_unrefp) JsonVariant *a = NULL, *b = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *a = NULL, *b = NULL;
_cleanup_free_ char *s = NULL, *t = NULL;
- assert_se(json_build(&a, JSON_BUILD_STRING("hallo")) >= 0);
- assert_se(json_build(&b, JSON_BUILD_LITERAL(" \"hallo\" ")) >= 0);
- assert_se(json_variant_equal(a, b));
+ assert_se(sd_json_build(&a, SD_JSON_BUILD_STRING("hallo")) >= 0);
+ assert_se(sd_json_build(&b, SD_JSON_BUILD_LITERAL(" \"hallo\" ")) >= 0);
+ assert_se(sd_json_variant_equal(a, b));
- b = json_variant_unref(b);
+ b = sd_json_variant_unref(b);
- assert_se(json_build(&b, JSON_BUILD_VARIANT(a)) >= 0);
- assert_se(json_variant_equal(a, b));
+ assert_se(sd_json_build(&b, SD_JSON_BUILD_VARIANT(a)) >= 0);
+ assert_se(sd_json_variant_equal(a, b));
- b = json_variant_unref(b);
- assert_se(json_build(&b, JSON_BUILD_STRING("pief")) >= 0);
- assert_se(!json_variant_equal(a, b));
+ b = sd_json_variant_unref(b);
+ assert_se(sd_json_build(&b, SD_JSON_BUILD_STRING("pief")) >= 0);
+ assert_se(!sd_json_variant_equal(a, b));
- a = json_variant_unref(a);
- b = json_variant_unref(b);
+ a = sd_json_variant_unref(a);
+ b = sd_json_variant_unref(b);
- assert_se(json_build(&a, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("one", JSON_BUILD_INTEGER(7)),
- JSON_BUILD_PAIR("two", JSON_BUILD_REAL(2.0)),
- JSON_BUILD_PAIR("three", JSON_BUILD_INTEGER(0)))) >= 0);
+ assert_se(sd_json_build(&a, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("one", SD_JSON_BUILD_INTEGER(7)),
+ SD_JSON_BUILD_PAIR("two", SD_JSON_BUILD_REAL(2.0)),
+ SD_JSON_BUILD_PAIR("three", SD_JSON_BUILD_INTEGER(0)))) >= 0);
- assert_se(json_build(&b, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("two", JSON_BUILD_INTEGER(2)),
- JSON_BUILD_PAIR("three", JSON_BUILD_REAL(0)),
- JSON_BUILD_PAIR("one", JSON_BUILD_REAL(7)))) >= 0);
+ assert_se(sd_json_build(&b, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("two", SD_JSON_BUILD_INTEGER(2)),
+ SD_JSON_BUILD_PAIR("three", SD_JSON_BUILD_REAL(0)),
+ SD_JSON_BUILD_PAIR("one", SD_JSON_BUILD_REAL(7)))) >= 0);
- assert_se(json_variant_equal(a, b));
+ assert_se(sd_json_variant_equal(a, b));
- a = json_variant_unref(a);
- b = json_variant_unref(b);
+ a = sd_json_variant_unref(a);
+ b = sd_json_variant_unref(b);
const char* arr_1234[] = {"one", "two", "three", "four", NULL};
- assert_se(json_build(&a, JSON_BUILD_ARRAY(JSON_BUILD_OBJECT(JSON_BUILD_PAIR("x", JSON_BUILD_BOOLEAN(true)),
- JSON_BUILD_PAIR("y", JSON_BUILD_OBJECT(JSON_BUILD_PAIR("this", JSON_BUILD_NULL)))),
- JSON_BUILD_VARIANT(NULL),
- JSON_BUILD_LITERAL(NULL),
- JSON_BUILD_STRING(NULL),
- JSON_BUILD_NULL,
- JSON_BUILD_INTEGER(77),
- JSON_BUILD_ARRAY(JSON_BUILD_VARIANT(JSON_VARIANT_STRING_CONST("foobar")),
- JSON_BUILD_VARIANT(JSON_VARIANT_STRING_CONST("zzz"))),
- JSON_BUILD_STRV((char**) arr_1234))) >= 0);
-
- assert_se(json_variant_format(a, 0, &s) >= 0);
+ assert_se(sd_json_build(&a, SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("x", SD_JSON_BUILD_BOOLEAN(true)),
+ SD_JSON_BUILD_PAIR("y", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("this", SD_JSON_BUILD_NULL)))),
+ SD_JSON_BUILD_VARIANT(NULL),
+ SD_JSON_BUILD_LITERAL(NULL),
+ SD_JSON_BUILD_STRING(NULL),
+ SD_JSON_BUILD_NULL,
+ SD_JSON_BUILD_INTEGER(77),
+ SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_VARIANT(JSON_VARIANT_STRING_CONST("foobar")),
+ SD_JSON_BUILD_VARIANT(JSON_VARIANT_STRING_CONST("zzz"))),
+ SD_JSON_BUILD_STRV((char**) arr_1234))) >= 0);
+
+ assert_se(sd_json_variant_format(a, 0, &s) >= 0);
log_info("GOT: %s", s);
- assert_se(json_parse(s, 0, &b, NULL, NULL) >= 0);
- assert_se(json_variant_equal(a, b));
+ assert_se(sd_json_parse(s, 0, &b, NULL, NULL) >= 0);
+ assert_se(sd_json_variant_equal(a, b));
- a = json_variant_unref(a);
- b = json_variant_unref(b);
+ a = sd_json_variant_unref(a);
+ b = sd_json_variant_unref(b);
- assert_se(json_build(&a, JSON_BUILD_REAL(M_PI)) >= 0);
+ assert_se(sd_json_build(&a, SD_JSON_BUILD_REAL(M_PI)) >= 0);
s = mfree(s);
- assert_se(json_variant_format(a, 0, &s) >= 0);
+ assert_se(sd_json_variant_format(a, 0, &s) >= 0);
log_info("GOT: %s", s);
- assert_se(json_parse(s, 0, &b, NULL, NULL) >= 0);
- assert_se(json_variant_format(b, 0, &t) >= 0);
+ assert_se(sd_json_parse(s, 0, &b, NULL, NULL) >= 0);
+ assert_se(sd_json_variant_format(b, 0, &t) >= 0);
log_info("GOT: %s", t);
ASSERT_STREQ(s, t);
- a = json_variant_unref(a);
- b = json_variant_unref(b);
+ a = sd_json_variant_unref(a);
+ b = sd_json_variant_unref(b);
- assert_se(json_build(&a, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("x", JSON_BUILD_STRING("y")),
- JSON_BUILD_PAIR("z", JSON_BUILD_CONST_STRING("a")),
- JSON_BUILD_PAIR("b", JSON_BUILD_CONST_STRING("c"))
+ assert_se(sd_json_build(&a, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("x", SD_JSON_BUILD_STRING("y")),
+ SD_JSON_BUILD_PAIR("z", JSON_BUILD_CONST_STRING("a")),
+ SD_JSON_BUILD_PAIR("b", JSON_BUILD_CONST_STRING("c"))
)) >= 0);
- assert_se(json_build(&b, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("x", JSON_BUILD_STRING("y")),
- JSON_BUILD_PAIR_CONDITION(false, "p", JSON_BUILD_STRING("q")),
- JSON_BUILD_PAIR_CONDITION(true, "z", JSON_BUILD_CONST_STRING("a")),
- JSON_BUILD_PAIR_CONDITION(false, "j", JSON_BUILD_ARRAY(JSON_BUILD_STRING("k"), JSON_BUILD_CONST_STRING("u"), JSON_BUILD_CONST_STRING("i"))),
- JSON_BUILD_PAIR("b", JSON_BUILD_CONST_STRING("c"))
+ assert_se(sd_json_build(&b, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("x", SD_JSON_BUILD_STRING("y")),
+ SD_JSON_BUILD_PAIR_CONDITION(false, "p", SD_JSON_BUILD_STRING("q")),
+ SD_JSON_BUILD_PAIR_CONDITION(true, "z", JSON_BUILD_CONST_STRING("a")),
+ SD_JSON_BUILD_PAIR_CONDITION(false, "j", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_STRING("k"), JSON_BUILD_CONST_STRING("u"), JSON_BUILD_CONST_STRING("i"))),
+ SD_JSON_BUILD_PAIR("b", JSON_BUILD_CONST_STRING("c"))
)) >= 0);
- assert_se(json_variant_equal(a, b));
+ assert_se(sd_json_variant_equal(a, b));
}
TEST(json_parse_file_empty) {
_cleanup_fclose_ FILE *f = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
assert_se(fopen_unlocked("/dev/null", "re", &f) >= 0);
- assert_se(json_parse_file(f, "waldo", 0, &v, NULL, NULL) == -ENODATA);
+ assert_se(sd_json_parse_file(f, "waldo", 0, &v, NULL, NULL) == -ENODATA);
ASSERT_NULL(v);
}
TEST(json_parse_file_invalid) {
_cleanup_fclose_ FILE *f = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
assert_se(f = fmemopen_unlocked((void*) "kookoo", 6, "r"));
- assert_se(json_parse_file(f, "waldo", 0, &v, NULL, NULL) == -EINVAL);
+ assert_se(sd_json_parse_file(f, "waldo", 0, &v, NULL, NULL) == -EINVAL);
ASSERT_NULL(v);
}
"}\n";
_cleanup_fclose_ FILE *f = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
printf("--- original begin ---\n"
"%s"
assert_se(f = fmemopen_unlocked((void*) data, strlen(data), "r"));
- assert_se(json_parse_file(f, "waldo", 0, &v, NULL, NULL) >= 0);
+ assert_se(sd_json_parse_file(f, "waldo", 0, &v, NULL, NULL) >= 0);
printf("--- non-pretty begin ---\n");
- json_variant_dump(v, 0, stdout, NULL);
+ sd_json_variant_dump(v, 0, stdout, NULL);
printf("\n--- non-pretty end ---\n");
printf("--- pretty begin ---\n");
- json_variant_dump(v, JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR|JSON_FORMAT_SOURCE, stdout, NULL);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_SOURCE, stdout, NULL);
printf("--- pretty end ---\n");
}
TEST(depth) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
v = JSON_VARIANT_STRING_CONST("start");
/* Let's verify that the maximum depth checks work */
for (unsigned i = 0;; i++) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
assert_se(i <= UINT16_MAX);
if (i & 1)
- r = json_variant_new_array(&w, &v, 1);
+ r = sd_json_variant_new_array(&w, &v, 1);
else
- r = json_variant_new_object(&w, (JsonVariant*[]) { JSON_VARIANT_STRING_CONST("key"), v }, 2);
+ r = sd_json_variant_new_object(&w, (sd_json_variant*[]) { JSON_VARIANT_STRING_CONST("key"), v }, 2);
if (r == -ELNRNG) {
log_info("max depth at %u", i);
break;
assert_se(r >= 0);
- json_variant_unref(v);
+ sd_json_variant_unref(v);
v = TAKE_PTR(w);
}
- json_variant_dump(v, 0, stdout, NULL);
+ sd_json_variant_dump(v, 0, stdout, NULL);
fputs("\n", stdout);
}
TEST(normalize) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL;
_cleanup_free_ char *t = NULL;
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("b", JSON_BUILD_STRING("x")),
- JSON_BUILD_PAIR("c", JSON_BUILD_CONST_STRING("y")),
- JSON_BUILD_PAIR("a", JSON_BUILD_CONST_STRING("z")))) >= 0);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("b", SD_JSON_BUILD_STRING("x")),
+ SD_JSON_BUILD_PAIR("c", JSON_BUILD_CONST_STRING("y")),
+ SD_JSON_BUILD_PAIR("a", JSON_BUILD_CONST_STRING("z")))) >= 0);
- assert_se(!json_variant_is_sorted(v));
- assert_se(!json_variant_is_normalized(v));
+ assert_se(!sd_json_variant_is_sorted(v));
+ assert_se(!sd_json_variant_is_normalized(v));
- assert_se(json_variant_format(v, 0, &t) >= 0);
+ assert_se(sd_json_variant_format(v, 0, &t) >= 0);
ASSERT_STREQ(t, "{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}");
t = mfree(t);
- assert_se(json_build(&w, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("bar", JSON_BUILD_STRING("zzz")),
- JSON_BUILD_PAIR("foo", JSON_BUILD_VARIANT(v)))) >= 0);
+ assert_se(sd_json_build(&w, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("bar", SD_JSON_BUILD_STRING("zzz")),
+ SD_JSON_BUILD_PAIR("foo", SD_JSON_BUILD_VARIANT(v)))) >= 0);
- assert_se(json_variant_is_sorted(w));
- assert_se(!json_variant_is_normalized(w));
+ assert_se(sd_json_variant_is_sorted(w));
+ assert_se(!sd_json_variant_is_normalized(w));
- assert_se(json_variant_format(w, 0, &t) >= 0);
+ assert_se(sd_json_variant_format(w, 0, &t) >= 0);
ASSERT_STREQ(t, "{\"bar\":\"zzz\",\"foo\":{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}}");
t = mfree(t);
- assert_se(json_variant_sort(&v) >= 0);
- assert_se(json_variant_is_sorted(v));
- assert_se(json_variant_is_normalized(v));
+ assert_se(sd_json_variant_sort(&v) >= 0);
+ assert_se(sd_json_variant_is_sorted(v));
+ assert_se(sd_json_variant_is_normalized(v));
- assert_se(json_variant_format(v, 0, &t) >= 0);
+ assert_se(sd_json_variant_format(v, 0, &t) >= 0);
ASSERT_STREQ(t, "{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}");
t = mfree(t);
- assert_se(json_variant_normalize(&w) >= 0);
- assert_se(json_variant_is_sorted(w));
- assert_se(json_variant_is_normalized(w));
+ assert_se(sd_json_variant_normalize(&w) >= 0);
+ assert_se(sd_json_variant_is_sorted(w));
+ assert_se(sd_json_variant_is_normalized(w));
- assert_se(json_variant_format(w, 0, &t) >= 0);
+ assert_se(sd_json_variant_format(w, 0, &t) >= 0);
ASSERT_STREQ(t, "{\"bar\":\"zzz\",\"foo\":{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}}");
t = mfree(t);
}
TEST(bisect) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
- /* Tests the bisection logic in json_variant_by_key() */
+ /* Tests the bisection logic in sd_json_variant_by_key() */
for (char c = 'z'; c >= 'a'; c--) {
if ((c % 3) == 0)
continue;
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
- assert_se(json_variant_new_stringn(&w, (char[4]) { '<', c, c, '>' }, 4) >= 0);
- assert_se(json_variant_set_field(&v, (char[2]) { c, 0 }, w) >= 0);
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
+ assert_se(sd_json_variant_new_stringn(&w, (char[4]) { '<', c, c, '>' }, 4) >= 0);
+ assert_se(sd_json_variant_set_field(&v, (char[2]) { c, 0 }, w) >= 0);
}
- json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
- assert_se(!json_variant_is_sorted(v));
- assert_se(!json_variant_is_normalized(v));
- assert_se(json_variant_normalize(&v) >= 0);
- assert_se(json_variant_is_sorted(v));
- assert_se(json_variant_is_normalized(v));
+ assert_se(!sd_json_variant_is_sorted(v));
+ assert_se(!sd_json_variant_is_normalized(v));
+ assert_se(sd_json_variant_normalize(&v) >= 0);
+ assert_se(sd_json_variant_is_sorted(v));
+ assert_se(sd_json_variant_is_normalized(v));
- json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
for (char c = 'a'; c <= 'z'; c++) {
- JsonVariant *k;
+ sd_json_variant *k;
const char *z;
- k = json_variant_by_key(v, (char[2]) { c, 0 });
+ k = sd_json_variant_by_key(v, (char[2]) { c, 0 });
assert_se(!k == ((c % 3) == 0));
if (!k)
continue;
- assert_se(json_variant_is_string(k));
+ assert_se(sd_json_variant_is_string(k));
z = (char[5]){ '<', c, c, '>', 0};
- ASSERT_STREQ(json_variant_string(k), z);
+ ASSERT_STREQ(sd_json_variant_string(k), z);
}
}
-static void test_float_match(JsonVariant *v) {
+static void test_float_match(sd_json_variant *v) {
const double delta = 0.0001;
- assert_se(json_variant_is_array(v));
- assert_se(json_variant_elements(v) == 11);
- assert_se(fabs(1.0 - (DBL_MIN / json_variant_real(json_variant_by_index(v, 0)))) <= delta);
- assert_se(fabs(1.0 - (DBL_MAX / json_variant_real(json_variant_by_index(v, 1)))) <= delta);
- assert_se(json_variant_is_null(json_variant_by_index(v, 2))); /* nan is not supported by json → null */
- assert_se(json_variant_is_null(json_variant_by_index(v, 3))); /* +inf is not supported by json → null */
- assert_se(json_variant_is_null(json_variant_by_index(v, 4))); /* -inf is not supported by json → null */
- assert_se(json_variant_is_null(json_variant_by_index(v, 5)) ||
- fabs(1.0 - (HUGE_VAL / json_variant_real(json_variant_by_index(v, 5)))) <= delta); /* HUGE_VAL might be +inf, but might also be something else */
- assert_se(json_variant_is_real(json_variant_by_index(v, 6)) &&
- json_variant_is_integer(json_variant_by_index(v, 6)) &&
- json_variant_integer(json_variant_by_index(v, 6)) == 0);
- assert_se(json_variant_is_real(json_variant_by_index(v, 7)) &&
- json_variant_is_integer(json_variant_by_index(v, 7)) &&
- json_variant_integer(json_variant_by_index(v, 7)) == 10);
- assert_se(json_variant_is_real(json_variant_by_index(v, 8)) &&
- json_variant_is_integer(json_variant_by_index(v, 8)) &&
- json_variant_integer(json_variant_by_index(v, 8)) == -10);
- assert_se(json_variant_is_real(json_variant_by_index(v, 9)) &&
- !json_variant_is_integer(json_variant_by_index(v, 9)));
- assert_se(fabs(1.0 - (DBL_MIN / 2 / json_variant_real(json_variant_by_index(v, 9)))) <= delta);
- assert_se(json_variant_is_real(json_variant_by_index(v, 10)) &&
- !json_variant_is_integer(json_variant_by_index(v, 10)));
- assert_se(fabs(1.0 - (-DBL_MIN / 2 / json_variant_real(json_variant_by_index(v, 10)))) <= delta);
+ assert_se(sd_json_variant_is_array(v));
+ assert_se(sd_json_variant_elements(v) == 11);
+ assert_se(fabs(1.0 - (DBL_MIN / sd_json_variant_real(sd_json_variant_by_index(v, 0)))) <= delta);
+ assert_se(fabs(1.0 - (DBL_MAX / sd_json_variant_real(sd_json_variant_by_index(v, 1)))) <= delta);
+ assert_se(sd_json_variant_is_null(sd_json_variant_by_index(v, 2))); /* nan is not supported by json → null */
+ assert_se(sd_json_variant_is_null(sd_json_variant_by_index(v, 3))); /* +inf is not supported by json → null */
+ assert_se(sd_json_variant_is_null(sd_json_variant_by_index(v, 4))); /* -inf is not supported by json → null */
+ assert_se(sd_json_variant_is_null(sd_json_variant_by_index(v, 5)) ||
+ fabs(1.0 - (HUGE_VAL / sd_json_variant_real(sd_json_variant_by_index(v, 5)))) <= delta); /* HUGE_VAL might be +inf, but might also be something else */
+ assert_se(sd_json_variant_is_real(sd_json_variant_by_index(v, 6)) &&
+ sd_json_variant_is_integer(sd_json_variant_by_index(v, 6)) &&
+ sd_json_variant_integer(sd_json_variant_by_index(v, 6)) == 0);
+ assert_se(sd_json_variant_is_real(sd_json_variant_by_index(v, 7)) &&
+ sd_json_variant_is_integer(sd_json_variant_by_index(v, 7)) &&
+ sd_json_variant_integer(sd_json_variant_by_index(v, 7)) == 10);
+ assert_se(sd_json_variant_is_real(sd_json_variant_by_index(v, 8)) &&
+ sd_json_variant_is_integer(sd_json_variant_by_index(v, 8)) &&
+ sd_json_variant_integer(sd_json_variant_by_index(v, 8)) == -10);
+ assert_se(sd_json_variant_is_real(sd_json_variant_by_index(v, 9)) &&
+ !sd_json_variant_is_integer(sd_json_variant_by_index(v, 9)));
+ assert_se(fabs(1.0 - (DBL_MIN / 2 / sd_json_variant_real(sd_json_variant_by_index(v, 9)))) <= delta);
+ assert_se(sd_json_variant_is_real(sd_json_variant_by_index(v, 10)) &&
+ !sd_json_variant_is_integer(sd_json_variant_by_index(v, 10)));
+ assert_se(fabs(1.0 - (-DBL_MIN / 2 / sd_json_variant_real(sd_json_variant_by_index(v, 10)))) <= delta);
}
TEST(float) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL;
_cleanup_free_ char *text = NULL;
- assert_se(json_build(&v, JSON_BUILD_ARRAY(
- JSON_BUILD_REAL(DBL_MIN),
- JSON_BUILD_REAL(DBL_MAX),
- JSON_BUILD_REAL(NAN),
- JSON_BUILD_REAL(INFINITY),
- JSON_BUILD_REAL(-INFINITY),
- JSON_BUILD_REAL(HUGE_VAL),
- JSON_BUILD_REAL(0),
- JSON_BUILD_REAL(10),
- JSON_BUILD_REAL(-10),
- JSON_BUILD_REAL(DBL_MIN / 2),
- JSON_BUILD_REAL(-DBL_MIN / 2))) >= 0);
-
- json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_ARRAY(
+ SD_JSON_BUILD_REAL(DBL_MIN),
+ SD_JSON_BUILD_REAL(DBL_MAX),
+ SD_JSON_BUILD_REAL(NAN),
+ SD_JSON_BUILD_REAL(INFINITY),
+ SD_JSON_BUILD_REAL(-INFINITY),
+ SD_JSON_BUILD_REAL(HUGE_VAL),
+ SD_JSON_BUILD_REAL(0),
+ SD_JSON_BUILD_REAL(10),
+ SD_JSON_BUILD_REAL(-10),
+ SD_JSON_BUILD_REAL(DBL_MIN / 2),
+ SD_JSON_BUILD_REAL(-DBL_MIN / 2))) >= 0);
+
+ sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
test_float_match(v);
- assert_se(json_variant_format(v, 0, &text) >= 0);
- assert_se(json_parse(text, 0, &w, NULL, NULL) >= 0);
+ assert_se(sd_json_variant_format(v, 0, &text) >= 0);
+ assert_se(sd_json_parse(text, 0, &w, NULL, NULL) >= 0);
- json_variant_dump(w, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ sd_json_variant_dump(w, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
test_float_match(w);
}
-static void test_equal_text(JsonVariant *v, const char *text) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+static void test_equal_text(sd_json_variant *v, const char *text) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
- assert_se(json_parse(text, 0, &w, NULL, NULL) >= 0);
- assert_se(json_variant_equal(v, w) || (!v && json_variant_is_null(w)));
+ assert_se(sd_json_parse(text, 0, &w, NULL, NULL) >= 0);
+ assert_se(sd_json_variant_equal(v, w) || (!v && sd_json_variant_is_null(w)));
}
TEST(set_field) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
test_equal_text(v, "null");
- assert_se(json_variant_set_field(&v, "foo", NULL) >= 0);
+ assert_se(sd_json_variant_set_field(&v, "foo", NULL) >= 0);
test_equal_text(v, "{\"foo\" : null}");
- assert_se(json_variant_set_field(&v, "bar", JSON_VARIANT_STRING_CONST("quux")) >= 0);
+ assert_se(sd_json_variant_set_field(&v, "bar", JSON_VARIANT_STRING_CONST("quux")) >= 0);
test_equal_text(v, "{\"foo\" : null, \"bar\" : \"quux\"}");
- assert_se(json_variant_set_field(&v, "foo", JSON_VARIANT_STRING_CONST("quux2")) >= 0);
+ assert_se(sd_json_variant_set_field(&v, "foo", JSON_VARIANT_STRING_CONST("quux2")) >= 0);
test_equal_text(v, "{\"foo\" : \"quux2\", \"bar\" : \"quux\"}");
- assert_se(json_variant_set_field(&v, "bar", NULL) >= 0);
+ assert_se(sd_json_variant_set_field(&v, "bar", NULL) >= 0);
test_equal_text(v, "{\"foo\" : \"quux2\", \"bar\" : null}");
}
}
TEST(json_variant_merge_objectb) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL, *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL;
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("b", JSON_BUILD_STRING("x")),
- JSON_BUILD_PAIR("c", JSON_BUILD_CONST_STRING("y")),
- JSON_BUILD_PAIR("a", JSON_BUILD_CONST_STRING("z")))) >= 0);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("b", SD_JSON_BUILD_STRING("x")),
+ SD_JSON_BUILD_PAIR("c", JSON_BUILD_CONST_STRING("y")),
+ SD_JSON_BUILD_PAIR("a", JSON_BUILD_CONST_STRING("z")))) >= 0);
- assert_se(json_variant_merge_objectb(&w, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("b", JSON_BUILD_STRING("x")))) >= 0);
- assert_se(json_variant_merge_objectb(&w, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("c", JSON_BUILD_STRING("y")))) >= 0);
- assert_se(json_variant_merge_objectb(&w, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("a", JSON_BUILD_STRING("z")))) >= 0);
+ assert_se(sd_json_variant_merge_objectb(&w, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("b", SD_JSON_BUILD_STRING("x")))) >= 0);
+ assert_se(sd_json_variant_merge_objectb(&w, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_STRING("y")))) >= 0);
+ assert_se(sd_json_variant_merge_objectb(&w, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("a", SD_JSON_BUILD_STRING("z")))) >= 0);
- assert_se(json_variant_equal(v, w));
+ assert_se(sd_json_variant_equal(v, w));
}
static void json_array_append_with_source_one(bool source) {
- _cleanup_(json_variant_unrefp) JsonVariant *a, *b;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *a, *b;
/* Parse two sources, each with a different name and line/column numbers */
- assert_se(json_parse_with_source(" [41]", source ? "string 1" : NULL, 0,
+ assert_se(sd_json_parse_with_source(" [41]", source ? "string 1" : NULL, 0,
&a, NULL, NULL) >= 0);
- assert_se(json_parse_with_source("\n\n [42]", source ? "string 2" : NULL, 0,
+ assert_se(sd_json_parse_with_source("\n\n [42]", source ? "string 2" : NULL, 0,
&b, NULL, NULL) >= 0);
- assert_se(json_variant_is_array(a));
- assert_se(json_variant_elements(a) == 1);
- assert_se(json_variant_is_array(b));
- assert_se(json_variant_elements(b) == 1);
+ assert_se(sd_json_variant_is_array(a));
+ assert_se(sd_json_variant_elements(a) == 1);
+ assert_se(sd_json_variant_is_array(b));
+ assert_se(sd_json_variant_elements(b) == 1);
/* Verify source information */
const char *s1, *s2;
unsigned line1, col1, line2, col2;
- assert_se(json_variant_get_source(a, &s1, &line1, &col1) >= 0);
- assert_se(json_variant_get_source(b, &s2, &line2, &col2) >= 0);
+ assert_se(sd_json_variant_get_source(a, &s1, &line1, &col1) >= 0);
+ assert_se(sd_json_variant_get_source(b, &s2, &line2, &col2) >= 0);
ASSERT_STREQ(s1, source ? "string 1" : NULL);
ASSERT_STREQ(s2, source ? "string 2" : NULL);
/* Append one elem from the second array (and source) to the first. */
- JsonVariant *elem;
- assert_se(elem = json_variant_by_index(b, 0));
- assert_se(json_variant_is_integer(elem));
- assert_se(json_variant_elements(elem) == 0);
+ sd_json_variant *elem;
+ assert_se(elem = sd_json_variant_by_index(b, 0));
+ assert_se(sd_json_variant_is_integer(elem));
+ assert_se(sd_json_variant_elements(elem) == 0);
- assert_se(json_variant_append_array(&a, elem) >= 0);
+ assert_se(sd_json_variant_append_array(&a, elem) >= 0);
- assert_se(json_variant_is_array(a));
- assert_se(json_variant_elements(a) == 2);
+ assert_se(sd_json_variant_is_array(a));
+ assert_se(sd_json_variant_elements(a) == 2);
/* Verify that source information was propagated correctly */
- assert_se(json_variant_get_source(elem, &s1, &line1, &col1) >= 0);
- assert_se(elem = json_variant_by_index(a, 1));
- assert_se(json_variant_get_source(elem, &s2, &line2, &col2) >= 0);
+ assert_se(sd_json_variant_get_source(elem, &s1, &line1, &col1) >= 0);
+ assert_se(elem = sd_json_variant_by_index(a, 1));
+ assert_se(sd_json_variant_get_source(elem, &s2, &line2, &col2) >= 0);
ASSERT_STREQ(s1, source ? "string 2" : NULL);
ASSERT_STREQ(s2, source ? "string 2" : NULL);
}
TEST(json_array_append_nodup) {
- _cleanup_(json_variant_unrefp) JsonVariant *l = NULL, *s = NULL, *wd = NULL, *nd = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL, *s = NULL, *wd = NULL, *nd = NULL;
- assert_se(json_build(&l, JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "bar", "baz", "foo", "qux", "baz"))) >= 0);
- assert_se(json_build(&s, JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "qux"))) >= 0);
+ assert_se(sd_json_build(&l, SD_JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "bar", "baz", "foo", "qux", "baz"))) >= 0);
+ assert_se(sd_json_build(&s, SD_JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "qux"))) >= 0);
- assert_se(!json_variant_equal(l, s));
- assert_se(json_variant_elements(l) == 8);
- assert_se(json_variant_elements(s) == 4);
+ assert_se(!sd_json_variant_equal(l, s));
+ assert_se(sd_json_variant_elements(l) == 8);
+ assert_se(sd_json_variant_elements(s) == 4);
- JsonVariant *i;
+ sd_json_variant *i;
JSON_VARIANT_ARRAY_FOREACH(i, l) {
- assert_se(json_variant_append_array(&wd, i) >= 0);
- assert_se(json_variant_append_array_nodup(&nd, i) >= 0);
+ assert_se(sd_json_variant_append_array(&wd, i) >= 0);
+ assert_se(sd_json_variant_append_array_nodup(&nd, i) >= 0);
}
- assert_se(json_variant_elements(wd) == 8);
- assert_se(json_variant_equal(l, wd));
- assert_se(!json_variant_equal(s, wd));
+ assert_se(sd_json_variant_elements(wd) == 8);
+ assert_se(sd_json_variant_equal(l, wd));
+ assert_se(!sd_json_variant_equal(s, wd));
- assert_se(json_variant_elements(nd) == 4);
- assert_se(!json_variant_equal(l, nd));
- assert_se(json_variant_equal(s, nd));
+ assert_se(sd_json_variant_elements(nd) == 4);
+ assert_se(!sd_json_variant_equal(l, nd));
+ assert_se(sd_json_variant_equal(s, nd));
}
TEST(json_dispatch) {
int16_t k, l;
} foobar = {};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
-
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("a", JSON_BUILD_UNSIGNED(UINT64_MAX)),
- JSON_BUILD_PAIR("b", JSON_BUILD_STRING("18446744073709551615")),
- JSON_BUILD_PAIR("c", JSON_BUILD_INTEGER(INT64_MIN)),
- JSON_BUILD_PAIR("d", JSON_BUILD_STRING("-9223372036854775808")),
- JSON_BUILD_PAIR("e", JSON_BUILD_UNSIGNED(UINT32_MAX)),
- JSON_BUILD_PAIR("f", JSON_BUILD_STRING("4294967295")),
- JSON_BUILD_PAIR("g", JSON_BUILD_INTEGER(INT32_MIN)),
- JSON_BUILD_PAIR("h", JSON_BUILD_STRING("-2147483648")),
- JSON_BUILD_PAIR("i", JSON_BUILD_UNSIGNED(UINT16_MAX)),
- JSON_BUILD_PAIR("j", JSON_BUILD_STRING("65535")),
- JSON_BUILD_PAIR("k", JSON_BUILD_INTEGER(INT16_MIN)),
- JSON_BUILD_PAIR("l", JSON_BUILD_STRING("-32768")))) >= 0);
-
- assert_se(json_variant_dump(v, JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO, stdout, /* prefix= */ NULL) >= 0);
-
- JsonDispatch table[] = {
- { "a", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct foobar, a) },
- { "b", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint64, offsetof(struct foobar, b) },
- { "c", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int64, offsetof(struct foobar, c) },
- { "d", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int64, offsetof(struct foobar, d) },
- { "e", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint32, offsetof(struct foobar, e) },
- { "f", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint32, offsetof(struct foobar, f) },
- { "g", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int32, offsetof(struct foobar, g) },
- { "h", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int32, offsetof(struct foobar, h) },
- { "i", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint16, offsetof(struct foobar, i) },
- { "j", _JSON_VARIANT_TYPE_INVALID, json_dispatch_uint16, offsetof(struct foobar, j) },
- { "k", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int16, offsetof(struct foobar, k) },
- { "l", _JSON_VARIANT_TYPE_INVALID, json_dispatch_int16, offsetof(struct foobar, l) },
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("a", SD_JSON_BUILD_UNSIGNED(UINT64_MAX)),
+ SD_JSON_BUILD_PAIR("b", SD_JSON_BUILD_STRING("18446744073709551615")),
+ SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
+ SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
+ SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_UNSIGNED(UINT32_MAX)),
+ SD_JSON_BUILD_PAIR("f", SD_JSON_BUILD_STRING("4294967295")),
+ SD_JSON_BUILD_PAIR("g", SD_JSON_BUILD_INTEGER(INT32_MIN)),
+ SD_JSON_BUILD_PAIR("h", SD_JSON_BUILD_STRING("-2147483648")),
+ SD_JSON_BUILD_PAIR("i", SD_JSON_BUILD_UNSIGNED(UINT16_MAX)),
+ SD_JSON_BUILD_PAIR("j", SD_JSON_BUILD_STRING("65535")),
+ SD_JSON_BUILD_PAIR("k", SD_JSON_BUILD_INTEGER(INT16_MIN)),
+ SD_JSON_BUILD_PAIR("l", SD_JSON_BUILD_STRING("-32768")))) >= 0);
+
+ assert_se(sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO, stdout, /* prefix= */ NULL) >= 0);
+
+ sd_json_dispatch_field table[] = {
+ { "a", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct foobar, a) },
+ { "b", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64, offsetof(struct foobar, b) },
+ { "c", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int64, offsetof(struct foobar, c) },
+ { "d", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int64, offsetof(struct foobar, d) },
+ { "e", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint32, offsetof(struct foobar, e) },
+ { "f", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint32, offsetof(struct foobar, f) },
+ { "g", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int32, offsetof(struct foobar, g) },
+ { "h", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int32, offsetof(struct foobar, h) },
+ { "i", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(struct foobar, i) },
+ { "j", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(struct foobar, j) },
+ { "k", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int16, offsetof(struct foobar, k) },
+ { "l", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int16, offsetof(struct foobar, l) },
{}
};
- assert_se(json_dispatch(v, table, JSON_LOG, &foobar) >= 0);
+ assert_se(sd_json_dispatch(v, table, SD_JSON_LOG, &foobar) >= 0);
assert_se(foobar.a == UINT64_MAX);
assert_se(foobar.b == UINT64_MAX);
.d = mybar,
};
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
- assert_se(json_build(&j, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("a", JSON_BUILD_STRING("mybaz")),
- JSON_BUILD_PAIR("b", JSON_BUILD_STRING("mybar")),
- JSON_BUILD_PAIR("c", JSON_BUILD_STRING("myfoo")),
- JSON_BUILD_PAIR("d", JSON_BUILD_NULL))) >= 0);
+ assert_se(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("a", SD_JSON_BUILD_STRING("mybaz")),
+ SD_JSON_BUILD_PAIR("b", SD_JSON_BUILD_STRING("mybar")),
+ SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_STRING("myfoo")),
+ SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_NULL))) >= 0);
- assert_se(json_dispatch(j,
- (const JsonDispatch[]) {
- { "a", _JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, a), 0 },
- { "b", _JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, b), 0 },
- { "c", _JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, c), 0 },
- { "d", _JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, d), 0 },
+ assert_se(sd_json_dispatch(j,
+ (const sd_json_dispatch_field[]) {
+ { "a", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, a), 0 },
+ { "b", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, b), 0 },
+ { "c", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, c), 0 },
+ { "d", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_mytestenum, offsetof(struct data, d), 0 },
{},
},
/* flags= */ 0,
}
TEST(json_sensitive) {
- _cleanup_(json_variant_unrefp) JsonVariant *a = NULL, *b = NULL, *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *a = NULL, *b = NULL, *v = NULL;
_cleanup_free_ char *s = NULL;
int r;
- assert_se(json_build(&a, JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "bar", "baz", "foo", "qux", "baz"))) >= 0);
- assert_se(json_build(&b, JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "qux"))) >= 0);
+ assert_se(sd_json_build(&a, SD_JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "bar", "baz", "foo", "qux", "baz"))) >= 0);
+ assert_se(sd_json_build(&b, SD_JSON_BUILD_STRV(STRV_MAKE("foo", "bar", "baz", "qux"))) >= 0);
- json_variant_sensitive(a);
+ sd_json_variant_sensitive(a);
- assert_se(json_variant_format(a, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
+ assert_se(sd_json_variant_format(a, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
ASSERT_STREQ(s, "\"<sensitive data>\"");
s = mfree(s);
- r = json_variant_format(b, JSON_FORMAT_CENSOR_SENSITIVE, &s);
+ r = sd_json_variant_format(b, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s);
assert_se(r >= 0);
assert_se(s);
assert_se((size_t) r == strlen(s));
s = mfree(s);
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("c", JSON_BUILD_INTEGER(INT64_MIN)),
- JSON_BUILD_PAIR("d", JSON_BUILD_STRING("-9223372036854775808")),
- JSON_BUILD_PAIR("e", JSON_BUILD_EMPTY_OBJECT))) >= 0);
- json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
+ SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
+ SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
- r = json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s);
+ r = sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s);
assert_se(r >= 0);
assert_se(s);
assert_se((size_t) r == strlen(s));
s = mfree(s);
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("b", b),
- JSON_BUILD_PAIR("c", JSON_BUILD_INTEGER(INT64_MIN)),
- JSON_BUILD_PAIR("d", JSON_BUILD_STRING("-9223372036854775808")),
- JSON_BUILD_PAIR("e", JSON_BUILD_EMPTY_OBJECT))) >= 0);
- json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("b", b),
+ SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
+ SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
+ SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
- r = json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s);
+ r = sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s);
assert_se(r >= 0);
assert_se(s);
assert_se((size_t) r == strlen(s));
s = mfree(s);
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("b", b),
- JSON_BUILD_PAIR_VARIANT("a", a),
- JSON_BUILD_PAIR("c", JSON_BUILD_INTEGER(INT64_MIN)),
- JSON_BUILD_PAIR("d", JSON_BUILD_STRING("-9223372036854775808")),
- JSON_BUILD_PAIR("e", JSON_BUILD_EMPTY_OBJECT))) >= 0);
- json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("b", b),
+ SD_JSON_BUILD_PAIR_VARIANT("a", a),
+ SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
+ SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
+ SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
- assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
+ assert_se(sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"a\":\"<sensitive data>\",\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{}}");
s = mfree(s);
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("b", b),
- JSON_BUILD_PAIR("c", JSON_BUILD_INTEGER(INT64_MIN)),
- JSON_BUILD_PAIR_VARIANT("a", a),
- JSON_BUILD_PAIR("d", JSON_BUILD_STRING("-9223372036854775808")),
- JSON_BUILD_PAIR("e", JSON_BUILD_EMPTY_OBJECT))) >= 0);
- json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("b", b),
+ SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
+ SD_JSON_BUILD_PAIR_VARIANT("a", a),
+ SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
+ SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
- assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
+ assert_se(sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"a\":\"<sensitive data>\",\"d\":\"-9223372036854775808\",\"e\":{}}");
s = mfree(s);
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("b", b),
- JSON_BUILD_PAIR("c", JSON_BUILD_INTEGER(INT64_MIN)),
- JSON_BUILD_PAIR("d", JSON_BUILD_STRING("-9223372036854775808")),
- JSON_BUILD_PAIR_VARIANT("a", a),
- JSON_BUILD_PAIR("e", JSON_BUILD_EMPTY_OBJECT))) >= 0);
- json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("b", b),
+ SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
+ SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
+ SD_JSON_BUILD_PAIR_VARIANT("a", a),
+ SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT))) >= 0);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
- assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
+ assert_se(sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"a\":\"<sensitive data>\",\"e\":{}}");
s = mfree(s);
- v = json_variant_unref(v);
+ v = sd_json_variant_unref(v);
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_VARIANT("b", b),
- JSON_BUILD_PAIR("c", JSON_BUILD_INTEGER(INT64_MIN)),
- JSON_BUILD_PAIR("d", JSON_BUILD_STRING("-9223372036854775808")),
- JSON_BUILD_PAIR("e", JSON_BUILD_EMPTY_OBJECT),
- JSON_BUILD_PAIR_VARIANT("a", a))) >= 0);
- json_variant_dump(v, JSON_FORMAT_COLOR|JSON_FORMAT_PRETTY, NULL, NULL);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_VARIANT("b", b),
+ SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(INT64_MIN)),
+ SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_STRING("-9223372036854775808")),
+ SD_JSON_BUILD_PAIR("e", SD_JSON_BUILD_EMPTY_OBJECT),
+ SD_JSON_BUILD_PAIR_VARIANT("a", a))) >= 0);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_COLOR|SD_JSON_FORMAT_PRETTY, NULL, NULL);
- assert_se(json_variant_format(v, JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
+ assert_se(sd_json_variant_format(v, SD_JSON_FORMAT_CENSOR_SENSITIVE, &s) >= 0);
ASSERT_STREQ(s, "{\"b\":[\"foo\",\"bar\",\"baz\",\"qux\"],\"c\":-9223372036854775808,\"d\":\"-9223372036854775808\",\"e\":{},\"a\":\"<sensitive data>\"}");
}
TEST(json_iovec) {
struct iovec iov1 = CONST_IOVEC_MAKE_STRING("üxknürz"), iov2 = CONST_IOVEC_MAKE_STRING("wuffwuffmiau");
- _cleanup_(json_variant_unrefp) JsonVariant *j = NULL;
- assert_se(json_build(&j, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("nr1", JSON_BUILD_IOVEC_BASE64(&iov1)),
- JSON_BUILD_PAIR("nr2", JSON_BUILD_IOVEC_HEX(&iov2)))) >= 0);
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
+ assert_se(sd_json_build(&j, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("nr1", JSON_BUILD_IOVEC_BASE64(&iov1)),
+ SD_JSON_BUILD_PAIR("nr2", JSON_BUILD_IOVEC_HEX(&iov2)))) >= 0);
- json_variant_dump(j, JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO, /* f= */ NULL, /* prefix= */ NULL);
+ sd_json_variant_dump(j, SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO, /* f= */ NULL, /* prefix= */ NULL);
_cleanup_(iovec_done) struct iovec a = {}, b = {};
- assert_se(json_variant_unbase64_iovec(json_variant_by_key(j, "nr1"), &a) >= 0);
- assert_se(json_variant_unhex_iovec(json_variant_by_key(j, "nr2"), &b) >= 0);
+ assert_se(json_variant_unbase64_iovec(sd_json_variant_by_key(j, "nr1"), &a) >= 0);
+ assert_se(json_variant_unhex_iovec(sd_json_variant_by_key(j, "nr2"), &b) >= 0);
assert_se(iovec_memcmp(&iov1, &a) == 0);
assert_se(iovec_memcmp(&iov2, &b) == 0);
#include "tests.h"
TEST(parse_json_argument) {
- JsonFormatFlags flags = JSON_FORMAT_PRETTY;
+ sd_json_format_flags_t flags = SD_JSON_FORMAT_PRETTY;
assert_se(parse_json_argument("help", &flags) == 0);
- assert_se(flags == JSON_FORMAT_PRETTY);
+ assert_se(flags == SD_JSON_FORMAT_PRETTY);
assert_se(parse_json_argument("off", &flags) == 1);
- assert_se(flags == JSON_FORMAT_OFF);
+ assert_se(flags == SD_JSON_FORMAT_OFF);
}
TEST(parse_path_argument) {
assert_se(varlink_idl_parse(text, NULL, NULL, &parsed) >= 0);
test_parse_format_one(parsed);
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
- assert_se(json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("a", JSON_BUILD_STRING("x")),
- JSON_BUILD_PAIR("b", JSON_BUILD_UNSIGNED(44)),
- JSON_BUILD_PAIR("d", JSON_BUILD_ARRAY(JSON_BUILD_UNSIGNED(5), JSON_BUILD_UNSIGNED(7), JSON_BUILD_UNSIGNED(107))),
- JSON_BUILD_PAIR("g", JSON_BUILD_OBJECT(JSON_BUILD_PAIR("f", JSON_BUILD_REAL(0.5f)))))) >= 0);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("a", SD_JSON_BUILD_STRING("x")),
+ SD_JSON_BUILD_PAIR("b", SD_JSON_BUILD_UNSIGNED(44)),
+ SD_JSON_BUILD_PAIR("d", SD_JSON_BUILD_ARRAY(SD_JSON_BUILD_UNSIGNED(5), SD_JSON_BUILD_UNSIGNED(7), SD_JSON_BUILD_UNSIGNED(107))),
+ SD_JSON_BUILD_PAIR("g", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("f", SD_JSON_BUILD_REAL(0.5f)))))) >= 0);
- json_variant_dump(v, JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO, stdout, NULL);
+ sd_json_variant_dump(v, SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO, stdout, NULL);
const VarlinkSymbol* symbol = ASSERT_PTR(varlink_idl_find_symbol(parsed, VARLINK_METHOD, "Mymethod"));
assert_se(test_recursive_one(20000) < 0 );
}
-static int test_method(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- JsonVariant *foo = json_variant_by_key(parameters, "foo"), *bar = json_variant_by_key(parameters, "bar");
+static int test_method(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ sd_json_variant *foo = sd_json_variant_by_key(parameters, "foo"), *bar = sd_json_variant_by_key(parameters, "bar");
return varlink_replyb(link,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("waldo", json_variant_unsigned(foo) * json_variant_unsigned(bar)),
- JSON_BUILD_PAIR_UNSIGNED("quux", json_variant_unsigned(foo) + json_variant_unsigned(bar))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("waldo", sd_json_variant_unsigned(foo) * sd_json_variant_unsigned(bar)),
+ SD_JSON_BUILD_PAIR_UNSIGNED("quux", sd_json_variant_unsigned(foo) + sd_json_variant_unsigned(bar))));
}
-static int done_method(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int done_method(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
assert_se(sd_event_exit(varlink_get_event(link), 0) >= 0);
return 0;
}
assert_se(pthread_create(&t, NULL, server_thread, FD_TO_PTR(TAKE_FD(fd[1]))) == 0);
assert_se(varlink_connect_fd(&v, TAKE_FD(fd[0])) >= 0);
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
const char *error_id = NULL;
assert_se(varlink_callb(v, "xyz.TestMethod", &reply, &error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("foo", 8),
- JSON_BUILD_PAIR_UNSIGNED("bar", 9))) >= 0);
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("foo", 8),
+ SD_JSON_BUILD_PAIR_UNSIGNED("bar", 9))) >= 0);
- _cleanup_(json_variant_unrefp) JsonVariant *expected_reply = NULL;
- assert_se(json_build(&expected_reply,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("waldo", 8*9),
- JSON_BUILD_PAIR_UNSIGNED("quux", 8+9))) >= 0);
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *expected_reply = NULL;
+ assert_se(sd_json_build(&expected_reply,
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("waldo", 8*9),
+ SD_JSON_BUILD_PAIR_UNSIGNED("quux", 8+9))) >= 0);
assert_se(!error_id);
- json_variant_dump(reply, JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO, NULL, NULL);
- json_variant_dump(expected_reply, JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO, NULL, NULL);
- assert_se(json_variant_equal(reply, expected_reply));
+ sd_json_variant_dump(reply, SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL);
+ sd_json_variant_dump(expected_reply, SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO, NULL, NULL);
+ assert_se(sd_json_variant_equal(reply, expected_reply));
assert_se(varlink_callb(v, "xyz.TestMethod", &reply, &error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("foo", 9),
- JSON_BUILD_PAIR_UNSIGNED("bar", 8),
- JSON_BUILD_PAIR_STRING("optional", "pfft"))) >= 0);
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("foo", 9),
+ SD_JSON_BUILD_PAIR_UNSIGNED("bar", 8),
+ SD_JSON_BUILD_PAIR_STRING("optional", "pfft"))) >= 0);
assert_se(!error_id);
- assert_se(json_variant_equal(reply, expected_reply));
+ assert_se(sd_json_variant_equal(reply, expected_reply));
assert_se(varlink_callb(v, "xyz.TestMethod", &reply, &error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_UNSIGNED("foo", 8),
- JSON_BUILD_PAIR_UNSIGNED("bar", 9),
- JSON_BUILD_PAIR_STRING("zzz", "pfft"))) >= 0);
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_UNSIGNED("foo", 8),
+ SD_JSON_BUILD_PAIR_UNSIGNED("bar", 9),
+ SD_JSON_BUILD_PAIR_STRING("zzz", "pfft"))) >= 0);
ASSERT_STREQ(error_id, VARLINK_ERROR_INVALID_PARAMETER);
assert_se(varlink_callb(v, "xyz.TestMethod", &reply, &error_id,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_BOOLEAN("foo", true),
- JSON_BUILD_PAIR_UNSIGNED("bar", 9))) >= 0);
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_BOOLEAN("foo", true),
+ SD_JSON_BUILD_PAIR_UNSIGNED("bar", 9))) >= 0);
ASSERT_STREQ(error_id, VARLINK_ERROR_INVALID_PARAMETER);
assert_se(varlink_send(v, "xyz.Done", NULL) >= 0);
#include <pthread.h>
#include "sd-event.h"
+#include "sd-json.h"
#include "data-fd-util.h"
#include "fd-util.h"
-#include "json.h"
+#include "json-util.h"
#include "rm-rf.h"
#include "strv.h"
#include "tests.h"
static int n_done = 0;
static int block_write_fd = -EBADF;
-static int method_something(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *ret = NULL;
- JsonVariant *a, *b;
+static int method_something(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *ret = NULL;
+ sd_json_variant *a, *b;
int64_t x, y;
int r;
- a = json_variant_by_key(parameters, "a");
+ a = sd_json_variant_by_key(parameters, "a");
if (!a)
return varlink_error(link, "io.test.BadParameters", NULL);
- x = json_variant_integer(a);
+ x = sd_json_variant_integer(a);
- b = json_variant_by_key(parameters, "b");
+ b = sd_json_variant_by_key(parameters, "b");
if (!b)
return varlink_error(link, "io.test.BadParameters", NULL);
- y = json_variant_integer(b);
+ y = sd_json_variant_integer(b);
- r = json_build(&ret, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("sum", JSON_BUILD_INTEGER(x + y))));
+ r = sd_json_build(&ret, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("sum", SD_JSON_BUILD_INTEGER(x + y))));
if (r < 0)
return r;
return varlink_reply(link, ret);
}
-static int method_something_more(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *ret = NULL;
+static int method_something_more(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *ret = NULL;
int r;
struct Something {
int y;
};
- static const JsonDispatch dispatch_table[] = {
- { "a", JSON_VARIANT_INTEGER, json_dispatch_int, offsetof(struct Something, x), JSON_MANDATORY },
- { "b", JSON_VARIANT_INTEGER, json_dispatch_int, offsetof(struct Something, y), JSON_MANDATORY},
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "a", SD_JSON_VARIANT_INTEGER, sd_json_dispatch_int, offsetof(struct Something, x), SD_JSON_MANDATORY },
+ { "b", SD_JSON_VARIANT_INTEGER, sd_json_dispatch_int, offsetof(struct Something, y), SD_JSON_MANDATORY},
{}
};
struct Something s = {};
return r;
for (int i = 0; i < 5; i++) {
- _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
- r = json_build(&w, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("sum", JSON_BUILD_INTEGER(s.x + (s.y * i)))));
+ r = sd_json_build(&w, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("sum", SD_JSON_BUILD_INTEGER(s.x + (s.y * i)))));
if (r < 0)
return r;
return r;
}
- r = json_build(&ret, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("sum", JSON_BUILD_INTEGER(s.x + (s.y * 5)))));
+ r = sd_json_build(&ret, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("sum", SD_JSON_BUILD_INTEGER(s.x + (s.y * 5)))));
if (r < 0)
return r;
assert_se(memcmp_nn(buf, n, rbuf, m) == 0);
}
-static int method_passfd(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *ret = NULL;
- JsonVariant *a;
+static int method_passfd(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *ret = NULL;
+ sd_json_variant *a;
int r;
- a = json_variant_by_key(parameters, "fd");
+ a = sd_json_variant_by_key(parameters, "fd");
if (!a)
return varlink_error(link, "io.test.BadParameters", NULL);
- ASSERT_STREQ(json_variant_string(a), "whoop");
+ ASSERT_STREQ(sd_json_variant_string(a), "whoop");
int xx = varlink_peek_fd(link, 0),
yy = varlink_peek_fd(link, 1),
assert_se(vv >= 0);
assert_se(ww >= 0);
- r = json_build(&ret, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("yo", JSON_BUILD_INTEGER(88))));
+ r = sd_json_build(&ret, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("yo", SD_JSON_BUILD_INTEGER(88))));
if (r < 0)
return r;
return varlink_reply(link, ret);
}
-static int method_done(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int method_done(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
if (++n_done == 2)
sd_event_exit(varlink_get_event(link), EXIT_FAILURE);
return 0;
}
-static int reply(Varlink *link, JsonVariant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
- JsonVariant *sum;
+static int reply(Varlink *link, sd_json_variant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
+ sd_json_variant *sum;
- sum = json_variant_by_key(parameters, "sum");
+ sum = sd_json_variant_by_key(parameters, "sum");
- assert_se(json_variant_integer(sum) == 7+22);
+ assert_se(sd_json_variant_integer(sum) == 7+22);
if (++n_done == 2)
sd_event_exit(varlink_get_event(link), EXIT_FAILURE);
return 0;
}
-static int overload_reply(Varlink *link, JsonVariant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
+static int overload_reply(Varlink *link, sd_json_variant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
/* This method call reply should always be called with a disconnection, since the method call should
* be talking to an overloaded server */
assert_se(asprintf(&t, "flood-%zu", k) >= 0);
assert_se(varlink_set_description(connections[k], t) >= 0);
assert_se(varlink_attach_event(connections[k], e, k) >= 0);
- assert_se(varlink_sendb(connections[k], "io.test.Rubbish", JSON_BUILD_OBJECT(JSON_BUILD_PAIR("id", JSON_BUILD_INTEGER(k)))) >= 0);
+ assert_se(varlink_sendb(connections[k], "io.test.Rubbish", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("id", SD_JSON_BUILD_INTEGER(k)))) >= 0);
}
/* Then, create one more, which should fail */
assert_se(varlink_set_description(c, "overload-client") >= 0);
assert_se(varlink_attach_event(c, e, k) >= 0);
assert_se(varlink_bind_reply(c, overload_reply) >= 0);
- assert_se(varlink_invokeb(c, "io.test.Overload", JSON_BUILD_OBJECT(JSON_BUILD_PAIR("foo", JSON_BUILD_CONST_STRING("bar")))) >= 0);
+ assert_se(varlink_invokeb(c, "io.test.Overload", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("foo", JSON_BUILD_CONST_STRING("bar")))) >= 0);
/* Unblock it */
log_debug("Unblocking server...");
static void *thread(void *arg) {
_cleanup_(varlink_flush_close_unrefp) Varlink *c = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *i = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *wrong = NULL;
- JsonVariant *o = NULL, *k = NULL, *j = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *i = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *wrong = NULL;
+ sd_json_variant *o = NULL, *k = NULL, *j = NULL;
const char *error_id;
const char *e;
int x = 0;
- assert_se(json_build(&i, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("a", JSON_BUILD_INTEGER(88)),
- JSON_BUILD_PAIR("b", JSON_BUILD_INTEGER(99)))) >= 0);
+ assert_se(sd_json_build(&i, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("a", SD_JSON_BUILD_INTEGER(88)),
+ SD_JSON_BUILD_PAIR("b", SD_JSON_BUILD_INTEGER(99)))) >= 0);
assert_se(varlink_connect_address(&c, arg) >= 0);
assert_se(varlink_set_description(c, "thread-client") >= 0);
assert_se(varlink_set_allow_fd_passing_output(c, true) >= 0);
/* Test that client is able to perform two sequential varlink_collect calls if first resulted in an error */
- assert_se(json_build(&wrong, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("a", JSON_BUILD_INTEGER(88)),
- JSON_BUILD_PAIR("c", JSON_BUILD_INTEGER(99)))) >= 0);
+ assert_se(sd_json_build(&wrong, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("a", SD_JSON_BUILD_INTEGER(88)),
+ SD_JSON_BUILD_PAIR("c", SD_JSON_BUILD_INTEGER(99)))) >= 0);
assert_se(varlink_collect(c, "io.test.DoSomethingMore", wrong, &j, &error_id) >= 0);
assert_se(strcmp_ptr(error_id, "org.varlink.service.InvalidParameter") == 0);
assert_se(varlink_collect(c, "io.test.DoSomethingMore", i, &j, &error_id) >= 0);
assert_se(!error_id);
- assert_se(json_variant_is_array(j) && !json_variant_is_blank_array(j));
+ assert_se(sd_json_variant_is_array(j) && !sd_json_variant_is_blank_array(j));
JSON_VARIANT_ARRAY_FOREACH(k, j) {
- assert_se(json_variant_integer(json_variant_by_key(k, "sum")) == 88 + (99 * x));
+ assert_se(sd_json_variant_integer(sd_json_variant_by_key(k, "sum")) == 88 + (99 * x));
x++;
}
assert_se(x == 6);
assert_se(varlink_call(c, "io.test.DoSomething", i, &o, &e) >= 0);
- assert_se(json_variant_integer(json_variant_by_key(o, "sum")) == 88 + 99);
+ assert_se(sd_json_variant_integer(sd_json_variant_by_key(o, "sum")) == 88 + 99);
assert_se(!e);
int fd1 = acquire_data_fd("foo");
assert_se(varlink_push_fd(c, fd2) == 1);
assert_se(varlink_push_fd(c, fd3) == 2);
- assert_se(varlink_callb(c, "io.test.PassFD", &o, &e, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("fd", JSON_BUILD_STRING("whoop")))) >= 0);
+ assert_se(varlink_callb(c, "io.test.PassFD", &o, &e, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("fd", SD_JSON_BUILD_STRING("whoop")))) >= 0);
int fd4 = varlink_peek_fd(c, 0);
int fd5 = varlink_peek_fd(c, 1);
test_fd(fd4, "miau", 4);
test_fd(fd5, "wuff", 4);
- assert_se(varlink_callb(c, "io.test.IDontExist", &o, &e, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("x", JSON_BUILD_REAL(5.5)))) >= 0);
- ASSERT_STREQ(json_variant_string(json_variant_by_key(o, "method")), "io.test.IDontExist");
+ assert_se(varlink_callb(c, "io.test.IDontExist", &o, &e, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("x", SD_JSON_BUILD_REAL(5.5)))) >= 0);
+ ASSERT_STREQ(sd_json_variant_string(sd_json_variant_by_key(o, "method")), "io.test.IDontExist");
ASSERT_STREQ(e, VARLINK_ERROR_METHOD_NOT_FOUND);
flood_test(arg);
_cleanup_(varlink_server_unrefp) VarlinkServer *s = NULL;
_cleanup_(varlink_flush_close_unrefp) Varlink *c = NULL;
_cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_close_pair_ int block_fds[2] = EBADF_PAIR;
pthread_t t;
assert_se(varlink_server_attach_event(s, e, 0) >= 0);
assert_se(varlink_server_set_connections_max(s, OVERLOAD_CONNECTIONS) >= 0);
- assert_se(json_build(&v, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("a", JSON_BUILD_INTEGER(7)),
- JSON_BUILD_PAIR("b", JSON_BUILD_INTEGER(22)))) >= 0);
+ assert_se(sd_json_build(&v, SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR("a", SD_JSON_BUILD_INTEGER(7)),
+ SD_JSON_BUILD_PAIR("b", SD_JSON_BUILD_INTEGER(22)))) >= 0);
assert_se(varlink_connect_address(&c, sp) >= 0);
assert_se(varlink_set_description(c, "main-client") >= 0);
#include <unistd.h>
#include "sd-device.h"
+#include "sd-json.h"
#include "alloc-util.h"
#include "device-enumerator-private.h"
#include "fd-util.h"
#include "fileio.h"
#include "glyph-util.h"
-#include "json.h"
#include "pager.h"
#include "parse-argument.h"
#include "sort-util.h"
static const char *arg_export_prefix = NULL;
static usec_t arg_wait_for_initialization_timeout = 0;
PagerFlags arg_pager_flags = 0;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
/* Put a limit on --tree descent level to not exhaust our stack */
#define TREE_DEPTH_MAX 64
return 0;
}
-static int record_to_json(sd_device *device, JsonVariant **ret) {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+static int record_to_json(sd_device *device, sd_json_variant **ret) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
const char *str;
int r;
* all the other ones have a matching property which will already be included. */
if (sd_device_get_sysname(device, &str) >= 0) {
- r = json_variant_set_field_string(&v, "SYSNAME", str);
+ r = sd_json_variant_set_field_string(&v, "SYSNAME", str);
if (r < 0)
return r;
}
if (sd_device_get_sysnum(device, &str) >= 0) {
- r = json_variant_set_field_string(&v, "SYSNUM", str);
+ r = sd_json_variant_set_field_string(&v, "SYSNUM", str);
if (r < 0)
return r;
}
FOREACH_DEVICE_PROPERTY(device, key, val) {
- r = json_variant_set_field_string(&v, key, val);
+ r = sd_json_variant_set_field_string(&v, key, val);
if (r < 0)
return r;
}
pager_open(arg_pager_flags);
FOREACH_DEVICE_AND_SUBSYSTEM(e, d)
- if (arg_json_format_flags & JSON_FORMAT_OFF)
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF)
(void) print_record(d, NULL);
else {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = record_to_json(d, &v);
if (r < 0)
return r;
- (void) json_variant_dump(v, arg_json_format_flags, stdout, NULL);
+ (void) sd_json_variant_dump(v, arg_json_format_flags, stdout, NULL);
}
return 0;
return 0;
case QUERY_ALL:
- if (arg_json_format_flags & JSON_FORMAT_OFF)
+ if (arg_json_format_flags & SD_JSON_FORMAT_OFF)
return print_record(device, NULL);
else {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = record_to_json(device, &v);
if (r < 0)
return r;
- (void) json_variant_dump(v, arg_json_format_flags, stdout, NULL);
+ (void) sd_json_variant_dump(v, arg_json_format_flags, stdout, NULL);
}
return 0;
static bool arg_legend = true;
static char** arg_services = NULL;
static UserDBFlags arg_userdb_flags = 0;
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static bool arg_chain = false;
STATIC_DESTRUCTOR_REGISTER(arg_services, strv_freep);
break;
case OUTPUT_JSON:
- json_variant_dump(ur->json, arg_json_format_flags, NULL, 0);
+ sd_json_variant_dump(ur->json, arg_json_format_flags, NULL, 0);
break;
case OUTPUT_FRIENDLY:
}
case OUTPUT_JSON:
- json_variant_dump(gr->json, arg_json_format_flags, NULL, 0);
+ sd_json_variant_dump(gr->json, arg_json_format_flags, NULL, 0);
break;
case OUTPUT_FRIENDLY:
break;
case OUTPUT_JSON: {
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
- r = json_build(&v, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("user", JSON_BUILD_STRING(user)),
- JSON_BUILD_PAIR("group", JSON_BUILD_STRING(group))));
+ r = sd_json_build(&v, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("user", SD_JSON_BUILD_STRING(user)),
+ SD_JSON_BUILD_PAIR("group", SD_JSON_BUILD_STRING(group))));
if (r < 0)
return log_error_errno(r, "Failed to build JSON object: %m");
- json_variant_dump(v, arg_json_format_flags, NULL, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, NULL, NULL);
break;
}
} else
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid --output= mode: %s", optarg);
- arg_json_format_flags = arg_output == OUTPUT_JSON ? JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR_AUTO : JSON_FORMAT_OFF;
+ arg_json_format_flags = arg_output == OUTPUT_JSON ? SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR_AUTO : SD_JSON_FORMAT_OFF;
break;
case ARG_JSON:
if (r <= 0)
return r;
- arg_output = FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF) ? _OUTPUT_INVALID : OUTPUT_JSON;
+ arg_output = FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF) ? _OUTPUT_INVALID : OUTPUT_JSON;
break;
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR_AUTO;
arg_output = OUTPUT_JSON;
break;
const char *service;
} LookupParameters;
-static int add_nss_service(JsonVariant **v) {
- _cleanup_(json_variant_unrefp) JsonVariant *status = NULL, *z = NULL;
+static int add_nss_service(sd_json_variant **v) {
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *status = NULL, *z = NULL;
sd_id128_t mid;
int r;
/* Patch in service field if it's missing. The assumption here is that this field is unset only for
* NSS records */
- if (json_variant_by_key(*v, "service"))
+ if (sd_json_variant_by_key(*v, "service"))
return 0;
r = sd_id128_get_machine(&mid);
if (r < 0)
return r;
- status = json_variant_ref(json_variant_by_key(*v, "status"));
- z = json_variant_ref(json_variant_by_key(status, SD_ID128_TO_STRING(mid)));
+ status = sd_json_variant_ref(sd_json_variant_by_key(*v, "status"));
+ z = sd_json_variant_ref(sd_json_variant_by_key(status, SD_ID128_TO_STRING(mid)));
- if (json_variant_by_key(z, "service"))
+ if (sd_json_variant_by_key(z, "service"))
return 0;
- r = json_variant_set_field_string(&z, "service", "io.systemd.NameServiceSwitch");
+ r = sd_json_variant_set_field_string(&z, "service", "io.systemd.NameServiceSwitch");
if (r < 0)
return r;
- r = json_variant_set_field(&status, SD_ID128_TO_STRING(mid), z);
+ r = sd_json_variant_set_field(&status, SD_ID128_TO_STRING(mid), z);
if (r < 0)
return r;
- return json_variant_set_field(v, "status", status);
+ return sd_json_variant_set_field(v, "status", status);
}
-static int build_user_json(Varlink *link, UserRecord *ur, JsonVariant **ret) {
+static int build_user_json(Varlink *link, UserRecord *ur, sd_json_variant **ret) {
_cleanup_(user_record_unrefp) UserRecord *stripped = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
UserRecordLoadFlags flags;
uid_t peer_uid;
bool trusted;
(FLAGS_SET(ur->mask, USER_RECORD_PRIVILEGED) &&
!FLAGS_SET(stripped->mask, USER_RECORD_PRIVILEGED));
- v = json_variant_ref(stripped->json);
+ v = sd_json_variant_ref(stripped->json);
r = add_nss_service(&v);
if (r < 0)
return r;
- return json_build(ret, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("record", JSON_BUILD_VARIANT(v)),
- JSON_BUILD_PAIR("incomplete", JSON_BUILD_BOOLEAN(stripped->incomplete))));
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_VARIANT(v)),
+ SD_JSON_BUILD_PAIR("incomplete", SD_JSON_BUILD_BOOLEAN(stripped->incomplete))));
}
static int userdb_flags_from_service(Varlink *link, const char *service, UserDBFlags *ret) {
return 0;
}
-static int vl_method_get_user_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_user_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "uid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), 0 },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), 0 },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
LookupParameters p = {
.uid = UID_INVALID,
r = userdb_by_name(p.user_name, userdb_flags, &hr);
else {
_cleanup_(userdb_iterator_freep) UserDBIterator *iterator = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *last = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *last = NULL;
r = userdb_all(userdb_flags, &iterator);
if (IN_SET(r, -ESRCH, -ENOLINK))
if (r < 0)
return r;
- last = json_variant_unref(last);
+ last = sd_json_variant_unref(last);
}
r = build_user_json(link, z, &last);
return varlink_reply(link, v);
}
-static int build_group_json(Varlink *link, GroupRecord *gr, JsonVariant **ret) {
+static int build_group_json(Varlink *link, GroupRecord *gr, sd_json_variant **ret) {
_cleanup_(group_record_unrefp) GroupRecord *stripped = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
UserRecordLoadFlags flags;
uid_t peer_uid;
bool trusted;
(FLAGS_SET(gr->mask, USER_RECORD_PRIVILEGED) &&
!FLAGS_SET(stripped->mask, USER_RECORD_PRIVILEGED));
- v = json_variant_ref(gr->json);
+ v = sd_json_variant_ref(gr->json);
r = add_nss_service(&v);
if (r < 0)
return r;
- return json_build(ret, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("record", JSON_BUILD_VARIANT(v)),
- JSON_BUILD_PAIR("incomplete", JSON_BUILD_BOOLEAN(stripped->incomplete))));
+ return sd_json_build(ret, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_VARIANT(v)),
+ SD_JSON_BUILD_PAIR("incomplete", SD_JSON_BUILD_BOOLEAN(stripped->incomplete))));
}
-static int vl_method_get_group_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
+static int vl_method_get_group_record(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "gid", JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), 0 },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), 0 },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
- _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
_cleanup_(group_record_unrefp) GroupRecord *g = NULL;
LookupParameters p = {
.gid = GID_INVALID,
r = groupdb_by_name(p.group_name, userdb_flags, &g);
else {
_cleanup_(userdb_iterator_freep) UserDBIterator *iterator = NULL;
- _cleanup_(json_variant_unrefp) JsonVariant *last = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *last = NULL;
r = groupdb_all(userdb_flags, &iterator);
if (IN_SET(r, -ESRCH, -ENOLINK))
if (r < 0)
return r;
- last = json_variant_unref(last);
+ last = sd_json_variant_unref(last);
}
r = build_group_json(link, z, &last);
return varlink_reply(link, v);
}
-static int vl_method_get_memberships(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- static const JsonDispatch dispatch_table[] = {
- { "userName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name), 0 },
- { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), 0 },
- { "service", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
+static int vl_method_get_memberships(Varlink *link, sd_json_variant *parameters, VarlinkMethodFlags flags, void *userdata) {
+ static const sd_json_dispatch_field dispatch_table[] = {
+ { "userName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, user_name), 0 },
+ { "groupName", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, group_name), 0 },
+ { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
{}
};
if (last_user_name) {
assert(last_group_name);
- r = varlink_notifyb(link, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(last_user_name)),
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(last_group_name))));
+ r = varlink_notifyb(link, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(last_user_name)),
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(last_group_name))));
if (r < 0)
return r;
}
assert(last_group_name);
- return varlink_replyb(link, JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(last_user_name)),
- JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(last_group_name))));
+ return varlink_replyb(link, SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(last_user_name)),
+ SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(last_group_name))));
}
static int process_connection(VarlinkServer *server, int _fd) {
#include "verbs.h"
#include "version.h"
-static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
+static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static VarlinkMethodFlags arg_method_flags = 0;
static bool arg_collect = false;
break;
case 'j':
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
break;
case '?':
/* If more than one reply is expected, imply JSON-SEQ output */
if (FLAGS_SET(arg_method_flags, VARLINK_METHOD_MORE))
- arg_json_format_flags |= JSON_FORMAT_SEQ;
+ arg_json_format_flags |= SD_JSON_FORMAT_SEQ;
return 1;
}
if (r < 0)
return r;
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
r = varlink_call_and_log(vl, "org.varlink.service.GetInfo", /* parameters= */ NULL, &reply);
if (r < 0)
return r;
pager_open(arg_pager_flags);
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
- static const struct JsonDispatch dispatch_table[] = {
- { "vendor", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(GetInfoData, vendor), JSON_MANDATORY },
- { "product", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(GetInfoData, product), JSON_MANDATORY },
- { "version", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(GetInfoData, version), JSON_MANDATORY },
- { "url", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(GetInfoData, url), JSON_MANDATORY },
- { "interfaces", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(GetInfoData, interfaces), JSON_MANDATORY },
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
+ static const struct sd_json_dispatch_field dispatch_table[] = {
+ { "vendor", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(GetInfoData, vendor), SD_JSON_MANDATORY },
+ { "product", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(GetInfoData, product), SD_JSON_MANDATORY },
+ { "version", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(GetInfoData, version), SD_JSON_MANDATORY },
+ { "url", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(GetInfoData, url), SD_JSON_MANDATORY },
+ { "interfaces", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(GetInfoData, interfaces), SD_JSON_MANDATORY },
{}
};
_cleanup_(get_info_data_done) GetInfoData data = {};
- r = json_dispatch(reply, dispatch_table, JSON_LOG, &data);
+ r = sd_json_dispatch(reply, dispatch_table, SD_JSON_LOG, &data);
if (r < 0)
return r;
return table_log_print_error(r);
}
} else {
- JsonVariant *v;
+ sd_json_variant *v;
v = streq_ptr(argv[0], "list-interfaces") ?
- json_variant_by_key(reply, "interfaces") : reply;
+ sd_json_variant_by_key(reply, "interfaces") : reply;
- json_variant_dump(v, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(v, arg_json_format_flags, stdout, NULL);
}
return 0;
if (r < 0)
return r;
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
r = varlink_callb_and_log(
vl,
"org.varlink.service.GetInterfaceDescription",
&reply,
- JSON_BUILD_OBJECT(JSON_BUILD_PAIR_STRING("interface", interface)));
+ SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_STRING("interface", interface)));
if (r < 0)
return r;
pager_open(arg_pager_flags);
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF)) {
- static const struct JsonDispatch dispatch_table[] = {
- { "description", JSON_VARIANT_STRING, json_dispatch_const_string, 0, JSON_MANDATORY },
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF)) {
+ static const struct sd_json_dispatch_field dispatch_table[] = {
+ { "description", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, 0, SD_JSON_MANDATORY },
{}
};
_cleanup_(varlink_interface_freep) VarlinkInterface *vi = NULL;
const char *description = NULL;
unsigned line = 0, column = 0;
- r = json_dispatch(reply, dispatch_table, JSON_LOG, &description);
+ r = sd_json_dispatch(reply, dispatch_table, SD_JSON_LOG, &description);
if (r < 0)
return r;
return log_error_errno(r, "Failed to format parsed interface description: %m");
}
} else
- json_variant_dump(reply, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(reply, arg_json_format_flags, stdout, NULL);
return 0;
}
static int reply_callback(
Varlink *link,
- JsonVariant *parameters,
+ sd_json_variant *parameters,
const char *error,
VarlinkReplyFlags flags,
void *userdata) {
} else
r = 0;
- json_variant_dump(parameters, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(parameters, arg_json_format_flags, stdout, NULL);
return r;
}
static int verb_call(int argc, char *argv[], void *userdata) {
- _cleanup_(json_variant_unrefp) JsonVariant *jp = NULL;
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *jp = NULL;
_cleanup_(varlink_unrefp) Varlink *vl = NULL;
const char *url, *method, *parameter;
unsigned line = 0, column = 0;
parameter = argc > 3 && !streq(argv[3], "-") ? argv[3] : NULL;
/* No JSON mode explicitly configured? Then default to the same as -j */
- if (FLAGS_SET(arg_json_format_flags, JSON_FORMAT_OFF))
- arg_json_format_flags = JSON_FORMAT_PRETTY_AUTO|JSON_FORMAT_COLOR_AUTO;
+ if (FLAGS_SET(arg_json_format_flags, SD_JSON_FORMAT_OFF))
+ arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
/* For pipeable text tools it's kinda customary to finish output off in a newline character, and not
* leave incomplete lines hanging around. */
- arg_json_format_flags |= JSON_FORMAT_NEWLINE;
+ arg_json_format_flags |= SD_JSON_FORMAT_NEWLINE;
if (parameter) {
/* <argv[4]> is correct, as dispatch_verb() shifts arguments by one for the verb. */
- r = json_parse_with_source(parameter, "<argv[4]>", 0, &jp, &line, &column);
+ r =
sd_json_parse_with_source(parameter, "<argv[4]>", 0, &jp, &line, &column);
if (r < 0)
return log_error_errno(r, "Failed to parse parameters at <argv[4]>:%u:%u: %m", line, column);
} else {
- r = json_parse_file_at(stdin, AT_FDCWD, "<stdin>", 0, &jp, &line, &column);
+ r = sd_json_parse_file_at(stdin, AT_FDCWD, "<stdin>", 0, &jp, &line, &column);
if (r < 0)
return log_error_errno(r, "Failed to parse parameters at <stdin>:%u:%u: %m", line, column);
}
return r;
if (arg_collect) {
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
const char *error = NULL;
r = varlink_collect(vl, method, jp, &reply, &error);
r = 0;
pager_open(arg_pager_flags);
- json_variant_dump(reply, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(reply, arg_json_format_flags, stdout, NULL);
return r;
} else if (arg_method_flags & VARLINK_METHOD_ONEWAY) {
return ret;
} else {
- JsonVariant *reply = NULL;
+ sd_json_variant *reply = NULL;
const char *error = NULL;
r = varlink_call(vl, method, jp, &reply, &error);
pager_open(arg_pager_flags);
- json_variant_dump(reply, arg_json_format_flags, stdout, NULL);
+ sd_json_variant_dump(reply, arg_json_format_flags, stdout, NULL);
return r;
}
#include "sd-bus.h"
#include "sd-id128.h"
+#include "sd-json.h"
#include "bus-error.h"
#include "bus-locator.h"
-#include "json.h"
+#include "json-util.h"
#include "macro.h"
#include "process-util.h"
#include "socket-util.h"
return varlink_callb_and_log(vl,
"io.systemd.Machine.Register",
NULL,
- JSON_BUILD_OBJECT(
- JSON_BUILD_PAIR_STRING("name", machine_name),
- JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(uuid), "id", JSON_BUILD_ID128(uuid)),
- JSON_BUILD_PAIR_STRING("service", service),
- JSON_BUILD_PAIR_STRING("class", "vm"),
- JSON_BUILD_PAIR_CONDITION(VSOCK_CID_IS_REGULAR(cid), "vSockCid", JSON_BUILD_UNSIGNED(cid)),
- JSON_BUILD_PAIR_CONDITION(directory, "rootDirectory", JSON_BUILD_STRING(directory)),
- JSON_BUILD_PAIR_CONDITION(address, "sshAddress", JSON_BUILD_STRING(address)),
- JSON_BUILD_PAIR_CONDITION(key_path, "sshPrivateKeyPath", JSON_BUILD_STRING(key_path))));
+ SD_JSON_BUILD_OBJECT(
+ SD_JSON_BUILD_PAIR_STRING("name", machine_name),
+ SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(uuid), "id", SD_JSON_BUILD_ID128(uuid)),
+ SD_JSON_BUILD_PAIR_STRING("service", service),
+ SD_JSON_BUILD_PAIR_STRING("class", "vm"),
+ SD_JSON_BUILD_PAIR_CONDITION(VSOCK_CID_IS_REGULAR(cid), "vSockCid", SD_JSON_BUILD_UNSIGNED(cid)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!directory, "rootDirectory", SD_JSON_BUILD_STRING(directory)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!address, "sshAddress", SD_JSON_BUILD_STRING(address)),
+ SD_JSON_BUILD_PAIR_CONDITION(!!key_path, "sshPrivateKeyPath", SD_JSON_BUILD_STRING(key_path))));
}
int unregister_machine(sd_bus *bus, const char *machine_name) {
#include <linux/vhost.h>
#include <sys/ioctl.h>
+#include "sd-json.h"
+
#include "architecture.h"
#include "conf-files.h"
#include "errno-util.h"
#include "escape.h"
#include "fd-util.h"
#include "fileio.h"
-#include "json.h"
+#include "json-util.h"
#include "log.h"
#include "macro.h"
#include "memory-util.h"
}
DEFINE_TRIVIAL_CLEANUP_FUNC(FirmwareData*, firmware_data_free);
-static int firmware_executable(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "filename", JSON_VARIANT_STRING, json_dispatch_string, offsetof(FirmwareData, firmware), JSON_MANDATORY },
- { "format", JSON_VARIANT_STRING, json_dispatch_string, offsetof(FirmwareData, firmware_format), JSON_MANDATORY },
+static int firmware_executable(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
+ static const sd_json_dispatch_field table[] = {
+ { "filename", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(FirmwareData, firmware), SD_JSON_MANDATORY },
+ { "format", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(FirmwareData, firmware_format), SD_JSON_MANDATORY },
{}
};
- return json_dispatch(v, table, flags, userdata);
+ return sd_json_dispatch(v, table, flags, userdata);
}
-static int firmware_nvram_template(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "filename", JSON_VARIANT_STRING, json_dispatch_string, offsetof(FirmwareData, vars), JSON_MANDATORY },
- { "format", JSON_VARIANT_STRING, json_dispatch_string, offsetof(FirmwareData, vars_format), JSON_MANDATORY },
+static int firmware_nvram_template(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
+ static const sd_json_dispatch_field table[] = {
+ { "filename", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(FirmwareData, vars), SD_JSON_MANDATORY },
+ { "format", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, offsetof(FirmwareData, vars_format), SD_JSON_MANDATORY },
{}
};
- return json_dispatch(v, table, flags, userdata);
+ return sd_json_dispatch(v, table, flags, userdata);
}
-static int firmware_mapping(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- static const JsonDispatch table[] = {
- { "device", JSON_VARIANT_STRING, NULL, 0, JSON_MANDATORY },
- { "executable", JSON_VARIANT_OBJECT, firmware_executable, 0, JSON_MANDATORY },
- { "nvram-template", JSON_VARIANT_OBJECT, firmware_nvram_template, 0, JSON_MANDATORY },
+static int firmware_mapping(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
+ static const sd_json_dispatch_field table[] = {
+ { "device", SD_JSON_VARIANT_STRING, NULL, 0, SD_JSON_MANDATORY },
+ { "executable", SD_JSON_VARIANT_OBJECT, firmware_executable, 0, SD_JSON_MANDATORY },
+ { "nvram-template", SD_JSON_VARIANT_OBJECT, firmware_nvram_template, 0, SD_JSON_MANDATORY },
{}
};
- return json_dispatch(v, table, flags, userdata);
+ return sd_json_dispatch(v, table, flags, userdata);
}
-static int target_architecture(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
+static int target_architecture(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
int r;
- JsonVariant *e;
+ sd_json_variant *e;
char ***supported_architectures = ASSERT_PTR(userdata);
- static const JsonDispatch table[] = {
- { "architecture", JSON_VARIANT_STRING, json_dispatch_string, 0, JSON_MANDATORY },
- { "machines", JSON_VARIANT_ARRAY, NULL, 0, JSON_MANDATORY },
+ static const sd_json_dispatch_field table[] = {
+ { "architecture", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, 0, SD_JSON_MANDATORY },
+ { "machines", SD_JSON_VARIANT_ARRAY, NULL, 0, SD_JSON_MANDATORY },
{}
};
JSON_VARIANT_ARRAY_FOREACH(e, v) {
_cleanup_free_ char *arch = NULL;
- r = json_dispatch(e, table, flags, &arch);
+ r = sd_json_dispatch(e, table, flags, &arch);
if (r < 0)
return r;
assert(path);
assert(ret);
- _cleanup_(json_variant_unrefp) JsonVariant *json = NULL;
- r = json_parse_file(
+ _cleanup_(sd_json_variant_unrefp) sd_json_variant *json = NULL;
+ r = sd_json_parse_file(
/* f= */ NULL,
path,
/* flags= */ 0,
if (r < 0)
return r;
- static const JsonDispatch table[] = {
- { "description", JSON_VARIANT_STRING, NULL, 0, JSON_MANDATORY },
- { "interface-types", JSON_VARIANT_ARRAY, NULL, 0, JSON_MANDATORY },
- { "mapping", JSON_VARIANT_OBJECT, firmware_mapping, 0, JSON_MANDATORY },
- { "targets", JSON_VARIANT_ARRAY, target_architecture, offsetof(FirmwareData, architectures), JSON_MANDATORY },
- { "features", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(FirmwareData, features), JSON_MANDATORY },
- { "tags", JSON_VARIANT_ARRAY, NULL, 0, JSON_MANDATORY },
+ static const sd_json_dispatch_field table[] = {
+ { "description", SD_JSON_VARIANT_STRING, NULL, 0, SD_JSON_MANDATORY },
+ { "interface-types", SD_JSON_VARIANT_ARRAY, NULL, 0, SD_JSON_MANDATORY },
+ { "mapping", SD_JSON_VARIANT_OBJECT, firmware_mapping, 0, SD_JSON_MANDATORY },
+ { "targets", SD_JSON_VARIANT_ARRAY, target_architecture, offsetof(FirmwareData, architectures), SD_JSON_MANDATORY },
+ { "features", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(FirmwareData, features), SD_JSON_MANDATORY },
+ { "tags", SD_JSON_VARIANT_ARRAY, NULL, 0, SD_JSON_MANDATORY },
{}
};
if (!fwd)
return -ENOMEM;
- r = json_dispatch(json, table, JSON_ALLOW_EXTENSIONS, fwd);
+ r = sd_json_dispatch(json, table, SD_JSON_ALLOW_EXTENSIONS, fwd);
if (r < 0)
return r;
projects / thirdparty / systemd.git / commitdiff
