consistently use "int" when retrieving "bool" from bus messages

[elogind.git] / src / libsystemd-bus / bus-message.c

diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c
index 96d177823584f1fb32fecd9842c913b26d700ec5..9543ae3b26acc6df0bc3a843c08f96cc68a24aec 100644 (file)
--- a/src/libsystemd-bus/bus-message.c
+++ b/src/libsystemd-bus/bus-message.c
@@ -440,7 +440,7 @@ static sd_bus_message *message_new(sd_bus *bus, uint8_t type) {
         return m;
 }
 
-int sd_bus_message_new_signal(
+_public_ int sd_bus_message_new_signal(
                 sd_bus *bus,
                 const char *path,
                 const char *interface,
@@ -450,16 +450,11 @@ int sd_bus_message_new_signal(
         sd_bus_message *t;
         int r;
 
-        if (!path)
-                return -EINVAL;
-        if (!interface)
-                return -EINVAL;
-        if (!member)
-                return -EINVAL;
-        if (!m)
-                return -EINVAL;
-        if (bus && bus->state == BUS_UNSET)
-                return -ENOTCONN;
+        assert_return(!bus || bus->state != BUS_UNSET, -ENOTCONN);
+        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);
 
         t = message_new(bus, SD_BUS_MESSAGE_SIGNAL);
         if (!t)
@@ -485,7 +480,7 @@ fail:
         return r;
 }
 
-int sd_bus_message_new_method_call(
+_public_ int sd_bus_message_new_method_call(
                 sd_bus *bus,
                 const char *destination,
                 const char *path,
@@ -496,18 +491,12 @@ int sd_bus_message_new_method_call(
         sd_bus_message *t;
         int r;
 
-        if (destination && !service_name_is_valid(destination))
-                return -EINVAL;
-        if (!object_path_is_valid(path))
-                return -EINVAL;
-        if (interface && !interface_name_is_valid(interface))
-                return -EINVAL;
-        if (!member_name_is_valid(member))
-                return -EINVAL;
-        if (!m)
-                return -EINVAL;
-        if (bus && bus->state == BUS_UNSET)
-                return -ENOTCONN;
+        assert_return(!bus || bus->state != BUS_UNSET, -ENOTCONN);
+        assert_return(!destination || service_name_is_valid(destination), -EINVAL);
+        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);
 
         t = message_new(bus, SD_BUS_MESSAGE_METHOD_CALL);
         if (!t)
@@ -549,16 +538,11 @@ static int message_new_reply(
         sd_bus_message *t;
         int r;
 
-        if (!call)
-                return -EINVAL;
-        if (!call->sealed)
-                return -EPERM;
-        if (call->header->type != SD_BUS_MESSAGE_METHOD_CALL)
-                return -EINVAL;
-        if (!m)
-                return -EINVAL;
-        if (bus && bus->state == BUS_UNSET)
-                return -ENOTCONN;
+        assert_return(!bus || bus->state != BUS_UNSET, -ENOTCONN);
+        assert_return(call, -EINVAL);
+        assert_return(call->sealed, -EPERM);
+        assert_return(call->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
+        assert_return(m, -EINVAL);
 
         t = message_new(bus, type);
         if (!t)
@@ -587,7 +571,7 @@ fail:
         return r;
 }
 
-int sd_bus_message_new_method_return(
+_public_ int sd_bus_message_new_method_return(
                 sd_bus *bus,
                 sd_bus_message *call,
                 sd_bus_message **m) {
@@ -595,7 +579,7 @@ int sd_bus_message_new_method_return(
         return message_new_reply(bus, call, SD_BUS_MESSAGE_METHOD_RETURN, m);
 }
 
-int sd_bus_message_new_method_error(
+_public_ int sd_bus_message_new_method_error(
                 sd_bus *bus,
                 sd_bus_message *call,
                 const sd_bus_error *e,
@@ -604,10 +588,8 @@ int sd_bus_message_new_method_error(
         sd_bus_message *t;
         int r;
 
-        if (!sd_bus_error_is_set(e))
-                return -EINVAL;
-        if (!m)
-                return -EINVAL;
+        assert_return(sd_bus_error_is_set(e), -EINVAL);
+        assert_return(m, -EINVAL);
 
         r = message_new_reply(bus, call, SD_BUS_MESSAGE_METHOD_ERROR, &t);
         if (r < 0)
@@ -631,7 +613,7 @@ fail:
         return r;
 }
 
-int sd_bus_message_new_method_errorf(
+_public_ int sd_bus_message_new_method_errorf(
                 sd_bus *bus,
                 sd_bus_message *call,
                 sd_bus_message **m,
@@ -656,7 +638,7 @@ int sd_bus_message_new_method_errorf(
         return sd_bus_message_new_method_error(bus, call, &error, m);
 }
 
-int sd_bus_message_new_method_errno(
+_public_ int sd_bus_message_new_method_errno(
                 sd_bus *bus,
                 sd_bus_message *call,
                 int error,
@@ -673,7 +655,7 @@ int sd_bus_message_new_method_errno(
         return sd_bus_message_new_method_error(bus, call, &berror, m);
 }
 
-int sd_bus_message_new_method_errnof(
+_public_ int sd_bus_message_new_method_errnof(
                 sd_bus *bus,
                 sd_bus_message *call,
                 sd_bus_message **m,
@@ -742,9 +724,8 @@ fail:
         return r;
 }
 
-sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
-        if (!m)
-                return NULL;
+_public_ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
+        assert_return(m, NULL);
 
         assert(m->n_ref > 0);
         m->n_ref++;
@@ -752,9 +733,8 @@ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
         return m;
 }
 
-sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
-        if (!m)
-                return NULL;
+_public_ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
+        assert_return(m, NULL);
 
         assert(m->n_ref > 0);
         m->n_ref--;
@@ -765,242 +745,188 @@ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
         return NULL;
 }
 
-int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
-        if (!m)
-                return -EINVAL;
-        if (!type)
-                return -EINVAL;
+_public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
+        assert_return(m, -EINVAL);
+        assert_return(type, -EINVAL);
 
         *type = m->header->type;
         return 0;
 }
 
-int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) {
-        if (!m)
-                return -EINVAL;
-        if (!serial)
-                return -EINVAL;
-        if (m->header->serial == 0)
-                return -ENOENT;
+_public_ int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) {
+        assert_return(m, -EINVAL);
+        assert_return(serial, -EINVAL);
+        assert_return(m->header->serial != 0, -ENOENT);
 
         *serial = BUS_MESSAGE_SERIAL(m);
         return 0;
 }
 
-int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) {
-        if (!m)
-                return -EINVAL;
-        if (!serial)
-                return -EINVAL;
-        if (m->reply_serial == 0)
-                return -ENOENT;
+_public_ int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) {
+        assert_return(m, -EINVAL);
+        assert_return(serial, -EINVAL);
+        assert_return(m->reply_serial != 0, -ENOENT);
 
         *serial = m->reply_serial;
         return 0;
 }
 
-int sd_bus_message_get_no_reply(sd_bus_message *m) {
-        if (!m)
-                return -EINVAL;
+_public_ int sd_bus_message_get_no_reply(sd_bus_message *m) {
+        assert_return(m, -EINVAL);
 
         return m->header->type == SD_BUS_MESSAGE_METHOD_CALL ? !!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) : 0;
 }
 
-const char *sd_bus_message_get_path(sd_bus_message *m) {
-        if (!m)
-                return NULL;
+_public_ const char *sd_bus_message_get_path(sd_bus_message *m) {
+        assert_return(m, NULL);
 
         return m->path;
 }
 
-const char *sd_bus_message_get_interface(sd_bus_message *m) {
-        if (!m)
-                return NULL;
+_public_ const char *sd_bus_message_get_interface(sd_bus_message *m) {
+        assert_return(m, NULL);
 
         return m->interface;
 }
 
-const char *sd_bus_message_get_member(sd_bus_message *m) {
-        if (!m)
-                return NULL;
+_public_ const char *sd_bus_message_get_member(sd_bus_message *m) {
+        assert_return(m, NULL);
 
         return m->member;
 }
-const char *sd_bus_message_get_destination(sd_bus_message *m) {
-        if (!m)
-                return NULL;
+
+_public_ const char *sd_bus_message_get_destination(sd_bus_message *m) {
+        assert_return(m, NULL);
 
         return m->destination;
 }
 
-const char *sd_bus_message_get_sender(sd_bus_message *m) {
-        if (!m)
-                return NULL;
+_public_ const char *sd_bus_message_get_sender(sd_bus_message *m) {
+        assert_return(m, NULL);
 
         return m->sender;
 }
 
-const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
-        if (!m)
-                return NULL;
-
-        if (!sd_bus_error_is_set(&m->error))
-                return NULL;
+_public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
+        assert_return(m, NULL);
+        assert_return(sd_bus_error_is_set(&m->error), NULL);
 
         return &m->error;
 }
 
-int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) {
-        if (!m)
-                return -EINVAL;
-        if (!uid)
-                return -EINVAL;
-        if (!m->uid_valid)
-                return -ESRCH;
+_public_ int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) {
+        assert_return(m, -EINVAL);
+        assert_return(uid, -EINVAL);
+        assert_return(m->uid_valid, -ESRCH);
 
         *uid = m->uid;
         return 0;
 }
 
-int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) {
-        if (!m)
-                return -EINVAL;
-        if (!gid)
-                return -EINVAL;
-        if (!m->gid_valid)
-                return -ESRCH;
+_public_ int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) {
+        assert_return(m, -EINVAL);
+        assert_return(gid, -EINVAL);
+        assert_return(m->gid_valid, -ESRCH);
 
         *gid = m->gid;
         return 0;
 }
 
-int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) {
-        if (!m)
-                return -EINVAL;
-        if (!pid)
-                return -EINVAL;
-        if (m->pid <= 0)
-                return -ESRCH;
+_public_ int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) {
+        assert_return(m, -EINVAL);
+        assert_return(pid, -EINVAL);
+        assert_return(m->pid > 0, -ESRCH);
 
         *pid = m->pid;
         return 0;
 }
 
-int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) {
-        if (!m)
-                return -EINVAL;
-        if (!tid)
-                return -EINVAL;
-        if (m->tid <= 0)
-                return -ESRCH;
+_public_ int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) {
+        assert_return(m, -EINVAL);
+        assert_return(tid, -EINVAL);
+        assert_return(m->tid > 0, -ESRCH);
 
         *tid = m->tid;
         return 0;
 }
 
-int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) {
-        if (!m)
-                return -EINVAL;
-        if (!usec)
-                return -EINVAL;
-        if (m->pid_starttime <= 0)
-                return -ESRCH;
+_public_ int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) {
+        assert_return(m, -EINVAL);
+        assert_return(usec, -EINVAL);
+        assert_return(m->pid_starttime > 0, -ESRCH);
 
         *usec = m->pid_starttime;
         return 0;
 }
 
-int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
-        if (!m)
-                return -EINVAL;
-        if (!m->label)
-                return -ESRCH;
+_public_ int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
+        assert_return(m, -EINVAL);
+        assert_return(m->label, -ESRCH);
 
         *ret = m->label;
         return 0;
 }
 
-int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
-        if (!m)
-                return -EINVAL;
-        if (!usec)
-                return -EINVAL;
-        if (m->monotonic <= 0)
-                return -ESRCH;
+_public_ int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
+        assert_return(m, -EINVAL);
+        assert_return(usec, -EINVAL);
+        assert_return(m->monotonic > 0, -ESRCH);
 
         *usec = m->monotonic;
         return 0;
 }
 
-int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
-        if (!m)
-                return -EINVAL;
-        if (!usec)
-                return -EINVAL;
-        if (m->realtime <= 0)
-                return -ESRCH;
+_public_ int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
+        assert_return(m, -EINVAL);
+        assert_return(usec, -EINVAL);
+        assert_return(m->realtime > 0, -ESRCH);
 
         *usec = m->realtime;
         return 0;
 }
 
-int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) {
-        if (!m)
-                return -EINVAL;
-        if (!ret)
-                return -EINVAL;
-        if (!m->comm)
-                return -ESRCH;
+_public_ int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) {
+        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
+        assert_return(m->comm, -ESRCH);
 
         *ret = m->comm;
         return 0;
 }
 
-int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) {
-        if (!m)
-                return -EINVAL;
-        if (!ret)
-                return -EINVAL;
-        if (!m->tid_comm)
-                return -ESRCH;
+_public_ int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) {
+        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
+        assert_return(m->tid_comm, -ESRCH);
 
         *ret = m->tid_comm;
         return 0;
 }
 
-int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) {
-        if (!m)
-                return -EINVAL;
-        if (!ret)
-                return -EINVAL;
-        if (!m->exe)
-                return -ESRCH;
+_public_ int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) {
+        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
+        assert_return(m->exe, -ESRCH);
 
         *ret = m->exe;
         return 0;
 }
 
-int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) {
-        if (!m)
-                return -EINVAL;
-        if (!ret)
-                return -EINVAL;
-        if (!m->cgroup)
-                return -ESRCH;
+_public_ int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) {
+        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
+        assert_return(m->cgroup, -ESRCH);
 
         *ret = m->cgroup;
         return 0;
 }
 
-int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
         int r;
 
-        if (!m)
-                return -EINVAL;
-        if (!ret)
-                return -EINVAL;
-        if (!m->cgroup)
-                return -ESRCH;
+        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
+        assert_return(m->cgroup, -ESRCH);
 
         if (!m->unit) {
                 r = cg_path_get_unit(m->cgroup, &m->unit);
@@ -1012,15 +938,12 @@ int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
         return 0;
 }
 
-int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
         int r;
 
-        if (!m)
-                return -EINVAL;
-        if (!ret)
-                return -EINVAL;
-        if (!m->cgroup)
-                return -ESRCH;
+        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
+        assert_return(m->cgroup, -ESRCH);
 
         if (!m->user_unit) {
                 r = cg_path_get_user_unit(m->cgroup, &m->user_unit);
@@ -1032,15 +955,12 @@ int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
         return 0;
 }
 
-int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
         int r;
 
-        if (!m)
-                return -EINVAL;
-        if (!ret)
-                return -EINVAL;
-        if (!m->cgroup)
-                return -ESRCH;
+        assert_return(m, -EINVAL);
+        assert_return(ret, -EINVAL);
+        assert_return(m->cgroup, -ESRCH);
 
         if (!m->session) {
                 r = cg_path_get_session(m->cgroup, &m->session);
@@ -1052,27 +972,21 @@ int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
         return 0;
 }
 
-int sd_bus_message_get_owner_uid(sd_bus_message *m, uid_t *uid) {
-        if (!m)
-                return -EINVAL;
-        if (!uid)
-                return -EINVAL;
-        if (!m->cgroup)
-                return -ESRCH;
+_public_ int sd_bus_message_get_owner_uid(sd_bus_message *m, uid_t *uid) {
+        assert_return(m, -EINVAL);
+        assert_return(uid, -EINVAL);
+        assert_return(m->cgroup, -ESRCH);
 
         return cg_path_get_owner_uid(m->cgroup, uid);
 }
 
-int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
+_public_ int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
         size_t n, i;
         const char *p;
         bool first;
 
-        if (!m)
-                return -EINVAL;
-
-        if (!m->cmdline)
-                return -ENOENT;
+        assert_return(m, -EINVAL);
+        assert_return(m->cmdline, -ESRCH);
 
         for (p = m->cmdline, n = 0; p < m->cmdline + m->cmdline_length; p++)
                 if (*p == 0)
@@ -1095,39 +1009,30 @@ int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
         return 0;
 }
 
-int sd_bus_message_get_audit_sessionid(sd_bus_message *m, uint32_t *sessionid) {
-        if (!m)
-                return -EINVAL;
-        if (!sessionid)
-                return -EINVAL;
-        if (!m->audit)
-                return -ESRCH;
+_public_ int sd_bus_message_get_audit_sessionid(sd_bus_message *m, uint32_t *sessionid) {
+        assert_return(m, -EINVAL);
+        assert_return(sessionid, -EINVAL);
+        assert_return(m->audit, -ESRCH);
 
         *sessionid = m->audit->sessionid;
         return 0;
 }
 
-int sd_bus_message_get_audit_loginuid(sd_bus_message *m, uid_t *uid) {
-        if (!m)
-                return -EINVAL;
-        if (!uid)
-                return -EINVAL;
-        if (!m->audit)
-                return -ESRCH;
+_public_ int sd_bus_message_get_audit_loginuid(sd_bus_message *m, uid_t *uid) {
+        assert_return(m, -EINVAL);
+        assert_return(uid, -EINVAL);
+        assert_return(m->audit, -ESRCH);
 
         *uid = m->audit->loginuid;
         return 0;
 }
 
-int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) {
+_public_ int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) {
         unsigned sz;
 
-        if (!m)
-                return -EINVAL;
-        if (capability < 0)
-                return -EINVAL;
-        if (!m->capability)
-                return -ESRCH;
+        assert_return(m, -EINVAL);
+        assert_return(capability < 0, -EINVAL);
+        assert_return(!m->capability, -ESRCH);
 
         sz = m->capability_size / 4;
         if ((unsigned) capability >= sz*8)
@@ -1136,9 +1041,10 @@ int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) {
         return !!(m->capability[2 * sz + (capability / 8)] & (1 << (capability % 8)));
 }
 
-int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member) {
-        if (!m)
-                return -EINVAL;
+_public_ int sd_bus_message_is_signal(sd_bus_message *m,
+                                      const char *interface,
+                                      const char *member) {
+        assert_return(m, -EINVAL);
 
         if (m->header->type != SD_BUS_MESSAGE_SIGNAL)
                 return 0;
@@ -1152,9 +1058,10 @@ int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const cha
         return 1;
 }
 
-int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, const char *member) {
-        if (!m)
-                return -EINVAL;
+_public_ int sd_bus_message_is_method_call(sd_bus_message *m,
+                                           const char *interface,
+                                           const char *member) {
+        assert_return(m, -EINVAL);
 
         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
                 return 0;
@@ -1168,9 +1075,8 @@ int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, cons
         return 1;
 }
 
-int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
-        if (!m)
-                return -EINVAL;
+_public_ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
+        assert_return(m, -EINVAL);
 
         if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
                 return 0;
@@ -1181,13 +1087,10 @@ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
         return 1;
 }
 
-int sd_bus_message_set_no_reply(sd_bus_message *m, int b) {
-        if (!m)
-                return -EINVAL;
-        if (m->sealed)
-                return -EPERM;
-        if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
-                return -EPERM;
+_public_ int sd_bus_message_set_no_reply(sd_bus_message *m, int b) {
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EPERM);
 
         if (b)
                 m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
@@ -1419,16 +1322,11 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
         uint32_t fdi = 0;
         int r;
 
-        if (!m)
-                return -EINVAL;
-        if (!p)
-                return -EINVAL;
-        if (m->sealed)
-                return -EPERM;
-        if (!bus_type_is_basic(type))
-                return -EINVAL;
-        if (m->poisoned)
-                return -ESTALE;
+        assert_return(m, -EINVAL);
+        assert_return(p, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(bus_type_is_basic(type), -EINVAL);
+        assert_return(!m->poisoned, -ESTALE);
 
         c = message_get_container(m);
 
@@ -1454,14 +1352,29 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
         switch (type) {
 
         case SD_BUS_TYPE_STRING:
+                /* To make things easy we'll serialize a NULL string
+                 * into the empty string */
+                p = strempty(p);
+
+                /* Fall through... */
         case SD_BUS_TYPE_OBJECT_PATH:
 
+                if (!p) {
+                        r = -EINVAL;
+                        goto fail;
+                }
+
                 align = 4;
                 sz = 4 + strlen(p) + 1;
                 break;
 
         case SD_BUS_TYPE_SIGNATURE:
 
+                if (!p) {
+                        r = -EINVAL;
+                        goto fail;
+                }
+
                 align = 1;
                 sz = 1 + strlen(p) + 1;
                 break;
@@ -1566,22 +1479,18 @@ fail:
         return r;
 }
 
-int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) {
+_public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) {
         return message_append_basic(m, type, p, NULL);
 }
 
-int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s) {
+_public_ int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s) {
         struct bus_container *c;
         void *a;
 
-        if (!m)
-                return -EINVAL;
-        if (!s)
-                return -EINVAL;
-        if (m->sealed)
-                return -EPERM;
-        if (m->poisoned)
-                return -ESTALE;
+        assert_return(m, -EINVAL);
+        assert_return(s, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(!m->poisoned, -ESTALE);
 
         c = message_get_container(m);
 
@@ -1836,7 +1745,7 @@ static int bus_message_open_dict_entry(
         return 0;
 }
 
-int sd_bus_message_open_container(
+_public_ int sd_bus_message_open_container(
                 sd_bus_message *m,
                 char type,
                 const char *contents) {
@@ -1847,14 +1756,10 @@ int sd_bus_message_open_container(
         size_t before;
         int r;
 
-        if (!m)
-                return -EINVAL;
-        if (m->sealed)
-                return -EPERM;
-        if (!contents)
-                return -EINVAL;
-        if (m->poisoned)
-                return -ESTALE;
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(contents, -EINVAL);
+        assert_return(!m->poisoned, -ESTALE);
 
         /* Make sure we have space for one more container */
         w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1));
@@ -1906,17 +1811,13 @@ int sd_bus_message_open_container(
         return 0;
 }
 
-int sd_bus_message_close_container(sd_bus_message *m) {
+_public_ int sd_bus_message_close_container(sd_bus_message *m) {
         struct bus_container *c;
 
-        if (!m)
-                return -EINVAL;
-        if (m->sealed)
-                return -EPERM;
-        if (m->n_containers <= 0)
-                return -EINVAL;
-        if (m->poisoned)
-                return -ESTALE;
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(m->n_containers > 0, -EINVAL);
+        assert_return(!m->poisoned, -ESTALE);
 
         c = message_get_container(m);
         if (c->enclosing != SD_BUS_TYPE_ARRAY)
@@ -2165,18 +2066,14 @@ int bus_message_append_ap(
         return 0;
 }
 
-int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
+_public_ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
         va_list ap;
         int r;
 
-        if (!m)
-                return -EINVAL;
-        if (m->sealed)
-                return -EPERM;
-        if (m->poisoned)
-                return -ESTALE;
-        if (!types)
-                return 0;
+        assert_return(m, -EINVAL);
+        assert_return(types, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(!m->poisoned, -ESTALE);
 
         va_start(ap, types);
         r = bus_message_append_ap(m, types, ap);
@@ -2185,21 +2082,19 @@ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
         return r;
 }
 
-int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t size, void **ptr) {
+_public_ int sd_bus_message_append_array_space(sd_bus_message *m,
+                                               char type,
+                                               size_t size,
+                                               void **ptr) {
         ssize_t align, sz;
         void *a;
         int r;
 
-        if (!m)
-                return -EINVAL;
-        if (m->sealed)
-                return -EPERM;
-        if (!bus_type_is_trivial(type))
-                return -EINVAL;
-        if (!ptr && size > 0)
-                return -EINVAL;
-        if (m->poisoned)
-                return -ESTALE;
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(bus_type_is_trivial(type), -EINVAL);
+        assert_return(ptr || size == 0, -EINVAL);
+        assert_return(!m->poisoned, -ESTALE);
 
         align = bus_type_get_alignment(type);
         sz = bus_type_get_size(type);
@@ -2226,12 +2121,18 @@ int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t size,
         return 0;
 }
 
-int sd_bus_message_append_array(sd_bus_message *m, char type, const void *ptr, size_t size) {
+_public_ int sd_bus_message_append_array(sd_bus_message *m,
+                                         char type,
+                                         const void *ptr,
+                                         size_t size) {
         int r;
         void *p;
 
-        if (!ptr && size > 0)
-                return -EINVAL;
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(bus_type_is_trivial(type), -EINVAL);
+        assert_return(ptr || size == 0, -EINVAL);
+        assert_return(!m->poisoned, -ESTALE);
 
         r = sd_bus_message_append_array_space(m, type, size, &p);
         if (r < 0)
@@ -2243,7 +2144,9 @@ int sd_bus_message_append_array(sd_bus_message *m, char type, const void *ptr, s
         return 0;
 }
 
-int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, sd_memfd *memfd) {
+_public_ int sd_bus_message_append_array_memfd(sd_bus_message *m,
+                                               char type,
+                                               sd_memfd *memfd) {
         _cleanup_close_ int copy_fd = -1;
         struct bus_body_part *part;
         ssize_t align, sz;
@@ -2309,7 +2212,7 @@ int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, sd_memfd *me
         return sd_bus_message_close_container(m);
 }
 
-int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) {
+_public_ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) {
         _cleanup_close_ int copy_fd = -1;
         struct bus_body_part *part;
         struct bus_container *c;
@@ -2385,7 +2288,7 @@ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) {
         return 0;
 }
 
-int sd_bus_message_append_strv(sd_bus_message *m, char **l) {
+_public_ int sd_bus_message_append_strv(sd_bus_message *m, char **l) {
         char **i;
         int r;
 
@@ -2491,6 +2394,15 @@ static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align,
         return 1;
 }
 
+static bool message_end_of_signature(sd_bus_message *m) {
+        struct bus_container *c;
+
+        assert(m);
+
+        c = message_get_container(m);
+        return !c->signature || c->signature[c->index] == 0;
+}
+
 static bool message_end_of_array(sd_bus_message *m, size_t index) {
         struct bus_container *c;
 
@@ -2503,6 +2415,22 @@ static bool message_end_of_array(sd_bus_message *m, size_t index) {
         return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
 }
 
+int sd_bus_message_at_end(sd_bus_message *m, int complete) {
+        assert_return(m, -EINVAL);
+        assert_return(m->sealed, -EPERM);
+
+        if (complete && m->n_containers > 0)
+                return false;
+
+        if (message_end_of_signature(m))
+                return true;
+
+        if (message_end_of_array(m, m->rindex))
+                return true;
+
+        return false;
+}
+
 static struct bus_body_part* find_part(sd_bus_message *m, size_t index, size_t sz, void **p) {
         struct bus_body_part *part;
         size_t begin;
@@ -2640,26 +2568,22 @@ static bool validate_object_path(const char *s, size_t l) {
         return true;
 }
 
-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 *p) {
         struct bus_container *c;
         void *q;
         int r;
 
-        if (!m)
-                return -EINVAL;
-        if (!m->sealed)
-                return -EPERM;
-        if (!bus_type_is_basic(type))
-                return -EINVAL;
-
-        c = message_get_container(m);
+        assert_return(m, -EINVAL);
+        assert_return(m->sealed, -EPERM);
+        assert_return(bus_type_is_basic(type), -EINVAL);
 
-        if (!c->signature || c->signature[c->index] == 0)
+        if (message_end_of_signature(m))
                 return -ENXIO;
 
         if (message_end_of_array(m, m->rindex))
                 return 0;
 
+        c = message_get_container(m);
         if (c->signature[c->index] != type)
                 return -ENXIO;
 
@@ -2745,7 +2669,7 @@ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
 
                 case SD_BUS_TYPE_BOOLEAN:
                         if (p)
-                                *(unsigned*) p = !!*(uint32_t*) q;
+                                *(int*) p = !!*(uint32_t*) q;
                         break;
 
                 case SD_BUS_TYPE_INT16:
@@ -2975,7 +2899,9 @@ static int bus_message_enter_dict_entry(
         return 1;
 }
 
-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) {
         struct bus_container *c, *w;
         uint32_t *array_size = NULL;
         char *signature;
@@ -3029,14 +2955,14 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con
                 return -ENOMEM;
         m->containers = w;
 
-        c = message_get_container(m);
-
-        if (!c->signature || c->signature[c->index] == 0)
+        if (message_end_of_signature(m))
                 return -ENXIO;
 
         if (message_end_of_array(m, m->rindex))
                 return 0;
 
+        c = message_get_container(m);
+
         signature = strdup(contents);
         if (!signature)
                 return -ENOMEM;
@@ -3072,15 +2998,12 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con
         return 1;
 }
 
-int sd_bus_message_exit_container(sd_bus_message *m) {
+_public_ int sd_bus_message_exit_container(sd_bus_message *m) {
         struct bus_container *c;
 
-        if (!m)
-                return -EINVAL;
-        if (!m->sealed)
-                return -EPERM;
-        if (m->n_containers <= 0)
-                return -EINVAL;
+        assert_return(m, -EINVAL);
+        assert_return(m->sealed, -EPERM);
+        assert_return(m->n_containers > 0, -EINVAL);
 
         c = message_get_container(m);
         if (c->enclosing == SD_BUS_TYPE_ARRAY) {
@@ -3123,21 +3046,21 @@ static void message_quit_container(sd_bus_message *m) {
         c->index = c->saved_index;
 }
 
-int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) {
+_public_ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) {
         struct bus_container *c;
         int r;
 
         assert_return(m, -EINVAL);
         assert_return(m->sealed, -EPERM);
 
-        c = message_get_container(m);
-
-        if (!c->signature || c->signature[c->index] == 0)
+        if (message_end_of_signature(m))
                 goto eof;
 
         if (message_end_of_array(m, m->rindex))
                 goto eof;
 
+        c = message_get_container(m);
+
         if (bus_type_is_basic(c->signature[c->index])) {
                 if (contents)
                         *contents = NULL;
@@ -3237,19 +3160,17 @@ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **content
 
 eof:
         if (type)
-                *type = c->enclosing;
+                *type = 0;
         if (contents)
                 *contents = NULL;
         return 0;
 }
 
-int sd_bus_message_rewind(sd_bus_message *m, int complete) {
+_public_ int sd_bus_message_rewind(sd_bus_message *m, int complete) {
         struct bus_container *c;
 
-        if (!m)
-                return -EINVAL;
-        if (!m->sealed)
-                return -EPERM;
+        assert_return(m, -EINVAL);
+        assert_return(m->sealed, -EPERM);
 
         if (complete) {
                 message_reset_containers(m);
@@ -3464,7 +3385,7 @@ static int message_read_ap(
         return 1;
 }
 
-int sd_bus_message_read(sd_bus_message *m, const char *types, ...) {
+_public_ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) {
         va_list ap;
         int r;
 
@@ -3479,7 +3400,7 @@ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) {
         return r;
 }
 
-int sd_bus_message_skip(sd_bus_message *m, const char *types) {
+_public_ int sd_bus_message_skip(sd_bus_message *m, const char *types) {
         int r;
 
         assert_return(m, -EINVAL);
@@ -3621,25 +3542,22 @@ int sd_bus_message_skip(sd_bus_message *m, const char *types) {
         }
 }
 
-int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ptr, size_t *size) {
+_public_ int sd_bus_message_read_array(sd_bus_message *m,
+                                       char type,
+                                       const void **ptr,
+                                       size_t *size) {
         struct bus_container *c;
         void *p;
         size_t sz;
         ssize_t align;
         int r;
 
-        if (!m)
-                return -EINVAL;
-        if (!m->sealed)
-                return -EPERM;
-        if (!bus_type_is_trivial(type))
-                return -EINVAL;
-        if (!ptr)
-                return -EINVAL;
-        if (!size)
-                return -EINVAL;
-        if (BUS_MESSAGE_NEED_BSWAP(m))
-                return -ENOTSUP;
+        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(!BUS_MESSAGE_NEED_BSWAP(m), -ENOTSUP);
 
         align = bus_type_get_alignment(type);
         if (align < 0)
@@ -4165,15 +4083,11 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) {
         return 0;
 }
 
-int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) {
-        if (!m)
-                return -EINVAL;
-        if (!destination)
-                return -EINVAL;
-        if (m->sealed)
-                return -EPERM;
-        if (m->destination)
-                return -EEXIST;
+_public_ int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) {
+        assert_return(m, -EINVAL);
+        assert_return(destination, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(!m->destination, -EEXIST);
 
         return message_append_field_string(m, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination);
 }
@@ -4510,7 +4424,7 @@ int bus_message_read_strv_extend(sd_bus_message *m, char ***l) {
         return 0;
 }
 
-int sd_bus_message_read_strv(sd_bus_message *m, char ***l) {
+_public_ int sd_bus_message_read_strv(sd_bus_message *m, char ***l) {
         char **strv = NULL;
         int r;
 
@@ -4593,7 +4507,7 @@ int bus_header_message_size(struct bus_header *h, size_t *sum) {
         return 0;
 }
 
-int sd_bus_message_get_errno(sd_bus_message *m) {
+_public_ int sd_bus_message_get_errno(sd_bus_message *m) {
         assert_return(m, -EINVAL);
 
         if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
@@ -4602,17 +4516,16 @@ int sd_bus_message_get_errno(sd_bus_message *m) {
         return sd_bus_error_get_errno(&m->error);
 }
 
-const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) {
+_public_ const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) {
         struct bus_container *c;
 
-        if (!m)
-                return NULL;
+        assert_return(m, NULL);
 
         c = complete ? &m->root_container : message_get_container(m);
         return c->signature ?: "";
 }
 
-int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) {
+_public_ int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) {
         bool done_something = false;
         int r;
 
@@ -4691,7 +4604,7 @@ int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) {
         return done_something;
 }
 
-int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents) {
+_public_ int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents) {
         const char *c;
         char t;
         int r;