HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-bus/bus-message.c
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);