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)));
}
"org.freedesktop.login1.Session",
"SetClass",
&error,
- /* reply= */ NULL,
+ /* ret_reply= */ NULL,
"s",
"user");
if (r < 0)
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)
if (!BUS_IS_OPEN(bus->state))
return -ENOTCONN;
- if (acquired) {
+ if (ret_acquired) {
r = sd_bus_call_method(
bus,
"org.freedesktop.DBus",
reply = sd_bus_message_unref(reply);
}
- if (activatable) {
+ if (ret_activatable) {
r = sd_bus_call_method(
bus,
"org.freedesktop.DBus",
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;
}
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;
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);
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;
}
}
- if (creds)
- *creds = TAKE_PTR(c);
+ if (ret)
+ *ret = TAKE_PTR(c);
return 0;
}
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;
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);
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,
if (r < 0)
return r;
- return sd_id128_from_string(mid, machine);
+ return sd_id128_from_string(mid, ret);
}
_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,
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,
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;
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;
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(
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;
_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;
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;
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(
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;
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(
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;
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;
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(
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;
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(
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;
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(
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;
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;
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;
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;
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;
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;
}
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;
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;
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;
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;
if (!uid_is_valid(c->audit_login_uid))
return -ENXIO;
- *uid = c->audit_login_uid;
+ *ret = c->audit_login_uid;
return 0;
}
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;
NULL
};
- *well_known_names = (char**) wkn;
+ *ret = (char**) wkn;
return 0;
}
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;
}
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;
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;
}
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 { \
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;
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)
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;
_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);
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,
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)
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,
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)
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;
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)
* 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)
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,
...) {
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,
...) {
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) {
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;
}
(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))
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)
return 0;
}
-static BusMessageBodyPart *message_append_part(sd_bus_message *m) {
+static BusMessageBodyPart* message_append_part(sd_bus_message *m) {
BusMessageBodyPart *part;
assert(m);
*c->array_size += expand;
}
-static void *message_extend_body(
+static void* message_extend_body(
sd_bus_message *m,
size_t align,
size_t sz) {
_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);
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++;
sd_bus_message *m,
BusMessageContainer *c,
const char *contents,
- uint32_t **array_size) {
+ uint32_t **ret_array_size) {
unsigned nindex;
int alignment;
assert(m);
assert(c);
assert(contents);
- assert(array_size);
+ assert(ret_array_size);
if (!signature_is_single(contents, true))
return -EINVAL;
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;
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;
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;
}
sd_bus_message *m,
char type,
size_t size,
- void **ptr) {
+ void **ret) {
ssize_t align, sz;
void *a;
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);
if (r < 0)
return r;
- *ptr = a;
+ *ret = a;
return 0;
}
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;
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;
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;
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;
if (!validate_signature(q, l))
return -EBADMSG;
- if (p)
- *(const char**) p = q;
+ if (ret)
+ *(const char**) ret = q;
} else {
ssize_t sz, align;
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: {
if (j >= m->n_fds)
return -EBADMSG;
- if (p)
- *(int*) p = m->fds[j];
+ if (ret)
+ *(int*) ret = m->fds[j];
break;
}
sd_bus_message *m,
BusMessageContainer *c,
const char *contents,
- uint32_t **array_size) {
+ uint32_t **ret_array_size) {
size_t rindex;
void *q;
assert(m);
assert(c);
assert(contents);
- assert(array_size);
+ assert(ret_array_size);
if (!signature_is_single(contents, true))
return -EINVAL;
if (r < 0)
return r;
- *array_size = (uint32_t*) q;
+ *ret_array_size = (uint32_t*) q;
m->rindex = rindex;
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;
_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;
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;
}
if (r < 0)
goto fail;
- *ptr = (const void*) p;
- *size = sz;
+ *ret_ptr = (const void*) p;
+ *ret_size = sz;
return 1;
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;
}
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;
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;
}
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;
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
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))
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))
const char *path,
BusVTableMember *p,
void **userdata,
- sd_bus_error *error) {
+ sd_bus_error *reterr_error) {
void *u;
int r;
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)
const char *prefix,
BusNodeEnumerator *first,
OrderedSet *s,
- sd_bus_error *error) {
+ sd_bus_error *reterr_error) {
int r;
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);
BusNode *n,
unsigned flags,
OrderedSet *s,
- sd_bus_error *error) {
+ sd_bus_error *reterr_error) {
int r;
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)
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)
BusNode *n,
unsigned flags,
OrderedSet **ret,
- sd_bus_error *error) {
+ sd_bus_error *reterr_error) {
_cleanup_ordered_set_free_ OrderedSet *s = NULL;
int r;
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;
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)
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;
}
#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;
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(
const char *property,
sd_bus_message *reply,
void *userdata,
- sd_bus_error *error) {
+ sd_bus_error *reterr_error) {
const void *p;
int r;
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;
}
const char *property,
sd_bus_message *value,
void *userdata,
- sd_bus_error *error) {
+ sd_bus_error *reterr_error) {
int r;
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;
}
BusNodeVTable *c,
const sd_bus_vtable *v,
void *userdata,
- sd_bus_error *error) {
+ sd_bus_error *reterr_error) {
sd_bus_slot *slot;
int r;
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)
const char *path,
BusNodeVTable *c,
void *userdata,
- sd_bus_error *error) {
+ sd_bus_error *reterr_error) {
const sd_bus_vtable *v;
int r;
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)
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 = {};
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)
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)
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;
assert(prefix);
assert(path);
assert(found_object_manager);
- assert(error);
+ assert(reterr_error);
n = hashmap_get(bus->nodes, prefix);
if (!n)
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)
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)
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;
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)
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)
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,
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;
LIST_PREPEND(callbacks, n->callbacks, &s->node_callback);
bus->nodes_modified = true;
- if (slot)
- *slot = s;
+ if (ret_slot)
+ *ret_slot = s;
return 0;
_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) {
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,
}
}
- 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;
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;
_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) {
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;
LIST_PREPEND(enumerators, n->enumerators, &s->node_enumerator);
bus->nodes_modified = true;
- if (slot)
- *slot = s;
+ if (ret_slot)
+ *ret_slot = s;
return 0;
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;
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;
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;
bool ignore_nodes_modified,
bool *found_object,
char **ret,
- sd_bus_error *error);
+ sd_bus_error *reterr_error);
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);
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);
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;
_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) {
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;
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)
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;
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);
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
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;
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))
}
/* 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))
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;
}
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);
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) {
_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;
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);
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;
if (r < 0)
return r;
- if (slot)
- *slot = s;
+ if (ret_slot)
+ *ret_slot = s;
s = NULL;
return r;
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;
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;
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;
}
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) {
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:
_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) {
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;
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;
}
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,
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;
if (r < 0)
return r;
- if (slot)
- *slot = s;
+ if (ret_slot)
+ *ret_slot = s;
s = NULL;
return 0;
_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) {
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;
}
* 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;
va_list list;
int r;
- assert_return(out, -EINVAL);
+ assert_return(ret, -EINVAL);
assert_return(path_template, -EINVAL);
path_length = strlen(path_template);
}
*path_pos = 0;
- *out = path;
+ *ret = path;
return 0;
}
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)
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;
}
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;
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;
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;
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;
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;
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);
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);
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);
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);
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);
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);
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"));
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"));
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))
return 1;
}
-static void *server(void *p) {
+static void* server(void *p) {
struct context *c = p;
sd_bus *bus = NULL;
sd_id128_t id;
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;
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);
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;
}
"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))
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;
/* 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;
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);
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);
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);
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);
/* 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);
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 */
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);
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);
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, ...);
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);
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 */
/* 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);
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");
SYSUPDATE_TARGET_INTERFACE,
"SetFeatureEnabled",
&error,
- /* reply= */ NULL,
+ /* ret_reply= */ NULL,
"sit",
*feature,
(int) enable,
projects / thirdparty / systemd.git / commitdiff
