X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Flibsystemd-bus%2Fbus-message.c;h=56bf88c39412b4e92296f6208488889ed1060419;hb=1d0e3c98840d89ec0a4dc521663320632a8516e7;hp=b26d446578951cd5b75dd3cc72e63294b8efb84f;hpb=938bcbab125298b9c49946ca0bd0b47890e4d140;p=elogind.git

diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c
index b26d44657..56bf88c39 100644
--- a/src/libsystemd-bus/bus-message.c
+++ b/src/libsystemd-bus/bus-message.c
@@ -129,7 +129,7 @@ static void message_free(sd_bus_message *m) {
                 uint64_t off;
 
                 off = (uint8_t *)m->kdbus - (uint8_t *)m->bus->kdbus_buffer;
-                ioctl(m->bus->input_fd, KDBUS_CMD_MSG_RELEASE, &off);
+                ioctl(m->bus->input_fd, KDBUS_CMD_FREE, &off);
         }
 
         if (m->bus)
@@ -143,16 +143,12 @@ static void message_free(sd_bus_message *m) {
         if (m->iovec != m->iovec_fixed)
                 free(m->iovec);
 
-        free(m->cmdline_array);
-
         message_reset_containers(m);
         free(m->root_container.signature);
 
         free(m->peeked_signature);
 
-        free(m->unit);
-        free(m->user_unit);
-        free(m->session);
+        bus_creds_done(&m->creds);
         free(m);
 }
 
@@ -305,6 +301,7 @@ static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x)
 }
 
 int bus_message_from_header(
+                sd_bus *bus,
                 void *buffer,
                 size_t length,
                 int *fds,
@@ -357,22 +354,28 @@ int bus_message_from_header(
         m->n_fds = n_fds;
 
         if (ucred) {
-                m->uid = ucred->uid;
-                m->pid = ucred->pid;
-                m->gid = ucred->gid;
-                m->uid_valid = m->gid_valid = true;
+                m->creds.uid = ucred->uid;
+                m->creds.pid = ucred->pid;
+                m->creds.gid = ucred->gid;
+                m->creds.mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID;
         }
 
         if (label) {
-                m->label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
-                memcpy(m->label, label, label_sz + 1);
+                m->creds.label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
+                memcpy(m->creds.label, label, label_sz + 1);
+
+                m->creds.mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
         }
 
+        if (bus)
+                m->bus = sd_bus_ref(bus);
+
         *ret = m;
         return 0;
 }
 
 int bus_message_from_malloc(
+                sd_bus *bus,
                 void *buffer,
                 size_t length,
                 int *fds,
@@ -382,9 +385,10 @@ int bus_message_from_malloc(
                 sd_bus_message **ret) {
 
         sd_bus_message *m;
+        size_t sz;
         int r;
 
-        r = bus_message_from_header(buffer, length, fds, n_fds, ucred, label, 0, &m);
+        r = bus_message_from_header(bus, buffer, length, fds, n_fds, ucred, label, 0, &m);
         if (r < 0)
                 return r;
 
@@ -393,11 +397,14 @@ int bus_message_from_malloc(
                 goto fail;
         }
 
-        m->n_body_parts = 1;
-        m->body.data = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
-        m->body.size = length - sizeof(struct bus_header) - ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
-        m->body.sealed = true;
-        m->body.memfd = -1;
+        sz = length - sizeof(struct bus_header) - ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
+        if (sz > 0) {
+                m->n_body_parts = 1;
+                m->body.data = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
+                m->body.size = sz;
+                m->body.sealed = true;
+                m->body.memfd = -1;
+        }
 
         m->n_iovec = 1;
         m->iovec = m->iovec_fixed;
@@ -530,7 +537,6 @@ fail:
 }
 
 static int message_new_reply(
-                sd_bus *bus,
                 sd_bus_message *call,
                 uint8_t type,
                 sd_bus_message **m) {
@@ -538,13 +544,13 @@ static int message_new_reply(
         sd_bus_message *t;
         int r;
 
-        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(!call->bus || call->bus->state != BUS_UNSET, -ENOTCONN);
         assert_return(m, -EINVAL);
 
-        t = message_new(bus, type);
+        t = message_new(call->bus, type);
         if (!t)
                 return -ENOMEM;
 
@@ -572,15 +578,13 @@ fail:
 }
 
 _public_ int sd_bus_message_new_method_return(
-                sd_bus *bus,
                 sd_bus_message *call,
                 sd_bus_message **m) {
 
-        return message_new_reply(bus, call, SD_BUS_MESSAGE_METHOD_RETURN, m);
+        return message_new_reply(call, SD_BUS_MESSAGE_METHOD_RETURN, m);
 }
 
 _public_ int sd_bus_message_new_method_error(
-                sd_bus *bus,
                 sd_bus_message *call,
                 const sd_bus_error *e,
                 sd_bus_message **m) {
@@ -591,7 +595,7 @@ _public_ int sd_bus_message_new_method_error(
         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);
+        r = message_new_reply(call, SD_BUS_MESSAGE_METHOD_ERROR, &t);
         if (r < 0)
                 return r;
 
@@ -614,7 +618,6 @@ fail:
 }
 
 _public_ int sd_bus_message_new_method_errorf(
-                sd_bus *bus,
                 sd_bus_message *call,
                 sd_bus_message **m,
                 const char *name,
@@ -623,23 +626,18 @@ _public_ int sd_bus_message_new_method_errorf(
 
         _cleanup_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         va_list ap;
-        int r;
 
         assert_return(name, -EINVAL);
         assert_return(m, -EINVAL);
 
         va_start(ap, format);
-        r = bus_error_setfv(&error, name, format, ap);
+        bus_error_setfv(&error, name, format, ap);
         va_end(ap);
 
-        if (r < 0)
-                return r;
-
-        return sd_bus_message_new_method_error(bus, call, &error, m);
+        return sd_bus_message_new_method_error(call, &error, m);
 }
 
 _public_ int sd_bus_message_new_method_errno(
-                sd_bus *bus,
                 sd_bus_message *call,
                 int error,
                 const sd_bus_error *p,
@@ -648,15 +646,14 @@ _public_ int sd_bus_message_new_method_errno(
         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
 
         if (sd_bus_error_is_set(p))
-                return sd_bus_message_new_method_error(bus, call, p, m);
+                return sd_bus_message_new_method_error(call, p, m);
 
         sd_bus_error_set_errno(&berror, error);
 
-        return sd_bus_message_new_method_error(bus, call, &berror, m);
+        return sd_bus_message_new_method_error(call, &berror, m);
 }
 
 _public_ int sd_bus_message_new_method_errnof(
-                sd_bus *bus,
                 sd_bus_message *call,
                 sd_bus_message **m,
                 int error,
@@ -665,16 +662,12 @@ _public_ int sd_bus_message_new_method_errnof(
 
         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
         va_list ap;
-        int r;
 
         va_start(ap, format);
-        r = bus_error_set_errnofv(&berror, error, format, ap);
+        bus_error_set_errnofv(&berror, error, format, ap);
         va_end(ap);
 
-        if (r < 0)
-                return r;
-
-        return sd_bus_message_new_method_error(bus, call, &berror, m);
+        return sd_bus_message_new_method_error(call, &berror, m);
 }
 
 int bus_message_new_synthetic_error(
@@ -777,6 +770,12 @@ _public_ int sd_bus_message_get_no_reply(sd_bus_message *m) {
         return m->header->type == SD_BUS_MESSAGE_METHOD_CALL ? !!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) : 0;
 }
 
+_public_ int sd_bus_message_get_no_auto_start(sd_bus_message *m) {
+        assert_return(m, -EINVAL);
+
+        return !!(m->header->flags & SD_BUS_MESSAGE_NO_AUTO_START);
+}
+
 _public_ const char *sd_bus_message_get_path(sd_bus_message *m) {
         assert_return(m, NULL);
 
@@ -814,63 +813,10 @@ _public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
         return &m->error;
 }
 
-_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;
-}
-
-_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;
-}
-
-_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;
-}
-
-_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;
-}
-
-_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;
-}
-
-_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;
-}
-
 _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);
+        assert_return(m->monotonic > 0, -ENODATA);
 
         *usec = m->monotonic;
         return 0;
@@ -879,166 +825,19 @@ _public_ int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t
 _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);
+        assert_return(m->realtime > 0, -ENODATA);
 
         *usec = m->realtime;
         return 0;
 }
 
-_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;
-}
-
-_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;
-}
-
-_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;
-}
-
-_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;
-}
-
-_public_ int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
-        int r;
-
-        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);
-                if (r < 0)
-                        return r;
-        }
-
-        *ret = m->unit;
-        return 0;
-}
-
-_public_ int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
-        int r;
-
-        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);
-                if (r < 0)
-                        return r;
-        }
-
-        *ret = m->user_unit;
-        return 0;
-}
-
-_public_ int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
-        int r;
-
-        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);
-                if (r < 0)
-                        return r;
-        }
-
-        *ret = m->session;
-        return 0;
-}
-
-_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);
-}
-
-_public_ int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
-        size_t n, i;
-        const char *p;
-        bool first;
-
-        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)
-                        n++;
-
-        m->cmdline_array = new(char*, n + 1);
-        if (!m->cmdline_array)
-                return -ENOMEM;
-
-        for (p = m->cmdline, i = 0, first = true; p < m->cmdline + m->cmdline_length; p++) {
-                if (first)
-                        m->cmdline_array[i++] = (char*) p;
-
-                first = *p == 0;
-        }
-
-        m->cmdline_array[i] = NULL;
-        *cmdline = m->cmdline_array;
-
-        return 0;
-}
-
-_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;
-}
-
-_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;
-}
-
-_public_ int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) {
-        unsigned sz;
-
-        assert_return(m, -EINVAL);
-        assert_return(capability < 0, -EINVAL);
-        assert_return(!m->capability, -ESRCH);
+_public_ sd_bus_creds *sd_bus_message_get_creds(sd_bus_message *m) {
+        assert_return(m, NULL);
 
-        sz = m->capability_size / 4;
-        if ((unsigned) capability >= sz*8)
-                return 0;
+        if (m->creds.mask == 0)
+                return NULL;
 
-        return !!(m->capability[2 * sz + (capability / 8)] & (1 << (capability % 8)));
+        return &m->creds;
 }
 
 _public_ int sd_bus_message_is_signal(sd_bus_message *m,
@@ -1100,6 +899,18 @@ _public_ int sd_bus_message_set_no_reply(sd_bus_message *m, int b) {
         return 0;
 }
 
+_public_ int sd_bus_message_set_no_auto_start(sd_bus_message *m, int b) {
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+
+        if (b)
+                m->header->flags |= SD_BUS_MESSAGE_NO_AUTO_START;
+        else
+                m->header->flags &= ~SD_BUS_MESSAGE_NO_AUTO_START;
+
+        return 0;
+}
+
 static struct bus_container *message_get_container(sd_bus_message *m) {
         assert(m);
 
@@ -2116,7 +1927,7 @@ int bus_message_append_ap(
                         return r;
         }
 
-        return 0;
+        return 1;
 }
 
 _public_ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
@@ -3276,6 +3087,7 @@ _public_ int sd_bus_message_rewind(sd_bus_message *m, int complete) {
 
         return !isempty(c->signature);
 }
+
 static int message_read_ap(
                 sd_bus_message *m,
                 const char *types,
@@ -4002,7 +3814,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
                         if (!streq(signature, "s"))
                                 return -EBADMSG;
 
-                        r = message_peek_field_string(m, sender_name_is_valid, &ri, &m->destination);
+                        r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination);
                         break;
 
                 case SD_BUS_MESSAGE_HEADER_SENDER:
@@ -4013,7 +3825,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
                         if (!streq(signature, "s"))
                                 return -EBADMSG;
 
-                        r = message_peek_field_string(m, sender_name_is_valid, &ri, &m->sender);
+                        r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender);
                         break;
 
 
@@ -4187,272 +3999,6 @@ _public_ int sd_bus_message_set_destination(sd_bus_message *m, const char *desti
         return message_append_field_string(m, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination);
 }
 
-int bus_message_dump(sd_bus_message *m, FILE *f, bool with_header) {
-        const char *u = NULL, *uu = NULL, *s = NULL;
-        char **cmdline = NULL;
-        unsigned level = 1;
-        int r;
-        uid_t owner, audit_loginuid;
-        uint32_t audit_sessionid;
-
-        assert(m);
-
-        if (!f)
-                f = stdout;
-
-        if (with_header) {
-                fprintf(f,
-                        "Message %p\n"
-                        "\tn_ref=%u\n"
-                        "\tendian=%c\n"
-                        "\ttype=%i\n"
-                        "\tflags=%u\n"
-                        "\tversion=%u\n"
-                        "\tserial=%u\n"
-                        "\tfields_size=%u\n"
-                        "\tbody_size=%u\n"
-                        "\tpath=%s\n"
-                        "\tinterface=%s\n"
-                        "\tmember=%s\n"
-                        "\tdestination=%s\n"
-                        "\tsender=%s\n"
-                        "\tsignature=%s\n"
-                        "\treply_serial=%u\n"
-                        "\tsealed=%s\n"
-                        "\tn_body_parts=%u\n",
-                        m,
-                        m->n_ref,
-                        m->header->endian,
-                        m->header->type,
-                        m->header->flags,
-                        m->header->version,
-                        BUS_MESSAGE_SERIAL(m),
-                        BUS_MESSAGE_FIELDS_SIZE(m),
-                        BUS_MESSAGE_BODY_SIZE(m),
-                        strna(m->path),
-                        strna(m->interface),
-                        strna(m->member),
-                        strna(m->destination),
-                        strna(m->sender),
-                        strna(m->root_container.signature),
-                        m->reply_serial,
-                        yes_no(m->sealed),
-                        m->n_body_parts);
-
-                if (sd_bus_error_is_set(&m->error))
-                        fprintf(f,
-                                "\terror.name=%s\n"
-                                "\terror.message=%s\n",
-                                strna(m->error.name),
-                                strna(m->error.message));
-
-                if (m->pid != 0)
-                        fprintf(f, "\tpid=%lu\n", (unsigned long) m->pid);
-                if (m->tid != 0)
-                        fprintf(f, "\ttid=%lu\n", (unsigned long) m->tid);
-                if (m->uid_valid)
-                        fprintf(f, "\tuid=%lu\n", (unsigned long) m->uid);
-                if (m->gid_valid)
-                        fprintf(f, "\tgid=%lu\n", (unsigned long) m->gid);
-                if (m->pid_starttime != 0)
-                        fprintf(f, "\tpid_starttime=%llu\n", (unsigned long long) m->pid_starttime);
-                if (m->monotonic != 0)
-                        fprintf(f, "\tmonotonic=%llu\n", (unsigned long long) m->monotonic);
-                if (m->realtime != 0)
-                        fprintf(f, "\trealtime=%llu\n", (unsigned long long) m->realtime);
-                if (m->exe)
-                        fprintf(f, "\texe=[%s]\n", m->exe);
-                if (m->comm)
-                        fprintf(f, "\tcomm=[%s]\n", m->comm);
-                if (m->tid_comm)
-                        fprintf(f, "\ttid_comm=[%s]\n", m->tid_comm);
-                if (m->label)
-                        fprintf(f, "\tlabel=[%s]\n", m->label);
-                if (m->cgroup)
-                        fprintf(f, "\tcgroup=[%s]\n", m->cgroup);
-
-                sd_bus_message_get_unit(m, &u);
-                if (u)
-                        fprintf(f, "\tunit=[%s]\n", u);
-                sd_bus_message_get_user_unit(m, &uu);
-                if (uu)
-                        fprintf(f, "\tuser_unit=[%s]\n", uu);
-                sd_bus_message_get_session(m, &s);
-                if (s)
-                        fprintf(f, "\tsession=[%s]\n", s);
-                if (sd_bus_message_get_owner_uid(m, &owner) >= 0)
-                        fprintf(f, "\towner_uid=%lu\n", (unsigned long) owner);
-                if (sd_bus_message_get_audit_loginuid(m, &audit_loginuid) >= 0)
-                        fprintf(f, "\taudit_loginuid=%lu\n", (unsigned long) audit_loginuid);
-                if (sd_bus_message_get_audit_sessionid(m, &audit_sessionid) >= 0)
-                        fprintf(f, "\taudit_sessionid=%lu\n", (unsigned long) audit_sessionid);
-
-                r = sd_bus_message_has_effective_cap(m, 5);
-                if (r >= 0)
-                        fprintf(f, "\tCAP_KILL=%s\n", yes_no(r));
-
-                if (sd_bus_message_get_cmdline(m, &cmdline) >= 0) {
-                        char **c;
-
-                        fputs("\tcmdline=[", f);
-                        STRV_FOREACH(c, cmdline) {
-                                if (c != cmdline)
-                                        fputc(' ', f);
-
-                                fputs(*c, f);
-                        }
-
-                        fputs("]\n", f);
-                }
-        }
-
-        r = sd_bus_message_rewind(m, true);
-        if (r < 0) {
-                log_error("Failed to rewind: %s", strerror(-r));
-                return r;
-        }
-
-        fprintf(f, "MESSAGE \"%s\" {\n", strempty(m->root_container.signature));
-
-        for(;;) {
-                _cleanup_free_ char *prefix = NULL;
-                const char *contents = NULL;
-                char type;
-                union {
-                        uint8_t u8;
-                        uint16_t u16;
-                        int16_t s16;
-                        uint32_t u32;
-                        int32_t s32;
-                        uint64_t u64;
-                        int64_t s64;
-                        double d64;
-                        const char *string;
-                        int i;
-                } basic;
-
-                r = sd_bus_message_peek_type(m, &type, &contents);
-                if (r < 0) {
-                        log_error("Failed to peek type: %s", strerror(-r));
-                        return r;
-                }
-
-                if (r == 0) {
-                        if (level <= 1)
-                                break;
-
-                        r = sd_bus_message_exit_container(m);
-                        if (r < 0) {
-                                log_error("Failed to exit container: %s", strerror(-r));
-                                return r;
-                        }
-
-                        level--;
-
-                        prefix = strrep("\t", level);
-                        if (!prefix)
-                                return log_oom();
-
-                        fprintf(f, "%s};\n", prefix);
-                        continue;
-                }
-
-                prefix = strrep("\t", level);
-                if (!prefix)
-                        return log_oom();
-
-                if (bus_type_is_container(type) > 0) {
-                        r = sd_bus_message_enter_container(m, type, contents);
-                        if (r < 0) {
-                                log_error("Failed to enter container: %s", strerror(-r));
-                                return r;
-                        }
-
-                        if (type == SD_BUS_TYPE_ARRAY)
-                                fprintf(f, "%sARRAY \"%s\" {\n", prefix, contents);
-                        else if (type == SD_BUS_TYPE_VARIANT)
-                                fprintf(f, "%sVARIANT \"%s\" {\n", prefix, contents);
-                        else if (type == SD_BUS_TYPE_STRUCT)
-                                fprintf(f, "%sSTRUCT \"%s\" {\n", prefix, contents);
-                        else if (type == SD_BUS_TYPE_DICT_ENTRY)
-                                fprintf(f, "%sDICT_ENTRY \"%s\" {\n", prefix, contents);
-
-                        level ++;
-
-                        continue;
-                }
-
-                r = sd_bus_message_read_basic(m, type, &basic);
-                if (r < 0) {
-                        log_error("Failed to get basic: %s", strerror(-r));
-                        return r;
-                }
-
-                assert(r > 0);
-
-                switch (type) {
-
-                case SD_BUS_TYPE_BYTE:
-                        fprintf(f, "%sBYTE %u;\n", prefix, basic.u8);
-                        break;
-
-                case SD_BUS_TYPE_BOOLEAN:
-                        fprintf(f, "%sBOOLEAN %s;\n", prefix, yes_no(basic.i));
-                        break;
-
-                case SD_BUS_TYPE_INT16:
-                        fprintf(f, "%sINT16 %i;\n", prefix, basic.s16);
-                        break;
-
-                case SD_BUS_TYPE_UINT16:
-                        fprintf(f, "%sUINT16 %u;\n", prefix, basic.u16);
-                        break;
-
-                case SD_BUS_TYPE_INT32:
-                        fprintf(f, "%sINT32 %i;\n", prefix, basic.s32);
-                        break;
-
-                case SD_BUS_TYPE_UINT32:
-                        fprintf(f, "%sUINT32 %u;\n", prefix, basic.u32);
-                        break;
-
-                case SD_BUS_TYPE_INT64:
-                        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);
-                        break;
-
-                case SD_BUS_TYPE_DOUBLE:
-                        fprintf(f, "%sDOUBLE %g;\n", prefix, basic.d64);
-                        break;
-
-                case SD_BUS_TYPE_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);
-                        break;
-
-                case SD_BUS_TYPE_SIGNATURE:
-                        fprintf(f, "%sSIGNATURE \"%s\";\n", prefix, basic.string);
-                        break;
-
-                case SD_BUS_TYPE_UNIX_FD:
-                        fprintf(f, "%sUNIX_FD %i;\n", prefix, basic.i);
-                        break;
-
-                default:
-                        assert_not_reached("Unknown basic type.");
-                }
-        }
-
-        fprintf(f, "};\n");
-        return 0;
-}
-
 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) {
         size_t total;
         void *p, *e;
@@ -4716,3 +4262,9 @@ _public_ int sd_bus_message_verify_type(sd_bus_message *m, char type, const char
 
         return 1;
 }
+
+_public_ sd_bus *sd_bus_message_get_bus(sd_bus_message *m) {
+        assert_return(m, NULL);
+
+        return m->bus;
+}