sd-bus: several coding style cleanups (#37867)

- replace `type *func()` -> `type* func()`,
- rename arguments for storing results,
- add several missing assertions.

src/home/homectl.c

@@ -1706,7 +1706,7 @@ static int verb_unregister_home(int argc, char *argv[], void *userdata) {
                         return bus_log_create_error(r);
 
                 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
-                r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, /* reply= */ NULL);
+                r = sd_bus_call(bus, m, HOME_SLOW_BUS_CALL_TIMEOUT_USEC, &error, /* ret_reply= */ NULL);
                 if (r < 0)
                         RET_GATHER(ret, log_error_errno(r, "Failed to unregister home: %s", bus_error_message(&error, r)));
         }
@@ -5117,7 +5117,7 @@ static int fallback_shell(int argc, char *argv[]) {
                                 "org.freedesktop.login1.Session",
                                 "SetClass",
                                 &error,
-                                /* reply= */ NULL,
+                                /* ret_reply= */ NULL,
                                 "s",
                                 "user");
                 if (r < 0)
@@ -5317,7 +5317,7 @@ static int add_signing_key_one(sd_bus *bus, const char *fn, FILE *key) {
                 return log_error_errno(r, "Failed to read key '%s': %m", fn);
 
         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
-        r = bus_call_method(bus, bus_mgr, "AddSigningKey", &error, /* reply= */ NULL, "sst", fn, pem, UINT64_C(0));
+        r = bus_call_method(bus, bus_mgr, "AddSigningKey", &error, /* ret_reply= */ NULL, "sst", fn, pem, UINT64_C(0));
         if (r < 0)
                 return log_error_errno(r, "Failed to add signing key '%s': %s", fn, bus_error_message(&error, r));
 
@@ -5424,7 +5424,7 @@ static int remove_signing_key_one(sd_bus *bus, const char *fn) {
         assert_se(fn);
 
         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
-        r = bus_call_method(bus, bus_mgr, "RemoveSigningKey", &error, /* reply= */ NULL, "st", fn, UINT64_C(0));
+        r = bus_call_method(bus, bus_mgr, "RemoveSigningKey", &error, /* ret_reply= */ NULL, "st", fn, UINT64_C(0));
         if (r < 0)
                 return log_error_errno(r, "Failed to remove signing key '%s': %s", fn, bus_error_message(&error, r));
 

src/libsystemd/sd-bus/bus-control.c

@@ -353,14 +353,14 @@ _public_ int sd_bus_release_name_async(
                         name);
 }
 
-_public_ int sd_bus_list_names(sd_bus *bus, char ***acquired, char ***activatable) {
+_public_ int sd_bus_list_names(sd_bus *bus, char ***ret_acquired, char ***ret_activatable) {
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
         _cleanup_strv_free_ char **x = NULL, **y = NULL;
         int r;
 
         assert_return(bus, -EINVAL);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
-        assert_return(acquired || activatable, -EINVAL);
+        assert_return(ret_acquired || ret_activatable, -EINVAL);
         assert_return(!bus_origin_changed(bus), -ECHILD);
 
         if (!bus->bus_client)
@@ -369,7 +369,7 @@ _public_ int sd_bus_list_names(sd_bus *bus, char ***acquired, char ***activatabl
         if (!BUS_IS_OPEN(bus->state))
                 return -ENOTCONN;
 
-        if (acquired) {
+        if (ret_acquired) {
                 r = sd_bus_call_method(
                                 bus,
                                 "org.freedesktop.DBus",
@@ -389,7 +389,7 @@ _public_ int sd_bus_list_names(sd_bus *bus, char ***acquired, char ***activatabl
                 reply = sd_bus_message_unref(reply);
         }
 
-        if (activatable) {
+        if (ret_activatable) {
                 r = sd_bus_call_method(
                                 bus,
                                 "org.freedesktop.DBus",
@@ -406,11 +406,11 @@ _public_ int sd_bus_list_names(sd_bus *bus, char ***acquired, char ***activatabl
                 if (r < 0)
                         return r;
 
-                *activatable = TAKE_PTR(y);
+                *ret_activatable = TAKE_PTR(y);
         }
 
-        if (acquired)
-                *acquired = TAKE_PTR(x);
+        if (ret_acquired)
+                *ret_acquired = TAKE_PTR(x);
 
         return 0;
 }
@@ -419,7 +419,7 @@ _public_ int sd_bus_get_name_creds(
                 sd_bus *bus,
                 const char *name,
                 uint64_t mask,
-                sd_bus_creds **creds) {
+                sd_bus_creds **ret) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply_unique = NULL, *reply = NULL;
         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *c = NULL;
@@ -430,7 +430,7 @@ _public_ int sd_bus_get_name_creds(
         assert_return(bus = bus_resolve(bus), -ENOPKG);
         assert_return(name, -EINVAL);
         assert_return((mask & ~SD_BUS_CREDS_AUGMENT) <= _SD_BUS_CREDS_ALL, -EOPNOTSUPP);
-        assert_return(mask == 0 || creds, -EINVAL);
+        assert_return(mask == 0 || ret, -EINVAL);
         assert_return(!bus_origin_changed(bus), -ECHILD);
         assert_return(service_name_is_valid(name), -EINVAL);
 
@@ -446,7 +446,7 @@ _public_ int sd_bus_get_name_creds(
                 return -EINVAL;
 
         if (streq(name, "org.freedesktop.DBus"))
-                return sd_bus_get_owner_creds(bus, mask, creds);
+                return sd_bus_get_owner_creds(bus, mask, ret);
 
         if (!BUS_IS_OPEN(bus->state))
                 return -ENOTCONN;
@@ -783,8 +783,8 @@ _public_ int sd_bus_get_name_creds(
                 }
         }
 
-        if (creds)
-                *creds = TAKE_PTR(c);
+        if (ret)
+                *ret = TAKE_PTR(c);
 
         return 0;
 }
@@ -1075,7 +1075,7 @@ int bus_remove_match_internal(
                         e);
 }
 
-_public_ int sd_bus_get_name_machine_id(sd_bus *bus, const char *name, sd_id128_t *machine) {
+_public_ int sd_bus_get_name_machine_id(sd_bus *bus, const char *name, sd_id128_t *ret) {
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL, *m = NULL;
         const char *mid;
         int r;
@@ -1083,7 +1083,7 @@ _public_ int sd_bus_get_name_machine_id(sd_bus *bus, const char *name, sd_id128_
         assert_return(bus, -EINVAL);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
         assert_return(name, -EINVAL);
-        assert_return(machine, -EINVAL);
+        assert_return(ret, -EINVAL);
         assert_return(!bus_origin_changed(bus), -ECHILD);
         assert_return(service_name_is_valid(name), -EINVAL);
 
@@ -1094,7 +1094,7 @@ _public_ int sd_bus_get_name_machine_id(sd_bus *bus, const char *name, sd_id128_
                 return -ENOTCONN;
 
         if (streq_ptr(name, bus->unique_name))
-                return sd_id128_get_machine(machine);
+                return sd_id128_get_machine(ret);
 
         r = sd_bus_message_new_method_call(
                         bus,
@@ -1118,5 +1118,5 @@ _public_ int sd_bus_get_name_machine_id(sd_bus *bus, const char *name, sd_id128_
         if (r < 0)
                 return r;
 
-        return sd_id128_from_string(mid, machine);
+        return sd_id128_from_string(mid, ret);
 }

src/libsystemd/sd-bus/bus-convenience.c

@@ -96,7 +96,7 @@ _public_ int sd_bus_emit_signal(
 
 _public_ int sd_bus_call_method_asyncv(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *destination,
                 const char *path,
                 const char *interface,
@@ -125,12 +125,12 @@ _public_ int sd_bus_call_method_asyncv(
                         return r;
         }
 
-        return sd_bus_call_async(bus, slot, m, callback, userdata, 0);
+        return sd_bus_call_async(bus, ret_slot, m, callback, userdata, 0);
 }
 
 _public_ int sd_bus_call_method_async(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *destination,
                 const char *path,
                 const char *interface,
@@ -143,7 +143,7 @@ _public_ int sd_bus_call_method_async(
         int r;
 
         va_start(ap, types);
-        r = sd_bus_call_method_asyncv(bus, slot, destination, path, interface, member, callback, userdata, types, ap);
+        r = sd_bus_call_method_asyncv(bus, ret_slot, destination, path, interface, member, callback, userdata, types, ap);
         va_end(ap);
 
         return r;
@@ -155,16 +155,16 @@ _public_ int sd_bus_call_methodv(
                 const char *path,
                 const char *interface,
                 const char *member,
-                sd_bus_error *error,
-                sd_bus_message **reply,
+                sd_bus_error *reterr_error,
+                sd_bus_message **ret_reply,
                 const char *types, va_list ap) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
         int r;
 
-        bus_assert_return(bus, -EINVAL, error);
-        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, error);
-        bus_assert_return(!bus_origin_changed(bus), -ECHILD, error);
+        bus_assert_return(bus, -EINVAL, reterr_error);
+        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, reterr_error);
+        bus_assert_return(!bus_origin_changed(bus), -ECHILD, reterr_error);
 
         if (!BUS_IS_OPEN(bus->state)) {
                 r = -ENOTCONN;
@@ -181,10 +181,10 @@ _public_ int sd_bus_call_methodv(
                         goto fail;
         }
 
-        return sd_bus_call(bus, m, 0, error, reply);
+        return sd_bus_call(bus, m, 0, reterr_error, ret_reply);
 
 fail:
-        return sd_bus_error_set_errno(error, r);
+        return sd_bus_error_set_errno(reterr_error, r);
 }
 
 _public_ int sd_bus_call_method(
@@ -193,15 +193,15 @@ _public_ int sd_bus_call_method(
                 const char *path,
                 const char *interface,
                 const char *member,
-                sd_bus_error *error,
-                sd_bus_message **reply,
+                sd_bus_error *reterr_error,
+                sd_bus_message **ret_reply,
                 const char *types, ...) {
 
         va_list ap;
         int r;
 
         va_start(ap, types);
-        r = sd_bus_call_methodv(bus, destination, path, interface, member, error, reply, types, ap);
+        r = sd_bus_call_methodv(bus, destination, path, interface, member, reterr_error, ret_reply, types, ap);
         va_end(ap);
 
         return r;
@@ -209,7 +209,8 @@ _public_ int sd_bus_call_method(
 
 _public_ int sd_bus_reply_method_returnv(
                 sd_bus_message *call,
-                const char *types, va_list ap) {
+                const char *types,
+                va_list ap) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
         int r;
@@ -395,20 +396,20 @@ _public_ int sd_bus_get_property(
                 const char *path,
                 const char *interface,
                 const char *member,
-                sd_bus_error *error,
-                sd_bus_message **reply,
+                sd_bus_error *reterr_error,
+                sd_bus_message **ret_reply,
                 const char *type) {
 
-        sd_bus_message *rep = NULL;
+        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
         int r;
 
-        bus_assert_return(bus, -EINVAL, error);
-        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, error);
-        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, error);
-        bus_assert_return(member_name_is_valid(member), -EINVAL, error);
-        bus_assert_return(reply, -EINVAL, error);
-        bus_assert_return(signature_is_single(type, false), -EINVAL, error);
-        bus_assert_return(!bus_origin_changed(bus), -ECHILD, error);
+        bus_assert_return(bus, -EINVAL, reterr_error);
+        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, reterr_error);
+        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, reterr_error);
+        bus_assert_return(member_name_is_valid(member), -EINVAL, reterr_error);
+        bus_assert_return(ret_reply, -EINVAL, reterr_error);
+        bus_assert_return(signature_is_single(type, false), -EINVAL, reterr_error);
+        bus_assert_return(!bus_origin_changed(bus), -ECHILD, reterr_error);
 
         if (!BUS_IS_OPEN(bus->state)) {
                 r = -ENOTCONN;
@@ -417,22 +418,20 @@ _public_ int sd_bus_get_property(
 
         r = sd_bus_call_method(bus, destination, path,
                                "org.freedesktop.DBus.Properties", "Get",
-                               error, &rep,
+                               reterr_error, &reply,
                                "ss", strempty(interface), member);
         if (r < 0)
                 return r;
 
-        r = sd_bus_message_enter_container(rep, 'v', type);
-        if (r < 0) {
-                sd_bus_message_unref(rep);
+        r = sd_bus_message_enter_container(reply, 'v', type);
+        if (r < 0)
                 goto fail;
-        }
 
-        *reply = rep;
+        *ret_reply = TAKE_PTR(reply);
         return 0;
 
 fail:
-        return sd_bus_error_set_errno(error, r);
+        return sd_bus_error_set_errno(reterr_error, r);
 }
 
 _public_ int sd_bus_get_property_trivial(
@@ -441,26 +440,27 @@ _public_ int sd_bus_get_property_trivial(
                 const char *path,
                 const char *interface,
                 const char *member,
-                sd_bus_error *error,
-                char type, void *ptr) {
+                sd_bus_error *reterr_error,
+                char type,
+                void *ret) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
         int r;
 
-        bus_assert_return(bus, -EINVAL, error);
-        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, error);
-        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, error);
-        bus_assert_return(member_name_is_valid(member), -EINVAL, error);
-        bus_assert_return(bus_type_is_trivial(type), -EINVAL, error);
-        bus_assert_return(ptr, -EINVAL, error);
-        bus_assert_return(!bus_origin_changed(bus), -ECHILD, error);
+        bus_assert_return(bus, -EINVAL, reterr_error);
+        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, reterr_error);
+        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, reterr_error);
+        bus_assert_return(member_name_is_valid(member), -EINVAL, reterr_error);
+        bus_assert_return(bus_type_is_trivial(type), -EINVAL, reterr_error);
+        bus_assert_return(ret, -EINVAL, reterr_error);
+        bus_assert_return(!bus_origin_changed(bus), -ECHILD, reterr_error);
 
         if (!BUS_IS_OPEN(bus->state)) {
                 r = -ENOTCONN;
                 goto fail;
         }
 
-        r = sd_bus_call_method(bus, destination, path, "org.freedesktop.DBus.Properties", "Get", error, &reply, "ss", strempty(interface), member);
+        r = sd_bus_call_method(bus, destination, path, "org.freedesktop.DBus.Properties", "Get", reterr_error, &reply, "ss", strempty(interface), member);
         if (r < 0)
                 return r;
 
@@ -468,14 +468,14 @@ _public_ int sd_bus_get_property_trivial(
         if (r < 0)
                 goto fail;
 
-        r = sd_bus_message_read_basic(reply, type, ptr);
+        r = sd_bus_message_read_basic(reply, type, ret);
         if (r < 0)
                 goto fail;
 
         return 0;
 
 fail:
-        return sd_bus_error_set_errno(error, r);
+        return sd_bus_error_set_errno(reterr_error, r);
 }
 
 _public_ int sd_bus_get_property_string(
@@ -484,7 +484,7 @@ _public_ int sd_bus_get_property_string(
                 const char *path,
                 const char *interface,
                 const char *member,
-                sd_bus_error *error,
+                sd_bus_error *reterr_error,
                 char **ret) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
@@ -492,19 +492,19 @@ _public_ int sd_bus_get_property_string(
         char *n;
         int r;
 
-        bus_assert_return(bus, -EINVAL, error);
-        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, error);
-        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, error);
-        bus_assert_return(member_name_is_valid(member), -EINVAL, error);
-        bus_assert_return(ret, -EINVAL, error);
-        bus_assert_return(!bus_origin_changed(bus), -ECHILD, error);
+        bus_assert_return(bus, -EINVAL, reterr_error);
+        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, reterr_error);
+        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, reterr_error);
+        bus_assert_return(member_name_is_valid(member), -EINVAL, reterr_error);
+        bus_assert_return(ret, -EINVAL, reterr_error);
+        bus_assert_return(!bus_origin_changed(bus), -ECHILD, reterr_error);
 
         if (!BUS_IS_OPEN(bus->state)) {
                 r = -ENOTCONN;
                 goto fail;
         }
 
-        r = sd_bus_call_method(bus, destination, path, "org.freedesktop.DBus.Properties", "Get", error, &reply, "ss", strempty(interface), member);
+        r = sd_bus_call_method(bus, destination, path, "org.freedesktop.DBus.Properties", "Get", reterr_error, &reply, "ss", strempty(interface), member);
         if (r < 0)
                 return r;
 
@@ -526,7 +526,7 @@ _public_ int sd_bus_get_property_string(
         return 0;
 
 fail:
-        return sd_bus_error_set_errno(error, r);
+        return sd_bus_error_set_errno(reterr_error, r);
 }
 
 _public_ int sd_bus_get_property_strv(
@@ -535,25 +535,25 @@ _public_ int sd_bus_get_property_strv(
                 const char *path,
                 const char *interface,
                 const char *member,
-                sd_bus_error *error,
+                sd_bus_error *reterr_error,
                 char ***ret) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
         int r;
 
-        bus_assert_return(bus, -EINVAL, error);
-        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, error);
-        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, error);
-        bus_assert_return(member_name_is_valid(member), -EINVAL, error);
-        bus_assert_return(ret, -EINVAL, error);
-        bus_assert_return(!bus_origin_changed(bus), -ECHILD, error);
+        bus_assert_return(bus, -EINVAL, reterr_error);
+        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, reterr_error);
+        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, reterr_error);
+        bus_assert_return(member_name_is_valid(member), -EINVAL, reterr_error);
+        bus_assert_return(ret, -EINVAL, reterr_error);
+        bus_assert_return(!bus_origin_changed(bus), -ECHILD, reterr_error);
 
         if (!BUS_IS_OPEN(bus->state)) {
                 r = -ENOTCONN;
                 goto fail;
         }
 
-        r = sd_bus_call_method(bus, destination, path, "org.freedesktop.DBus.Properties", "Get", error, &reply, "ss", strempty(interface), member);
+        r = sd_bus_call_method(bus, destination, path, "org.freedesktop.DBus.Properties", "Get", reterr_error, &reply, "ss", strempty(interface), member);
         if (r < 0)
                 return r;
 
@@ -568,7 +568,7 @@ _public_ int sd_bus_get_property_strv(
         return 0;
 
 fail:
-        return sd_bus_error_set_errno(error, r);
+        return sd_bus_error_set_errno(reterr_error, r);
 }
 
 _public_ int sd_bus_set_propertyv(
@@ -577,18 +577,18 @@ _public_ int sd_bus_set_propertyv(
                 const char *path,
                 const char *interface,
                 const char *member,
-                sd_bus_error *error,
+                sd_bus_error *reterr_error,
                 const char *type, va_list ap) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
         int r;
 
-        bus_assert_return(bus, -EINVAL, error);
-        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, error);
-        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, error);
-        bus_assert_return(member_name_is_valid(member), -EINVAL, error);
-        bus_assert_return(signature_is_single(type, false), -EINVAL, error);
-        bus_assert_return(!bus_origin_changed(bus), -ECHILD, error);
+        bus_assert_return(bus, -EINVAL, reterr_error);
+        bus_assert_return(bus = bus_resolve(bus), -ENOPKG, reterr_error);
+        bus_assert_return(isempty(interface) || interface_name_is_valid(interface), -EINVAL, reterr_error);
+        bus_assert_return(member_name_is_valid(member), -EINVAL, reterr_error);
+        bus_assert_return(signature_is_single(type, false), -EINVAL, reterr_error);
+        bus_assert_return(!bus_origin_changed(bus), -ECHILD, reterr_error);
 
         if (!BUS_IS_OPEN(bus->state)) {
                 r = -ENOTCONN;
@@ -615,10 +615,10 @@ _public_ int sd_bus_set_propertyv(
         if (r < 0)
                 goto fail;
 
-        return sd_bus_call(bus, m, 0, error, NULL);
+        return sd_bus_call(bus, m, 0, reterr_error, NULL);
 
 fail:
-        return sd_bus_error_set_errno(error, r);
+        return sd_bus_error_set_errno(reterr_error, r);
 }
 
 _public_ int sd_bus_set_property(
@@ -627,14 +627,14 @@ _public_ int sd_bus_set_property(
                 const char *path,
                 const char *interface,
                 const char *member,
-                sd_bus_error *error,
+                sd_bus_error *reterr_error,
                 const char *type, ...) {
 
         va_list ap;
         int r;
 
         va_start(ap, type);
-        r = sd_bus_set_propertyv(bus, destination, path, interface, member, error, type, ap);
+        r = sd_bus_set_propertyv(bus, destination, path, interface, member, reterr_error, type, ap);
         va_end(ap);
 
         return r;

src/libsystemd/sd-bus/bus-creds.c

@@ -59,7 +59,7 @@ void bus_creds_done(sd_bus_creds *c) {
         safe_close(c->pidfd);
 }
 
-_public_ sd_bus_creds *sd_bus_creds_ref(sd_bus_creds *c) {
+_public_ sd_bus_creds* sd_bus_creds_ref(sd_bus_creds *c) {
 
         if (!c)
                 return NULL;
@@ -79,7 +79,7 @@ _public_ sd_bus_creds *sd_bus_creds_ref(sd_bus_creds *c) {
         return c;
 }
 
-_public_ sd_bus_creds *sd_bus_creds_unref(sd_bus_creds *c) {
+_public_ sd_bus_creds* sd_bus_creds_unref(sd_bus_creds *c) {
 
         if (!c)
                 return NULL;
@@ -199,122 +199,122 @@ _public_ int sd_bus_creds_new_from_pidfd(sd_bus_creds **ret, int pidfd, uint64_t
         return bus_creds_new_from_pidref(ret, &pidref, mask);
 }
 
-_public_ int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid) {
+_public_ int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(uid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_UID))
                 return -ENODATA;
 
-        *uid = c->uid;
+        *ret = c->uid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *euid) {
+_public_ int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(euid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_EUID))
                 return -ENODATA;
 
-        *euid = c->euid;
+        *ret = c->euid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_suid(sd_bus_creds *c, uid_t *suid) {
+_public_ int sd_bus_creds_get_suid(sd_bus_creds *c, uid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(suid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_SUID))
                 return -ENODATA;
 
-        *suid = c->suid;
+        *ret = c->suid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_fsuid(sd_bus_creds *c, uid_t *fsuid) {
+_public_ int sd_bus_creds_get_fsuid(sd_bus_creds *c, uid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(fsuid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_FSUID))
                 return -ENODATA;
 
-        *fsuid = c->fsuid;
+        *ret = c->fsuid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid) {
+_public_ int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(gid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_GID))
                 return -ENODATA;
 
-        *gid = c->gid;
+        *ret = c->gid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *egid) {
+_public_ int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(egid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_EGID))
                 return -ENODATA;
 
-        *egid = c->egid;
+        *ret = c->egid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_sgid(sd_bus_creds *c, gid_t *sgid) {
+_public_ int sd_bus_creds_get_sgid(sd_bus_creds *c, gid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(sgid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_SGID))
                 return -ENODATA;
 
-        *sgid = c->sgid;
+        *ret = c->sgid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_fsgid(sd_bus_creds *c, gid_t *fsgid) {
+_public_ int sd_bus_creds_get_fsgid(sd_bus_creds *c, gid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(fsgid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_FSGID))
                 return -ENODATA;
 
-        *fsgid = c->fsgid;
+        *ret = c->fsgid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids) {
+_public_ int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **ret) {
         assert_return(c, -EINVAL);
-        assert_return(gids, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS))
                 return -ENODATA;
 
-        *gids = c->supplementary_gids;
+        *ret = c->supplementary_gids;
         return (int) c->n_supplementary_gids;
 }
 
-_public_ int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid) {
+_public_ int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(pid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_PID))
                 return -ENODATA;
 
         assert(c->pid > 0);
-        *pid = c->pid;
+        *ret = c->pid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_pidfd_dup(sd_bus_creds *c, int *ret_fd) {
+_public_ int sd_bus_creds_get_pidfd_dup(sd_bus_creds *c, int *ret) {
         _cleanup_close_ int copy = -EBADF;
 
         assert_return(c, -EINVAL);
-        assert_return(ret_fd, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_PIDFD))
                 return -ENODATA;
@@ -323,13 +323,13 @@ _public_ int sd_bus_creds_get_pidfd_dup(sd_bus_creds *c, int *ret_fd) {
         if (copy < 0)
                 return -errno;
 
-        *ret_fd = TAKE_FD(copy);
+        *ret = TAKE_FD(copy);
         return 0;
 }
 
-_public_ int sd_bus_creds_get_ppid(sd_bus_creds *c, pid_t *ppid) {
+_public_ int sd_bus_creds_get_ppid(sd_bus_creds *c, pid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(ppid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_PPID))
                 return -ENODATA;
@@ -340,19 +340,19 @@ _public_ int sd_bus_creds_get_ppid(sd_bus_creds *c, pid_t *ppid) {
         if (c->ppid == 0)
                 return -ENXIO;
 
-        *ppid = c->ppid;
+        *ret = c->ppid;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_tid(sd_bus_creds *c, pid_t *tid) {
+_public_ int sd_bus_creds_get_tid(sd_bus_creds *c, pid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(tid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_TID))
                 return -ENODATA;
 
         assert(c->tid > 0);
-        *tid = c->tid;
+        *ret = c->tid;
         return 0;
 }
 
@@ -552,12 +552,12 @@ _public_ int sd_bus_creds_get_session(sd_bus_creds *c, const char **ret) {
         return 0;
 }
 
-_public_ int sd_bus_creds_get_owner_uid(sd_bus_creds *c, uid_t *uid) {
+_public_ int sd_bus_creds_get_owner_uid(sd_bus_creds *c, uid_t *ret) {
         const char *shifted;
         int r;
 
         assert_return(c, -EINVAL);
-        assert_return(uid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_OWNER_UID))
                 return -ENODATA;
@@ -568,11 +568,12 @@ _public_ int sd_bus_creds_get_owner_uid(sd_bus_creds *c, uid_t *uid) {
         if (r < 0)
                 return r;
 
-        return cg_path_get_owner_uid(shifted, uid);
+        return cg_path_get_owner_uid(shifted, ret);
 }
 
-_public_ int sd_bus_creds_get_cmdline(sd_bus_creds *c, char ***cmdline) {
+_public_ int sd_bus_creds_get_cmdline(sd_bus_creds *c, char ***ret) {
         assert_return(c, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_CMDLINE))
                 return -ENODATA;
@@ -586,13 +587,13 @@ _public_ int sd_bus_creds_get_cmdline(sd_bus_creds *c, char ***cmdline) {
                         return -ENOMEM;
         }
 
-        *cmdline = c->cmdline_array;
+        *ret = c->cmdline_array;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_audit_session_id(sd_bus_creds *c, uint32_t *sessionid) {
+_public_ int sd_bus_creds_get_audit_session_id(sd_bus_creds *c, uint32_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(sessionid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_AUDIT_SESSION_ID))
                 return -ENODATA;
@@ -600,13 +601,13 @@ _public_ int sd_bus_creds_get_audit_session_id(sd_bus_creds *c, uint32_t *sessio
         if (!audit_session_is_valid(c->audit_session_id))
                 return -ENXIO;
 
-        *sessionid = c->audit_session_id;
+        *ret = c->audit_session_id;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_audit_login_uid(sd_bus_creds *c, uid_t *uid) {
+_public_ int sd_bus_creds_get_audit_login_uid(sd_bus_creds *c, uid_t *ret) {
         assert_return(c, -EINVAL);
-        assert_return(uid, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_AUDIT_LOGIN_UID))
                 return -ENODATA;
@@ -614,7 +615,7 @@ _public_ int sd_bus_creds_get_audit_login_uid(sd_bus_creds *c, uid_t *uid) {
         if (!uid_is_valid(c->audit_login_uid))
                 return -ENXIO;
 
-        *uid = c->audit_login_uid;
+        *ret = c->audit_login_uid;
         return 0;
 }
 
@@ -632,20 +633,20 @@ _public_ int sd_bus_creds_get_tty(sd_bus_creds *c, const char **ret) {
         return 0;
 }
 
-_public_ int sd_bus_creds_get_unique_name(sd_bus_creds *c, const char **unique_name) {
+_public_ int sd_bus_creds_get_unique_name(sd_bus_creds *c, const char **ret) {
         assert_return(c, -EINVAL);
-        assert_return(unique_name, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_UNIQUE_NAME))
                 return -ENODATA;
 
-        *unique_name = c->unique_name;
+        *ret = c->unique_name;
         return 0;
 }
 
-_public_ int sd_bus_creds_get_well_known_names(sd_bus_creds *c, char ***well_known_names) {
+_public_ int sd_bus_creds_get_well_known_names(sd_bus_creds *c, char ***ret) {
         assert_return(c, -EINVAL);
-        assert_return(well_known_names, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!(c->mask & SD_BUS_CREDS_WELL_KNOWN_NAMES))
                 return -ENODATA;
@@ -658,7 +659,7 @@ _public_ int sd_bus_creds_get_well_known_names(sd_bus_creds *c, char ***well_kno
                         NULL
                 };
 
-                *well_known_names = (char**) wkn;
+                *ret = (char**) wkn;
                 return 0;
         }
 
@@ -668,11 +669,11 @@ _public_ int sd_bus_creds_get_well_known_names(sd_bus_creds *c, char ***well_kno
                         NULL
                 };
 
-                *well_known_names = (char**) wkn;
+                *ret = (char**) wkn;
                 return 0;
         }
 
-        *well_known_names = c->well_known_names;
+        *ret = c->well_known_names;
         return 0;
 }
 

src/libsystemd/sd-bus/bus-internal.c

@@ -315,12 +315,12 @@ char* bus_address_escape(const char *v) {
         return r;
 }
 
-int bus_maybe_reply_error(sd_bus_message *m, int r, sd_bus_error *error) {
+int bus_maybe_reply_error(sd_bus_message *m, int r, const sd_bus_error *e) {
         assert(m);
 
-        if (sd_bus_error_is_set(error) || r < 0) {
+        if (sd_bus_error_is_set(e) || r < 0) {
                 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
-                        sd_bus_reply_method_errno(m, r, error);
+                        sd_bus_reply_method_errno(m, r, e);
         } else
                 return r;
 
@@ -336,7 +336,7 @@ int bus_maybe_reply_error(sd_bus_message *m, int r, sd_bus_error *error) {
                   strna(m->root_container.signature),
                   strna(m->error.name),
                   strna(m->error.message),
-                  bus_error_message(error, r));
+                  bus_error_message(e, r));
 
         return 1;
 }

src/libsystemd/sd-bus/bus-internal.h

@@ -395,7 +395,7 @@ int bus_set_address_user(sd_bus *bus);
 int bus_set_address_system_remote(sd_bus *b, const char *host);
 int bus_set_address_machine(sd_bus *b, RuntimeScope runtime_scope, const char *machine);
 
-int bus_maybe_reply_error(sd_bus_message *m, int r, sd_bus_error *error);
+int bus_maybe_reply_error(sd_bus_message *m, int r, const sd_bus_error *e);
 
 #define bus_assert_return(expr, r, error)                               \
         do {                                                            \

src/libsystemd/sd-bus/bus-message.c

@@ -21,7 +21,7 @@
 static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored);
 static int message_parse_fields(sd_bus_message *m);
 
-static void *adjust_pointer(const void *p, void *old_base, size_t sz, void *new_base) {
+static void* adjust_pointer(const void *p, void *old_base, size_t sz, void *new_base) {
 
         if (!p)
                 return NULL;
@@ -84,7 +84,7 @@ static void message_reset_parts(sd_bus_message *m) {
         m->cached_rindex_part_begin = 0;
 }
 
-static BusMessageContainer *message_get_last_container(sd_bus_message *m) {
+static BusMessageContainer* message_get_last_container(sd_bus_message *m) {
         assert(m);
 
         if (m->n_containers == 0)
@@ -144,7 +144,7 @@ static sd_bus_message* message_free(sd_bus_message *m) {
         return mfree(m);
 }
 
-static void *message_extend_fields(sd_bus_message *m, size_t sz, bool add_offset) {
+static void* message_extend_fields(sd_bus_message *m, size_t sz, bool add_offset) {
         void *op, *np;
         size_t old_size, new_size, start;
 
@@ -453,13 +453,13 @@ int bus_message_from_malloc(
 
 _public_ int sd_bus_message_new(
                 sd_bus *bus,
-                sd_bus_message **m,
+                sd_bus_message **ret,
                 uint8_t type) {
 
         assert_return(bus, -ENOTCONN);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
-        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
         /* Creation of messages with _SD_BUS_MESSAGE_TYPE_INVALID is allowed. */
         assert_return(type < _SD_BUS_MESSAGE_TYPE_MAX, -EINVAL);
 
@@ -479,13 +479,13 @@ _public_ int sd_bus_message_new(
         if (bus->allow_interactive_authorization)
                 t->header->flags |= BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION;
 
-        *m = t;
+        *ret = t;
         return 0;
 }
 
 _public_ int sd_bus_message_new_signal_to(
                 sd_bus *bus,
-                sd_bus_message **m,
+                sd_bus_message **ret,
                 const char *destination,
                 const char *path,
                 const char *interface,
@@ -501,7 +501,7 @@ _public_ int sd_bus_message_new_signal_to(
         assert_return(object_path_is_valid(path), -EINVAL);
         assert_return(interface_name_is_valid(interface), -EINVAL);
         assert_return(member_name_is_valid(member), -EINVAL);
-        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         r = sd_bus_message_new(bus, &t, SD_BUS_MESSAGE_SIGNAL);
         if (r < 0)
@@ -527,23 +527,23 @@ _public_ int sd_bus_message_new_signal_to(
                         return r;
         }
 
-        *m = TAKE_PTR(t);
+        *ret = TAKE_PTR(t);
         return 0;
 }
 
 _public_ int sd_bus_message_new_signal(
                 sd_bus *bus,
-                sd_bus_message **m,
+                sd_bus_message **ret,
                 const char *path,
                 const char *interface,
                 const char *member) {
 
-        return sd_bus_message_new_signal_to(bus, m, NULL, path, interface, member);
+        return sd_bus_message_new_signal_to(bus, ret, NULL, path, interface, member);
 }
 
 _public_ int sd_bus_message_new_method_call(
                 sd_bus *bus,
-                sd_bus_message **m,
+                sd_bus_message **ret,
                 const char *destination,
                 const char *path,
                 const char *interface,
@@ -559,7 +559,7 @@ _public_ int sd_bus_message_new_method_call(
         assert_return(object_path_is_valid(path), -EINVAL);
         assert_return(!interface || interface_name_is_valid(interface), -EINVAL);
         assert_return(member_name_is_valid(member), -EINVAL);
-        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         r = sd_bus_message_new(bus, &t, SD_BUS_MESSAGE_METHOD_CALL);
         if (r < 0)
@@ -586,14 +586,14 @@ _public_ int sd_bus_message_new_method_call(
                         return r;
         }
 
-        *m = TAKE_PTR(t);
+        *ret = TAKE_PTR(t);
         return 0;
 }
 
 static int message_new_reply(
                 sd_bus_message *call,
                 uint8_t type,
-                sd_bus_message **m) {
+                sd_bus_message **ret) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *t = NULL;
         uint64_t cookie;
@@ -603,7 +603,7 @@ static int message_new_reply(
         assert_return(call->sealed, -EPERM);
         assert_return(call->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
         assert_return(call->bus->state != BUS_UNSET, -ENOTCONN);
-        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         cookie = BUS_MESSAGE_COOKIE(call);
         if (cookie == 0)
@@ -636,27 +636,27 @@ static int message_new_reply(
          * to both the message call and the reply. */
         t->sensitive = call->sensitive;
 
-        *m = TAKE_PTR(t);
+        *ret = TAKE_PTR(t);
         return 0;
 }
 
 _public_ int sd_bus_message_new_method_return(
                 sd_bus_message *call,
-                sd_bus_message **m) {
+                sd_bus_message **ret) {
 
-        return message_new_reply(call, SD_BUS_MESSAGE_METHOD_RETURN, m);
+        return message_new_reply(call, SD_BUS_MESSAGE_METHOD_RETURN, ret);
 }
 
 _public_ int sd_bus_message_new_method_error(
                 sd_bus_message *call,
-                sd_bus_message **m,
+                sd_bus_message **ret,
                 const sd_bus_error *e) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *t = NULL;
         int r;
 
         assert_return(sd_bus_error_is_set(e), -EINVAL);
-        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         r = message_new_reply(call, SD_BUS_MESSAGE_METHOD_ERROR, &t);
         if (r < 0)
@@ -674,13 +674,13 @@ _public_ int sd_bus_message_new_method_error(
 
         t->error._need_free = -1;
 
-        *m = TAKE_PTR(t);
+        *ret = TAKE_PTR(t);
         return 0;
 }
 
 _public_ int sd_bus_message_new_method_errorf(
                 sd_bus_message *call,
-                sd_bus_message **m,
+                sd_bus_message **ret,
                 const char *name,
                 const char *format,
                 ...) {
@@ -689,34 +689,34 @@ _public_ int sd_bus_message_new_method_errorf(
         va_list ap;
 
         assert_return(name, -EINVAL);
-        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         va_start(ap, format);
         sd_bus_error_setfv(&error, name, format, ap);
         va_end(ap);
 
-        return sd_bus_message_new_method_error(call, m, &error);
+        return sd_bus_message_new_method_error(call, ret, &error);
 }
 
 _public_ int sd_bus_message_new_method_errno(
                 sd_bus_message *call,
-                sd_bus_message **m,
+                sd_bus_message **ret,
                 int error,
                 const sd_bus_error *p) {
 
         _cleanup_(sd_bus_error_free) sd_bus_error berror = SD_BUS_ERROR_NULL;
 
         if (sd_bus_error_is_set(p))
-                return sd_bus_message_new_method_error(call, m, p);
+                return sd_bus_message_new_method_error(call, ret, p);
 
         sd_bus_error_set_errno(&berror, error);
 
-        return sd_bus_message_new_method_error(call, m, &berror);
+        return sd_bus_message_new_method_error(call, ret, &berror);
 }
 
 _public_ int sd_bus_message_new_method_errnof(
                 sd_bus_message *call,
-                sd_bus_message **m,
+                sd_bus_message **ret,
                 int error,
                 const char *format,
                 ...) {
@@ -728,7 +728,7 @@ _public_ int sd_bus_message_new_method_errnof(
         sd_bus_error_set_errnofv(&berror, error, format, ap);
         va_end(ap);
 
-        return sd_bus_message_new_method_error(call, m, &berror);
+        return sd_bus_message_new_method_error(call, ret, &berror);
 }
 
 void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m) {
@@ -873,36 +873,36 @@ sd_bus_message* bus_message_unref_queued(sd_bus_message *m, sd_bus *bus) {
         return message_free(m);
 }
 
-_public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
+_public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *ret) {
         assert_return(m, -EINVAL);
-        assert_return(type, -EINVAL);
+        assert_return(ret, -EINVAL);
 
-        *type = m->header->type;
+        *ret = m->header->type;
         return 0;
 }
 
-_public_ int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *cookie) {
+_public_ int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *ret) {
         uint64_t c;
 
         assert_return(m, -EINVAL);
-        assert_return(cookie, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         c = BUS_MESSAGE_COOKIE(m);
         if (c == 0)
                 return -ENODATA;
 
-        *cookie = BUS_MESSAGE_COOKIE(m);
+        *ret = BUS_MESSAGE_COOKIE(m);
         return 0;
 }
 
-_public_ int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *cookie) {
+_public_ int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *ret) {
         assert_return(m, -EINVAL);
-        assert_return(cookie, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (m->reply_cookie == 0)
                 return -ENODATA;
 
-        *cookie = m->reply_cookie;
+        *ret = m->reply_cookie;
         return 0;
 }
 
@@ -926,37 +926,37 @@ _public_ int sd_bus_message_get_allow_interactive_authorization(sd_bus_message *
                 (m->header->flags & BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION);
 }
 
-_public_ const char *sd_bus_message_get_path(sd_bus_message *m) {
+_public_ const char* sd_bus_message_get_path(sd_bus_message *m) {
         assert_return(m, NULL);
 
         return m->path;
 }
 
-_public_ const char *sd_bus_message_get_interface(sd_bus_message *m) {
+_public_ const char* sd_bus_message_get_interface(sd_bus_message *m) {
         assert_return(m, NULL);
 
         return m->interface;
 }
 
-_public_ const char *sd_bus_message_get_member(sd_bus_message *m) {
+_public_ const char* sd_bus_message_get_member(sd_bus_message *m) {
         assert_return(m, NULL);
 
         return m->member;
 }
 
-_public_ const char *sd_bus_message_get_destination(sd_bus_message *m) {
+_public_ const char* sd_bus_message_get_destination(sd_bus_message *m) {
         assert_return(m, NULL);
 
         return m->destination;
 }
 
-_public_ const char *sd_bus_message_get_sender(sd_bus_message *m) {
+_public_ const char* sd_bus_message_get_sender(sd_bus_message *m) {
         assert_return(m, NULL);
 
         return m->sender;
 }
 
-_public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
+_public_ const sd_bus_error* sd_bus_message_get_error(sd_bus_message *m) {
         assert_return(m, NULL);
 
         if (!sd_bus_error_is_set(&m->error))
@@ -965,40 +965,40 @@ _public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
         return &m->error;
 }
 
-_public_ int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *usec) {
+_public_ int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *ret) {
         assert_return(m, -EINVAL);
-        assert_return(usec, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (m->monotonic <= 0)
                 return -ENODATA;
 
-        *usec = m->monotonic;
+        *ret = m->monotonic;
         return 0;
 }
 
-_public_ int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *usec) {
+_public_ int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *ret) {
         assert_return(m, -EINVAL);
-        assert_return(usec, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (m->realtime <= 0)
                 return -ENODATA;
 
-        *usec = m->realtime;
+        *ret = m->realtime;
         return 0;
 }
 
-_public_ int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *seqnum) {
+_public_ int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *ret) {
         assert_return(m, -EINVAL);
-        assert_return(seqnum, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (m->seqnum <= 0)
                 return -ENODATA;
 
-        *seqnum = m->seqnum;
+        *ret = m->seqnum;
         return 0;
 }
 
-_public_ sd_bus_creds *sd_bus_message_get_creds(sd_bus_message *m) {
+_public_ sd_bus_creds* sd_bus_message_get_creds(sd_bus_message *m) {
         assert_return(m, NULL);
 
         if (m->creds.mask == 0)
@@ -1085,7 +1085,7 @@ _public_ int sd_bus_message_set_allow_interactive_authorization(sd_bus_message *
         return 0;
 }
 
-static BusMessageBodyPart *message_append_part(sd_bus_message *m) {
+static BusMessageBodyPart* message_append_part(sd_bus_message *m) {
         BusMessageBodyPart *part;
 
         assert(m);
@@ -1181,7 +1181,7 @@ static void message_extend_containers(sd_bus_message *m, size_t expand) {
                         *c->array_size += expand;
 }
 
-static void *message_extend_body(
+static void* message_extend_body(
                 sd_bus_message *m,
                 size_t align,
                 size_t sz) {
@@ -1442,15 +1442,15 @@ _public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const voi
 _public_ int sd_bus_message_append_string_space(
                 sd_bus_message *m,
                 size_t size,
-                char **s) {
+                char **ret) {
 
         BusMessageContainer *c;
         void *a;
 
         assert_return(m, -EINVAL);
-        assert_return(s, -EINVAL);
         assert_return(!m->sealed, -EPERM);
         assert_return(!m->poisoned, -ESTALE);
+        assert_return(ret, -EINVAL);
 
         c = message_get_last_container(m);
 
@@ -1478,9 +1478,9 @@ _public_ int sd_bus_message_append_string_space(
                 return -ENOMEM;
 
         *(uint32_t*) a = size;
-        *s = (char*) a + 4;
+        *ret = (char*) a + 4;
 
-        (*s)[size] = 0;
+        (*ret)[size] = 0;
 
         if (c->enclosing != SD_BUS_TYPE_ARRAY)
                 c->index++;
@@ -1526,8 +1526,7 @@ static int bus_message_open_array(
                 sd_bus_message *m,
                 BusMessageContainer *c,
                 const char *contents,
-                uint32_t **array_size,
-                size_t *begin) {
+                uint32_t **ret_array_size) {
 
         unsigned nindex;
         int alignment;
@@ -1538,8 +1537,7 @@ static int bus_message_open_array(
         assert(m);
         assert(c);
         assert(contents);
-        assert(array_size);
-        assert(begin);
+        assert(ret_array_size);
 
         if (!signature_is_single(contents, true))
                 return -EINVAL;
@@ -1593,7 +1591,7 @@ static int bus_message_open_array(
                 a = adjust_pointer(a, op, os, m->body_end->data);
 
         *(uint32_t*) a = 0;
-        *array_size = a;
+        *ret_array_size = a;
 
         if (c->enclosing != SD_BUS_TYPE_ARRAY)
                 c->index = nindex;
@@ -1654,15 +1652,13 @@ static int bus_message_open_variant(
 static int bus_message_open_struct(
                 sd_bus_message *m,
                 BusMessageContainer *c,
-                const char *contents,
-                size_t *begin) {
+                const char *contents) {
 
         size_t nindex;
 
         assert(m);
         assert(c);
         assert(contents);
-        assert(begin);
 
         if (!signature_is_valid(contents, false))
                 return -EINVAL;
@@ -1706,13 +1702,11 @@ static int bus_message_open_struct(
 static int bus_message_open_dict_entry(
                 sd_bus_message *m,
                 BusMessageContainer *c,
-                const char *contents,
-                size_t *begin) {
+                const char *contents) {
 
         assert(m);
         assert(c);
         assert(contents);
-        assert(begin);
 
         if (!signature_is_pair(contents))
                 return -EINVAL;
@@ -1747,7 +1741,7 @@ _public_ int sd_bus_message_open_container(
         BusMessageContainer *c;
         uint32_t *array_size = NULL;
         _cleanup_free_ char *signature = NULL;
-        size_t before, begin = 0;
+        size_t before;
         int r;
 
         assert_return(m, -EINVAL);
@@ -1775,13 +1769,13 @@ _public_ int sd_bus_message_open_container(
         before = m->body_size;
 
         if (type == SD_BUS_TYPE_ARRAY)
-                r = bus_message_open_array(m, c, contents, &array_size, &begin);
+                r = bus_message_open_array(m, c, contents, &array_size);
         else if (type == SD_BUS_TYPE_VARIANT)
                 r = bus_message_open_variant(m, c, contents);
         else if (type == SD_BUS_TYPE_STRUCT)
-                r = bus_message_open_struct(m, c, contents, &begin);
+                r = bus_message_open_struct(m, c, contents);
         else if (type == SD_BUS_TYPE_DICT_ENTRY)
-                r = bus_message_open_dict_entry(m, c, contents, &begin);
+                r = bus_message_open_dict_entry(m, c, contents);
         else
                 r = -EINVAL;
         if (r < 0)
@@ -1793,7 +1787,6 @@ _public_ int sd_bus_message_open_container(
                 .signature = TAKE_PTR(signature),
                 .array_size = array_size,
                 .before = before,
-                .begin = begin,
         };
 
         return 0;
@@ -1826,9 +1819,17 @@ typedef struct BusTypeStack {
         unsigned n_array;
 } BusTypeStack;
 
-static int type_stack_push(BusTypeStack *stack, unsigned max, unsigned *i, const char *types, unsigned n_struct, unsigned n_array) {
+static int type_stack_push(
+                BusTypeStack *stack,
+                unsigned max,
+                unsigned *i,
+                const char *types,
+                unsigned n_struct,
+                unsigned n_array) {
+
         assert(stack);
         assert(max > 0);
+        assert(i);
 
         if (*i >= max)
                 return -EINVAL;
@@ -1841,20 +1842,28 @@ static int type_stack_push(BusTypeStack *stack, unsigned max, unsigned *i, const
         return 0;
 }
 
-static int type_stack_pop(BusTypeStack *stack, unsigned max, unsigned *i, const char **types, unsigned *n_struct, unsigned *n_array) {
+static int type_stack_pop(
+                BusTypeStack *stack,
+                unsigned max,
+                unsigned *i,
+                const char **ret_types,
+                unsigned *ret_n_struct,
+                unsigned *ret_n_array) {
+
         assert(stack);
         assert(max > 0);
-        assert(types);
-        assert(n_struct);
-        assert(n_array);
+        assert(i);
+        assert(ret_types);
+        assert(ret_n_struct);
+        assert(ret_n_array);
 
         if (*i <= 0)
                 return 0;
 
         (*i)--;
-        *types = stack[*i].types;
-        *n_struct = stack[*i].n_struct;
-        *n_array = stack[*i].n_array;
+        *ret_types = stack[*i].types;
+        *ret_n_struct = stack[*i].n_struct;
+        *ret_n_array = stack[*i].n_array;
 
         return 1;
 }
@@ -2080,7 +2089,7 @@ _public_ int sd_bus_message_append_array_space(
                 sd_bus_message *m,
                 char type,
                 size_t size,
-                void **ptr) {
+                void **ret) {
 
         ssize_t align, sz;
         void *a;
@@ -2089,7 +2098,7 @@ _public_ int sd_bus_message_append_array_space(
         assert_return(m, -EINVAL);
         assert_return(!m->sealed, -EPERM);
         assert_return(bus_type_is_trivial(type) && type != SD_BUS_TYPE_BOOLEAN, -EINVAL);
-        assert_return(ptr || size == 0, -EINVAL);
+        assert_return(ret || size == 0, -EINVAL);
         assert_return(!m->poisoned, -ESTALE);
 
         align = bus_type_get_alignment(type);
@@ -2113,7 +2122,7 @@ _public_ int sd_bus_message_append_array_space(
         if (r < 0)
                 return r;
 
-        *ptr = a;
+        *ret = a;
         return 0;
 }
 
@@ -2569,7 +2578,7 @@ _public_ int sd_bus_message_at_end(sd_bus_message *m, int complete) {
         return false;
 }
 
-static BusMessageBodyPart* find_part(sd_bus_message *m, size_t index, size_t sz, void **p) {
+static BusMessageBodyPart* find_part(sd_bus_message *m, size_t index, size_t sz, void **ret) {
         BusMessageBodyPart *part;
         size_t begin;
         int r;
@@ -2594,8 +2603,8 @@ static BusMessageBodyPart* find_part(sd_bus_message *m, size_t index, size_t sz,
                         if (r < 0)
                                 return NULL;
 
-                        if (p)
-                                *p = part->data ? (uint8_t*) part->data + index - begin
+                        if (ret)
+                                *ret = part->data ? (uint8_t*) part->data + index - begin
                                         : NULL; /* Avoid dereferencing a NULL pointer. */
 
                         m->cached_rindex_part = part;
@@ -2711,7 +2720,7 @@ static bool validate_object_path(const char *s, size_t l) {
         return true;
 }
 
-_public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
+_public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *ret) {
         BusMessageContainer *c;
         size_t rindex;
         void *q;
@@ -2757,8 +2766,8 @@ _public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
                 if (!ok)
                         return -EBADMSG;
 
-                if (p)
-                        *(const char**) p = q;
+                if (ret)
+                        *(const char**) ret = q;
 
         } else if (type == SD_BUS_TYPE_SIGNATURE) {
                 uint8_t l;
@@ -2779,8 +2788,8 @@ _public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
                 if (!validate_signature(q, l))
                         return -EBADMSG;
 
-                if (p)
-                        *(const char**) p = q;
+                if (ret)
+                        *(const char**) ret = q;
 
         } else {
                 ssize_t sz, align;
@@ -2798,32 +2807,32 @@ _public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
                 switch (type) {
 
                 case SD_BUS_TYPE_BYTE:
-                        if (p)
-                                *(uint8_t*) p = *(uint8_t*) q;
+                        if (ret)
+                                *(uint8_t*) ret = *(uint8_t*) q;
                         break;
 
                 case SD_BUS_TYPE_BOOLEAN:
-                        if (p)
-                                *(int*) p = !!*(uint32_t*) q;
+                        if (ret)
+                                *(int*) ret = !!*(uint32_t*) q;
                         break;
 
                 case SD_BUS_TYPE_INT16:
                 case SD_BUS_TYPE_UINT16:
-                        if (p)
-                                *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
+                        if (ret)
+                                *(uint16_t*) ret = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
                         break;
 
                 case SD_BUS_TYPE_INT32:
                 case SD_BUS_TYPE_UINT32:
-                        if (p)
-                                *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
+                        if (ret)
+                                *(uint32_t*) ret = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
                         break;
 
                 case SD_BUS_TYPE_INT64:
                 case SD_BUS_TYPE_UINT64:
                 case SD_BUS_TYPE_DOUBLE:
-                        if (p)
-                                *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
+                        if (ret)
+                                *(uint64_t*) ret = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
                         break;
 
                 case SD_BUS_TYPE_UNIX_FD: {
@@ -2833,8 +2842,8 @@ _public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
                         if (j >= m->n_fds)
                                 return -EBADMSG;
 
-                        if (p)
-                                *(int*) p = m->fds[j];
+                        if (ret)
+                                *(int*) ret = m->fds[j];
                         break;
                 }
 
@@ -2855,7 +2864,7 @@ static int bus_message_enter_array(
                 sd_bus_message *m,
                 BusMessageContainer *c,
                 const char *contents,
-                uint32_t **array_size) {
+                uint32_t **ret_array_size) {
 
         size_t rindex;
         void *q;
@@ -2864,7 +2873,7 @@ static int bus_message_enter_array(
         assert(m);
         assert(c);
         assert(contents);
-        assert(array_size);
+        assert(ret_array_size);
 
         if (!signature_is_single(contents, true))
                 return -EINVAL;
@@ -2895,7 +2904,7 @@ static int bus_message_enter_array(
         if (r < 0)
                 return r;
 
-        *array_size = (uint32_t*) q;
+        *ret_array_size = (uint32_t*) q;
 
         m->rindex = rindex;
 
@@ -3033,9 +3042,11 @@ static int bus_message_enter_dict_entry(
         return 1;
 }
 
-_public_ int sd_bus_message_enter_container(sd_bus_message *m,
-                                            char type,
-                                            const char *contents) {
+_public_ int sd_bus_message_enter_container(
+                sd_bus_message *m,
+                char type,
+                const char *contents) {
+
         BusMessageContainer *c;
         uint32_t *array_size = NULL;
         _cleanup_free_ char *signature = NULL;
@@ -3689,8 +3700,8 @@ _public_ int sd_bus_message_skip(sd_bus_message *m, const char *types) {
 _public_ int sd_bus_message_read_array(
                 sd_bus_message *m,
                 char type,
-                const void **ptr,
-                size_t *size) {
+                const void **ret_ptr,
+                size_t *ret_size) {
 
         BusMessageContainer *c;
         void *p;
@@ -3701,16 +3712,16 @@ _public_ int sd_bus_message_read_array(
         assert_return(m, -EINVAL);
         assert_return(m->sealed, -EPERM);
         assert_return(bus_type_is_trivial(type), -EINVAL);
-        assert_return(ptr, -EINVAL);
-        assert_return(size, -EINVAL);
+        assert_return(ret_ptr, -EINVAL);
+        assert_return(ret_size, -EINVAL);
         assert_return(!BUS_MESSAGE_NEED_BSWAP(m), -EOPNOTSUPP);
 
         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
         if (r < 0)
                 return r;
         if (r == 0) {
-                *ptr = NULL;
-                *size = 0;
+                *ret_ptr = NULL;
+                *ret_size = 0;
                 return 0;
         }
 
@@ -3736,8 +3747,8 @@ _public_ int sd_bus_message_read_array(
         if (r < 0)
                 goto fail;
 
-        *ptr = (const void*) p;
-        *size = sz;
+        *ret_ptr = (const void*) p;
+        *ret_size = sz;
 
         return 1;
 
@@ -4325,19 +4336,19 @@ _public_ int sd_bus_message_read_strv_extend(sd_bus_message *m, char ***l) {
         return 1;
 }
 
-_public_ int sd_bus_message_read_strv(sd_bus_message *m, char ***l) {
+_public_ int sd_bus_message_read_strv(sd_bus_message *m, char ***ret) {
         _cleanup_strv_free_ char **strv = NULL;
         int r;
 
         assert_return(m, -EINVAL);
         assert_return(m->sealed, -EPERM);
-        assert_return(l, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         r = sd_bus_message_read_strv_extend(m, &strv);
         if (r <= 0)
                 return r;
 
-        *l = TAKE_PTR(strv);
+        *ret = TAKE_PTR(strv);
         return 1;
 }
 
@@ -4552,7 +4563,7 @@ _public_ int sd_bus_message_verify_type(sd_bus_message *m, char type, const char
         return 1;
 }
 
-_public_ sd_bus *sd_bus_message_get_bus(sd_bus_message *m) {
+_public_ sd_bus* sd_bus_message_get_bus(sd_bus_message *m) {
         assert_return(m, NULL);
 
         return m->bus;
@@ -4647,18 +4658,18 @@ int bus_message_remarshal(sd_bus *bus, sd_bus_message **m) {
         return 0;
 }
 
-_public_ int sd_bus_message_get_priority(sd_bus_message *m, int64_t *priority) {
+_public_ int sd_bus_message_get_priority(sd_bus_message *m, int64_t *ret) {
         static bool warned = false;
 
         assert_return(m, -EINVAL);
-        assert_return(priority, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!warned) {
                 log_debug("sd_bus_message_get_priority() is deprecated and always returns 0.");
                 warned = true;
         }
 
-        *priority = 0;
+        *ret = 0;
         return 0;
 }
 

src/libsystemd/sd-bus/bus-objects.c

@@ -22,7 +22,7 @@ static int node_vtable_get_userdata(
                 const char *path,
                 BusNodeVTable *c,
                 void **userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         sd_bus_slot *s;
         void *u, *found_u = NULL;
@@ -37,14 +37,14 @@ static int node_vtable_get_userdata(
         if (c->find) {
                 bus->current_slot = sd_bus_slot_ref(s);
                 bus->current_userdata = u;
-                r = c->find(bus, path, c->interface, u, &found_u, error);
+                r = c->find(bus, path, c->interface, u, &found_u, reterr_error);
                 bus->current_userdata = NULL;
                 bus->current_slot = sd_bus_slot_unref(s);
 
                 if (r < 0)
                         return r;
-                if (sd_bus_error_is_set(error))
-                        return -sd_bus_error_get_errno(error);
+                if (sd_bus_error_is_set(reterr_error))
+                        return -sd_bus_error_get_errno(reterr_error);
                 if (r == 0)
                         return r;
         } else
@@ -56,7 +56,7 @@ static int node_vtable_get_userdata(
         return 1;
 }
 
-static void *vtable_method_convert_userdata(const sd_bus_vtable *p, void *u) {
+static void* vtable_method_convert_userdata(const sd_bus_vtable *p, void *u) {
         assert(p);
 
         if (!u || FLAGS_SET(p->flags, SD_BUS_VTABLE_ABSOLUTE_OFFSET))
@@ -65,7 +65,7 @@ static void *vtable_method_convert_userdata(const sd_bus_vtable *p, void *u) {
         return (uint8_t*) u + p->x.method.offset;
 }
 
-static void *vtable_property_convert_userdata(const sd_bus_vtable *p, void *u) {
+static void* vtable_property_convert_userdata(const sd_bus_vtable *p, void *u) {
         assert(p);
 
         if (!u || FLAGS_SET(p->flags, SD_BUS_VTABLE_ABSOLUTE_OFFSET))
@@ -79,7 +79,7 @@ static int vtable_property_get_userdata(
                 const char *path,
                 BusVTableMember *p,
                 void **userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         void *u;
         int r;
@@ -89,7 +89,7 @@ static int vtable_property_get_userdata(
         assert(p);
         assert(userdata);
 
-        r = node_vtable_get_userdata(bus, path, p->parent, &u, error);
+        r = node_vtable_get_userdata(bus, path, p->parent, &u, reterr_error);
         if (r <= 0)
                 return r;
         if (bus->nodes_modified)
@@ -104,7 +104,7 @@ static int add_enumerated_to_set(
                 const char *prefix,
                 BusNodeEnumerator *first,
                 OrderedSet *s,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         int r;
 
@@ -123,14 +123,14 @@ static int add_enumerated_to_set(
 
                 bus->current_slot = sd_bus_slot_ref(slot);
                 bus->current_userdata = slot->userdata;
-                r = c->callback(bus, prefix, slot->userdata, &children, error);
+                r = c->callback(bus, prefix, slot->userdata, &children, reterr_error);
                 bus->current_userdata = NULL;
                 bus->current_slot = sd_bus_slot_unref(slot);
 
                 if (r < 0)
                         return r;
-                if (sd_bus_error_is_set(error))
-                        return -sd_bus_error_get_errno(error);
+                if (sd_bus_error_is_set(reterr_error))
+                        return -sd_bus_error_get_errno(reterr_error);
 
                 strv_sort(children);
 
@@ -177,7 +177,7 @@ static int add_subtree_to_set(
                 BusNode *n,
                 unsigned flags,
                 OrderedSet *s,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         int r;
 
@@ -186,7 +186,7 @@ static int add_subtree_to_set(
         assert(n);
         assert(s);
 
-        r = add_enumerated_to_set(bus, prefix, n->enumerators, s, error);
+        r = add_enumerated_to_set(bus, prefix, n->enumerators, s, reterr_error);
         if (r < 0)
                 return r;
         if (bus->nodes_modified)
@@ -208,7 +208,7 @@ static int add_subtree_to_set(
 
                 if ((flags & CHILDREN_RECURSIVE) &&
                     ((flags & CHILDREN_SUBHIERARCHIES) || !i->object_managers)) {
-                        r = add_subtree_to_set(bus, prefix, i, flags, s, error);
+                        r = add_subtree_to_set(bus, prefix, i, flags, s, reterr_error);
                         if (r < 0)
                                 return r;
                         if (bus->nodes_modified)
@@ -225,7 +225,7 @@ static int get_child_nodes(
                 BusNode *n,
                 unsigned flags,
                 OrderedSet **ret,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         _cleanup_ordered_set_free_ OrderedSet *s = NULL;
         int r;
@@ -239,7 +239,7 @@ static int get_child_nodes(
         if (!s)
                 return -ENOMEM;
 
-        r = add_subtree_to_set(bus, prefix, n, flags, s, error);
+        r = add_subtree_to_set(bus, prefix, n, flags, s, reterr_error);
         if (r < 0)
                 return r;
 
@@ -261,7 +261,7 @@ static int node_callbacks_run(
         assert(found_object);
 
         LIST_FOREACH(callbacks, c, first) {
-                _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
+                _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
                 sd_bus_slot *slot;
 
                 if (bus->nodes_modified)
@@ -286,12 +286,12 @@ static int node_callbacks_run(
                 bus->current_slot = sd_bus_slot_ref(slot);
                 bus->current_handler = c->callback;
                 bus->current_userdata = slot->userdata;
-                r = c->callback(m, slot->userdata, &error_buffer);
+                r = c->callback(m, slot->userdata, &error);
                 bus->current_userdata = NULL;
                 bus->current_handler = NULL;
                 bus->current_slot = sd_bus_slot_unref(slot);
 
-                r = bus_maybe_reply_error(m, r, &error_buffer);
+                r = bus_maybe_reply_error(m, r, &error);
                 if (r != 0)
                         return r;
         }
@@ -301,7 +301,7 @@ static int node_callbacks_run(
 
 #define CAPABILITY_SHIFT(x) (((x) >> __builtin_ctzll(_SD_BUS_VTABLE_CAPABILITY_MASK)) & 0xFFFF)
 
-static int check_access(sd_bus *bus, sd_bus_message *m, BusVTableMember *c, sd_bus_error *error) {
+static int check_access(sd_bus *bus, sd_bus_message *m, BusVTableMember *c, sd_bus_error *reterr_error) {
         uint64_t cap;
         int r;
 
@@ -334,7 +334,7 @@ static int check_access(sd_bus *bus, sd_bus_message *m, BusVTableMember *c, sd_b
         if (r > 0)
                 return 0;
 
-        return sd_bus_error_setf(error, SD_BUS_ERROR_ACCESS_DENIED, "Access to %s.%s() not permitted.", c->interface, c->member);
+        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_ACCESS_DENIED, "Access to %s.%s() not permitted.", c->interface, c->member);
 }
 
 static int method_callbacks_run(
@@ -435,7 +435,7 @@ static int invoke_property_get(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         const void *p;
         int r;
@@ -452,14 +452,14 @@ static int invoke_property_get(
 
                 bus->current_slot = sd_bus_slot_ref(slot);
                 bus->current_userdata = userdata;
-                r = v->x.property.get(bus, path, interface, property, reply, userdata, error);
+                r = v->x.property.get(bus, path, interface, property, reply, userdata, reterr_error);
                 bus->current_userdata = NULL;
                 bus->current_slot = sd_bus_slot_unref(slot);
 
                 if (r < 0)
                         return r;
-                if (sd_bus_error_is_set(error))
-                        return -sd_bus_error_get_errno(error);
+                if (sd_bus_error_is_set(reterr_error))
+                        return -sd_bus_error_get_errno(reterr_error);
                 return r;
         }
 
@@ -499,7 +499,7 @@ static int invoke_property_set(
                 const char *property,
                 sd_bus_message *value,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         int r;
 
@@ -515,14 +515,14 @@ static int invoke_property_set(
 
                 bus->current_slot = sd_bus_slot_ref(slot);
                 bus->current_userdata = userdata;
-                r = v->x.property.set(bus, path, interface, property, value, userdata, error);
+                r = v->x.property.set(bus, path, interface, property, value, userdata, reterr_error);
                 bus->current_userdata = NULL;
                 bus->current_slot = sd_bus_slot_unref(slot);
 
                 if (r < 0)
                         return r;
-                if (sd_bus_error_is_set(error))
-                        return -sd_bus_error_get_errno(error);
+                if (sd_bus_error_is_set(reterr_error))
+                        return -sd_bus_error_get_errno(reterr_error);
                 return r;
         }
 
@@ -700,7 +700,7 @@ static int vtable_append_one_property(
                 BusNodeVTable *c,
                 const sd_bus_vtable *v,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         sd_bus_slot *slot;
         int r;
@@ -731,7 +731,7 @@ static int vtable_append_one_property(
 
         slot = container_of(c, sd_bus_slot, node_vtable);
 
-        r = invoke_property_get(bus, slot, v, path, c->interface, v->x.property.member, reply, vtable_property_convert_userdata(v, userdata), error);
+        r = invoke_property_get(bus, slot, v, path, c->interface, v->x.property.member, reply, vtable_property_convert_userdata(v, userdata), reterr_error);
         if (r < 0)
                 return r;
         if (bus->nodes_modified)
@@ -754,7 +754,7 @@ static int vtable_append_all_properties(
                 const char *path,
                 BusNodeVTable *c,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         const sd_bus_vtable *v;
         int r;
@@ -787,7 +787,7 @@ static int vtable_append_all_properties(
                     FLAGS_SET(v->flags, SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION))
                         continue;
 
-                r = vtable_append_one_property(bus, reply, path, c, v, userdata, error);
+                r = vtable_append_one_property(bus, reply, path, c, v, userdata, reterr_error);
                 if (r < 0)
                         return r;
                 if (bus->nodes_modified)
@@ -928,7 +928,7 @@ int introspect_path(
                 bool ignore_nodes_modified,
                 bool *found_object,
                 char **ret,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         _cleanup_ordered_set_free_ OrderedSet *s = NULL;
         _cleanup_(introspect_done) BusIntrospect intro = {};
@@ -941,7 +941,7 @@ int introspect_path(
                         return -ENOENT;
         }
 
-        r = get_child_nodes(bus, path, n, 0, &s, error);
+        r = get_child_nodes(bus, path, n, 0, &s, reterr_error);
         if (r < 0)
                 return r;
         if (bus->nodes_modified && !ignore_nodes_modified)
@@ -961,7 +961,7 @@ int introspect_path(
                 if (require_fallback && !c->is_fallback)
                         continue;
 
-                r = node_vtable_get_userdata(bus, path, c, NULL, error);
+                r = node_vtable_get_userdata(bus, path, c, NULL, reterr_error);
                 if (r < 0)
                         return r;
                 if (bus->nodes_modified && !ignore_nodes_modified)
@@ -1049,7 +1049,7 @@ static int object_manager_serialize_path(
                 const char *path,
                 bool require_fallback,
                 bool *found_object_manager,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         const char *previous_interface = NULL;
         bool found_something = false;
@@ -1061,7 +1061,7 @@ static int object_manager_serialize_path(
         assert(prefix);
         assert(path);
         assert(found_object_manager);
-        assert(error);
+        assert(reterr_error);
 
         n = hashmap_get(bus->nodes, prefix);
         if (!n)
@@ -1076,7 +1076,7 @@ static int object_manager_serialize_path(
                 if (require_fallback && !i->is_fallback)
                         continue;
 
-                r = node_vtable_get_userdata(bus, path, i, &u, error);
+                r = node_vtable_get_userdata(bus, path, i, &u, reterr_error);
                 if (r < 0)
                         return r;
                 if (bus->nodes_modified)
@@ -1151,7 +1151,7 @@ static int object_manager_serialize_path(
                                 return r;
                 }
 
-                r = vtable_append_all_properties(bus, reply, path, i, u, error);
+                r = vtable_append_all_properties(bus, reply, path, i, u, reterr_error);
                 if (r < 0)
                         return r;
                 if (bus->nodes_modified)
@@ -1187,7 +1187,7 @@ static int object_manager_serialize_path_and_fallbacks(
                 sd_bus *bus,
                 sd_bus_message *reply,
                 const char *path,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         _cleanup_free_ char *prefix = NULL;
         size_t pl;
@@ -1197,10 +1197,10 @@ static int object_manager_serialize_path_and_fallbacks(
         assert(bus);
         assert(reply);
         assert(path);
-        assert(error);
+        assert(reterr_error);
 
         /* First, add all vtables registered for this path */
-        r = object_manager_serialize_path(bus, reply, path, path, false, &found_object_manager, error);
+        r = object_manager_serialize_path(bus, reply, path, path, false, &found_object_manager, reterr_error);
         if (r < 0)
                 return r;
         if (bus->nodes_modified)
@@ -1214,7 +1214,7 @@ static int object_manager_serialize_path_and_fallbacks(
                 return -ENOMEM;
 
         OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
-                r = object_manager_serialize_path(bus, reply, prefix, path, true, &found_object_manager, error);
+                r = object_manager_serialize_path(bus, reply, prefix, path, true, &found_object_manager, reterr_error);
                 if (r < 0)
                         return r;
                 if (bus->nodes_modified)
@@ -1600,7 +1600,7 @@ static int bus_find_parent_object_manager(sd_bus *bus, BusNode **out, const char
 
 static int bus_add_object(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 bool fallback,
                 const char *path,
                 sd_bus_message_handler_t callback,
@@ -1620,7 +1620,7 @@ static int bus_add_object(
         if (!n)
                 return -ENOMEM;
 
-        s = bus_slot_allocate(bus, !slot, BUS_NODE_CALLBACK, sizeof(BusNodeCallback), userdata);
+        s = bus_slot_allocate(bus, !ret_slot, BUS_NODE_CALLBACK, sizeof(BusNodeCallback), userdata);
         if (!s) {
                 r = -ENOMEM;
                 goto fail;
@@ -1633,8 +1633,8 @@ static int bus_add_object(
         LIST_PREPEND(callbacks, n->callbacks, &s->node_callback);
         bus->nodes_modified = true;
 
-        if (slot)
-                *slot = s;
+        if (ret_slot)
+                *ret_slot = s;
 
         return 0;
 
@@ -1647,22 +1647,22 @@ fail:
 
 _public_ int sd_bus_add_object(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *path,
                 sd_bus_message_handler_t callback,
                 void *userdata) {
 
-        return bus_add_object(bus, slot, false, path, callback, userdata);
+        return bus_add_object(bus, ret_slot, false, path, callback, userdata);
 }
 
 _public_ int sd_bus_add_fallback(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *prefix,
                 sd_bus_message_handler_t callback,
                 void *userdata) {
 
-        return bus_add_object(bus, slot, true, prefix, callback, userdata);
+        return bus_add_object(bus, ret_slot, true, prefix, callback, userdata);
 }
 
 static void vtable_member_hash_func(const BusVTableMember *m, struct siphash *state) {
@@ -1787,7 +1787,7 @@ const sd_bus_vtable* bus_vtable_next(const sd_bus_vtable *vtable, const sd_bus_v
 
 static int add_object_vtable_internal(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *path,
                 const char *interface,
                 const sd_bus_vtable *vtable,
@@ -1839,7 +1839,7 @@ static int add_object_vtable_internal(
                 }
         }
 
-        s = bus_slot_allocate(bus, !slot, BUS_NODE_VTABLE, sizeof(BusNodeVTable), userdata);
+        s = bus_slot_allocate(bus, !ret_slot, BUS_NODE_VTABLE, sizeof(BusNodeVTable), userdata);
         if (!s) {
                 r = -ENOMEM;
                 goto fail;
@@ -1980,8 +1980,8 @@ static int add_object_vtable_internal(
         LIST_INSERT_AFTER(vtables, n->vtables, existing, &s->node_vtable);
         bus->nodes_modified = true;
 
-        if (slot)
-                *slot = s;
+        if (ret_slot)
+                *ret_slot = s;
 
         return 0;
 
@@ -1997,30 +1997,30 @@ _public_ const unsigned sd_bus_object_vtable_format = 242;
 
 _public_ int sd_bus_add_object_vtable(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *path,
                 const char *interface,
                 const sd_bus_vtable *vtable,
                 void *userdata) {
 
-        return add_object_vtable_internal(bus, slot, path, interface, vtable, false, NULL, userdata);
+        return add_object_vtable_internal(bus, ret_slot, path, interface, vtable, false, NULL, userdata);
 }
 
 _public_ int sd_bus_add_fallback_vtable(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *prefix,
                 const char *interface,
                 const sd_bus_vtable *vtable,
                 sd_bus_object_find_t find,
                 void *userdata) {
 
-        return add_object_vtable_internal(bus, slot, prefix, interface, vtable, true, find, userdata);
+        return add_object_vtable_internal(bus, ret_slot, prefix, interface, vtable, true, find, userdata);
 }
 
 _public_ int sd_bus_add_node_enumerator(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *path,
                 sd_bus_node_enumerator_t callback,
                 void *userdata) {
@@ -2039,7 +2039,7 @@ _public_ int sd_bus_add_node_enumerator(
         if (!n)
                 return -ENOMEM;
 
-        s = bus_slot_allocate(bus, !slot, BUS_NODE_ENUMERATOR, sizeof(BusNodeEnumerator), userdata);
+        s = bus_slot_allocate(bus, !ret_slot, BUS_NODE_ENUMERATOR, sizeof(BusNodeEnumerator), userdata);
         if (!s) {
                 r = -ENOMEM;
                 goto fail;
@@ -2051,8 +2051,8 @@ _public_ int sd_bus_add_node_enumerator(
         LIST_PREPEND(enumerators, n->enumerators, &s->node_enumerator);
         bus->nodes_modified = true;
 
-        if (slot)
-                *slot = s;
+        if (ret_slot)
+                *ret_slot = s;
 
         return 0;
 
@@ -3022,7 +3022,7 @@ _public_ int sd_bus_emit_interfaces_removed(sd_bus *bus, const char *path, const
         return sd_bus_emit_interfaces_removed_strv(bus, path, interfaces);
 }
 
-_public_ int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path) {
+_public_ int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **ret_slot, const char *path) {
         sd_bus_slot *s;
         BusNode *n;
         int r;
@@ -3036,7 +3036,7 @@ _public_ int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const ch
         if (!n)
                 return -ENOMEM;
 
-        s = bus_slot_allocate(bus, !slot, BUS_NODE_OBJECT_MANAGER, sizeof(BusNodeObjectManager), NULL);
+        s = bus_slot_allocate(bus, !ret_slot, BUS_NODE_OBJECT_MANAGER, sizeof(BusNodeObjectManager), NULL);
         if (!s) {
                 r = -ENOMEM;
                 goto fail;
@@ -3046,8 +3046,8 @@ _public_ int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const ch
         LIST_PREPEND(object_managers, n->object_managers, &s->node_object_manager);
         bus->nodes_modified = true;
 
-        if (slot)
-                *slot = s;
+        if (ret_slot)
+                *ret_slot = s;
 
         return 0;
 

src/libsystemd/sd-bus/bus-objects.h

@@ -16,4 +16,4 @@ int introspect_path(
                 bool ignore_nodes_modified,
                 bool *found_object,
                 char **ret,
-                sd_bus_error *error);
+                sd_bus_error *reterr_error);

src/libsystemd/sd-bus/bus-slot.c

@@ -199,13 +199,13 @@ _public_ sd_bus* sd_bus_slot_get_bus(sd_bus_slot *slot) {
         return slot->bus;
 }
 
-_public_ void *sd_bus_slot_get_userdata(sd_bus_slot *slot) {
+_public_ void* sd_bus_slot_get_userdata(sd_bus_slot *slot) {
         assert_return(slot, NULL);
 
         return slot->userdata;
 }
 
-_public_ void *sd_bus_slot_set_userdata(sd_bus_slot *slot, void *userdata) {
+_public_ void* sd_bus_slot_set_userdata(sd_bus_slot *slot, void *userdata) {
         void *ret;
 
         assert_return(slot, NULL);
@@ -223,16 +223,16 @@ _public_ int sd_bus_slot_set_destroy_callback(sd_bus_slot *slot, sd_bus_destroy_
         return 0;
 }
 
-_public_ int sd_bus_slot_get_destroy_callback(sd_bus_slot *slot, sd_bus_destroy_t *callback) {
+_public_ int sd_bus_slot_get_destroy_callback(sd_bus_slot *slot, sd_bus_destroy_t *ret) {
         assert_return(slot, -EINVAL);
 
-        if (callback)
-                *callback = slot->destroy_callback;
+        if (ret)
+                *ret = slot->destroy_callback;
 
         return !!slot->destroy_callback;
 }
 
-_public_ sd_bus_message *sd_bus_slot_get_current_message(sd_bus_slot *slot) {
+_public_ sd_bus_message* sd_bus_slot_get_current_message(sd_bus_slot *slot) {
         assert_return(slot, NULL);
         assert_return(slot->type >= 0, NULL);
 
@@ -299,14 +299,14 @@ _public_ int sd_bus_slot_set_description(sd_bus_slot *slot, const char *descript
         return free_and_strdup(&slot->description, description);
 }
 
-_public_ int sd_bus_slot_get_description(sd_bus_slot *slot, const char **description) {
+_public_ int sd_bus_slot_get_description(sd_bus_slot *slot, const char **ret) {
         assert_return(slot, -EINVAL);
-        assert_return(description, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (slot->description)
-                *description = slot->description;
+                *ret = slot->description;
         else if (slot->type == BUS_MATCH_CALLBACK)
-                *description = slot->match_callback.match_string;
+                *ret = slot->match_callback.match_string;
         else
                 return -ENXIO;
 

src/libsystemd/sd-bus/bus-track.c

@@ -116,7 +116,7 @@ static int bus_track_remove_name_fully(sd_bus_track *track, const char *name) {
 
 _public_ int sd_bus_track_new(
                 sd_bus *bus,
-                sd_bus_track **track,
+                sd_bus_track **ret,
                 sd_bus_track_handler_t handler,
                 void *userdata) {
 
@@ -124,7 +124,7 @@ _public_ int sd_bus_track_new(
 
         assert_return(bus, -EINVAL);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
-        assert_return(track, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (!bus->bus_client)
                 return -EINVAL;
@@ -143,11 +143,11 @@ _public_ int sd_bus_track_new(
 
         bus_track_add_to_queue(t);
 
-        *track = t;
+        *ret = t;
         return 0;
 }
 
-static sd_bus_track *track_free(sd_bus_track *track) {
+static sd_bus_track* track_free(sd_bus_track *track) {
         assert(track);
 
         if (track->in_list)
@@ -165,7 +165,7 @@ static sd_bus_track *track_free(sd_bus_track *track) {
 
 DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_bus_track, sd_bus_track, track_free);
 
-static int on_name_owner_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
+static int on_name_owner_changed(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
         sd_bus_track *track = ASSERT_PTR(userdata);
         const char *name;
         int r;
@@ -411,13 +411,13 @@ void bus_track_close(sd_bus_track *track) {
                 bus_track_dispatch(track);
 }
 
-_public_ void *sd_bus_track_get_userdata(sd_bus_track *track) {
+_public_ void* sd_bus_track_get_userdata(sd_bus_track *track) {
         assert_return(track, NULL);
 
         return track->userdata;
 }
 
-_public_ void *sd_bus_track_set_userdata(sd_bus_track *track, void *userdata) {
+_public_ void* sd_bus_track_set_userdata(sd_bus_track *track, void *userdata) {
         void *ret;
 
         assert_return(track, NULL);

src/libsystemd/sd-bus/sd-bus.c

@@ -74,7 +74,7 @@ static thread_local sd_bus *default_system_bus = NULL;
 static thread_local sd_bus *default_user_bus = NULL;
 static thread_local sd_bus *default_starter_bus = NULL;
 
-static sd_bus **bus_choose_default(int (**bus_open)(sd_bus **)) {
+static sd_bus** bus_choose_default(int (**bus_open)(sd_bus **)) {
         const char *e;
 
         /* Let's try our best to reuse another cached connection. If
@@ -545,7 +545,7 @@ void bus_set_state(sd_bus *bus, BusState state) {
         bus->state = state;
 }
 
-static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
+static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error) {
         const char *s;
         sd_bus *bus;
         int r;
@@ -1783,7 +1783,7 @@ _public_ void sd_bus_close(sd_bus *bus) {
         bus_close_fds(bus);
 }
 
-_public_ sd_bus *sd_bus_close_unref(sd_bus *bus) {
+_public_ sd_bus* sd_bus_close_unref(sd_bus *bus) {
         if (!bus)
                 return NULL;
         if (bus_origin_changed(bus))
@@ -1817,7 +1817,7 @@ void bus_enter_closing(sd_bus *bus) {
 }
 
 /* Define manually so we can add the PID check */
-_public_ sd_bus *sd_bus_ref(sd_bus *bus) {
+_public_ sd_bus* sd_bus_ref(sd_bus *bus) {
         if (!bus)
                 return NULL;
         if (bus_origin_changed(bus))
@@ -1886,19 +1886,19 @@ _public_ int sd_bus_can_send(sd_bus *bus, char type) {
         return bus_type_is_valid(type);
 }
 
-_public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
+_public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *ret) {
         int r;
 
         assert_return(bus, -EINVAL);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
-        assert_return(id, -EINVAL);
+        assert_return(ret, -EINVAL);
         assert_return(!bus_origin_changed(bus), -ECHILD);
 
         r = bus_ensure_running(bus);
         if (r < 0)
                 return r;
 
-        *id = bus->server_id;
+        *ret = bus->server_id;
         return 0;
 }
 
@@ -2218,7 +2218,7 @@ finish:
         return 1;
 }
 
-_public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
+_public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *ret_cookie) {
         int r;
 
         assert_return(m, -EINVAL);
@@ -2242,7 +2242,7 @@ _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destinat
                         return r;
         }
 
-        return sd_bus_send(bus, m, cookie);
+        return sd_bus_send(bus, m, ret_cookie);
 }
 
 static usec_t calc_elapse(sd_bus *bus, uint64_t usec) {
@@ -2277,13 +2277,13 @@ static int timeout_compare(const void *a, const void *b) {
 
 _public_ int sd_bus_call_async(
                 sd_bus *bus,
-                sd_bus_slot **slot,
-                sd_bus_message *_m,
+                sd_bus_slot **ret_slot,
+                sd_bus_message *m,
                 sd_bus_message_handler_t callback,
                 void *userdata,
                 uint64_t usec) {
 
-        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
+        _unused_ _cleanup_(sd_bus_message_unrefp) sd_bus_message *m_unref = sd_bus_message_ref(m);
         _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *s = NULL;
         int r;
 
@@ -2301,7 +2301,7 @@ _public_ int sd_bus_call_async(
                 return -ENOTCONN;
 
         /* If no callback is specified and there's no interest in a slot, then there's no reason to ask for a reply */
-        if (!callback && !slot && !m->sealed)
+        if (!callback && !ret_slot && !m->sealed)
                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
 
         r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
@@ -2316,8 +2316,8 @@ _public_ int sd_bus_call_async(
         if (r < 0)
                 return r;
 
-        if (slot || callback) {
-                s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(BusReplyCallback), userdata);
+        if (ret_slot || callback) {
+                s = bus_slot_allocate(bus, !ret_slot, BUS_REPLY_CALLBACK, sizeof(BusReplyCallback), userdata);
                 if (!s)
                         return -ENOMEM;
 
@@ -2344,8 +2344,8 @@ _public_ int sd_bus_call_async(
         if (r < 0)
                 return r;
 
-        if (slot)
-                *slot = s;
+        if (ret_slot)
+                *ret_slot = s;
         s = NULL;
 
         return r;
@@ -2381,8 +2381,8 @@ _public_ int sd_bus_call(
                 sd_bus *bus,
                 sd_bus_message *_m,
                 uint64_t usec,
-                sd_bus_error *error,
-                sd_bus_message **reply) {
+                sd_bus_error *reterr_error,
+                sd_bus_message **ret_reply) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
         usec_t timeout;
@@ -2390,16 +2390,16 @@ _public_ int sd_bus_call(
         size_t i;
         int r;
 
-        bus_assert_return(m, -EINVAL, error);
-        bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
-        bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
-        bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
+        bus_assert_return(m, -EINVAL, reterr_error);
+        bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, reterr_error);
+        bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, reterr_error);
+        bus_assert_return(!bus_error_is_dirty(reterr_error), -EINVAL, reterr_error);
 
         if (bus)
                 assert_return(bus = bus_resolve(bus), -ENOPKG);
         else
                 assert_return(bus = m->bus, -ENOTCONN);
-        bus_assert_return(!bus_origin_changed(bus), -ECHILD, error);
+        bus_assert_return(!bus_origin_changed(bus), -ECHILD, reterr_error);
 
         if (!BUS_IS_OPEN(bus->state)) {
                 r = -ENOTCONN;
@@ -2443,17 +2443,17 @@ _public_ int sd_bus_call(
                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
 
                                         if (incoming->n_fds <= 0 || bus->accept_fd) {
-                                                if (reply)
-                                                        *reply = TAKE_PTR(incoming);
+                                                if (ret_reply)
+                                                        *ret_reply = TAKE_PTR(incoming);
 
                                                 return 1;
                                         }
 
-                                        return sd_bus_error_set(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE,
+                                        return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INCONSISTENT_MESSAGE,
                                                                 "Reply message contained file descriptors which I couldn't accept. Sorry.");
 
                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
-                                        return sd_bus_error_copy(error, &incoming->error);
+                                        return sd_bus_error_copy(reterr_error, &incoming->error);
                                 else {
                                         r = -EIO;
                                         goto fail;
@@ -2524,7 +2524,7 @@ _public_ int sd_bus_call(
         }
 
 fail:
-        return sd_bus_error_set_errno(error, r);
+        return sd_bus_error_set_errno(reterr_error, r);
 }
 
 _public_ int sd_bus_get_fd(sd_bus *bus) {
@@ -2591,56 +2591,56 @@ _public_ int sd_bus_get_events(sd_bus *bus) {
         return flags;
 }
 
-_public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
+_public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *ret) {
         BusReplyCallback *c;
 
         assert_return(bus, -EINVAL);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
-        assert_return(timeout_usec, -EINVAL);
+        assert_return(ret, -EINVAL);
         assert_return(!bus_origin_changed(bus), -ECHILD);
 
         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
                 return -ENOTCONN;
 
         if (bus->track_queue) {
-                *timeout_usec = 0;
+                *ret = 0;
                 return 1;
         }
 
         switch (bus->state) {
 
         case BUS_AUTHENTICATING:
-                *timeout_usec = bus->auth_timeout;
+                *ret = bus->auth_timeout;
                 return 1;
 
         case BUS_RUNNING:
         case BUS_HELLO:
                 if (bus->rqueue_size > 0) {
-                        *timeout_usec = 0;
+                        *ret = 0;
                         return 1;
                 }
 
                 c = prioq_peek(bus->reply_callbacks_prioq);
                 if (!c) {
-                        *timeout_usec = UINT64_MAX;
+                        *ret = UINT64_MAX;
                         return 0;
                 }
 
                 if (c->timeout_usec == 0) {
-                        *timeout_usec = UINT64_MAX;
+                        *ret = UINT64_MAX;
                         return 0;
                 }
 
-                *timeout_usec = c->timeout_usec;
+                *ret = c->timeout_usec;
                 return 1;
 
         case BUS_CLOSING:
-                *timeout_usec = 0;
+                *ret = 0;
                 return 1;
 
         case BUS_WATCH_BIND:
         case BUS_OPENING:
-                *timeout_usec = UINT64_MAX;
+                *ret = UINT64_MAX;
                 return 0;
 
         default:
@@ -3439,7 +3439,7 @@ _public_ int sd_bus_flush(sd_bus *bus) {
 
 _public_ int sd_bus_add_filter(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 sd_bus_message_handler_t callback,
                 void *userdata) {
 
@@ -3450,7 +3450,7 @@ _public_ int sd_bus_add_filter(
         assert_return(callback, -EINVAL);
         assert_return(!bus_origin_changed(bus), -ECHILD);
 
-        s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(BusFilterCallback), userdata);
+        s = bus_slot_allocate(bus, !ret_slot, BUS_FILTER_CALLBACK, sizeof(BusFilterCallback), userdata);
         if (!s)
                 return -ENOMEM;
 
@@ -3459,8 +3459,8 @@ _public_ int sd_bus_add_filter(
         bus->filter_callbacks_modified = true;
         LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
 
-        if (slot)
-                *slot = s;
+        if (ret_slot)
+                *ret_slot = s;
 
         return 0;
 }
@@ -3530,7 +3530,7 @@ static int add_match_callback(
 
 int bus_add_match_full(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 bool asynchronous,
                 const char *match,
                 sd_bus_message_handler_t callback,
@@ -3554,7 +3554,7 @@ int bus_add_match_full(
         if (r < 0)
                 return r;
 
-        s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(BusMatchCallback), userdata);
+        s = bus_slot_allocate(bus, !ret_slot, BUS_MATCH_CALLBACK, sizeof(BusMatchCallback), userdata);
         if (!s)
                 return -ENOMEM;
 
@@ -3606,8 +3606,8 @@ int bus_add_match_full(
         if (r < 0)
                 return r;
 
-        if (slot)
-                *slot = s;
+        if (ret_slot)
+                *ret_slot = s;
         s = NULL;
 
         return 0;
@@ -3615,23 +3615,23 @@ int bus_add_match_full(
 
 _public_ int sd_bus_add_match(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *match,
                 sd_bus_message_handler_t callback,
                 void *userdata) {
 
-        return bus_add_match_full(bus, slot, false, match, callback, NULL, userdata, 0);
+        return bus_add_match_full(bus, ret_slot, false, match, callback, NULL, userdata, 0);
 }
 
 _public_ int sd_bus_add_match_async(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const char *match,
                 sd_bus_message_handler_t callback,
                 sd_bus_message_handler_t install_callback,
                 void *userdata) {
 
-        return bus_add_match_full(bus, slot, true, match, callback, install_callback, userdata, 0);
+        return bus_add_match_full(bus, ret_slot, true, match, callback, install_callback, userdata, 0);
 }
 
 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
@@ -3977,37 +3977,37 @@ _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
         return -ENXIO;
 }
 
-_public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
+_public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret) {
         _cleanup_free_ char *e = NULL;
-        char *ret;
+        char *s;
 
         assert_return(object_path_is_valid(prefix), -EINVAL);
         assert_return(external_id, -EINVAL);
-        assert_return(ret_path, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         e = bus_label_escape(external_id);
         if (!e)
                 return -ENOMEM;
 
-        ret = path_join(prefix, e);
-        if (!ret)
+        s = path_join(prefix, e);
+        if (!s)
                 return -ENOMEM;
 
-        *ret_path = ret;
+        *ret = s;
         return 0;
 }
 
-_public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
+_public_ int sd_bus_path_decode(const char *path, const char *prefix, char **ret) {
         const char *e;
-        char *ret;
+        char *s;
 
         assert_return(object_path_is_valid(path), -EINVAL);
         assert_return(object_path_is_valid(prefix), -EINVAL);
-        assert_return(external_id, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         e = object_path_startswith(path, prefix);
         if (!e) {
-                *external_id = NULL;
+                *ret = NULL;
                 return 0;
         }
 
@@ -4015,15 +4015,15 @@ _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **ext
          * corresponds to a subtree on a disk, and we want to return something that represents the root
          * of the filesystem. */
 
-        ret = bus_label_unescape(e);
-        if (!ret)
+        s = bus_label_unescape(e);
+        if (!s)
                 return -ENOMEM;
 
-        *external_id = ret;
+        *ret = s;
         return 1;
 }
 
-_public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
+_public_ int sd_bus_path_encode_many(char **ret, const char *path_template, ...) {
         _cleanup_strv_free_ char **labels = NULL;
         char *path, *path_pos, **label_pos;
         const char *sep, *template_pos;
@@ -4031,7 +4031,7 @@ _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...)
         va_list list;
         int r;
 
-        assert_return(out, -EINVAL);
+        assert_return(ret, -EINVAL);
         assert_return(path_template, -EINVAL);
 
         path_length = strlen(path_template);
@@ -4082,7 +4082,7 @@ _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...)
         }
 
         *path_pos = 0;
-        *out = path;
+        *ret = path;
         return 0;
 }
 
@@ -4195,10 +4195,11 @@ _public_ int sd_bus_try_close(sd_bus *bus) {
         return -EOPNOTSUPP;
 }
 
-_public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
+_public_ int sd_bus_get_description(sd_bus *bus, const char **ret) {
         assert_return(bus, -EINVAL);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
-        assert_return(description, -EINVAL);
+        assert_return(ret, -EINVAL);
+        assert_return(!bus_origin_changed(bus), -ECHILD);
 
         const char *d = bus->description;
         if (!d)
@@ -4206,44 +4207,43 @@ _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
         if (!d)
                 return -ENXIO;
 
-        *description = d;
+        *ret = d;
         return 0;
 }
 
-_public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
+_public_ int sd_bus_get_scope(sd_bus *bus, const char **ret) {
         assert_return(bus, -EINVAL);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
-        assert_return(scope, -EINVAL);
+        assert_return(ret, -EINVAL);
         assert_return(!bus_origin_changed(bus), -ECHILD);
 
         if (bus->runtime_scope < 0)
                 return -ENODATA;
 
-        *scope = runtime_scope_to_string(bus->runtime_scope);
+        *ret = runtime_scope_to_string(bus->runtime_scope);
         return 0;
 }
 
-_public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
+_public_ int sd_bus_get_address(sd_bus *bus, const char **ret) {
         assert_return(bus, -EINVAL);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
-        assert_return(address, -EINVAL);
+        assert_return(ret, -EINVAL);
         assert_return(!bus_origin_changed(bus), -ECHILD);
 
-        if (bus->address) {
-                *address = bus->address;
-                return 0;
-        }
+        if (!bus->address)
+                return -ENODATA;
 
-        return -ENODATA;
+        *ret = bus->address;
+        return 0;
 }
 
-_public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
+_public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *ret) {
         assert_return(bus, -EINVAL);
         assert_return(bus = bus_resolve(bus), -ENOPKG);
-        assert_return(mask, -EINVAL);
+        assert_return(ret, -EINVAL);
         assert_return(!bus_origin_changed(bus), -ECHILD);
 
-        *mask = bus->creds_mask;
+        *ret = bus->creds_mask;
         return 0;
 }
 

src/libsystemd/sd-bus/test-bus-objects.c

@@ -19,7 +19,7 @@ struct context {
         uint32_t automatic_integer_property;
 };
 
-static int something_handler(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int something_handler(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         struct context *c = userdata;
         const char *s;
         char *n = NULL;
@@ -45,7 +45,7 @@ static int something_handler(sd_bus_message *m, void *userdata, sd_bus_error *er
         return 1;
 }
 
-static int exit_handler(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int exit_handler(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         struct context *c = userdata;
         int r;
 
@@ -59,7 +59,7 @@ static int exit_handler(sd_bus_message *m, void *userdata, sd_bus_error *error)
         return 1;
 }
 
-static int get_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
+static int get_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error) {
         struct context *c = userdata;
         int r;
 
@@ -71,7 +71,7 @@ static int get_handler(sd_bus *bus, const char *path, const char *interface, con
         return 1;
 }
 
-static int set_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *error) {
+static int set_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *reterr_error) {
         struct context *c = userdata;
         const char *s;
         char *n;
@@ -91,7 +91,7 @@ static int set_handler(sd_bus *bus, const char *path, const char *interface, con
         return 1;
 }
 
-static int value_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
+static int value_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error) {
         _cleanup_free_ char *s = NULL;
         const char *x;
         int r;
@@ -107,7 +107,7 @@ static int value_handler(sd_bus *bus, const char *path, const char *interface, c
         return 1;
 }
 
-static int notify_test(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int notify_test(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         int r;
 
         assert_se(sd_bus_emit_properties_changed(sd_bus_message_get_bus(m), m->path, "org.freedesktop.systemd.ValueTest", "Value", NULL) >= 0);
@@ -118,7 +118,7 @@ static int notify_test(sd_bus_message *m, void *userdata, sd_bus_error *error) {
         return 1;
 }
 
-static int notify_test2(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int notify_test2(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         int r;
 
         assert_se(sd_bus_emit_properties_changed_strv(sd_bus_message_get_bus(m), m->path, "org.freedesktop.systemd.ValueTest", NULL) >= 0);
@@ -129,7 +129,7 @@ static int notify_test2(sd_bus_message *m, void *userdata, sd_bus_error *error)
         return 1;
 }
 
-static int emit_interfaces_added(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int emit_interfaces_added(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         int r;
 
         assert_se(sd_bus_emit_interfaces_added(sd_bus_message_get_bus(m), "/value/a/x", "org.freedesktop.systemd.ValueTest", NULL) >= 0);
@@ -140,7 +140,7 @@ static int emit_interfaces_added(sd_bus_message *m, void *userdata, sd_bus_error
         return 1;
 }
 
-static int emit_interfaces_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int emit_interfaces_removed(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         int r;
 
         assert_se(sd_bus_emit_interfaces_removed(sd_bus_message_get_bus(m), "/value/a/x", "org.freedesktop.systemd.ValueTest", NULL) >= 0);
@@ -151,7 +151,7 @@ static int emit_interfaces_removed(sd_bus_message *m, void *userdata, sd_bus_err
         return 1;
 }
 
-static int emit_object_added(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int emit_object_added(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         int r;
 
         assert_se(sd_bus_emit_object_added(sd_bus_message_get_bus(m), "/value/a/x") >= 0);
@@ -162,13 +162,13 @@ static int emit_object_added(sd_bus_message *m, void *userdata, sd_bus_error *er
         return 1;
 }
 
-static int emit_object_with_manager_added(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int emit_object_with_manager_added(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         assert_se(sd_bus_emit_object_added(sd_bus_message_get_bus(m), "/value/a") >= 0);
 
         return ASSERT_SE_NONNEG(sd_bus_reply_method_return(m, NULL));
 }
 
-static int emit_object_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int emit_object_removed(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         int r;
 
         assert_se(sd_bus_emit_object_removed(sd_bus_message_get_bus(m), "/value/a/x") >= 0);
@@ -207,7 +207,7 @@ static const sd_bus_vtable vtable2[] = {
         SD_BUS_VTABLE_END
 };
 
-static int enumerator_callback(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
+static int enumerator_callback(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *reterr_error) {
 
         if (object_path_startswith("/value", path))
                 assert_se(*nodes = strv_new("/value/c", "/value/b", "/value/a"));
@@ -215,7 +215,7 @@ static int enumerator_callback(sd_bus *bus, const char *path, void *userdata, ch
         return 1;
 }
 
-static int enumerator2_callback(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
+static int enumerator2_callback(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *reterr_error) {
 
         if (object_path_startswith("/value/a", path))
                 assert_se(*nodes = strv_new("/value/a/z", "/value/a/x", "/value/a/y"));
@@ -223,7 +223,7 @@ static int enumerator2_callback(sd_bus *bus, const char *path, void *userdata, c
         return 1;
 }
 
-static int enumerator3_callback(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
+static int enumerator3_callback(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *reterr_error) {
         _cleanup_strv_free_ char **v = NULL;
 
         if (!object_path_startswith("/value/b", path))
@@ -238,7 +238,7 @@ static int enumerator3_callback(sd_bus *bus, const char *path, void *userdata, c
         return 1;
 }
 
-static void *server(void *p) {
+static void* server(void *p) {
         struct context *c = p;
         sd_bus *bus = NULL;
         sd_id128_t id;

src/libsystemd/sd-bus/test-bus-peersockaddr.c

@@ -38,7 +38,7 @@ static bool gid_list_same(const gid_t *a, size_t n, const gid_t *b, size_t m) {
                 gid_list_contained(b, m, a, n);
 }
 
-static void *server(void *p) {
+static void* server(void *p) {
         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
         _cleanup_close_ int listen_fd = PTR_TO_INT(p), fd = -EBADF;
         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *c = NULL;

src/libsystemd/sd-bus/test-bus-vtable.c

@@ -21,7 +21,7 @@
 static struct context c = {};
 static int happy_finder_object = 0;
 
-static int happy_finder(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
+static int happy_finder(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *reterr_error) {
         assert(userdata);
         assert(userdata == &c);
 

src/libsystemd/sd-bus/test-vtable-data.h

@@ -11,19 +11,19 @@ struct context {
         uint32_t automatic_integer_property;
 };
 
-static int handler(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int handler(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         return 1;
 }
 
-static int value_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
+static int value_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error) {
         return 1;
 }
 
-static int get_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
+static int get_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error) {
         return 1;
 }
 
-static int set_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *error) {
+static int set_handler(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *reterr_error) {
         return 1;
 }
 

src/machine/machine.c

@@ -775,7 +775,7 @@ int machine_start_getty(Machine *m, const char *ptmx_name, sd_bus_error *error)
         container_bus = allocated_bus ?: m->manager->bus;
         getty = strjoina("container-getty@", p, ".service");
 
-        r = bus_call_method(container_bus, bus_systemd_mgr, "StartUnit", error, /* reply = */ NULL, "ss", getty, "replace");
+        r = bus_call_method(container_bus, bus_systemd_mgr, "StartUnit", error, /* ret_reply = */ NULL, "ss", getty, "replace");
         if (r < 0)
                 return log_debug_errno(r, "Failed to StartUnit '%s' in container '%s': %m", getty, m->name);
 

src/run/run.c

@@ -1727,7 +1727,7 @@ static int run_context_reconnect(RunContext *c) {
                                "org.freedesktop.systemd1.Unit",
                                "Ref",
                                &error,
-                               /* reply = */ NULL, NULL);
+                               /* ret_reply = */ NULL, NULL);
         if (r < 0) {
                 /* Hmm, the service manager probably hasn't finished reexecution just yet? Try again later. */
                 if (bus_error_is_connection(&error) || bus_error_is_unknown_service(&error))

src/shared/bus-get-properties.c

@@ -19,7 +19,7 @@ int bus_property_get_bool(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         int b = *(bool*) userdata;
 
@@ -33,7 +33,7 @@ int bus_property_set_bool(
                 const char *property,
                 sd_bus_message *value,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         int b, r;
 
@@ -52,7 +52,7 @@ int bus_property_get_tristate(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         /* Defaults to false. */
 
@@ -68,7 +68,7 @@ int bus_property_get_id128(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         sd_id128_t *id = userdata;
 
@@ -86,7 +86,7 @@ int bus_property_get_size(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         uint64_t sz = *(size_t*) userdata;
 
@@ -102,7 +102,7 @@ int bus_property_get_long(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         int64_t l = *(long*) userdata;
 
@@ -116,7 +116,7 @@ int bus_property_get_ulong(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         uint64_t ul = *(unsigned long*) userdata;
 
@@ -131,7 +131,7 @@ int bus_property_get_rlimit(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         const char *is_soft;
         struct rlimit *rl;
@@ -179,7 +179,7 @@ int bus_property_get_string_set(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         Set **s = ASSERT_PTR(userdata);
 
@@ -197,7 +197,7 @@ int bus_property_get_pidfdid(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         PidRef *pidref = ASSERT_PTR(userdata);
 

src/shared/bus-get-properties.h

@@ -5,10 +5,10 @@
 
 #include "forward.h"
 
-int bus_property_get_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
-int bus_property_set_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *error);
-int bus_property_get_tristate(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
-int bus_property_get_id128(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
+int bus_property_set_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *reterr_error);
+int bus_property_get_tristate(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
+int bus_property_get_id128(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
 
 #define bus_property_get_usec ((sd_bus_property_get_t) NULL)
 #define bus_property_set_usec ((sd_bus_property_set_t) NULL)
@@ -24,15 +24,15 @@ assert_cc(sizeof(unsigned) == sizeof(uint32_t));
 #if __SIZEOF_SIZE_T__ == 8
 #define bus_property_get_size ((sd_bus_property_get_t) NULL)
 #else
-int bus_property_get_size(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_size(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
 #endif
 
 #if __SIZEOF_LONG__ == 8
 #define bus_property_get_long ((sd_bus_property_get_t) NULL)
 #define bus_property_get_ulong ((sd_bus_property_get_t) NULL)
 #else
-int bus_property_get_long(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
-int bus_property_get_ulong(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_long(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
+int bus_property_get_ulong(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
 #endif
 
 /* uid_t and friends on Linux 32 bit. This means we can just use the
@@ -50,11 +50,11 @@ assert_cc(sizeof(pid_t) == sizeof(uint32_t));
 assert_cc(sizeof(mode_t) == sizeof(uint32_t));
 #define bus_property_get_mode ((sd_bus_property_get_t) NULL)
 
-int bus_property_get_rlimit(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_rlimit(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
 
-int bus_property_get_string_set(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_string_set(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
 
-int bus_property_get_pidfdid(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_pidfdid(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
 
 #define BUS_DEFINE_PROPERTY_GET_GLOBAL(function, bus_type, val)         \
         int function(sd_bus *bus,                                       \
@@ -63,7 +63,7 @@ int bus_property_get_pidfdid(sd_bus *bus, const char *path, const char *interfac
                      const char *property,                              \
                      sd_bus_message *reply,                             \
                      void *userdata,                                    \
-                     sd_bus_error *error) {                             \
+                     sd_bus_error *reterr_error) {                      \
                                                                         \
                 assert(bus);                                            \
                 assert(reply);                                          \
@@ -78,7 +78,7 @@ int bus_property_get_pidfdid(sd_bus *bus, const char *path, const char *interfac
                      const char *property,                              \
                      sd_bus_message *reply,                             \
                      void *userdata,                                    \
-                     sd_bus_error *error) {                             \
+                     sd_bus_error *reterr_error) {                      \
                                                                         \
                 data_type *data = ASSERT_PTR(userdata);                 \
                                                                         \
@@ -105,6 +105,6 @@ int bus_property_get_pidfdid(sd_bus *bus, const char *path, const char *interfac
         SD_BUS_PROPERTY(name "Monotonic", "t", bus_property_get_usec, (offset) + offsetof(struct dual_timestamp, monotonic), (flags))
 
 /* For deprecated properties. */
-int bus_property_get_bool_false(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
-int bus_property_get_bool_true(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
-int bus_property_get_uint64_max(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_bool_false(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
+int bus_property_get_bool_true(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
+int bus_property_get_uint64_max(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);

src/shared/bus-locator.c

@@ -92,7 +92,7 @@ const BusLocator* const bus_hostname = &(BusLocator){
  * within a single struct. */
 int bus_call_method_async(
                 sd_bus *bus,
-                sd_bus_slot **slot,
+                sd_bus_slot **ret_slot,
                 const BusLocator *locator,
                 const char *member,
                 sd_bus_message_handler_t callback,
@@ -105,7 +105,7 @@ int bus_call_method_async(
         assert(locator);
 
         va_start(ap, types);
-        r = sd_bus_call_method_asyncv(bus, slot, locator->destination, locator->path, locator->interface, member, callback, userdata, types, ap);
+        r = sd_bus_call_method_asyncv(bus, ret_slot, locator->destination, locator->path, locator->interface, member, callback, userdata, types, ap);
         va_end(ap);
 
         return r;
@@ -115,8 +115,8 @@ int bus_call_method(
                 sd_bus *bus,
                 const BusLocator *locator,
                 const char *member,
-                sd_bus_error *error,
-                sd_bus_message **reply,
+                sd_bus_error *reterr_error,
+                sd_bus_message **ret_reply,
                 const char *types, ...) {
 
         va_list ap;
@@ -125,7 +125,7 @@ int bus_call_method(
         assert(locator);
 
         va_start(ap, types);
-        r = sd_bus_call_methodv(bus, locator->destination, locator->path, locator->interface, member, error, reply, types, ap);
+        r = sd_bus_call_methodv(bus, locator->destination, locator->path, locator->interface, member, reterr_error, ret_reply, types, ap);
         va_end(ap);
 
         return r;
@@ -135,56 +135,57 @@ int bus_get_property(
                 sd_bus *bus,
                 const BusLocator *locator,
                 const char *member,
-                sd_bus_error *error,
-                sd_bus_message **reply,
+                sd_bus_error *reterr_error,
+                sd_bus_message **ret_reply,
                 const char *type) {
 
         assert(locator);
 
-        return sd_bus_get_property(bus, locator->destination, locator->path, locator->interface, member, error, reply, type);
+        return sd_bus_get_property(bus, locator->destination, locator->path, locator->interface, member, reterr_error, ret_reply, type);
 }
 
 int bus_get_property_trivial(
                 sd_bus *bus,
                 const BusLocator *locator,
                 const char *member,
-                sd_bus_error *error,
-                char type, void *ptr) {
+                sd_bus_error *reterr_error,
+                char type,
+                void *ret) {
 
         assert(locator);
 
-        return sd_bus_get_property_trivial(bus, locator->destination, locator->path, locator->interface, member, error, type, ptr);
+        return sd_bus_get_property_trivial(bus, locator->destination, locator->path, locator->interface, member, reterr_error, type, ret);
 }
 
 int bus_get_property_string(
                 sd_bus *bus,
                 const BusLocator *locator,
                 const char *member,
-                sd_bus_error *error,
+                sd_bus_error *reterr_error,
                 char **ret) {
 
         assert(locator);
 
-        return sd_bus_get_property_string(bus, locator->destination, locator->path, locator->interface, member, error, ret);
+        return sd_bus_get_property_string(bus, locator->destination, locator->path, locator->interface, member, reterr_error, ret);
 }
 
 int bus_get_property_strv(
                 sd_bus *bus,
                 const BusLocator *locator,
                 const char *member,
-                sd_bus_error *error,
+                sd_bus_error *reterr_error,
                 char ***ret) {
 
         assert(locator);
 
-        return sd_bus_get_property_strv(bus, locator->destination, locator->path, locator->interface, member, error, ret);
+        return sd_bus_get_property_strv(bus, locator->destination, locator->path, locator->interface, member, reterr_error, ret);
 }
 
 int bus_set_property(
                 sd_bus *bus,
                 const BusLocator *locator,
                 const char *member,
-                sd_bus_error *error,
+                sd_bus_error *reterr_error,
                 const char *type, ...) {
 
         va_list ap;
@@ -193,7 +194,7 @@ int bus_set_property(
         assert(locator);
 
         va_start(ap, type);
-        r = sd_bus_set_propertyv(bus, locator->destination, locator->path, locator->interface, member, error, type, ap);
+        r = sd_bus_set_propertyv(bus, locator->destination, locator->path, locator->interface, member, reterr_error, type, ap);
         va_end(ap);
 
         return r;
@@ -201,7 +202,7 @@ int bus_set_property(
 
 int bus_match_signal(
                 sd_bus *bus,
-                sd_bus_slot **ret,
+                sd_bus_slot **ret_slot,
                 const BusLocator *locator,
                 const char *member,
                 sd_bus_message_handler_t callback,
@@ -209,12 +210,12 @@ int bus_match_signal(
 
         assert(locator);
 
-        return sd_bus_match_signal(bus, ret, locator->destination, locator->path, locator->interface, member, callback, userdata);
+        return sd_bus_match_signal(bus, ret_slot, locator->destination, locator->path, locator->interface, member, callback, userdata);
 }
 
 int bus_match_signal_async(
                 sd_bus *bus,
-                sd_bus_slot **ret,
+                sd_bus_slot **ret_slot,
                 const BusLocator *locator,
                 const char *member,
                 sd_bus_message_handler_t callback,
@@ -223,16 +224,16 @@ int bus_match_signal_async(
 
         assert(locator);
 
-        return sd_bus_match_signal_async(bus, ret, locator->destination, locator->path, locator->interface, member, callback, install_callback, userdata);
+        return sd_bus_match_signal_async(bus, ret_slot, locator->destination, locator->path, locator->interface, member, callback, install_callback, userdata);
 }
 
 int bus_message_new_method_call(
                 sd_bus *bus,
-                sd_bus_message **m,
+                sd_bus_message **ret,
                 const BusLocator *locator,
                 const char *member) {
 
         assert(locator);
 
-        return sd_bus_message_new_method_call(bus, m, locator->destination, locator->path, locator->interface, member);
+        return sd_bus_message_new_method_call(bus, ret, locator->destination, locator->path, locator->interface, member);
 }

src/shared/bus-locator.h

@@ -26,13 +26,13 @@ extern const BusLocator* const bus_timesync_mgr;
 
 /* Shorthand flavors of the sd-bus convenience helpers with destination,path,interface strings encapsulated
  * within a single struct. */
-int bus_call_method_async(sd_bus *bus, sd_bus_slot **slot, const BusLocator *locator, const char *member, sd_bus_message_handler_t callback, void *userdata, const char *types, ...);
-int bus_call_method(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *error, sd_bus_message **reply, const char *types, ...);
-int bus_get_property(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *error, sd_bus_message **reply, const char *type);
-int bus_get_property_trivial(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *error, char type, void *ptr);
-int bus_get_property_string(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *error, char **ret);
-int bus_get_property_strv(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *error, char ***ret);
-int bus_set_property(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *error, const char *type, ...);
-int bus_match_signal(sd_bus *bus, sd_bus_slot **ret, const BusLocator *locator, const char *member, sd_bus_message_handler_t callback, void *userdata);
-int bus_match_signal_async(sd_bus *bus, sd_bus_slot **ret, const BusLocator *locator, const char *member, sd_bus_message_handler_t callback, sd_bus_message_handler_t install_callback, void *userdata);
-int bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const BusLocator *locator, const char *member);
+int bus_call_method_async(sd_bus *bus, sd_bus_slot **ret_slot, const BusLocator *locator, const char *member, sd_bus_message_handler_t callback, void *userdata, const char *types, ...);
+int bus_call_method(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *reterr_error, sd_bus_message **ret_reply, const char *types, ...);
+int bus_get_property(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *reterr_error, sd_bus_message **ret_reply, const char *type);
+int bus_get_property_trivial(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *reterr_error, char type, void *ret);
+int bus_get_property_string(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *reterr_error, char **ret);
+int bus_get_property_strv(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *reterr_error, char ***ret);
+int bus_set_property(sd_bus *bus, const BusLocator *locator, const char *member, sd_bus_error *reterr_error, const char *type, ...);
+int bus_match_signal(sd_bus *bus, sd_bus_slot **ret_slot, const BusLocator *locator, const char *member, sd_bus_message_handler_t callback, void *userdata);
+int bus_match_signal_async(sd_bus *bus, sd_bus_slot **ret_slot, const BusLocator *locator, const char *member, sd_bus_message_handler_t callback, sd_bus_message_handler_t install_callback, void *userdata);
+int bus_message_new_method_call(sd_bus *bus, sd_bus_message **ret, const BusLocator *locator, const char *member);

src/shared/bus-log-control-api.c

@@ -20,7 +20,7 @@ int bus_property_get_log_level(
                 const char *property,
                 sd_bus_message *reply,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         _cleanup_free_ char *t = NULL;
         int r;
@@ -42,7 +42,7 @@ int bus_property_set_log_level(
                 const char *property,
                 sd_bus_message *value,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         const char *t;
         int r;
@@ -56,7 +56,7 @@ int bus_property_set_log_level(
 
         r = log_level_from_string(t);
         if (r < 0)
-                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log level '%s'", t);
+                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log level '%s'", t);
 
         log_info("Setting log level to %s.", t);
         log_set_max_level(r);
@@ -73,7 +73,7 @@ int bus_property_set_log_target(
                 const char *property,
                 sd_bus_message *value,
                 void *userdata,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         LogTarget target;
         const char *t;
@@ -88,7 +88,7 @@ int bus_property_set_log_target(
 
         target = log_target_from_string(t);
         if (target < 0)
-                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log target '%s'", t);
+                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log target '%s'", t);
 
         log_info("Setting log target to %s.", log_target_to_string(target));
         log_set_target_and_open(target);

src/shared/bus-log-control-api.h

@@ -7,10 +7,10 @@ extern const BusObjectImplementation log_control_object;
 
 int bus_log_control_api_register(sd_bus *bus);
 
-int bus_property_get_log_level(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
-int bus_property_set_log_level(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *error);
+int bus_property_get_log_level(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
+int bus_property_set_log_level(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *reterr_error);
 
-int bus_property_get_log_target(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
-int bus_property_set_log_target(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_log_target(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
+int bus_property_set_log_target(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
 
-int bus_property_get_syslog_identifier(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_syslog_identifier(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);

src/shared/bus-map-properties.c

@@ -8,7 +8,7 @@
 #include "string-util.h"
 #include "strv.h"
 
-int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
+int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata) {
         sd_id128_t *p = userdata;
         int r;
 
@@ -21,7 +21,7 @@ int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_err
         return 0;
 }
 
-int bus_map_strv_sort(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
+int bus_map_strv_sort(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata) {
         char ***p = ASSERT_PTR(userdata);
         int r;
 
@@ -35,7 +35,7 @@ int bus_map_strv_sort(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus
         return 0;
 }
 
-int bus_map_job_id(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
+int bus_map_job_id(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata) {
         uint32_t *p = ASSERT_PTR(userdata);
 
         assert(m);
@@ -139,7 +139,7 @@ int bus_message_map_all_properties(
                 sd_bus_message *m,
                 const struct bus_properties_map *map,
                 unsigned flags,
-                sd_bus_error *error,
+                sd_bus_error *reterr_error,
                 void *userdata) {
 
         int r;
@@ -179,7 +179,7 @@ int bus_message_map_all_properties(
 
                         v = (uint8_t *)userdata + prop->offset;
                         if (map[i].set)
-                                r = prop->set(sd_bus_message_get_bus(m), member, m, error, v);
+                                r = prop->set(sd_bus_message_get_bus(m), member, m, reterr_error, v);
                         else
                                 r = map_basic(m, flags, v);
                         if (r < 0)
@@ -214,18 +214,18 @@ int bus_map_all_properties(
                 const char *path,
                 const struct bus_properties_map *map,
                 unsigned flags,
-                sd_bus_error *error,
-                sd_bus_message **reply,
+                sd_bus_error *reterr_error,
+                sd_bus_message **ret_reply,
                 void *userdata) {
 
-        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
+        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
         int r;
 
         assert(bus);
         assert(destination);
         assert(path);
         assert(map);
-        assert(reply || (flags & BUS_MAP_STRDUP));
+        assert(ret_reply || (flags & BUS_MAP_STRDUP));
 
         r = sd_bus_call_method(
                         bus,
@@ -233,18 +233,18 @@ int bus_map_all_properties(
                         path,
                         "org.freedesktop.DBus.Properties",
                         "GetAll",
-                        error,
-                        &m,
+                        reterr_error,
+                        &reply,
                         "s", "");
         if (r < 0)
                 return r;
 
-        r = bus_message_map_all_properties(m, map, flags, error, userdata);
+        r = bus_message_map_all_properties(reply, map, flags, reterr_error, userdata);
         if (r < 0)
                 return r;
 
-        if (reply)
-                *reply = sd_bus_message_ref(m);
+        if (ret_reply)
+                *ret_reply = TAKE_PTR(reply);
 
         return r;
 }

src/shared/bus-map-properties.h

@@ -3,7 +3,7 @@
 
 #include "forward.h"
 
-typedef int (*bus_property_set_t) (sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata);
+typedef int (*bus_property_set_t)(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata);
 
 struct bus_properties_map {
         const char *member;
@@ -17,10 +17,10 @@ enum {
         BUS_MAP_BOOLEAN_AS_BOOL = 1 << 1, /* If set, each "b" message is written to a bool pointer. If not set, "b" is written to an int pointer. */
 };
 
-int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata);
-int bus_map_strv_sort(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata);
-int bus_map_job_id(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata);
+int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata);
+int bus_map_strv_sort(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata);
+int bus_map_job_id(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata);
 
-int bus_message_map_all_properties(sd_bus_message *m, const struct bus_properties_map *map, unsigned flags, sd_bus_error *error, void *userdata);
+int bus_message_map_all_properties(sd_bus_message *m, const struct bus_properties_map *map, unsigned flags, sd_bus_error *reterr_error, void *userdata);
 int bus_map_all_properties(sd_bus *bus, const char *destination, const char *path, const struct bus_properties_map *map,
-                           unsigned flags, sd_bus_error *error, sd_bus_message **reply, void *userdata);
+                           unsigned flags, sd_bus_error *reterr_error, sd_bus_message **ret_reply, void *userdata);

src/shared/bus-message-util.c

@@ -42,7 +42,7 @@ int bus_message_read_id128(sd_bus_message *m, sd_id128_t *ret) {
         }
 }
 
-int bus_message_read_ifindex(sd_bus_message *message, sd_bus_error *error, int *ret) {
+int bus_message_read_ifindex(sd_bus_message *message, sd_bus_error *reterr_error, int *ret) {
         int ifindex, r;
 
         assert(message);
@@ -55,14 +55,14 @@ int bus_message_read_ifindex(sd_bus_message *message, sd_bus_error *error, int *
                 return r;
 
         if (ifindex <= 0)
-                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");
+                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");
 
         *ret = ifindex;
 
         return 0;
 }
 
-int bus_message_read_family(sd_bus_message *message, sd_bus_error *error, int *ret) {
+int bus_message_read_family(sd_bus_message *message, sd_bus_error *reterr_error, int *ret) {
         int family, r;
 
         assert(message);
@@ -75,20 +75,20 @@ int bus_message_read_family(sd_bus_message *message, sd_bus_error *error, int *r
                 return r;
 
         if (!IN_SET(family, AF_INET, AF_INET6))
-                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
+                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
 
         *ret = family;
         return 0;
 }
 
-int bus_message_read_in_addr_auto(sd_bus_message *message, sd_bus_error *error, int *ret_family, union in_addr_union *ret_addr) {
+int bus_message_read_in_addr_auto(sd_bus_message *message, sd_bus_error *reterr_error, int *ret_family, union in_addr_union *ret_addr) {
         int family, r;
         const void *d;
         size_t sz;
 
         assert(message);
 
-        r = bus_message_read_family(message, error, &family);
+        r = bus_message_read_family(message, reterr_error, &family);
         if (r < 0)
                 return r;
 
@@ -97,7 +97,7 @@ int bus_message_read_in_addr_auto(sd_bus_message *message, sd_bus_error *error,
                 return r;
 
         if (sz != FAMILY_ADDRESS_SIZE(family))
-                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");
+                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");
 
         if (ret_family)
                 *ret_family = family;
@@ -108,7 +108,7 @@ int bus_message_read_in_addr_auto(sd_bus_message *message, sd_bus_error *error,
 
 static int bus_message_read_dns_one(
                         sd_bus_message *message,
-                        sd_bus_error *error,
+                        sd_bus_error *reterr_error,
                         bool extended,
                         int *ret_family,
                         union in_addr_union *ret_address,
@@ -129,12 +129,12 @@ static int bus_message_read_dns_one(
         if (r <= 0)
                 return r;
 
-        r = bus_message_read_in_addr_auto(message, error, &family, &a);
+        r = bus_message_read_in_addr_auto(message, reterr_error, &family, &a);
         if (r < 0)
                 return r;
 
         if (!dns_server_address_valid(family, &a)) {
-                r = sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNS server address");
+                r = sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNS server address");
                 assert(r < 0);
                 return r;
         }
@@ -166,7 +166,7 @@ static int bus_message_read_dns_one(
 
 int bus_message_read_dns_servers(
                         sd_bus_message *message,
-                        sd_bus_error *error,
+                        sd_bus_error *reterr_error,
                         bool extended,
                         struct in_addr_full ***ret_dns,
                         size_t *ret_n_dns) {
@@ -189,7 +189,7 @@ int bus_message_read_dns_servers(
                 uint16_t port;
                 int family;
 
-                r = bus_message_read_dns_one(message, error, extended, &family, &a, &port, &server_name);
+                r = bus_message_read_dns_one(message, reterr_error, extended, &family, &a, &port, &server_name);
                 if (r < 0)
                         goto clear;
                 if (r == 0)

src/shared/bus-message-util.h

@@ -5,13 +5,13 @@
 
 int bus_message_read_id128(sd_bus_message *m, sd_id128_t *ret);
 
-int bus_message_read_ifindex(sd_bus_message *message, sd_bus_error *error, int *ret);
-int bus_message_read_family(sd_bus_message *message, sd_bus_error *error, int *ret);
-int bus_message_read_in_addr_auto(sd_bus_message *message, sd_bus_error *error, int *ret_family, union in_addr_union *ret_addr);
+int bus_message_read_ifindex(sd_bus_message *message, sd_bus_error *reterr_error, int *ret);
+int bus_message_read_family(sd_bus_message *message, sd_bus_error *reterr_error, int *ret);
+int bus_message_read_in_addr_auto(sd_bus_message *message, sd_bus_error *reterr_error, int *ret_family, union in_addr_union *ret_addr);
 
 int bus_message_read_dns_servers(
                         sd_bus_message *message,
-                        sd_bus_error *error,
+                        sd_bus_error *reterr_error,
                         bool extended,
                         struct in_addr_full ***ret_dns,
                         size_t *ret_n_dns);

src/shared/bus-object.c

@@ -117,7 +117,7 @@ static void list_paths(
 int bus_introspect_implementations(
                 FILE *out,
                 const char *pattern,
-                const BusObjectImplementation* const* bus_objects) {
+                const BusObjectImplementation* const *bus_objects) {
 
         const BusObjectImplementation *impl, *main_impl = NULL;
         _cleanup_free_ char *s = NULL;

src/shared/bus-object.h

@@ -26,4 +26,4 @@ int bus_add_implementation(sd_bus *bus, const BusObjectImplementation *impl, voi
 int bus_introspect_implementations(
                 FILE *out,
                 const char *pattern,
-                const BusObjectImplementation* const* bus_objects);
+                const BusObjectImplementation* const *bus_objects);

src/shared/bus-polkit.c

@@ -109,8 +109,8 @@ int bus_test_polkit(
                 const char *action,
                 const char **details,
                 uid_t good_user,
-                bool *_challenge,
-                sd_bus_error *ret_error) {
+                bool *ret_challenge,
+                sd_bus_error *reterr_error) {
 
         int r;
 
@@ -126,8 +126,11 @@ int bus_test_polkit(
         r = sd_bus_query_sender_privilege(call, -1);
         if (r < 0)
                 return r;
-        if (r > 0)
+        if (r > 0) {
+                if (ret_challenge)
+                        *ret_challenge = false;
                 return 1;
+        }
 
 #if ENABLE_POLKIT
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *request = NULL, *reply = NULL;
@@ -137,11 +140,11 @@ int bus_test_polkit(
         if (r < 0)
                 return r;
 
-        r = sd_bus_call(call->bus, request, 0, ret_error, &reply);
+        r = sd_bus_call(call->bus, request, 0, reterr_error, &reply);
         if (r < 0) {
                 /* Treat no PK available as access denied */
-                if (bus_error_is_unknown_service(ret_error)) {
-                        sd_bus_error_free(ret_error);
+                if (bus_error_is_unknown_service(reterr_error)) {
+                        sd_bus_error_free(reterr_error);
                         return -EACCES;
                 }
 
@@ -159,8 +162,8 @@ int bus_test_polkit(
         if (authorized)
                 return 1;
 
-        if (_challenge) {
-                *_challenge = challenge;
+        if (ret_challenge) {
+                *ret_challenge = challenge;
                 return 0;
         }
 #endif
@@ -177,7 +180,7 @@ typedef struct AsyncPolkitQueryAction {
         LIST_FIELDS(struct AsyncPolkitQueryAction, authorized);
 } AsyncPolkitQueryAction;
 
-static AsyncPolkitQueryAction *async_polkit_query_action_free(AsyncPolkitQueryAction *a) {
+static AsyncPolkitQueryAction* async_polkit_query_action_free(AsyncPolkitQueryAction *a) {
         if (!a)
                 return NULL;
 
@@ -209,7 +212,7 @@ typedef struct AsyncPolkitQuery {
         sd_bus_error error;                                     /* the precise error, in case error_action is set */
 } AsyncPolkitQuery;
 
-static AsyncPolkitQuery *async_polkit_query_free(AsyncPolkitQuery *q) {
+static AsyncPolkitQuery* async_polkit_query_free(AsyncPolkitQuery *q) {
         if (!q)
                 return NULL;
 
@@ -390,7 +393,7 @@ static int async_polkit_process_reply(sd_bus_message *reply, AsyncPolkitQuery *q
         return 1;
 }
 
-static int async_polkit_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
+static int async_polkit_callback(sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error) {
         AsyncPolkitQuery *q = ASSERT_PTR(userdata);
         int r;
 
@@ -428,7 +431,7 @@ static int async_polkit_query_check_action(
                 const char *action,
                 const char **details,
                 PolkitFlags flags,
-                sd_bus_error *ret_error) {
+                sd_bus_error *reterr_error) {
 
         assert(q);
         assert(action);
@@ -437,7 +440,7 @@ static int async_polkit_query_check_action(
                 return 1; /* Allow! */
 
         if (q->error_action && streq(q->error_action->action, action))
-                return sd_bus_error_copy(ret_error, &q->error);
+                return sd_bus_error_copy(reterr_error, &q->error);
 
         if (q->denied_action && streq(q->denied_action->action, action))
                 return -EACCES; /* Deny! */
@@ -541,7 +544,7 @@ int bus_verify_polkit_async_full(
                 uid_t good_user,
                 PolkitFlags flags,
                 Hashmap **registry,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         int r;
 
@@ -562,7 +565,7 @@ int bus_verify_polkit_async_full(
         /* This is a repeated invocation of this function, hence let's check if we've already got
          * a response from polkit for this action */
         if (q) {
-                r = async_polkit_query_check_action(q, action, details, flags, error);
+                r = async_polkit_query_check_action(q, action, details, flags, reterr_error);
                 if (r != 0) {
                         log_debug("Found matching previous polkit authentication for '%s'.", action);
                         return r;

src/shared/bus-polkit.h

@@ -14,11 +14,11 @@ typedef enum PolkitFlags {
         _POLKIT_MASK_PUBLIC      = POLKIT_ALLOW_INTERACTIVE | POLKIT_ALWAYS_QUERY, /* polkit accepts these flags verbatim */
 } PolkitFlags;
 
-int bus_test_polkit(sd_bus_message *call, const char *action, const char **details, uid_t good_user, bool *_challenge, sd_bus_error *e);
+int bus_test_polkit(sd_bus_message *call, const char *action, const char **details, uid_t good_user, bool *ret_challenge, sd_bus_error *reterr_error);
 
-int bus_verify_polkit_async_full(sd_bus_message *call, const char *action, const char **details, uid_t good_user, PolkitFlags flags, Hashmap **registry, sd_bus_error *error);
-static inline int bus_verify_polkit_async(sd_bus_message *call, const char *action, const char **details, Hashmap **registry, sd_bus_error *error) {
-        return bus_verify_polkit_async_full(call, action, details, UID_INVALID, 0, registry, error);
+int bus_verify_polkit_async_full(sd_bus_message *call, const char *action, const char **details, uid_t good_user, PolkitFlags flags, Hashmap **registry, sd_bus_error *reterr_error);
+static inline int bus_verify_polkit_async(sd_bus_message *call, const char *action, const char **details, Hashmap **registry, sd_bus_error *reterr_error) {
+        return bus_verify_polkit_async_full(call, action, details, UID_INVALID, 0, registry, reterr_error);
 }
 
 int varlink_verify_polkit_async_full(sd_varlink *link, sd_bus *bus, const char *action, const char **details, uid_t good_user, PolkitFlags flags, Hashmap **registry);

src/shared/bus-print-properties.c

@@ -427,7 +427,7 @@ int bus_print_all_properties(
                 bus_message_print_t func,
                 char **filter,
                 BusPrintPropertyFlags flags,
-                sd_bus_error *reterr) {
+                sd_bus_error *reterr_error) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
         int r;
@@ -440,7 +440,7 @@ int bus_print_all_properties(
                         path,
                         "org.freedesktop.DBus.Properties",
                         "GetAll",
-                        reterr,
+                        reterr_error,
                         &reply,
                         "s", "");
         if (r < 0)

src/shared/bus-print-properties.h

@@ -13,4 +13,4 @@ typedef int (*bus_message_print_t) (const char *name, const char *expected_value
 int bus_print_property_value(const char *name, const char *expected_value, BusPrintPropertyFlags flags, const char *value);
 int bus_print_property_valuef(const char *name, const char *expected_value, BusPrintPropertyFlags flags, const char *fmt, ...) _printf_(4,5);
 int bus_message_print_all_properties(sd_bus_message *m, bus_message_print_t func, char **filter, BusPrintPropertyFlags flags, Set **found_properties);
-int bus_print_all_properties(sd_bus *bus, const char *dest, const char *path, bus_message_print_t func, char **filter, BusPrintPropertyFlags flags, sd_bus_error *reterr);
+int bus_print_all_properties(sd_bus *bus, const char *dest, const char *path, bus_message_print_t func, char **filter, BusPrintPropertyFlags flags, sd_bus_error *reterr_error);

src/shared/bus-unit-procs.c

@@ -332,7 +332,7 @@ int unit_show_processes(
                 const char *prefix,
                 unsigned n_columns,
                 OutputFlags flags,
-                sd_bus_error *error) {
+                sd_bus_error *reterr_error) {
 
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
         Hashmap *cgroups = NULL;
@@ -353,7 +353,7 @@ int unit_show_processes(
                         bus,
                         bus_systemd_mgr,
                         "GetUnitProcesses",
-                        error,
+                        reterr_error,
                         &reply,
                         "s",
                         unit);

src/shared/bus-unit-procs.h

@@ -3,4 +3,4 @@
 
 #include "forward.h"
 
-int unit_show_processes(sd_bus *bus, const char *unit, const char *cgroup_path, const char *prefix, unsigned n_columns, OutputFlags flags, sd_bus_error *error);
+int unit_show_processes(sd_bus *bus, const char *unit, const char *cgroup_path, const char *prefix, unsigned n_columns, OutputFlags flags, sd_bus_error *reterr_error);

src/shared/bus-unit-util.c

@@ -2944,7 +2944,7 @@ int bus_append_unit_property_assignment(sd_bus_message *m, UnitType t, const cha
                                "Unknown assignment: %s", assignment);
 }
 
-int bus_append_unit_property_assignment_many(sd_bus_message *m, UnitType t, char **l) {
+int bus_append_unit_property_assignment_many(sd_bus_message *m, UnitType t, char * const *l) {
         int r;
 
         assert(m);
@@ -3014,7 +3014,7 @@ int bus_deserialize_and_dump_unit_file_changes(sd_bus_message *m, bool quiet) {
         return 0;
 }
 
-int unit_load_state(sd_bus *bus, const char *name, char **load_state) {
+int unit_load_state(sd_bus *bus, const char *name, char **ret) {
         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
         _cleanup_free_ char *path = NULL;
         int r;
@@ -3033,7 +3033,7 @@ int unit_load_state(sd_bus *bus, const char *name, char **load_state) {
                         "org.freedesktop.systemd1.Unit",
                         "LoadState",
                         &error,
-                        load_state);
+                        ret);
         if (r < 0)
                 return log_error_errno(r, "Failed to get load state of %s: %s", name, bus_error_message(&error, r));
 
@@ -3132,7 +3132,7 @@ static int unit_freezer_action(UnitFreezer *f, bool freeze) {
         r = bus_call_method(f->bus, bus_systemd_mgr,
                             freeze ? "FreezeUnit" : "ThawUnit",
                             &error,
-                            /* reply = */ NULL,
+                            /* ret_reply = */ NULL,
                             "s",
                             f->name);
         if (r < 0) {

src/shared/bus-unit-util.h

@@ -30,13 +30,13 @@ typedef struct UnitInfo {
 int bus_parse_unit_info(sd_bus_message *message, UnitInfo *u);
 
 int bus_append_unit_property_assignment(sd_bus_message *m, UnitType t, const char *assignment);
-int bus_append_unit_property_assignment_many(sd_bus_message *m, UnitType t, char **l);
+int bus_append_unit_property_assignment_many(sd_bus_message *m, UnitType t, char * const *l);
 
 int bus_append_scope_pidref(sd_bus_message *m, const PidRef *pidref, bool allow_pidfd);
 
 int bus_deserialize_and_dump_unit_file_changes(sd_bus_message *m, bool quiet);
 
-int unit_load_state(sd_bus *bus, const char *name, char **load_state);
+int unit_load_state(sd_bus *bus, const char *name, char **ret);
 
 int unit_info_compare(const UnitInfo *a, const UnitInfo *b);
 

src/shared/bus-util.c

@@ -37,7 +37,7 @@
 #include "time-util.h"
 #include "uid-classification.h"
 
-static int name_owner_change_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
+static int name_owner_change_callback(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         sd_event *e = ASSERT_PTR(userdata);
 
         assert(m);
@@ -179,19 +179,19 @@ int bus_event_loop_with_idle(
         return code;
 }
 
-int bus_name_has_owner(sd_bus *c, const char *name, sd_bus_error *error) {
+int bus_name_has_owner(sd_bus *bus, const char *name, sd_bus_error *reterr_error) {
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *rep = NULL;
         int r, has_owner = 0;
 
-        assert(c);
+        assert(bus);
         assert(name);
 
-        r = sd_bus_call_method(c,
+        r = sd_bus_call_method(bus,
                                "org.freedesktop.DBus",
                                "/org/freedesktop/dbus",
                                "org.freedesktop.DBus",
                                "NameHasOwner",
-                               error,
+                               reterr_error,
                                &rep,
                                "s",
                                name);
@@ -200,7 +200,7 @@ int bus_name_has_owner(sd_bus *c, const char *name, sd_bus_error *error) {
 
         r = sd_bus_message_read_basic(rep, 'b', &has_owner);
         if (r < 0)
-                return sd_bus_error_set_errno(error, r);
+                return sd_bus_error_set_errno(reterr_error, r);
 
         return has_owner;
 }
@@ -219,13 +219,13 @@ bool bus_error_is_connection(const sd_bus_error *error) {
                                       SD_BUS_ERROR_TIMED_OUT);
 }
 
-int bus_check_peercred(sd_bus *c) {
+int bus_check_peercred(sd_bus *bus) {
         struct ucred ucred;
         int fd, r;
 
-        assert(c);
+        assert(bus);
 
-        fd = sd_bus_get_fd(c);
+        fd = sd_bus_get_fd(bus);
         if (fd < 0)
                 return fd;
 
@@ -239,11 +239,11 @@ int bus_check_peercred(sd_bus *c) {
         return 1;
 }
 
-int bus_connect_system_systemd(sd_bus **ret_bus) {
+int bus_connect_system_systemd(sd_bus **ret) {
         _cleanup_(sd_bus_close_unrefp) sd_bus *bus = NULL;
         int r;
 
-        assert(ret_bus);
+        assert(ret);
 
         r = sd_bus_new(&bus);
         if (r < 0)
@@ -261,17 +261,17 @@ int bus_connect_system_systemd(sd_bus **ret_bus) {
         if (r < 0)
                 return r;
 
-        *ret_bus = TAKE_PTR(bus);
+        *ret = TAKE_PTR(bus);
         return 0;
 }
 
-int bus_connect_user_systemd(sd_bus **ret_bus) {
+int bus_connect_user_systemd(sd_bus **ret) {
         _cleanup_(sd_bus_close_unrefp) sd_bus *bus = NULL;
         _cleanup_free_ char *ee = NULL;
         const char *e;
         int r;
 
-        assert(ret_bus);
+        assert(ret);
 
         e = secure_getenv("XDG_RUNTIME_DIR");
         if (!e)
@@ -297,7 +297,7 @@ int bus_connect_user_systemd(sd_bus **ret_bus) {
         if (r < 0)
                 return r;
 
-        *ret_bus = TAKE_PTR(bus);
+        *ret = TAKE_PTR(bus);
         return 0;
 }
 
@@ -374,13 +374,13 @@ int bus_set_address_capsule_bus(sd_bus *bus, const char *capsule, int *ret_pin_f
         return bus_set_address_capsule(bus, capsule, "bus", ret_pin_fd);
 }
 
-int bus_connect_capsule_systemd(const char *capsule, sd_bus **ret_bus) {
+int bus_connect_capsule_systemd(const char *capsule, sd_bus **ret) {
         _cleanup_(sd_bus_close_unrefp) sd_bus *bus = NULL;
         _cleanup_close_ int inode_fd = -EBADF;
         int r;
 
         assert(capsule);
-        assert(ret_bus);
+        assert(ret);
 
         r = sd_bus_new(&bus);
         if (r < 0)
@@ -394,17 +394,17 @@ int bus_connect_capsule_systemd(const char *capsule, sd_bus **ret_bus) {
         if (r < 0)
                 return r;
 
-        *ret_bus = TAKE_PTR(bus);
+        *ret = TAKE_PTR(bus);
         return 0;
 }
 
-int bus_connect_capsule_bus(const char *capsule, sd_bus **ret_bus) {
+int bus_connect_capsule_bus(const char *capsule, sd_bus **ret) {
         _cleanup_(sd_bus_close_unrefp) sd_bus *bus = NULL;
         _cleanup_close_ int inode_fd = -EBADF;
         int r;
 
         assert(capsule);
-        assert(ret_bus);
+        assert(ret);
 
         r = sd_bus_new(&bus);
         if (r < 0)
@@ -422,7 +422,7 @@ int bus_connect_capsule_bus(const char *capsule, sd_bus **ret_bus) {
         if (r < 0)
                 return r;
 
-        *ret_bus = TAKE_PTR(bus);
+        *ret = TAKE_PTR(bus);
         return 0;
 }
 
@@ -511,13 +511,13 @@ int bus_connect_transport_systemd(
                 BusTransport transport,
                 const char *host,
                 RuntimeScope runtime_scope,
-                sd_bus **ret_bus) {
+                sd_bus **ret) {
 
         int r;
 
         assert(transport >= 0);
         assert(transport < _BUS_TRANSPORT_MAX);
-        assert(ret_bus);
+        assert(ret);
 
         switch (transport) {
 
@@ -527,14 +527,14 @@ int bus_connect_transport_systemd(
                 switch (runtime_scope) {
 
                 case RUNTIME_SCOPE_USER:
-                        r = bus_connect_user_systemd(ret_bus);
+                        r = bus_connect_user_systemd(ret);
                         /* We used to always fall back to the user session bus if we couldn't connect to the
                          * private manager bus. To keep compat with existing code that was setting
                          * DBUS_SESSION_BUS_ADDRESS without setting XDG_RUNTIME_DIR, connect to the user
                          * session bus if DBUS_SESSION_BUS_ADDRESS is set and XDG_RUNTIME_DIR isn't. */
                         if (r == -ENOMEDIUM && secure_getenv("DBUS_SESSION_BUS_ADDRESS")) {
                                 log_debug_errno(r, "$XDG_RUNTIME_DIR not set, unable to connect to private bus. Falling back to session bus.");
-                                r = sd_bus_default_user(ret_bus);
+                                r = sd_bus_default_user(ret);
                         }
 
                         return r;
@@ -548,9 +548,9 @@ int bus_connect_transport_systemd(
                         /* If we are root then let's talk directly to the system instance, instead of
                          * going via the bus. */
                         if (geteuid() == 0)
-                                return bus_connect_system_systemd(ret_bus);
+                                return bus_connect_system_systemd(ret);
 
-                        return sd_bus_default_system(ret_bus);
+                        return sd_bus_default_system(ret);
 
                 default:
                         assert_not_reached();
@@ -560,15 +560,15 @@ int bus_connect_transport_systemd(
 
         case BUS_TRANSPORT_REMOTE:
                 assert_return(runtime_scope == RUNTIME_SCOPE_SYSTEM, -EOPNOTSUPP);
-                return sd_bus_open_system_remote(ret_bus, host);
+                return sd_bus_open_system_remote(ret, host);
 
         case BUS_TRANSPORT_MACHINE:
                 assert_return(runtime_scope == RUNTIME_SCOPE_SYSTEM, -EOPNOTSUPP);
-                return sd_bus_open_system_machine(ret_bus, host);
+                return sd_bus_open_system_machine(ret, host);
 
         case BUS_TRANSPORT_CAPSULE:
                 assert_return(runtime_scope == RUNTIME_SCOPE_USER, -EINVAL);
-                return bus_connect_capsule_systemd(host, ret_bus);
+                return bus_connect_capsule_systemd(host, ret);
 
         default:
                 assert_not_reached();
@@ -788,7 +788,7 @@ int bus_open_system_watch_bind_with_description(sd_bus **ret, const char *descri
         return 0;
 }
 
-int bus_reply_pair_array(sd_bus_message *m, char **l) {
+int bus_reply_pair_array(sd_bus_message *m, char * const *l) {
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
         int r;
 
@@ -818,7 +818,7 @@ int bus_reply_pair_array(sd_bus_message *m, char **l) {
         return sd_bus_send(NULL, reply, NULL);
 }
 
-static int method_dump_memory_state_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
+static int method_dump_memory_state_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
         _cleanup_(memstream_done) MemStream m = {};
         _cleanup_free_ char *dump = NULL;
         _cleanup_close_ int fd = -EBADF;
@@ -853,7 +853,7 @@ static int method_dump_memory_state_by_fd(sd_bus_message *message, void *userdat
 
 /* The default install callback will fail and disconnect the bus if it cannot register the match, but this
  * is only a debug method, we definitely don't want to fail in case there's some permission issue. */
-static int dummy_install_callback(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
+static int dummy_install_callback(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
         return 1;
 }
 
@@ -930,8 +930,7 @@ int bus_get_instance_id(sd_bus *bus, sd_id128_t *ret) {
 
         r = sd_bus_call_method(bus,
                                "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "GetId",
-                               /* ret_error = */ NULL, &reply,
-                               NULL);
+                               /* reterr_error = */ NULL, &reply, NULL);
         if (r < 0)
                 return r;
 

src/shared/bus-util.h

@@ -21,19 +21,19 @@ typedef bool (*check_idle_t)(void *userdata);
 
 int bus_event_loop_with_idle(sd_event *e, sd_bus *bus, const char *name, usec_t timeout, check_idle_t check_idle, void *userdata);
 
-int bus_name_has_owner(sd_bus *c, const char *name, sd_bus_error *error);
+int bus_name_has_owner(sd_bus *bus, const char *name, sd_bus_error *reterr_error);
 
 bool bus_error_is_unknown_service(const sd_bus_error *error);
 bool bus_error_is_connection(const sd_bus_error *error);
 
-int bus_check_peercred(sd_bus *c);
+int bus_check_peercred(sd_bus *bus);
 
 int bus_set_address_capsule_bus(sd_bus *bus, const char *capsule, int *ret_pin_fd);
 
-int bus_connect_system_systemd(sd_bus **ret_bus);
-int bus_connect_user_systemd(sd_bus **ret_bus);
-int bus_connect_capsule_systemd(const char *capsule, sd_bus **ret_bus);
-int bus_connect_capsule_bus(const char *capsule, sd_bus **ret_bus);
+int bus_connect_system_systemd(sd_bus **ret);
+int bus_connect_user_systemd(sd_bus **ret);
+int bus_connect_capsule_systemd(const char *capsule, sd_bus **ret);
+int bus_connect_capsule_bus(const char *capsule, sd_bus **ret);
 
 int bus_connect_transport(BusTransport transport, const char *host, RuntimeScope runtime_scope, sd_bus **bus);
 int bus_connect_transport_systemd(BusTransport transport, const char *host, RuntimeScope runtime_scope, sd_bus **bus);
@@ -62,7 +62,7 @@ static inline int bus_open_system_watch_bind(sd_bus **ret) {
         return bus_open_system_watch_bind_with_description(ret, NULL);
 }
 
-int bus_reply_pair_array(sd_bus_message *m, char **l);
+int bus_reply_pair_array(sd_bus_message *m, char * const *l);
 
 /* Listen to GetMallocInfo() calls to 'destination' and return malloc_info() via FD */
 int bus_register_malloc_status(sd_bus *bus, const char *destination);

src/shared/bus-wait-for-jobs.c

@@ -45,7 +45,7 @@ BusWaitForJobs* bus_wait_for_jobs_free(BusWaitForJobs *d) {
         return mfree(d);
 }
 
-static int match_disconnected(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int match_disconnected(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         assert(m);
 
         log_warning("D-Bus connection terminated while waiting for jobs.");
@@ -54,7 +54,7 @@ static int match_disconnected(sd_bus_message *m, void *userdata, sd_bus_error *e
         return 0;
 }
 
-static int match_job_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int match_job_removed(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         BusWaitForJobs *d = ASSERT_PTR(userdata);
         _cleanup_free_ char *job_found = NULL;
         const char *path, *unit, *result;

src/shared/bus-wait-for-units.c

@@ -40,7 +40,7 @@ typedef struct BusWaitForUnits {
         bool has_failed:1;
 } BusWaitForUnits;
 
-static WaitForItem *wait_for_item_free(WaitForItem *item) {
+static WaitForItem* wait_for_item_free(WaitForItem *item) {
         int r;
 
         if (!item)
@@ -99,7 +99,7 @@ static void bus_wait_for_units_clear(BusWaitForUnits *d) {
         d->items = hashmap_free(d->items);
 }
 
-static int match_disconnected(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int match_disconnected(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         BusWaitForUnits *d = ASSERT_PTR(userdata);
 
         assert(m);
@@ -228,7 +228,7 @@ static int wait_for_item_parse_properties(WaitForItem *item, sd_bus_message *m)
         return 0;
 }
 
-static int on_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
+static int on_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         WaitForItem *item = ASSERT_PTR(userdata);
         const char *interface;
         int r;
@@ -249,7 +249,7 @@ static int on_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error
         return 0;
 }
 
-static int on_get_all_properties(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
+static int on_get_all_properties(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error) {
         WaitForItem *item = ASSERT_PTR(userdata);
         const sd_bus_error *e;
         int r;

src/systemd/sd-bus-protocol.h

@@ -182,11 +182,11 @@ __extension__ enum {
 
 /* Callbacks */
 
-typedef int (*sd_bus_message_handler_t)(sd_bus_message *m, void *userdata, sd_bus_error *ret_error);
-typedef int (*sd_bus_property_get_t) (sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *ret_error);
-typedef int (*sd_bus_property_set_t) (sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *ret_error);
-typedef int (*sd_bus_object_find_t) (sd_bus *bus, const char *path, const char *interface, void *userdata, void **ret_found, sd_bus_error *ret_error);
-typedef int (*sd_bus_node_enumerator_t) (sd_bus *bus, const char *prefix, void *userdata, char ***ret_nodes, sd_bus_error *ret_error);
+typedef int (*sd_bus_message_handler_t)(sd_bus_message *m, void *userdata, sd_bus_error *reterr_error);
+typedef int (*sd_bus_property_get_t) (sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *reterr_error);
+typedef int (*sd_bus_property_set_t) (sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *reterr_error);
+typedef int (*sd_bus_object_find_t) (sd_bus *bus, const char *path, const char *interface, void *userdata, void **ret_found, sd_bus_error *reterr_error);
+typedef int (*sd_bus_node_enumerator_t) (sd_bus *bus, const char *prefix, void *userdata, char ***ret_nodes, sd_bus_error *reterr_error);
 typedef int (*sd_bus_track_handler_t) (sd_bus_track *track, void *userdata);
 typedef _sd_destroy_t sd_bus_destroy_t;
 

src/systemd/sd-bus.h

@@ -69,12 +69,12 @@ int sd_bus_is_trusted(sd_bus *bus);
 int sd_bus_set_monitor(sd_bus *bus, int b);
 int sd_bus_is_monitor(sd_bus *bus);
 int sd_bus_set_description(sd_bus *bus, const char *description);
-int sd_bus_get_description(sd_bus *bus, const char **description);
+int sd_bus_get_description(sd_bus *bus, const char **ret);
 int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t creds_mask);
 int sd_bus_negotiate_timestamp(sd_bus *bus, int b);
 int sd_bus_negotiate_fds(sd_bus *bus, int b);
 int sd_bus_can_send(sd_bus *bus, char type);
-int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *creds_mask);
+int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *ret);
 int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b);
 int sd_bus_get_allow_interactive_authorization(sd_bus *bus);
 int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b);
@@ -103,21 +103,21 @@ void sd_bus_default_flush_close(void);
 int sd_bus_is_open(sd_bus *bus);
 int sd_bus_is_ready(sd_bus *bus);
 
-int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id);
-int sd_bus_get_scope(sd_bus *bus, const char **scope);
-int sd_bus_get_tid(sd_bus *bus, pid_t *tid);
+int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *ret);
+int sd_bus_get_scope(sd_bus *bus, const char **ret);
+int sd_bus_get_tid(sd_bus *bus, pid_t *ret);
 int sd_bus_get_owner_creds(sd_bus *bus, uint64_t creds_mask, sd_bus_creds **ret);
 
 int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *ret_cookie);
-int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie);
-int sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_bus_error *ret_error, sd_bus_message **reply);
-int sd_bus_call_async(sd_bus *bus, sd_bus_slot **slot, sd_bus_message *m, sd_bus_message_handler_t callback, void *userdata, uint64_t usec);
+int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *ret_cookie);
+int sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_bus_error *reterr_error, sd_bus_message **ret_reply);
+int sd_bus_call_async(sd_bus *bus, sd_bus_slot **ret_slot, sd_bus_message *m, sd_bus_message_handler_t callback, void *userdata, uint64_t usec);
 
 int sd_bus_get_fd(sd_bus *bus);
 int sd_bus_get_events(sd_bus *bus);
-int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec);
-int sd_bus_process(sd_bus *bus, sd_bus_message **r);
-int sd_bus_process_priority(sd_bus *bus, int64_t max_priority, sd_bus_message **r) _sd_deprecated_;
+int sd_bus_get_timeout(sd_bus *bus, uint64_t *ret);
+int sd_bus_process(sd_bus *bus, sd_bus_message **ret);
+int sd_bus_process_priority(sd_bus *bus, int64_t max_priority, sd_bus_message **ret) _sd_deprecated_;
 int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec);
 int sd_bus_flush(sd_bus *bus);
 int sd_bus_enqueue_for_read(sd_bus *bus, sd_bus_message *m);
@@ -137,15 +137,15 @@ int sd_bus_get_n_queued_write(sd_bus *bus, uint64_t *ret);
 int sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec);
 int sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret);
 
-int sd_bus_add_filter(sd_bus *bus, sd_bus_slot **slot, sd_bus_message_handler_t callback, void *userdata);
-int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata);
-int sd_bus_add_match_async(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, sd_bus_message_handler_t install_callback, void *userdata);
-int sd_bus_add_object(sd_bus *bus, sd_bus_slot **slot, const char *path, sd_bus_message_handler_t callback, void *userdata);
-int sd_bus_add_fallback(sd_bus *bus, sd_bus_slot **slot, const char *prefix, sd_bus_message_handler_t callback, void *userdata);
-int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata);
-int sd_bus_add_fallback_vtable(sd_bus *bus, sd_bus_slot **slot, const char *prefix, const char *interface, const sd_bus_vtable *vtable, sd_bus_object_find_t find, void *userdata);
-int sd_bus_add_node_enumerator(sd_bus *bus, sd_bus_slot **slot, const char *path, sd_bus_node_enumerator_t callback, void *userdata);
-int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path);
+int sd_bus_add_filter(sd_bus *bus, sd_bus_slot **ret_slot, sd_bus_message_handler_t callback, void *userdata);
+int sd_bus_add_match(sd_bus *bus, sd_bus_slot **ret_slot, const char *match, sd_bus_message_handler_t callback, void *userdata);
+int sd_bus_add_match_async(sd_bus *bus, sd_bus_slot **ret_slot, const char *match, sd_bus_message_handler_t callback, sd_bus_message_handler_t install_callback, void *userdata);
+int sd_bus_add_object(sd_bus *bus, sd_bus_slot **ret_slot, const char *path, sd_bus_message_handler_t callback, void *userdata);
+int sd_bus_add_fallback(sd_bus *bus, sd_bus_slot **ret_slot, const char *prefix, sd_bus_message_handler_t callback, void *userdata);
+int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **ret_slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata);
+int sd_bus_add_fallback_vtable(sd_bus *bus, sd_bus_slot **ret_slot, const char *prefix, const char *interface, const sd_bus_vtable *vtable, sd_bus_object_find_t find, void *userdata);
+int sd_bus_add_node_enumerator(sd_bus *bus, sd_bus_slot **ret_slot, const char *path, sd_bus_node_enumerator_t callback, void *userdata);
+int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **ret_slot, const char *path);
 
 int sd_bus_pending_method_calls(sd_bus *bus);
 
@@ -158,11 +158,11 @@ sd_bus* sd_bus_slot_get_bus(sd_bus_slot *slot);
 void* sd_bus_slot_get_userdata(sd_bus_slot *slot);
 void* sd_bus_slot_set_userdata(sd_bus_slot *slot, void *userdata);
 int sd_bus_slot_set_description(sd_bus_slot *slot, const char *description);
-int sd_bus_slot_get_description(sd_bus_slot *slot, const char **description);
+int sd_bus_slot_get_description(sd_bus_slot *slot, const char **ret);
 int sd_bus_slot_get_floating(sd_bus_slot *slot);
 int sd_bus_slot_set_floating(sd_bus_slot *slot, int b);
 int sd_bus_slot_set_destroy_callback(sd_bus_slot *s, sd_bus_destroy_t callback);
-int sd_bus_slot_get_destroy_callback(sd_bus_slot *s, sd_bus_destroy_t *callback);
+int sd_bus_slot_get_destroy_callback(sd_bus_slot *s, sd_bus_destroy_t *ret);
 
 sd_bus_message* sd_bus_slot_get_current_message(sd_bus_slot *slot);
 sd_bus_message_handler_t sd_bus_slot_get_current_handler(sd_bus_slot *slot);
@@ -170,25 +170,25 @@ void* sd_bus_slot_get_current_userdata(sd_bus_slot *slot);
 
 /* Message object */
 
-int sd_bus_message_new(sd_bus *bus, sd_bus_message **m, uint8_t type);
-int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member);
-int sd_bus_message_new_signal_to(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member);
-int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member);
-int sd_bus_message_new_method_return(sd_bus_message *call, sd_bus_message **m);
-int sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message **m, const sd_bus_error *e);
-int sd_bus_message_new_method_errorf(sd_bus_message *call, sd_bus_message **m, const char *name, const char *format, ...) _sd_printf_(4, 5);
-int sd_bus_message_new_method_errno(sd_bus_message *call, sd_bus_message **m, int error, const sd_bus_error *e);
-int sd_bus_message_new_method_errnof(sd_bus_message *call, sd_bus_message **m, int error, const char *format, ...) _sd_printf_(4, 5);
+int sd_bus_message_new(sd_bus *bus, sd_bus_message **ret, uint8_t type);
+int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **ret, const char *path, const char *interface, const char *member);
+int sd_bus_message_new_signal_to(sd_bus *bus, sd_bus_message **ret, const char *destination, const char *path, const char *interface, const char *member);
+int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **ret, const char *destination, const char *path, const char *interface, const char *member);
+int sd_bus_message_new_method_return(sd_bus_message *call, sd_bus_message **ret);
+int sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message **ret, const sd_bus_error *e);
+int sd_bus_message_new_method_errorf(sd_bus_message *call, sd_bus_message **ret, const char *name, const char *format, ...) _sd_printf_(4, 5);
+int sd_bus_message_new_method_errno(sd_bus_message *call, sd_bus_message **ret, int error, const sd_bus_error *e);
+int sd_bus_message_new_method_errnof(sd_bus_message *call, sd_bus_message **ret, int error, const char *format, ...) _sd_printf_(4, 5);
 
 sd_bus_message* sd_bus_message_ref(sd_bus_message *m);
 sd_bus_message* sd_bus_message_unref(sd_bus_message *m);
 
 int sd_bus_message_seal(sd_bus_message *m, uint64_t cookie, uint64_t timeout_usec);
 
-int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type);
-int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *cookie);
-int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *cookie);
-int sd_bus_message_get_priority(sd_bus_message *m, int64_t *priority) _sd_deprecated_;
+int sd_bus_message_get_type(sd_bus_message *m, uint8_t *ret);
+int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *ret);
+int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *ret);
+int sd_bus_message_get_priority(sd_bus_message *m, int64_t *ret) _sd_deprecated_;
 
 int sd_bus_message_get_expect_reply(sd_bus_message *m);
 int sd_bus_message_get_auto_start(sd_bus_message *m);
@@ -203,9 +203,9 @@ const char* sd_bus_message_get_sender(sd_bus_message *m);
 const sd_bus_error* sd_bus_message_get_error(sd_bus_message *m);
 int sd_bus_message_get_errno(sd_bus_message *m);
 
-int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *usec);
-int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *usec);
-int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *seqnum);
+int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *ret);
+int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *ret);
+int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *ret);
 
 sd_bus* sd_bus_message_get_bus(sd_bus_message *m);
 sd_bus_creds* sd_bus_message_get_creds(sd_bus_message *m); /* do not unref the result */
@@ -228,10 +228,10 @@ int sd_bus_message_append(sd_bus_message *m, const char *types, ...);
 int sd_bus_message_appendv(sd_bus_message *m, const char *types, va_list ap);
 int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p);
 int sd_bus_message_append_array(sd_bus_message *m, char type, const void *ptr, size_t size);
-int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t size, void **ptr);
+int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t size, void **ret);
 int sd_bus_message_append_array_iovec(sd_bus_message *m, char type, const struct iovec *iov, unsigned n);
 int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, int memfd, uint64_t offset, uint64_t size);
-int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s);
+int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **ret);
 int sd_bus_message_append_string_iovec(sd_bus_message *m, const struct iovec *iov, unsigned n);
 int sd_bus_message_append_string_memfd(sd_bus_message *m, int memfd, uint64_t offset, uint64_t size);
 int sd_bus_message_append_strv(sd_bus_message *m, char **l);
@@ -241,9 +241,9 @@ int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all);
 
 int sd_bus_message_read(sd_bus_message *m, const char *types, ...);
 int sd_bus_message_readv(sd_bus_message *m, const char *types, va_list ap);
-int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p);
-int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ptr, size_t *size);
-int sd_bus_message_read_strv(sd_bus_message *m, char ***l); /* free the result! */
+int sd_bus_message_read_basic(sd_bus_message *m, char type, void *ret);
+int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ret_ptr, size_t *ret_size);
+int sd_bus_message_read_strv(sd_bus_message *m, char ***ret); /* free the result! */
 int sd_bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 int sd_bus_message_skip(sd_bus_message *m, const char *types);
 int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *contents);
@@ -264,23 +264,23 @@ int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags);
 int sd_bus_request_name_async(sd_bus *bus, sd_bus_slot **ret_slot, const char *name, uint64_t flags, sd_bus_message_handler_t callback, void *userdata);
 int sd_bus_release_name(sd_bus *bus, const char *name);
 int sd_bus_release_name_async(sd_bus *bus, sd_bus_slot **ret_slot, const char *name, sd_bus_message_handler_t callback, void *userdata);
-int sd_bus_list_names(sd_bus *bus, char ***acquired, char ***activatable); /* free the results */
-int sd_bus_get_name_creds(sd_bus *bus, const char *name, uint64_t mask, sd_bus_creds **creds); /* unref the result! */
-int sd_bus_get_name_machine_id(sd_bus *bus, const char *name, sd_id128_t *machine);
+int sd_bus_list_names(sd_bus *bus, char ***ret_acquired, char ***ret_activatable); /* free the results */
+int sd_bus_get_name_creds(sd_bus *bus, const char *name, uint64_t mask, sd_bus_creds **ret); /* unref the result! */
+int sd_bus_get_name_machine_id(sd_bus *bus, const char *name, sd_id128_t *ret);
 
 /* Convenience calls */
 
 int sd_bus_message_send(sd_bus_message *m);
-int sd_bus_call_methodv(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, sd_bus_message **reply, const char *types, va_list ap);
-int sd_bus_call_method(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, sd_bus_message **reply, const char *types, ...);
-int sd_bus_call_method_asyncv(sd_bus *bus, sd_bus_slot **slot, const char *destination, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata, const char *types, va_list ap);
-int sd_bus_call_method_async(sd_bus *bus, sd_bus_slot **slot, const char *destination, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata, const char *types, ...);
-int sd_bus_get_property(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, sd_bus_message **reply, const char *type);
-int sd_bus_get_property_trivial(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, char type, void *ret_ptr);
-int sd_bus_get_property_string(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, char **ret); /* free the result! */
-int sd_bus_get_property_strv(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, char ***ret); /* free the result! */
-int sd_bus_set_propertyv(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, const char *type, va_list ap);
-int sd_bus_set_property(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, const char *type, ...);
+int sd_bus_call_methodv(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *reterr_error, sd_bus_message **ret_reply, const char *types, va_list ap);
+int sd_bus_call_method(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *reterr_error, sd_bus_message **ret_reply, const char *types, ...);
+int sd_bus_call_method_asyncv(sd_bus *bus, sd_bus_slot **ret_slot, const char *destination, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata, const char *types, va_list ap);
+int sd_bus_call_method_async(sd_bus *bus, sd_bus_slot **ret_slot, const char *destination, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata, const char *types, ...);
+int sd_bus_get_property(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *reterr_error, sd_bus_message **ret_reply, const char *type);
+int sd_bus_get_property_trivial(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *reterr_error, char type, void *ret);
+int sd_bus_get_property_string(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *reterr_error, char **ret); /* free the result! */
+int sd_bus_get_property_strv(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *reterr_error, char ***ret); /* free the result! */
+int sd_bus_set_propertyv(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *reterr_error, const char *type, va_list ap);
+int sd_bus_set_property(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *reterr_error, const char *type, ...);
 
 int sd_bus_reply_method_returnv(sd_bus_message *call, const char *types, va_list ap);
 int sd_bus_reply_method_return(sd_bus_message *call, const char *types, ...);
@@ -306,7 +306,7 @@ int sd_bus_emit_interfaces_added(sd_bus *bus, const char *path, const char *inte
 int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces);
 int sd_bus_emit_interfaces_removed(sd_bus *bus, const char *path, const char *interface, ...) _sd_sentinel_;
 
-int sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **creds);
+int sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **ret);
 int sd_bus_query_sender_privilege(sd_bus_message *m, int capability);
 
 int sd_bus_match_signal(sd_bus *bus, sd_bus_slot **ret, const char *sender, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata);
@@ -321,41 +321,41 @@ sd_bus_creds* sd_bus_creds_unref(sd_bus_creds *c);
 uint64_t sd_bus_creds_get_mask(const sd_bus_creds *c);
 uint64_t sd_bus_creds_get_augmented_mask(const sd_bus_creds *c);
 
-int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid);
-int sd_bus_creds_get_pidfd_dup(sd_bus_creds *c, int *ret_fd);
-int sd_bus_creds_get_ppid(sd_bus_creds *c, pid_t *ppid);
-int sd_bus_creds_get_tid(sd_bus_creds *c, pid_t *tid);
-int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid);
-int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *euid);
-int sd_bus_creds_get_suid(sd_bus_creds *c, uid_t *suid);
-int sd_bus_creds_get_fsuid(sd_bus_creds *c, uid_t *fsuid);
-int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid);
-int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *egid);
-int sd_bus_creds_get_sgid(sd_bus_creds *c, gid_t *sgid);
-int sd_bus_creds_get_fsgid(sd_bus_creds *c, gid_t *fsgid);
-int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids);
-int sd_bus_creds_get_comm(sd_bus_creds *c, const char **comm);
-int sd_bus_creds_get_tid_comm(sd_bus_creds *c, const char **comm);
-int sd_bus_creds_get_exe(sd_bus_creds *c, const char **exe);
-int sd_bus_creds_get_cmdline(sd_bus_creds *c, char ***cmdline);
-int sd_bus_creds_get_cgroup(sd_bus_creds *c, const char **cgroup);
-int sd_bus_creds_get_unit(sd_bus_creds *c, const char **unit);
-int sd_bus_creds_get_slice(sd_bus_creds *c, const char **slice);
-int sd_bus_creds_get_user_unit(sd_bus_creds *c, const char **unit);
-int sd_bus_creds_get_user_slice(sd_bus_creds *c, const char **slice);
-int sd_bus_creds_get_session(sd_bus_creds *c, const char **session);
-int sd_bus_creds_get_owner_uid(sd_bus_creds *c, uid_t *uid);
+int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *ret);
+int sd_bus_creds_get_pidfd_dup(sd_bus_creds *c, int *ret);
+int sd_bus_creds_get_ppid(sd_bus_creds *c, pid_t *ret);
+int sd_bus_creds_get_tid(sd_bus_creds *c, pid_t *ret);
+int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *ret);
+int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *ret);
+int sd_bus_creds_get_suid(sd_bus_creds *c, uid_t *ret);
+int sd_bus_creds_get_fsuid(sd_bus_creds *c, uid_t *ret);
+int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *ret);
+int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *ret);
+int sd_bus_creds_get_sgid(sd_bus_creds *c, gid_t *ret);
+int sd_bus_creds_get_fsgid(sd_bus_creds *c, gid_t *ret);
+int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **ret);
+int sd_bus_creds_get_comm(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_tid_comm(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_exe(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_cmdline(sd_bus_creds *c, char ***ret);
+int sd_bus_creds_get_cgroup(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_unit(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_slice(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_user_unit(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_user_slice(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_session(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_owner_uid(sd_bus_creds *c, uid_t *ret);
 int sd_bus_creds_has_effective_cap(sd_bus_creds *c, int capability);
 int sd_bus_creds_has_permitted_cap(sd_bus_creds *c, int capability);
 int sd_bus_creds_has_inheritable_cap(sd_bus_creds *c, int capability);
 int sd_bus_creds_has_bounding_cap(sd_bus_creds *c, int capability);
-int sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **context);
-int sd_bus_creds_get_audit_session_id(sd_bus_creds *c, uint32_t *sessionid);
-int sd_bus_creds_get_audit_login_uid(sd_bus_creds *c, uid_t *loginuid);
-int sd_bus_creds_get_tty(sd_bus_creds *c, const char **tty);
-int sd_bus_creds_get_unique_name(sd_bus_creds *c, const char **name);
-int sd_bus_creds_get_well_known_names(sd_bus_creds *c, char ***names);
-int sd_bus_creds_get_description(sd_bus_creds *c, const char **name);
+int sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_audit_session_id(sd_bus_creds *c, uint32_t *ret);
+int sd_bus_creds_get_audit_login_uid(sd_bus_creds *c, uid_t *ret);
+int sd_bus_creds_get_tty(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_unique_name(sd_bus_creds *c, const char **ret);
+int sd_bus_creds_get_well_known_names(sd_bus_creds *c, char ***ret);
+int sd_bus_creds_get_description(sd_bus_creds *c, const char **ret);
 
 /* Error structures */
 
@@ -408,14 +408,14 @@ int sd_bus_error_add_map(const sd_bus_error_map *map);
 
 /* Label escaping */
 
-int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path);
-int sd_bus_path_encode_many(char **out, const char *path_template, ...);
-int sd_bus_path_decode(const char *path, const char *prefix, char **ret_external_id);
+int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret);
+int sd_bus_path_encode_many(char **ret, const char *path_template, ...);
+int sd_bus_path_decode(const char *path, const char *prefix, char **ret);
 int sd_bus_path_decode_many(const char *path, const char *path_template, ...);
 
 /* Tracking peers */
 
-int sd_bus_track_new(sd_bus *bus, sd_bus_track **track, sd_bus_track_handler_t handler, void *userdata);
+int sd_bus_track_new(sd_bus *bus, sd_bus_track **ret, sd_bus_track_handler_t handler, void *userdata);
 sd_bus_track* sd_bus_track_ref(sd_bus_track *track);
 sd_bus_track* sd_bus_track_unref(sd_bus_track *track);
 

src/sysupdate/updatectl.c

@@ -964,7 +964,8 @@ static int update_interrupted(sd_event_source *source, void *userdata) {
                                op->job_path,
                                "org.freedesktop.sysupdate1.Job",
                                "Cancel",
-                               &error, /* reply= */ NULL,
+                               &error,
+                               /* ret_reply= */ NULL,
                                NULL);
         if (r < 0)
                 return log_bus_error(r, &error, NULL, "call Cancel");
@@ -1412,7 +1413,7 @@ static int verb_enable(int argc, char **argv, void *userdata) {
                                        SYSUPDATE_TARGET_INTERFACE,
                                        "SetFeatureEnabled",
                                        &error,
-                                       /* reply= */ NULL,
+                                       /* ret_reply= */ NULL,
                                        "sit",
                                        *feature,
                                        (int) enable,

src/vmspawn/vmspawn.c

@@ -915,7 +915,7 @@ static int shutdown_vm_graceful(sd_event_source *s, const struct signalfd_siginf
                 goto fallback;
         }
 
-        r = bus_call_method(bus, bus_login_mgr, "PowerOff", &error, /* reply= */ NULL, "b", false);
+        r = bus_call_method(bus, bus_login_mgr, "PowerOff", &error, /* ret_reply= */ NULL, "b", false);
         if (r >= 0) {
                 log_info("Requested powering off VM through D-Bus.");
                 return 0;
@@ -924,7 +924,7 @@ static int shutdown_vm_graceful(sd_event_source *s, const struct signalfd_siginf
         log_warning_errno(r, "Failed to shutdown VM via logind, ignoring: %s", bus_error_message(&error, r));
         sd_bus_error_free(&error);
 
-        r = bus_call_method(bus, bus_systemd_mgr, "PowerOff", &error, /* reply= */ NULL, /* types= */ NULL);
+        r = bus_call_method(bus, bus_systemd_mgr, "PowerOff", &error, /* ret_reply= */ NULL, /* types= */ NULL);
         if (r >= 0) {
                 log_info("Requested powering off VM through D-Bus.");
                 return 0;