HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

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

140,617 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 81f78f8036f3d70b14af45edd5d008e1d7ca1d64

Lines 1–1000 of 4,752

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include "sd-bus.h"
 
#include "alloc-util.h"
#include "bus-internal.h"
#include "bus-message.h"
#include "bus-signature.h"
#include "bus-type.h"
#include "fd-util.h"
#include "iovec-util.h"
#include "log.h"
#include "memfd-util.h"
#include "memory-util.h"
#include "string-util.h"
#include "strv.h"
#include "utf8.h"
 
static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored);
static int message_parse_fields(sd_bus_message *m, bool got_ctrunc);
 
static void* adjust_pointer(const void *p, void *old_base, size_t sz, void *new_base) {
 
        if (!p)
                return NULL;
 
        if (old_base == new_base)
                return (void*) p;
 
        if ((uint8_t*) p < (uint8_t*) old_base)
                return (void*) p;
 
        if ((uint8_t*) p >= (uint8_t*) old_base + sz)
                return (void*) p;
 
        return (uint8_t*) new_base + ((uint8_t*) p - (uint8_t*) old_base);
}
 
static void message_free_part(sd_bus_message *m, BusMessageBodyPart *part) {
        assert(m);
        assert(part);
 
        if (part->memfd >= 0) {
                /* erase if requested, but only if the memfd is not sealed yet, i.e. is writable */
                if (m->sensitive && !m->sealed)
                        explicit_bzero_safe(part->data, part->size);
 
                close_and_munmap(part->memfd, part->mmap_begin, part->mapped);
        } else if (part->munmap_this)
                /* We don't erase sensitive data here, since the data is memory mapped from someone else, and
                 * we just don't know if it's OK to write to it */
                munmap(part->mmap_begin, part->mapped);
        else {
                /* Erase this if that is requested. Since this is regular memory we know we can write it. */
                if (m->sensitive)
                        explicit_bzero_safe(part->data, part->size);
 
                if (part->free_this)
                        free(part->data);
        }
 
        if (part != &m->body)
                free(part);
}
 
static void message_reset_parts(sd_bus_message *m) {
        BusMessageBodyPart *part;
 
        assert(m);
 
        part = &m->body;
        while (m->n_body_parts > 0) {
                BusMessageBodyPart *next = part->next;
                message_free_part(m, part);
                part = next;
                m->n_body_parts--;
        }
 
        m->body_end = NULL;
 
        m->cached_rindex_part = NULL;
        m->cached_rindex_part_begin = 0;
}
 
static BusMessageContainer* message_get_last_container(sd_bus_message *m) {
        assert(m);
 
        if (m->n_containers == 0)
                return &m->root_container;
 
        assert(m->containers);
        return m->containers + m->n_containers - 1;
}
 
static void message_free_last_container(sd_bus_message *m) {
        BusMessageContainer *c;
 
        c = message_get_last_container(m);
 
        free(c->signature);
        free(c->peeked_signature);
 
        /* Move to previous container, but not if we are on root container */
        if (m->n_containers > 0)
                m->n_containers--;
}
 
static void message_reset_containers(sd_bus_message *m) {
        assert(m);
 
        while (m->n_containers > 0)
                message_free_last_container(m);
 
        m->containers = mfree(m->containers);
        m->root_container.index = 0;
}
 
static sd_bus_message* message_free(sd_bus_message *m) {
        assert(m);
 
        message_reset_parts(m);
 
        if (m->free_header)
                free(m->header);
 
        /* Note that we don't unref m->bus here. That's already done by sd_bus_message_unref() as each user
         * reference to the bus message also is considered a reference to the bus connection itself. */
 
        if (m->free_fds) {
                close_many(m->fds, m->n_fds);
                free(m->fds);
        }
 
        if (m->iovec != m->iovec_fixed)
                free(m->iovec);
 
        message_reset_containers(m);
        assert(m->n_containers == 0);
        message_free_last_container(m);
 
        bus_creds_done(&m->creds);
        return mfree(m);
}
 
static void* message_extend_fields(sd_bus_message *m, size_t sz) {
        void *op, *np;
        size_t old_size, new_size, start;
 
        assert(m);
 
        if (m->poisoned)
                return NULL;
 
        old_size = sizeof(BusMessageHeader) + m->fields_size;
        start = ALIGN8(old_size);
        new_size = start + sz;
 
        if (new_size < start || new_size > UINT32_MAX)
                goto poison;
 
        if (old_size == new_size)
                return (uint8_t*) m->header + old_size;
 
        if (m->free_header) {
                np = realloc(m->header, ALIGN8(new_size));
                if (!np)
                        goto poison;
        } else {
                /* Initially, the header is allocated as part of
                 * the sd_bus_message itself, let's replace it by
                 * dynamic data */
 
                np = malloc(ALIGN8(new_size));
                if (!np)
                        goto poison;
 
                memcpy(np, m->header, sizeof(BusMessageHeader));
        }
 
        /* Zero out padding */
        if (start > old_size)
                memzero((uint8_t*) np + old_size, start - old_size);
 
        op = m->header;
        m->header = np;
        m->fields_size = new_size - sizeof(BusMessageHeader);
 
        /* Adjust quick access pointers */
        m->path = adjust_pointer(m->path, op, old_size, m->header);
        m->interface = adjust_pointer(m->interface, op, old_size, m->header);
        m->member = adjust_pointer(m->member, op, old_size, m->header);
        m->destination = adjust_pointer(m->destination, op, old_size, m->header);
        m->sender = adjust_pointer(m->sender, op, old_size, m->header);
        m->error.name = adjust_pointer(m->error.name, op, old_size, m->header);
 
        m->free_header = true;
 
        return (uint8_t*) np + start;
 
poison:
        m->poisoned = true;
        return NULL;
}
 
static int message_append_field_string(
                sd_bus_message *m,
                uint64_t h,
                char type,
                const char *s,
                const char **ret) {
 
        size_t l;
        uint8_t *p;
 
        assert(m);
 
        /* dbus only allows 8-bit header field ids */
        if (h > 0xFF)
                return -EINVAL;
 
        /* dbus doesn't allow strings over 32-bit */
        l = strlen(s);
        if (l > UINT32_MAX)
                return -EINVAL;
 
        /* Signature "(yv)" where the variant contains "s" */
 
        /* (field id byte + (signature length + signature 's' + NUL) + (string length + string + NUL)) */
        p = message_extend_fields(m, 4 + 4 + l + 1);
        if (!p)
                return -ENOMEM;
 
        p[0] = (uint8_t) h;
        p[1] = 1;
        p[2] = type;
        p[3] = 0;
 
        ((uint32_t*) p)[1] = l;
        memcpy(p + 8, s, l + 1);
 
        if (ret)
                *ret = (char*) p + 8;
 
        return 0;
}
 
static int message_append_field_signature(
                sd_bus_message *m,
                uint64_t h,
                const char *s,
                const char **ret) {
 
        size_t l;
        uint8_t *p;
 
        assert(m);
 
        /* dbus only allows 8-bit header field ids */
        if (h > 0xFF)
                return -EINVAL;
 
        /* dbus doesn't allow signatures over 8-bit */
        l = strlen(s);
        if (l > SD_BUS_MAXIMUM_SIGNATURE_LENGTH)
                return -EINVAL;
 
        /* Signature "(yv)" where the variant contains "g" */
 
        /* (field id byte + (signature length + signature 'g' + NUL) + (string length + string + NUL)) */
        p = message_extend_fields(m, 4 + 1 + l + 1);
        if (!p)
                return -ENOMEM;
 
        p[0] = (uint8_t) h;
        p[1] = 1;
        p[2] = SD_BUS_TYPE_SIGNATURE;
        p[3] = 0;
        p[4] = l;
        memcpy(p + 5, s, l + 1);
 
        if (ret)
                *ret = (const char*) p + 5;
 
        return 0;
}
 
static int message_append_field_uint32(sd_bus_message *m, uint64_t h, uint32_t x) {
        uint8_t *p;
 
        assert(m);
 
        /* dbus only allows 8-bit header field ids */
        if (h > 0xFF)
                return -EINVAL;
 
        /* (field id byte + (signature length + signature 'u' + NUL) + value) */
        p = message_extend_fields(m, 4 + 4);
        if (!p)
                return -ENOMEM;
 
        p[0] = (uint8_t) h;
        p[1] = 1;
        p[2] = 'u';
        p[3] = 0;
 
        ((uint32_t*) p)[1] = x;
 
        return 0;
}
 
static int message_append_reply_cookie(sd_bus_message *m, uint64_t cookie) {
        assert(m);
 
        /* 64-bit cookies are not supported */
        if (cookie > UINT32_MAX)
                return -EOPNOTSUPP;
 
        return message_append_field_uint32(m, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) cookie);
}
 
static int message_from_header(
                sd_bus *bus,
                void *buffer,
                size_t message_size,
                int *fds,
                size_t n_fds,
                const char *label,
                sd_bus_message **ret) {
 
        _cleanup_free_ sd_bus_message *m = NULL;
        BusMessageHeader *h;
        size_t a, label_sz = 0; /* avoid false maybe-uninitialized warning */
 
        assert(bus);
        assert(buffer || message_size <= 0);
        assert(fds || n_fds <= 0);
        assert(ret);
 
        if (message_size < sizeof(BusMessageHeader))
                return -EBADMSG;
 
        h = buffer;
        if (!IN_SET(h->version, 1, 2))
                return -EBADMSG;
 
        if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID)
                return -EBADMSG;
 
        if (!IN_SET(h->endian, BUS_LITTLE_ENDIAN, BUS_BIG_ENDIAN))
                return -EBADMSG;
 
        /* Note that we are happy with unknown flags in the flags header! */
 
        a = ALIGN(sizeof(sd_bus_message));
        /* Silence static analyzers, ALIGN cannot overflow for sizeof() */
        assert(a != SIZE_MAX);
 
        if (label) {
                label_sz = strlen(label);
                assert_se(INC_SAFE(&a, label_sz + 1));
        }
 
        m = malloc0(a);
        if (!m)
                return -ENOMEM;
 
        m->creds = (sd_bus_creds) { SD_BUS_CREDS_INIT_FIELDS };
        m->sealed = true;
        m->header = buffer;
 
        if (h->serial == 0)
                return -EBADMSG;
 
        m->fields_size = BUS_MESSAGE_BSWAP32(m, h->fields_size);
        m->body_size = BUS_MESSAGE_BSWAP32(m, h->body_size);
 
        assert(message_size >= sizeof(BusMessageHeader));
        if (ALIGN8(m->fields_size) > message_size - sizeof(BusMessageHeader) ||
            m->body_size != message_size - sizeof(BusMessageHeader) - ALIGN8(m->fields_size))
                return -EBADMSG;
 
        m->fds = fds;
        m->n_fds = n_fds;
 
        if (label) {
                m->creds.label = (char*) m + ALIGN(sizeof(sd_bus_message));
                memcpy(m->creds.label, label, label_sz + 1);
 
                m->creds.mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
        }
 
        m->n_ref = 1;
        m->bus = sd_bus_ref(bus);
 
        *ret = TAKE_PTR(m);
 
        return 0;
}
 
int bus_message_from_malloc(
                sd_bus *bus,
                void *buffer,
                size_t length,
                int *fds,
                size_t n_fds,
                bool got_ctrunc,
                const char *label,
                sd_bus_message **ret) {
 
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
        size_t sz;
        int r;
 
        assert(ret);
 
        r = message_from_header(
                        bus,
                        buffer, length,
                        fds, n_fds,
                        label,
                        &m);
        if (r < 0)
                return r;
 
        sz = length - sizeof(BusMessageHeader) - ALIGN8(m->fields_size);
        if (sz > 0) {
                m->n_body_parts = 1;
                m->body.data = (uint8_t*) buffer + sizeof(BusMessageHeader) + ALIGN8(m->fields_size);
                m->body.size = sz;
                m->body.sealed = true;
                m->body.memfd = -EBADF;
        }
 
        m->n_iovec = 1;
        m->iovec = m->iovec_fixed;
        m->iovec[0] = IOVEC_MAKE(buffer, length);
 
        r = message_parse_fields(m, got_ctrunc);
        if (r < 0)
                return r;
 
        /* We take possession of the memory and fds now */
        m->free_header = true;
        m->free_fds = true;
 
        *ret = TAKE_PTR(m);
        return 0;
}
 
_public_ int sd_bus_message_new(
                sd_bus *bus,
                sd_bus_message **ret,
                uint8_t type) {
 
        assert_return(bus, -ENOTCONN);
        assert_return(bus = bus_resolve(bus), -ENOPKG);
        assert_return(bus->state != BUS_UNSET, -ENOTCONN);
        assert_return(ret, -EINVAL);
        /* Creation of messages with _SD_BUS_MESSAGE_TYPE_INVALID is allowed. */
        assert_return(type < _SD_BUS_MESSAGE_TYPE_MAX, -EINVAL);
 
        /* Silence static analyzers, ALIGN cannot overflow for sizeof() */
        assert(ALIGN(sizeof(sd_bus_message)) != SIZE_MAX);
        sd_bus_message *t = malloc0(ALIGN(sizeof(sd_bus_message)) + sizeof(BusMessageHeader));
        if (!t)
                return -ENOMEM;
 
        t->n_ref = 1;
        t->creds = (sd_bus_creds) { SD_BUS_CREDS_INIT_FIELDS };
        t->bus = sd_bus_ref(bus);
        t->header = (BusMessageHeader*) ((uint8_t*) t + ALIGN(sizeof(struct sd_bus_message)));
        t->header->endian = BUS_NATIVE_ENDIAN;
        t->header->type = type;
        t->header->version = bus->message_version;
        t->allow_fds = bus->can_fds || !IN_SET(bus->state, BUS_HELLO, BUS_RUNNING);
 
        if (bus->allow_interactive_authorization)
                t->header->flags |= BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION;
 
        *ret = t;
        return 0;
}
 
_public_ int sd_bus_message_new_signal_to(
                sd_bus *bus,
                sd_bus_message **ret,
                const char *destination,
                const char *path,
                const char *interface,
                const char *member) {
 
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *t = NULL;
        int r;
 
        assert_return(bus, -ENOTCONN);
        assert_return(bus = bus_resolve(bus), -ENOPKG);
        assert_return(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_name_is_valid(interface), -EINVAL);
        assert_return(member_name_is_valid(member), -EINVAL);
        assert_return(ret, -EINVAL);
 
        r = sd_bus_message_new(bus, &t, SD_BUS_MESSAGE_SIGNAL);
        if (r < 0)
                return -ENOMEM;
 
        assert(t);
 
        t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
 
        r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
        if (r < 0)
                return r;
        r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
        if (r < 0)
                return r;
        r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
        if (r < 0)
                return r;
 
        if (destination) {
                r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &t->destination);
                if (r < 0)
                        return r;
        }
 
        *ret = TAKE_PTR(t);
        return 0;
}
 
_public_ int sd_bus_message_new_signal(
                sd_bus *bus,
                sd_bus_message **ret,
                const char *path,
                const char *interface,
                const char *member) {
 
        return sd_bus_message_new_signal_to(bus, ret, NULL, path, interface, member);
}
 
_public_ int sd_bus_message_new_method_call(
                sd_bus *bus,
                sd_bus_message **ret,
                const char *destination,
                const char *path,
                const char *interface,
                const char *member) {
 
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *t = NULL;
        int r;
 
        assert_return(bus, -ENOTCONN);
        assert_return(bus = bus_resolve(bus), -ENOPKG);
        assert_return(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(ret, -EINVAL);
 
        r = sd_bus_message_new(bus, &t, SD_BUS_MESSAGE_METHOD_CALL);
        if (r < 0)
                return -ENOMEM;
 
        assert(t);
 
        r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
        if (r < 0)
                return r;
        r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
        if (r < 0)
                return r;
 
        if (interface) {
                r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
                if (r < 0)
                        return r;
        }
 
        if (destination) {
                r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &t->destination);
                if (r < 0)
                        return r;
        }
 
        *ret = TAKE_PTR(t);
        return 0;
}
 
static int message_new_reply(
                sd_bus_message *call,
                uint8_t type,
                sd_bus_message **ret) {
 
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *t = NULL;
        uint64_t cookie;
        int r;
 
        assert_return(call, -EINVAL);
        assert_return(call->sealed, -EPERM);
        assert_return(call->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
        assert_return(call->bus->state != BUS_UNSET, -ENOTCONN);
        assert_return(ret, -EINVAL);
 
        cookie = BUS_MESSAGE_COOKIE(call);
        if (cookie == 0)
                return -EOPNOTSUPP;
 
        r = sd_bus_message_new(call->bus, &t, type);
        if (r < 0)
                return -ENOMEM;
 
        assert(t);
 
        t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
        t->reply_cookie = cookie;
        r = message_append_reply_cookie(t, t->reply_cookie);
        if (r < 0)
                return r;
 
        if (call->sender) {
                r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, call->sender, &t->destination);
                if (r < 0)
                        return r;
        }
 
        t->dont_send = FLAGS_SET(call->header->flags, BUS_MESSAGE_NO_REPLY_EXPECTED);
        t->enforced_reply_signature = call->enforced_reply_signature;
 
        /* let's copy the sensitive flag over. Let's do that as a safety precaution to keep a transaction
         * wholly sensitive if already the incoming message was sensitive. This is particularly useful when a
         * vtable record sets the SD_BUS_VTABLE_SENSITIVE flag on a method call, since this means it applies
         * to both the message call and the reply. */
        t->sensitive = call->sensitive;
 
        *ret = TAKE_PTR(t);
        return 0;
}
 
_public_ int sd_bus_message_new_method_return(
                sd_bus_message *call,
                sd_bus_message **ret) {
 
        return message_new_reply(call, SD_BUS_MESSAGE_METHOD_RETURN, ret);
}
 
_public_ int sd_bus_message_new_method_error(
                sd_bus_message *call,
                sd_bus_message **ret,
                const sd_bus_error *e) {
 
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *t = NULL;
        int r;
 
        assert_return(sd_bus_error_is_set(e), -EINVAL);
        assert_return(ret, -EINVAL);
 
        r = message_new_reply(call, SD_BUS_MESSAGE_METHOD_ERROR, &t);
        if (r < 0)
                return r;
 
        r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
        if (r < 0)
                return r;
 
        if (e->message) {
                r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
                if (r < 0)
                        return r;
        }
 
        t->error._need_free = -1;
 
        *ret = TAKE_PTR(t);
        return 0;
}
 
_public_ int sd_bus_message_new_method_errorf(
                sd_bus_message *call,
                sd_bus_message **ret,
                const char *name,
                const char *format,
                ...) {
 
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        va_list ap;
 
        assert_return(name, -EINVAL);
        assert_return(ret, -EINVAL);
 
        va_start(ap, format);
        sd_bus_error_setfv(&error, name, format, ap);
        va_end(ap);
 
        return sd_bus_message_new_method_error(call, ret, &error);
}
 
_public_ int sd_bus_message_new_method_errno(
                sd_bus_message *call,
                sd_bus_message **ret,
                int error,
                const sd_bus_error *e) {
 
        _cleanup_(sd_bus_error_free) sd_bus_error berror = SD_BUS_ERROR_NULL;
 
        if (sd_bus_error_is_set(e))
                return sd_bus_message_new_method_error(call, ret, e);
 
        sd_bus_error_set_errno(&berror, error);
 
        return sd_bus_message_new_method_error(call, ret, &berror);
}
 
_public_ int sd_bus_message_new_method_errnof(
                sd_bus_message *call,
                sd_bus_message **ret,
                int error,
                const char *format,
                ...) {
 
        _cleanup_(sd_bus_error_free) sd_bus_error berror = SD_BUS_ERROR_NULL;
        va_list ap;
 
        va_start(ap, format);
        sd_bus_error_set_errnofv(&berror, error, format, ap);
        va_end(ap);
 
        return sd_bus_message_new_method_error(call, ret, &berror);
}
 
void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m) {
        assert(bus);
        assert(m);
 
        m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus.Local";
        m->creds.well_known_names_local = true;
        m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
}
 
void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m) {
        assert(bus);
        assert(m);
 
        m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
        m->creds.well_known_names_driver = true;
        m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
}
 
int bus_message_new_synthetic_error(
                sd_bus *bus,
                uint64_t cookie,
                const sd_bus_error *e,
                sd_bus_message **m) {
 
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *t = NULL;
        int r;
 
        assert(bus);
        assert(sd_bus_error_is_set(e));
        assert(m);
 
        r = sd_bus_message_new(bus, &t, SD_BUS_MESSAGE_METHOD_ERROR);
        if (r < 0)
                return -ENOMEM;
 
        assert(t);
 
        t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
        t->reply_cookie = cookie;
 
        r = message_append_reply_cookie(t, t->reply_cookie);
        if (r < 0)
                return r;
 
        if (bus && bus->unique_name) {
                r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, bus->unique_name, &t->destination);
                if (r < 0)
                        return r;
        }
 
        r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
        if (r < 0)
                return r;
 
        if (e->message) {
                r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
                if (r < 0)
                        return r;
        }
 
        t->error._need_free = -1;
 
        bus_message_set_sender_driver(bus, t);
 
        *m = TAKE_PTR(t);
        return 0;
}
 
_public_ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
        if (!m)
                return NULL;
 
        /* We are fine if this message so far was either explicitly reffed or not reffed but queued into at
         * least one bus connection object. */
        assert(m->n_ref > 0 || m->n_queued > 0);
 
        m->n_ref++;
 
        /* Each user reference to a bus message shall also be considered a ref on the bus */
        sd_bus_ref(m->bus);
        return m;
}
 
_public_ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
        if (!m)
                return NULL;
 
        assert(m->n_ref > 0);
 
        sd_bus_unref(m->bus); /* Each regular ref is also a ref on the bus connection. Let's hence drop it
                               * here. Note we have to do this before decrementing our own n_ref here, since
                               * otherwise, if this message is currently queued sd_bus_unref() might call
                               * bus_message_unref_queued() for this which might then destroy the message
                               * while we are still processing it. */
        m->n_ref--;
 
        if (m->n_ref > 0 || m->n_queued > 0)
                return NULL;
 
        /* Unset the bus field if neither the user has a reference nor this message is queued. We are careful
         * to reset the field only after the last reference to the bus is dropped, after all we might keep
         * multiple references to the bus, once for each reference kept on ourselves. */
        m->bus = NULL;
 
        return message_free(m);
}
 
sd_bus_message* bus_message_ref_queued(sd_bus_message *m, sd_bus *bus) {
        if (!m)
                return NULL;
 
        /* If this is a different bus than the message is associated with, then implicitly turn this into a
         * regular reference. This means that you can create a memory leak by enqueuing a message generated
         * on one bus onto another at the same time as enqueueing a message from the second one on the first,
         * as we'll not detect the cyclic references there. */
        if (bus != m->bus)
                return sd_bus_message_ref(m);
 
        assert(m->n_ref > 0 || m->n_queued > 0);
        m->n_queued++;
 
        return m;
}
 
sd_bus_message* bus_message_unref_queued(sd_bus_message *m, sd_bus *bus) {
        if (!m)
                return NULL;
 
        if (bus != m->bus)
                return sd_bus_message_unref(m);
 
        assert(m->n_queued > 0);
        m->n_queued--;
 
        if (m->n_ref > 0 || m->n_queued > 0)
                return NULL;
 
        m->bus = NULL;
 
        return message_free(m);
}
 
_public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *ret) {
        assert_return(m, -EINVAL);
        assert_return(ret, -EINVAL);
 
        *ret = m->header->type;
        return 0;
}
 
_public_ int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *ret) {
        uint64_t c;
 
        assert_return(m, -EINVAL);
        assert_return(ret, -EINVAL);
 
        c = BUS_MESSAGE_COOKIE(m);
        if (c == 0)
                return -ENODATA;
 
        *ret = BUS_MESSAGE_COOKIE(m);
        return 0;
}
 
_public_ int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *ret) {
        assert_return(m, -EINVAL);
        assert_return(ret, -EINVAL);
 
        if (m->reply_cookie == 0)
                return -ENODATA;
 
        *ret = m->reply_cookie;
        return 0;
}
 
_public_ int sd_bus_message_get_expect_reply(sd_bus_message *m) {
        assert_return(m, -EINVAL);
 
        return m->header->type == SD_BUS_MESSAGE_METHOD_CALL &&
                !(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED);
}
 
_public_ int sd_bus_message_get_auto_start(sd_bus_message *m) {
        assert_return(m, -EINVAL);
 
        return !(m->header->flags & BUS_MESSAGE_NO_AUTO_START);
}
 
_public_ int sd_bus_message_get_allow_interactive_authorization(sd_bus_message *m) {
        assert_return(m, -EINVAL);
 
        return m->header->type == SD_BUS_MESSAGE_METHOD_CALL &&
                (m->header->flags & BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION);
}
 
_public_ const char* sd_bus_message_get_path(sd_bus_message *m) {
        assert_return(m, NULL);
 
        return m->path;
}
 
_public_ const char* sd_bus_message_get_interface(sd_bus_message *m) {
        assert_return(m, NULL);
 
        return m->interface;
}
 
_public_ const char* sd_bus_message_get_member(sd_bus_message *m) {
        assert_return(m, NULL);
 
        return m->member;
}
 
_public_ const char* sd_bus_message_get_destination(sd_bus_message *m) {
        assert_return(m, NULL);
 
        return m->destination;
}
 
_public_ const char* sd_bus_message_get_sender(sd_bus_message *m) {
        assert_return(m, NULL);
 
        return m->sender;
}
 
_public_ const sd_bus_error* sd_bus_message_get_error(sd_bus_message *m) {
        assert_return(m, NULL);
 
        if (!sd_bus_error_is_set(&m->error))
                return NULL;
 
        return &m->error;
}
 
_public_ int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *ret) {
        assert_return(m, -EINVAL);
        assert_return(ret, -EINVAL);
 
        if (m->monotonic <= 0)
                return -ENODATA;
 
        *ret = m->monotonic;
        return 0;
}
 
_public_ int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *ret) {
        assert_return(m, -EINVAL);
        assert_return(ret, -EINVAL);
 
        if (m->realtime <= 0)
                return -ENODATA;
 
        *ret = m->realtime;
        return 0;
}
 
_public_ int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *ret) {
        assert_return(m, -EINVAL);
        assert_return(ret, -EINVAL);
 
        if (m->seqnum <= 0)
                return -ENODATA;
 
        *ret = m->seqnum;
        return 0;
}
 
_public_ sd_bus_creds* sd_bus_message_get_creds(sd_bus_message *m) {
        assert_return(m, NULL);