shared: prefer using SD_JSON_BUILD_PAIR_* over SD_JSON_BUILD_PAIR()

No functional change, just refactoring.

diff --git a/src/shared/bootspec.c b/src/shared/bootspec.c
index 290f12a9798f544e62fc0c952a713ee0266073ed..12f67fbce1e8f27890e93aa974f50b5eea97cea2 100644 (file)
--- a/src/shared/bootspec.c
+++ b/src/shared/bootspec.c
@@ -1813,7 +1813,7 @@ static int json_cmdline(
 
         r = sd_json_variant_merge_objectbo(
                         v,
-                        SD_JSON_BUILD_PAIR("addons", SD_JSON_BUILD_VARIANT(addons_array)),
+                        SD_JSON_BUILD_PAIR_VARIANT("addons", addons_array),
                         SD_JSON_BUILD_PAIR_CONDITION(!!combined_cmdline, "cmdline", SD_JSON_BUILD_STRING(combined_cmdline)));
         if (r < 0)
                 return log_oom();
@@ -1959,8 +1959,8 @@ int boot_entry_to_json(const BootConfig *c, size_t i, sd_json_variant **ret) {
 
         r = sd_json_variant_merge_objectbo(
                         &v,
-                        SD_JSON_BUILD_PAIR("type", SD_JSON_BUILD_STRING(boot_entry_type_to_string(e->type))),
-                        SD_JSON_BUILD_PAIR("source", SD_JSON_BUILD_STRING(boot_entry_source_to_string(e->source))),
+                        SD_JSON_BUILD_PAIR_STRING("type", boot_entry_type_to_string(e->type)),
+                        SD_JSON_BUILD_PAIR_STRING("source", boot_entry_source_to_string(e->source)),
                         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)),
@@ -1987,7 +1987,7 @@ int boot_entry_to_json(const BootConfig *c, size_t i, sd_json_variant **ret) {
                         &v,
                         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)),
-                        SD_JSON_BUILD_PAIR("isReported", SD_JSON_BUILD_BOOLEAN(e->reported_by_loader)),
+                        SD_JSON_BUILD_PAIR_BOOLEAN("isReported", 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)),

diff --git a/src/shared/creds-util.c b/src/shared/creds-util.c
index ae448cbd59b1c1781d290075f57c57022eca15ef..a54883744fe076b3f532ee4468d089291a241501 100644 (file)
--- a/src/shared/creds-util.c
+++ b/src/shared/creds-util.c
@@ -1588,7 +1588,7 @@ int ipc_encrypt_credential(const char *name, usec_t timestamp, usec_t not_after,
                         &reply,
                         &error_id,
                         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_VARIANT("data", 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")),
@@ -1648,7 +1648,7 @@ int ipc_decrypt_credential(const char *validate_name, usec_t validate_timestamp,
                         &reply,
                         &error_id,
                         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_VARIANT("blob", 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)),

diff --git a/src/shared/dissect-image.c b/src/shared/dissect-image.c
index ff59029f9f4235bd40ebd49f39e062d7bc3c4235..081fec28776bea7ebf5be7f944d2bdc223ec717b 100644 (file)
--- a/src/shared/dissect-image.c
+++ b/src/shared/dissect-image.c
@@ -4807,16 +4807,16 @@ int mountfsd_mount_image(
                         "io.systemd.MountFileSystem.MountImage",
                         &reply,
                         &error_id,
-                        SD_JSON_BUILD_PAIR("imageFileDescriptor", SD_JSON_BUILD_UNSIGNED(0)),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("imageFileDescriptor", 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_BOOLEAN("readOnly", FLAGS_SET(flags, DISSECT_IMAGE_MOUNT_READ_ONLY)),
+                        SD_JSON_BUILD_PAIR_BOOLEAN("growFileSystems", FLAGS_SET(flags, DISSECT_IMAGE_GROWFS)),
                         SD_JSON_BUILD_PAIR_CONDITION(!!ps, "imagePolicy", SD_JSON_BUILD_STRING(ps)),
-                        SD_JSON_BUILD_PAIR("veritySharing", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(flags, DISSECT_IMAGE_VERITY_SHARE))),
+                        SD_JSON_BUILD_PAIR_BOOLEAN("veritySharing", FLAGS_SET(flags, DISSECT_IMAGE_VERITY_SHARE)),
                         SD_JSON_BUILD_PAIR_CONDITION(verity_data_fd >= 0, "verityDataFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd >= 0 ? 2 : 1)),
                         JSON_BUILD_PAIR_IOVEC_HEX("verityRootHash", &verity->root_hash),
                         JSON_BUILD_PAIR_IOVEC_BASE64("verityRootHashSignature", &verity->root_hash_sig),
-                        SD_JSON_BUILD_PAIR("allowInteractiveAuthentication", SD_JSON_BUILD_BOOLEAN(FLAGS_SET(flags, DISSECT_IMAGE_ALLOW_INTERACTIVE_AUTH))));
+                        SD_JSON_BUILD_PAIR_BOOLEAN("allowInteractiveAuthentication", FLAGS_SET(flags, DISSECT_IMAGE_ALLOW_INTERACTIVE_AUTH)));
         if (r < 0)
                 return r;
 

diff --git a/src/shared/dns-rr.c b/src/shared/dns-rr.c
index d0ed39a08b00d48ee0bf9630105c99944229edb6..515ab67b060f84749afb524bf5eca2c8e0e6907a 100644 (file)
--- a/src/shared/dns-rr.c
+++ b/src/shared/dns-rr.c
@@ -2313,11 +2313,11 @@ int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret) {
         case DNS_TYPE_SRV:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("priority", rr->srv.priority),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("weight", rr->srv.weight),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("port", rr->srv.port),
+                                SD_JSON_BUILD_PAIR_STRING("name", rr->srv.name));
 
         case DNS_TYPE_PTR:
         case DNS_TYPE_NS:
@@ -2325,15 +2325,15 @@ int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret) {
         case DNS_TYPE_DNAME:
                 return sd_json_buildo(
                                 ret,
-                                SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
-                                SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(rr->ptr.name)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_STRING("name", rr->ptr.name));
 
         case DNS_TYPE_HINFO:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_STRING("cpu", rr->hinfo.cpu),
+                                SD_JSON_BUILD_PAIR_STRING("os", rr->hinfo.os));
 
         case DNS_TYPE_SPF:
         case DNS_TYPE_TXT: {
@@ -2345,90 +2345,90 @@ int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret) {
 
                 return sd_json_buildo(
                                 ret,
-                                SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
-                                SD_JSON_BUILD_PAIR("items", SD_JSON_BUILD_VARIANT(l)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_VARIANT("items", l));
         }
 
         case DNS_TYPE_A:
                 return sd_json_buildo(
                                 ret,
-                                SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                 SD_JSON_BUILD_PAIR("address", JSON_BUILD_IN4_ADDR(&rr->a.in_addr)));
 
         case DNS_TYPE_AAAA:
                 return sd_json_buildo(
                                 ret,
-                                SD_JSON_BUILD_PAIR("key", SD_JSON_BUILD_VARIANT(k)),
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                 SD_JSON_BUILD_PAIR("address", JSON_BUILD_IN6_ADDR(&rr->aaaa.in6_addr)));
 
         case DNS_TYPE_SOA:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_STRING("mname", rr->soa.mname),
+                                SD_JSON_BUILD_PAIR_STRING("rname", rr->soa.rname),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("serial", rr->soa.serial),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("refresh", rr->soa.refresh),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("expire", rr->soa.retry),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("minimum", rr->soa.minimum));
 
         case DNS_TYPE_MX:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("priority", rr->mx.priority),
+                                SD_JSON_BUILD_PAIR_STRING("exchange", rr->mx.exchange));
         case DNS_TYPE_LOC:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("version", rr->loc.version),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("size", rr->loc.size),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("horiz_pre", rr->loc.horiz_pre),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("vert_pre", rr->loc.vert_pre),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("latitude", rr->loc.latitude),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("longitude", rr->loc.longitude),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("altitude", rr->loc.altitude));
 
         case DNS_TYPE_DS:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("keyTag", rr->ds.key_tag),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->ds.algorithm),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("digestType", rr->ds.digest_type),
+                                SD_JSON_BUILD_PAIR_HEX("digest", rr->ds.digest, rr->ds.digest_size));
 
         case DNS_TYPE_SSHFP:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->sshfp.algorithm),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("fptype", rr->sshfp.fptype),
+                                SD_JSON_BUILD_PAIR_HEX("fingerprint", rr->sshfp.fingerprint, rr->sshfp.fingerprint_size));
 
         case DNS_TYPE_DNSKEY:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("flags", rr->dnskey.flags),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("protocol", rr->dnskey.protocol),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->dnskey.algorithm),
+                                SD_JSON_BUILD_PAIR_BASE64("dnskey", rr->dnskey.key, rr->dnskey.key_size));
 
         case DNS_TYPE_RRSIG:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_STRING("signer", rr->rrsig.signer),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("typeCovered", rr->rrsig.type_covered),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->rrsig.algorithm),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("labels", rr->rrsig.labels),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("originalTtl", rr->rrsig.original_ttl),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("expiration", rr->rrsig.expiration),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("inception", rr->rrsig.inception),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("keyTag", rr->rrsig.key_tag),
+                                SD_JSON_BUILD_PAIR_BASE64("signature", rr->rrsig.signature, rr->rrsig.signature_size));
 
         case DNS_TYPE_NSEC: {
                 _cleanup_(sd_json_variant_unrefp) sd_json_variant *bm = NULL;
@@ -2439,9 +2439,9 @@ int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret) {
 
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_STRING("nextDomain", rr->nsec.next_domain_name),
+                                SD_JSON_BUILD_PAIR_VARIANT("types", bm));
         }
 
         case DNS_TYPE_NSEC3: {
@@ -2453,23 +2453,23 @@ int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret) {
 
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->nsec3.algorithm),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("flags", rr->nsec3.flags),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("iterations", rr->nsec3.iterations),
+                                SD_JSON_BUILD_PAIR_HEX("salt", rr->nsec3.salt, rr->nsec3.salt_size),
+                                SD_JSON_BUILD_PAIR_BASE32HEX("hash", rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size),
+                                SD_JSON_BUILD_PAIR_VARIANT("types", bm));
         }
 
         case DNS_TYPE_TLSA:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("certUsage", rr->tlsa.cert_usage),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("selector", rr->tlsa.selector),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("matchingType", rr->tlsa.matching_type),
+                                SD_JSON_BUILD_PAIR_HEX("data", rr->tlsa.data, rr->tlsa.data_size));
 
         case DNS_TYPE_SVCB:
         case DNS_TYPE_HTTPS: {
@@ -2480,31 +2480,31 @@ int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret) {
 
                 return sd_json_buildo(
                                 ret,
-                                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("svcparams", SD_JSON_BUILD_VARIANT(p)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("priority", rr->svcb.priority),
+                                SD_JSON_BUILD_PAIR_STRING("target", rr->svcb.target_name),
+                                SD_JSON_BUILD_PAIR_VARIANT("svcparams", p));
         }
 
         case DNS_TYPE_CAA:
                 return sd_json_buildo(
                                 ret,
-                                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)));
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("flags", rr->caa.flags),
+                                SD_JSON_BUILD_PAIR_STRING("tag", rr->caa.tag),
+                                SD_JSON_BUILD_PAIR_OCTESCAPE("value", rr->caa.value, rr->caa.value_size));
 
         case DNS_TYPE_NAPTR:
                 return sd_json_buildo(
                                 ret,
-                                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)),
+                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("order", rr->naptr.order),
+                                SD_JSON_BUILD_PAIR_UNSIGNED("preference", 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 */
-                                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)));
+                                SD_JSON_BUILD_PAIR_STRING("naptrFlags", rr->naptr.flags),
+                                SD_JSON_BUILD_PAIR_STRING("services", rr->naptr.services),
+                                SD_JSON_BUILD_PAIR_STRING("regexp", rr->naptr.regexp),
+                                SD_JSON_BUILD_PAIR_STRING("replacement", rr->naptr.replacement));
 
         default:
                 /* Can't provide broken-down format */

diff --git a/src/shared/machine-bind-user.c b/src/shared/machine-bind-user.c
index e0f6ef66500cbf6fbf06c6035f7e2543d1dbea07..278f7c99d0ccc9eb48bdc5a533fa47c3c8749074 100644 (file)
--- a/src/shared/machine-bind-user.c
+++ b/src/shared/machine-bind-user.c
@@ -139,11 +139,11 @@ static int convert_user(
         r = user_record_build(
                         &converted_user,
                         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_STRING("userName", u->user_name),
+                                        SD_JSON_BUILD_PAIR_UNSIGNED("uid", allocate_uid),
+                                        SD_JSON_BUILD_PAIR_UNSIGNED("gid", 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_STRING("homeDirectory", h),
                                         SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.NSpawn")),
                                         JSON_BUILD_PAIR_STRING_NON_EMPTY("shell", shell),
                                         SD_JSON_BUILD_PAIR_STRV("memberOf", groups),
@@ -156,8 +156,8 @@ static int convert_user(
         r = group_record_build(
                         &converted_group,
                         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_STRING("groupName", g->group_name),
+                                        SD_JSON_BUILD_PAIR_UNSIGNED("gid", 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)

diff --git a/src/shared/nsresource.c b/src/shared/nsresource.c
index eef72e631bcf6a8a2f7ee9ebdc688390885a0264..31d96bad7cc2243e122b847e28997729e6f0b9f7 100644 (file)
--- a/src/shared/nsresource.c
+++ b/src/shared/nsresource.c
@@ -99,10 +99,10 @@ int nsresource_allocate_userns(const char *name, uint64_t size) {
                         "io.systemd.NamespaceResource.AllocateUserRange",
                         &reply,
                         &error_id,
-                        SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(name)),
-                        SD_JSON_BUILD_PAIR("mangleName", SD_JSON_BUILD_BOOLEAN(true)),
-                        SD_JSON_BUILD_PAIR("size", SD_JSON_BUILD_UNSIGNED(size)),
-                        SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx)));
+                        SD_JSON_BUILD_PAIR_STRING("name", name),
+                        SD_JSON_BUILD_PAIR_BOOLEAN("mangleName", true),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("size", size),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("userNamespaceFileDescriptor", userns_fd_idx));
         if (r < 0)
                 return log_debug_errno(r, "Failed to call AllocateUserRange() varlink call: %m");
         if (streq_ptr(error_id, "io.systemd.NamespaceResource.UserNamespaceInterfaceNotSupported"))
@@ -156,9 +156,9 @@ int nsresource_register_userns(const char *name, int userns_fd) {
                         "io.systemd.NamespaceResource.RegisterUserNamespace",
                         &reply,
                         &error_id,
-                        SD_JSON_BUILD_PAIR("name", SD_JSON_BUILD_STRING(name)),
-                        SD_JSON_BUILD_PAIR("mangleName", SD_JSON_BUILD_BOOLEAN(true)),
-                        SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx)));
+                        SD_JSON_BUILD_PAIR_STRING("name", name),
+                        SD_JSON_BUILD_PAIR_BOOLEAN("mangleName", true),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("userNamespaceFileDescriptor", userns_fd_idx));
         if (r < 0)
                 return log_debug_errno(r, "Failed to call RegisterUserNamespace() varlink call: %m");
         if (streq_ptr(error_id, "io.systemd.NamespaceResource.UserNamespaceInterfaceNotSupported"))
@@ -207,8 +207,8 @@ int nsresource_add_mount(int userns_fd, int mount_fd) {
                         "io.systemd.NamespaceResource.AddMountToUserNamespace",
                         &reply,
                         &error_id,
-                        SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx)),
-                        SD_JSON_BUILD_PAIR("mountFileDescriptor", SD_JSON_BUILD_UNSIGNED(mount_fd_idx)));
+                        SD_JSON_BUILD_PAIR_UNSIGNED("userNamespaceFileDescriptor", userns_fd_idx),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("mountFileDescriptor", 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")) {
@@ -259,8 +259,8 @@ int nsresource_add_cgroup(int userns_fd, int cgroup_fd) {
                         "io.systemd.NamespaceResource.AddControlGroupToUserNamespace",
                         &reply,
                         &error_id,
-                        SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx)),
-                        SD_JSON_BUILD_PAIR("controlGroupFileDescriptor", SD_JSON_BUILD_UNSIGNED(cgroup_fd_idx)));
+                        SD_JSON_BUILD_PAIR_UNSIGNED("userNamespaceFileDescriptor", userns_fd_idx),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("controlGroupFileDescriptor", 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")) {
@@ -336,8 +336,8 @@ int nsresource_add_netif_veth(
                         "io.systemd.NamespaceResource.AddNetworkToUserNamespace",
                         &reply,
                         &error_id,
-                        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_UNSIGNED("userNamespaceFileDescriptor", userns_fd_idx),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("networkNamespaceFileDescriptor", 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)
@@ -406,7 +406,7 @@ int nsresource_add_netif_tap(
                         "io.systemd.NamespaceResource.AddNetworkToUserNamespace",
                         &reply,
                         &error_id,
-                        SD_JSON_BUILD_PAIR("userNamespaceFileDescriptor", SD_JSON_BUILD_UNSIGNED(userns_fd_idx)),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("userNamespaceFileDescriptor", userns_fd_idx),
                         SD_JSON_BUILD_PAIR("mode", JSON_BUILD_CONST_STRING("tap")));
         if (r < 0)
                 return log_debug_errno(r, "Failed to call AddNetworkToUserNamespace() varlink call: %m");

diff --git a/src/shared/tpm2-util.c b/src/shared/tpm2-util.c
index c74162302caeb9ae7bfca349b87eaf1c00202945..f185c5ab8b1bf076dd606576ed73e225b6875d49 100644 (file)
--- a/src/shared/tpm2-util.c
+++ b/src/shared/tpm2-util.c
@@ -6612,7 +6612,7 @@ static int tpm2_userspace_log(
                 r = sd_json_variant_append_arraybo(
                                 &array,
                                 SD_JSON_BUILD_PAIR_STRING("hashAlg", a),
-                                SD_JSON_BUILD_PAIR("digest", SD_JSON_BUILD_HEX(&values->digests[i].digest, EVP_MD_size(implementation))));
+                                SD_JSON_BUILD_PAIR_HEX("digest", &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");
         }
@@ -6627,13 +6627,13 @@ static int tpm2_userspace_log(
                         &v,
                         SD_JSON_BUILD_PAIR_CONDITION(pcr_index != UINT_MAX, "pcr", SD_JSON_BUILD_UNSIGNED(pcr_index)),
                         SD_JSON_BUILD_PAIR_CONDITION(nv_index != UINT32_MAX, "nv_index", SD_JSON_BUILD_UNSIGNED(nv_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_VARIANT("digests", array),
+                        SD_JSON_BUILD_PAIR_STRING("content_type", "systemd"),
                         SD_JSON_BUILD_PAIR("content", SD_JSON_BUILD_OBJECT(
                                                            SD_JSON_BUILD_PAIR_CONDITION(!!nv_index_name, "nvIndexName", SD_JSON_BUILD_STRING(nv_index_name)),
                                                            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_ID128("bootId", boot_id),
+                                                           SD_JSON_BUILD_PAIR_UNSIGNED("timestamp", 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");
@@ -8466,11 +8466,11 @@ int tpm2_make_luks2_json(
                         &v,
                         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", SD_JSON_BUILD_VARIANT(bj)),
-                        SD_JSON_BUILD_PAIR("tpm2-pcrs", SD_JSON_BUILD_VARIANT(hmj)),
+                        SD_JSON_BUILD_PAIR_VARIANT("tpm2-blob", bj),
+                        SD_JSON_BUILD_PAIR_VARIANT("tpm2-pcrs", 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", SD_JSON_BUILD_VARIANT(phj)),
+                        SD_JSON_BUILD_PAIR_VARIANT("tpm2-policy-hash", phj),
                         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)),

diff --git a/src/shared/user-record-nss.c b/src/shared/user-record-nss.c
index 10a5a75e9fe52c52459add47abb1617c19bcb4de..96adbb21f1dcd98b118453e5d8e60c77092a6708 100644 (file)
--- a/src/shared/user-record-nss.c
+++ b/src/shared/user-record-nss.c
@@ -149,13 +149,13 @@ int nss_passwd_to_user_record(
         hr->json = sd_json_variant_unref(hr->json);
         r = sd_json_buildo(
                         &hr->json,
-                        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(user_record_gid(hr))),
+                        SD_JSON_BUILD_PAIR_STRING("userName", hr->user_name),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("uid", hr->uid),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("gid", user_record_gid(hr)),
                         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(!strv_isempty(hr->hashed_password), "privileged", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_STRV("hashedPassword", 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)),
@@ -331,10 +331,10 @@ int nss_group_to_group_record(
 
         r = sd_json_buildo(
                         &g->json,
-                        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_STRING("groupName", g->group_name),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("gid", 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->hashed_password), "privileged", SD_JSON_BUILD_OBJECT(SD_JSON_BUILD_PAIR_STRV("hashedPassword", g->hashed_password))),
                         SD_JSON_BUILD_PAIR_CONDITION(!strv_isempty(g->administrators), "administrators", SD_JSON_BUILD_STRV(g->administrators)));
         if (r < 0)
                 return r;

diff --git a/src/shared/userdb.c b/src/shared/userdb.c
index 99cceb25a4c02912a05b06654f401ca5d2f17e58..a6b4a5dae96fb9919becb49720835f3719a6ff79 100644 (file)
--- a/src/shared/userdb.c
+++ b/src/shared/userdb.c
@@ -736,12 +736,12 @@ static int synthetic_foreign_user_build(uid_t foreign_uid, UserRecord **ret) {
 
         return user_record_buildo(
                         ret,
-                        SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(un)),
-                        SD_JSON_BUILD_PAIR("realName", SD_JSON_BUILD_STRING(rn)),
-                        SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(FOREIGN_UID_BASE + foreign_uid)),
-                        SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(FOREIGN_UID_BASE + foreign_uid)),
+                        SD_JSON_BUILD_PAIR_STRING("userName", un),
+                        SD_JSON_BUILD_PAIR_STRING("realName", rn),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("uid", FOREIGN_UID_BASE + foreign_uid),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("gid", FOREIGN_UID_BASE + foreign_uid),
                         SD_JSON_BUILD_PAIR("shell", JSON_BUILD_CONST_STRING(NOLOGIN)),
-                        SD_JSON_BUILD_PAIR("locked", SD_JSON_BUILD_BOOLEAN(true)),
+                        SD_JSON_BUILD_PAIR_BOOLEAN("locked", true),
                         SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("foreign")));
 }
 
@@ -916,7 +916,7 @@ int userdb_by_name(const char *name, const UserDBMatch *match, UserDBFlags flags
         if (!valid_user_group_name(name, VALID_USER_RELAX))
                 return -EINVAL;
 
-        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(name)));
+        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR_STRING("userName", name));
         if (r < 0)
                 return r;
 
@@ -1006,7 +1006,7 @@ int userdb_by_uid(uid_t uid, const UserDBMatch *match, UserDBFlags flags, UserRe
         if (!uid_is_valid(uid))
                 return -EINVAL;
 
-        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR("uid", SD_JSON_BUILD_UNSIGNED(uid)));
+        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR_UNSIGNED("uid", uid));
         if (r < 0)
                 return r;
 
@@ -1258,9 +1258,9 @@ static int synthetic_foreign_group_build(gid_t foreign_gid, GroupRecord **ret) {
 
         return group_record_buildo(
                         ret,
-                        SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(gn)),
-                        SD_JSON_BUILD_PAIR("description", SD_JSON_BUILD_STRING(d)),
-                        SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(FOREIGN_UID_BASE + foreign_gid)),
+                        SD_JSON_BUILD_PAIR_STRING("groupName", gn),
+                        SD_JSON_BUILD_PAIR_STRING("description", d),
+                        SD_JSON_BUILD_PAIR_UNSIGNED("gid", FOREIGN_UID_BASE + foreign_gid),
                         SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("foreign")));
 }
 
@@ -1372,7 +1372,7 @@ int groupdb_by_name(const char *name, const UserDBMatch *match, UserDBFlags flag
         if (!valid_user_group_name(name, VALID_USER_RELAX))
                 return -EINVAL;
 
-        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(name)));
+        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR_STRING("groupName", name));
         if (r < 0)
                 return r;
 
@@ -1458,7 +1458,7 @@ int groupdb_by_gid(gid_t gid, const UserDBMatch *match, UserDBFlags flags, Group
         if (!gid_is_valid(gid))
                 return -EINVAL;
 
-        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR("gid", SD_JSON_BUILD_UNSIGNED(gid)));
+        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR_UNSIGNED("gid", gid));
         if (r < 0)
                 return r;
 
@@ -1686,7 +1686,7 @@ int membershipdb_by_user(const char *name, UserDBFlags flags, UserDBIterator **r
         if (!valid_user_group_name(name, VALID_USER_RELAX))
                 return -EINVAL;
 
-        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR("userName", SD_JSON_BUILD_STRING(name)));
+        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR_STRING("userName", name));
         if (r < 0)
                 return r;
 
@@ -1731,7 +1731,7 @@ int membershipdb_by_group(const char *name, UserDBFlags flags, UserDBIterator **
         if (!valid_user_group_name(name, VALID_USER_RELAX))
                 return -EINVAL;
 
-        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR("groupName", SD_JSON_BUILD_STRING(name)));
+        r = sd_json_buildo(&query, SD_JSON_BUILD_PAIR_STRING("groupName", name));
         if (r < 0)
                 return r;