chiark / gitweb /
~ianmdlvl / elogind.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
systemctl: make sure daemon-reload returns success
[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 e68b43bbae8ef1a21ae6b6cbfdb025fb4a05ff05..411156a12a2b8c75dba2fb232d87798ad9b215ef 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,
@@ -480,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,
@@ -571,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) {
@@ -579,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,
@@ -613,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,
@@ -638,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,
@@ -655,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,
@@ -724,7 +724,7 @@ fail:
         return r;
 }
 
-sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
+_public_ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
         assert_return(m, NULL);
 
         assert(m->n_ref > 0);
@@ -733,7 +733,7 @@ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
         return m;
 }
 
-sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
+_public_ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
         assert_return(m, NULL);
 
         assert(m->n_ref > 0);
@@ -745,7 +745,7 @@ 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) {
+_public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
         assert_return(m, -EINVAL);
         assert_return(type, -EINVAL);
 
@@ -753,7 +753,7 @@ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
         return 0;
 }
 
-int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) {
+_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);
@@ -762,7 +762,7 @@ int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) {
         return 0;
 }
 
-int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) {
+_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);
@@ -771,49 +771,50 @@ int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) {
         return 0;
 }
 
-int sd_bus_message_get_no_reply(sd_bus_message *m) {
+_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) {
+_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) {
+_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) {
+_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) {
+
+_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) {
+_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) {
+_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) {
+_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);
@@ -822,7 +823,7 @@ int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) {
         return 0;
 }
 
-int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) {
+_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);
@@ -831,7 +832,7 @@ int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) {
         return 0;
 }
 
-int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) {
+_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);
@@ -840,7 +841,7 @@ int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) {
         return 0;
 }
 
-int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) {
+_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);
@@ -849,7 +850,7 @@ int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) {
         return 0;
 }
 
-int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) {
+_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);
@@ -858,7 +859,7 @@ int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) {
         return 0;
 }
 
-int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
         assert_return(m, -EINVAL);
         assert_return(m->label, -ESRCH);
 
@@ -866,7 +867,7 @@ int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
         return 0;
 }
 
-int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
+_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);
@@ -875,7 +876,7 @@ int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
         return 0;
 }
 
-int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
+_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);
@@ -884,7 +885,7 @@ int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
         return 0;
 }
 
-int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) {
+_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);
@@ -893,7 +894,7 @@ int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) {
         return 0;
 }
 
-int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) {
+_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);
@@ -902,7 +903,7 @@ int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) {
         return 0;
 }
 
-int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) {
+_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);
@@ -911,7 +912,7 @@ int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) {
         return 0;
 }
 
-int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) {
+_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);
@@ -920,7 +921,7 @@ int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) {
         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;
 
         assert_return(m, -EINVAL);
@@ -937,7 +938,7 @@ 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;
 
         assert_return(m, -EINVAL);
@@ -954,7 +955,7 @@ 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;
 
         assert_return(m, -EINVAL);
@@ -971,7 +972,7 @@ 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) {
+_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);
@@ -979,7 +980,7 @@ int sd_bus_message_get_owner_uid(sd_bus_message *m, uid_t *uid) {
         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;
@@ -1008,7 +1009,7 @@ 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) {
+_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);
@@ -1017,7 +1018,7 @@ int sd_bus_message_get_audit_sessionid(sd_bus_message *m, uint32_t *sessionid) {
         return 0;
 }
 
-int sd_bus_message_get_audit_loginuid(sd_bus_message *m, uid_t *uid) {
+_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);
@@ -1026,7 +1027,7 @@ int sd_bus_message_get_audit_loginuid(sd_bus_message *m, uid_t *uid) {
         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;
 
         assert_return(m, -EINVAL);
@@ -1040,7 +1041,9 @@ 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) {
+_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)
@@ -1055,7 +1058,9 @@ 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) {
+_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)
@@ -1070,7 +1075,7 @@ 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) {
+_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)
@@ -1082,7 +1087,7 @@ 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) {
+_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);
@@ -1318,7 +1323,6 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
         int r;
 
         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);
@@ -1347,19 +1351,40 @@ 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;
 
         case SD_BUS_TYPE_BOOLEAN:
+
+                if (!p) {
+                        r = -EINVAL;
+                        goto fail;
+                }
+
                 align = sz = 4;
 
                 assert_cc(sizeof(int) == sizeof(uint32_t));
@@ -1371,6 +1396,11 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
         case SD_BUS_TYPE_UNIX_FD: {
                 int z, *f;
 
+                if (!p) {
+                        r = -EINVAL;
+                        goto fail;
+                }
+
                 if (!m->allow_fds) {
                         r = -ENOTSUP;
                         goto fail;
@@ -1405,6 +1435,11 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
         }
 
         default:
+                if (!p) {
+                        r = -EINVAL;
+                        goto fail;
+                }
+
                 align = bus_type_get_alignment(type);
                 sz = bus_type_get_size(type);
                 break;
@@ -1459,11 +1494,11 @@ 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;
 
@@ -1725,7 +1760,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) {
@@ -1791,7 +1826,7 @@ 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;
 
         assert_return(m, -EINVAL);
@@ -2046,7 +2081,7 @@ 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;
 
@@ -2062,7 +2097,10 @@ 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;
@@ -2098,7 +2136,10 @@ 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;
 
@@ -2118,7 +2159,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;
@@ -2184,7 +2227,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;
@@ -2260,7 +2303,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;
 
@@ -2387,7 +2430,7 @@ 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) {
+_public_ int sd_bus_message_at_end(sd_bus_message *m, int complete) {
         assert_return(m, -EINVAL);
         assert_return(m->sealed, -EPERM);
 
@@ -2540,7 +2583,7 @@ 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;
@@ -2641,7 +2684,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:
@@ -2871,7 +2914,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;
@@ -2968,12 +3013,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;
 
         assert_return(m, -EINVAL);
         assert_return(m->sealed, -EPERM);
-        assert_return(m->n_containers > 0, -EINVAL);
+        assert_return(m->n_containers > 0, -ENOENT);
 
         c = message_get_container(m);
         if (c->enclosing == SD_BUS_TYPE_ARRAY) {
@@ -3016,7 +3061,7 @@ 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;
 
@@ -3136,7 +3181,7 @@ eof:
         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;
 
         assert_return(m, -EINVAL);
@@ -3355,7 +3400,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;
 
@@ -3370,7 +3415,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);
@@ -3512,7 +3557,10 @@ 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;
@@ -3537,12 +3585,18 @@ int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ptr, si
         c = message_get_container(m);
         sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
 
-        r = message_peek_body(m, &m->rindex, align, sz, &p);
-        if (r < 0)
-                goto fail;
-        if (r == 0) {
-                r = -EBADMSG;
-                goto fail;
+        if (sz == 0)
+                /* Zero length array, let's return some aligned
+                 * pointer that is not NULL */
+                p = (uint8_t*) NULL + align;
+        else {
+                r = message_peek_body(m, &m->rindex, align, sz, &p);
+                if (r < 0)
+                        goto fail;
+                if (r == 0) {
+                        r = -EBADMSG;
+                        goto fail;
+                }
         }
 
         r = sd_bus_message_exit_container(m);
@@ -3874,7 +3928,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
                         if (!streq(signature, "s"))
                                 return -EBADMSG;
 
-                        r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination);
+                        r = message_peek_field_string(m, sender_name_is_valid, &ri, &m->destination);
                         break;
 
                 case SD_BUS_MESSAGE_HEADER_SENDER:
@@ -3885,7 +3939,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
                         if (!streq(signature, "s"))
                                 return -EBADMSG;
 
-                        r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender);
+                        r = message_peek_field_string(m, sender_name_is_valid, &ri, &m->sender);
                         break;
 
 
@@ -4050,7 +4104,7 @@ 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) {
+_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);
@@ -4184,7 +4238,7 @@ int bus_message_dump(sd_bus_message *m, FILE *f, bool with_header) {
                 return r;
         }
 
-        fprintf(f, "BEGIN_MESSAGE \"%s\" {\n", strempty(m->root_container.signature));
+        fprintf(f, "MESSAGE \"%s\" {\n", strempty(m->root_container.signature));
 
         for(;;) {
                 _cleanup_free_ char *prefix = NULL;
@@ -4208,6 +4262,7 @@ int bus_message_dump(sd_bus_message *m, FILE *f, bool with_header) {
                         log_error("Failed to peek type: %s", strerror(-r));
                         return r;
                 }
+
                 if (r == 0) {
                         if (level <= 1)
                                 break;
@@ -4224,15 +4279,7 @@ int bus_message_dump(sd_bus_message *m, FILE *f, bool with_header) {
                         if (!prefix)
                                 return log_oom();
 
-                        if (type == SD_BUS_TYPE_ARRAY)
-                                fprintf(f, "%s} END_ARRAY \n", prefix);
-                        else if (type == SD_BUS_TYPE_VARIANT)
-                                fprintf(f, "%s} END_VARIANT\n", prefix);
-                        else if (type == SD_BUS_TYPE_STRUCT)
-                                fprintf(f, "%s} END_STRUCT\n", prefix);
-                        else if (type == SD_BUS_TYPE_DICT_ENTRY)
-                                fprintf(f, "%s} END_DICT_ENTRY\n", prefix);
-
+                        fprintf(f, "%s};\n", prefix);
                         continue;
                 }
 
@@ -4248,13 +4295,13 @@ int bus_message_dump(sd_bus_message *m, FILE *f, bool with_header) {
                         }
 
                         if (type == SD_BUS_TYPE_ARRAY)
-                                fprintf(f, "%sBEGIN_ARRAY \"%s\" {\n", prefix, contents);
+                                fprintf(f, "%sARRAY \"%s\" {\n", prefix, contents);
                         else if (type == SD_BUS_TYPE_VARIANT)
-                                fprintf(f, "%sBEGIN_VARIANT \"%s\" {\n", prefix, contents);
+                                fprintf(f, "%sVARIANT \"%s\" {\n", prefix, contents);
                         else if (type == SD_BUS_TYPE_STRUCT)
-                                fprintf(f, "%sBEGIN_STRUCT \"%s\" {\n", prefix, contents);
+                                fprintf(f, "%sSTRUCT \"%s\" {\n", prefix, contents);
                         else if (type == SD_BUS_TYPE_DICT_ENTRY)
-                                fprintf(f, "%sBEGIN_DICT_ENTRY \"%s\" {\n", prefix, contents);
+                                fprintf(f, "%sDICT_ENTRY \"%s\" {\n", prefix, contents);
 
                         level ++;
 
@@ -4272,55 +4319,55 @@ int bus_message_dump(sd_bus_message *m, FILE *f, bool with_header) {
                 switch (type) {
 
                 case SD_BUS_TYPE_BYTE:
-                        fprintf(f, "%sBYTE: %u\n", prefix, basic.u8);
+                        fprintf(f, "%sBYTE %u;\n", prefix, basic.u8);
                         break;
 
                 case SD_BUS_TYPE_BOOLEAN:
-                        fprintf(f, "%sBOOLEAN: %s\n", prefix, yes_no(basic.i));
+                        fprintf(f, "%sBOOLEAN %s;\n", prefix, yes_no(basic.i));
                         break;
 
                 case SD_BUS_TYPE_INT16:
-                        fprintf(f, "%sINT16: %i\n", prefix, basic.s16);
+                        fprintf(f, "%sINT16 %i;\n", prefix, basic.s16);
                         break;
 
                 case SD_BUS_TYPE_UINT16:
-                        fprintf(f, "%sUINT16: %u\n", prefix, basic.u16);
+                        fprintf(f, "%sUINT16 %u;\n", prefix, basic.u16);
                         break;
 
                 case SD_BUS_TYPE_INT32:
-                        fprintf(f, "%sINT32: %i\n", prefix, basic.s32);
+                        fprintf(f, "%sINT32 %i;\n", prefix, basic.s32);
                         break;
 
                 case SD_BUS_TYPE_UINT32:
-                        fprintf(f, "%sUINT32: %u\n", prefix, basic.u32);
+                        fprintf(f, "%sUINT32 %u;\n", prefix, basic.u32);
                         break;
 
                 case SD_BUS_TYPE_INT64:
-                        fprintf(f, "%sINT64: %lli\n", prefix, (long long) basic.s64);
+                        fprintf(f, "%sINT64 %lli;\n", prefix, (long long) basic.s64);
                         break;
 
                 case SD_BUS_TYPE_UINT64:
-                        fprintf(f, "%sUINT64: %llu\n", prefix, (unsigned long long) basic.u64);
+                        fprintf(f, "%sUINT64 %llu;\n", prefix, (unsigned long long) basic.u64);
                         break;
 
                 case SD_BUS_TYPE_DOUBLE:
-                        fprintf(f, "%sDOUBLE: %g\n", prefix, basic.d64);
+                        fprintf(f, "%sDOUBLE %g;\n", prefix, basic.d64);
                         break;
 
                 case SD_BUS_TYPE_STRING:
-                        fprintf(f, "%sSTRING: \"%s\"\n", prefix, basic.string);
+                        fprintf(f, "%sSTRING \"%s\";\n", prefix, basic.string);
                         break;
 
                 case SD_BUS_TYPE_OBJECT_PATH:
-                        fprintf(f, "%sOBJECT_PATH: \"%s\"\n", prefix, basic.string);
+                        fprintf(f, "%sOBJECT_PATH \"%s\";\n", prefix, basic.string);
                         break;
 
                 case SD_BUS_TYPE_SIGNATURE:
-                        fprintf(f, "%sSIGNATURE: \"%s\"\n", prefix, basic.string);
+                        fprintf(f, "%sSIGNATURE \"%s\";\n", prefix, basic.string);
                         break;
 
                 case SD_BUS_TYPE_UNIX_FD:
-                        fprintf(f, "%sUNIX_FD: %i\n", prefix, basic.i);
+                        fprintf(f, "%sUNIX_FD %i;\n", prefix, basic.i);
                         break;
 
                 default:
@@ -4328,7 +4375,7 @@ int bus_message_dump(sd_bus_message *m, FILE *f, bool with_header) {
                 }
         }
 
-        fprintf(f, "} END_MESSAGE\n");
+        fprintf(f, "};\n");
         return 0;
 }
 
@@ -4388,10 +4435,10 @@ int bus_message_read_strv_extend(sd_bus_message *m, char ***l) {
         if (r < 0)
                 return r;
 
-        return 0;
+        return 1;
 }
 
-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;
 
@@ -4474,7 +4521,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)
@@ -4483,7 +4530,7 @@ 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;
 
         assert_return(m, NULL);
@@ -4492,7 +4539,7 @@ const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) {
         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;
 
@@ -4571,7 +4618,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;
Unnamed repository; edit this file 'description' to name the repository.