sd-json: add new sd_json_variant_unset_field() call

src/libsystemd/libsystemd.sym

@@ -1065,6 +1065,7 @@ global:
         sd_device_enumerator_add_all_parents;
         sd_json_variant_type_from_string;
         sd_json_variant_type_to_string;
+        sd_json_variant_unset_field;
         sd_varlink_get_current_method;
         sd_varlink_get_input_fd;
         sd_varlink_get_output_fd;

src/libsystemd/sd-json/sd-json.c

@@ -2129,6 +2129,55 @@ _public_ int sd_json_variant_set_field_strv(sd_json_variant **v, const char *fie
         return sd_json_variant_set_field(v, field, m);
 }
 
+_public_ int sd_json_variant_unset_field(sd_json_variant **v, const char *field) {
+        int r;
+
+        assert_return(v, -EINVAL);
+        assert_return(field, -EINVAL);
+
+        if (sd_json_variant_is_blank_object(*v))
+                return 0;
+        if (!sd_json_variant_is_object(*v))
+                return -EINVAL;
+
+        _cleanup_free_ sd_json_variant **array = NULL;
+        size_t k = 0;
+        for (size_t i = 0; i < sd_json_variant_elements(*v); i += 2) {
+                sd_json_variant *p;
+
+                p = sd_json_variant_by_index(*v, i);
+                if (!sd_json_variant_is_string(p))
+                        return -EINVAL;
+
+                if (streq(sd_json_variant_string(p), field)) {
+                        if (!array) {
+                                array = new(sd_json_variant*, sd_json_variant_elements(*v) - 2);
+                                if (!array)
+                                        return -ENOMEM;
+
+                                for (k = 0; k < i; k++)
+                                        array[k] = sd_json_variant_by_index(*v, k);
+                        }
+                } else if (array) {
+                        array[k++] = p;
+                        array[k++] = sd_json_variant_by_index(*v, i + 1);
+                }
+        }
+
+        if (!array)
+                return 0;
+
+        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
+        r = sd_json_variant_new_object(&w, array, k);
+        if (r < 0)
+                return r;
+
+        json_variant_propagate_sensitive(*v, w);
+        JSON_VARIANT_REPLACE(*v, TAKE_PTR(w));
+
+        return 1;
+}
+
 _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;

src/systemd/sd-json.h

@@ -168,6 +168,8 @@ int sd_json_variant_set_field_unsigned(sd_json_variant **v, const char *field, u
 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);
 
+int sd_json_variant_unset_field(sd_json_variant **v, const char *field);
+
 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);

src/test/test-json.c

@@ -1419,4 +1419,42 @@ TEST(fd_info) {
         pidref_done(&pidref);
 }
 
+TEST(json_variant_unset_field) {
+        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
+
+        ASSERT_OK_POSITIVE(sd_json_variant_is_blank_object(v));
+        ASSERT_OK_ZERO(sd_json_variant_unset_field(&v, "foo"));
+        ASSERT_OK_POSITIVE(sd_json_variant_is_blank_object(v));
+
+        ASSERT_NULL(v);
+
+        ASSERT_OK(sd_json_buildo(&v,
+                                 SD_JSON_BUILD_PAIR_STRING("foo", "bar"),
+                                 SD_JSON_BUILD_PAIR_STRING("quux", "waldo"),
+                                 SD_JSON_BUILD_PAIR_STRING("piff", "paff")));
+
+        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = sd_json_variant_ref(v);
+
+        ASSERT_OK_POSITIVE(sd_json_variant_equal(v, w));
+        ASSERT_OK_ZERO(sd_json_variant_unset_field(&v, "fooxxx"));
+        ASSERT_OK_POSITIVE(sd_json_variant_equal(v, w));
+        ASSERT_OK_POSITIVE(sd_json_variant_unset_field(&v, "foo"));
+        ASSERT_OK_ZERO(sd_json_variant_equal(v, w));
+
+        _cleanup_(sd_json_variant_unrefp) sd_json_variant *x = NULL;
+        ASSERT_OK(sd_json_buildo(&x,
+                                 SD_JSON_BUILD_PAIR_STRING("quux", "waldo"),
+                                 SD_JSON_BUILD_PAIR_STRING("piff", "paff")));
+        ASSERT_OK_POSITIVE(sd_json_variant_equal(v, x));
+
+        ASSERT_OK_POSITIVE(sd_json_variant_unset_field(&v, "piff"));
+        x = sd_json_variant_unref(x);
+        ASSERT_OK(sd_json_buildo(&x,
+                                 SD_JSON_BUILD_PAIR_STRING("quux", "waldo")));
+        ASSERT_OK_POSITIVE(sd_json_variant_equal(x, v));
+
+        ASSERT_OK_POSITIVE(sd_json_variant_unset_field(&v, "quux"));
+        ASSERT_OK_POSITIVE(sd_json_variant_is_blank_object(v));
+}
+
 DEFINE_TEST_MAIN(LOG_DEBUG);