Merge pull request #28376 from yuwata/json_append

Use json_append() and json_variant_append_array()

src/shared/logs-show.c

@@ -938,22 +938,21 @@ void json_escape(
 
 typedef struct JsonData {
         JsonVariant* name;
-        size_t n_values;
-        JsonVariant* values[];
+        JsonVariant* values;
 } JsonData;
 
-static JsonData* json_data_free(struct JsonData *d) {
+static JsonData* json_data_free(JsonData *d) {
         if (!d)
                 return NULL;
 
         json_variant_unref(d->name);
-
-        FOREACH_ARRAY(v, d->values, d->n_values)
-                json_variant_unref(*v);
+        json_variant_unref(d->values);
 
         return mfree(d);
 }
 
+DEFINE_TRIVIAL_CLEANUP_FUNC(JsonData*, json_data_free);
+
 DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(json_data_hash_ops_free,
                                       char, string_hash_func, string_compare_func,
                                       JsonData, json_data_free);
@@ -966,7 +965,7 @@ static int update_json_data(
                 size_t size) {
 
         _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
-        JsonData *d = NULL;
+        JsonData *d;
         int r;
 
         assert(name);
@@ -986,35 +985,31 @@ static int update_json_data(
 
         d = hashmap_get(h, name);
         if (d) {
-                JsonData *w;
+                r = json_variant_append_array(&d->values, v);
+                if (r < 0)
+                        return log_error_errno(r, "Failed to append JSON value into array: %m");
+        } else {
+                _cleanup_(json_data_freep) JsonData *e = NULL;
 
-                w = realloc(d, offsetof(JsonData, values) + sizeof(JsonVariant*) * (d->n_values + 1));
-                if (!w)
+                e = new0(JsonData, 1);
+                if (!e)
                         return log_oom();
 
-                d = w;
-                assert_se(hashmap_update(h, json_variant_string(d->name), d) >= 0);
-        } else {
-                _cleanup_(json_variant_unrefp) JsonVariant *n = NULL;
-
-                r = json_variant_new_string(&n, name);
+                r = json_variant_new_string(&e->name, name);
                 if (r < 0)
                         return log_error_errno(r, "Failed to allocate JSON name variant: %m");
 
-                d = malloc0(offsetof(JsonData, values) + sizeof(JsonVariant*));
-                if (!d)
-                        return log_oom();
+                r = 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(n), d);
-                if (r < 0) {
-                        free(d);
-                        return log_error_errno(r, "Failed to insert JSON name into hashmap: %m");
-                }
+                r = hashmap_put(h, json_variant_string(e->name), e);
+                if (r < 0)
+                        return log_error_errno(r, "Failed to insert JSON data into hashmap: %m");
 
-                d->name = TAKE_PTR(n);
+                TAKE_PTR(e);
         }
 
-        d->values[d->n_values++] = TAKE_PTR(v);
         return 0;
 }
 
@@ -1156,28 +1151,20 @@ static int output_json(
         CLEANUP_ARRAY(array, n, json_variant_unref_many);
 
         HASHMAP_FOREACH(d, h) {
-                assert(d->n_values > 0);
+                assert(json_variant_elements(d->values) > 0);
 
                 array[n++] = json_variant_ref(d->name);
 
-                if (d->n_values == 1)
-                        array[n++] = json_variant_ref(d->values[0]);
-                else {
-                        _cleanup_(json_variant_unrefp) JsonVariant *q = NULL;
-
-                        r = json_variant_new_array(&q, d->values, d->n_values);
-                        if (r < 0)
-                                return log_error_errno(r, "Failed to create JSON array: %m");
-
-                        array[n++] = TAKE_PTR(q);
-                }
+                if (json_variant_elements(d->values) == 1)
+                        array[n++] = json_variant_ref(json_variant_by_index(d->values, 0));
+                else
+                        array[n++] = json_variant_ref(d->values);
         }
 
         r = 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,
                                  output_mode_to_json_format_flags(mode) |
                                  (FLAGS_SET(flags, OUTPUT_COLOR) ? JSON_FORMAT_COLOR : 0),

src/shared/tpm2-util.c

@@ -3838,34 +3838,30 @@ int tpm2_pcr_mask_from_string(const char *arg, uint32_t *ret_mask) {
 
 int tpm2_make_pcr_json_array(uint32_t pcr_mask, JsonVariant **ret) {
         _cleanup_(json_variant_unrefp) JsonVariant *a = NULL;
-        JsonVariant* pcr_array[TPM2_PCRS_MAX];
-        unsigned n_pcrs = 0;
         int r;
 
-        for (size_t i = 0; i < ELEMENTSOF(pcr_array); i++) {
+        assert(ret);
+
+        for (size_t i = 0; i < TPM2_PCRS_MAX; i++) {
+                _cleanup_(json_variant_unrefp) JsonVariant *e = NULL;
+
                 if ((pcr_mask & (UINT32_C(1) << i)) == 0)
                         continue;
 
-                r = json_variant_new_integer(pcr_array + n_pcrs, i);
+                r = json_variant_new_integer(&e, i);
                 if (r < 0)
-                        goto finish;
+                        return r;
 
-                n_pcrs++;
+                r = json_variant_append_array(&a, e);
+                if (r < 0)
+                        return r;
         }
 
-        r = json_variant_new_array(&a, pcr_array, n_pcrs);
-        if (r < 0)
-                goto finish;
+        if (!a)
+                return json_variant_new_array(ret, NULL, 0);
 
-        if (ret)
-                *ret = TAKE_PTR(a);
-        r = 0;
-
-finish:
-        FOREACH_ARRAY(v, pcr_array, n_pcrs)
-                json_variant_unref(*v);
-
-        return r;
+        *ret = TAKE_PTR(a);
+        return 0;
 }
 
 int tpm2_parse_pcr_json_array(JsonVariant *v, uint32_t *ret) {