HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-bus/bus-message.c
Git blob: 81f78f8036f3d70b14af45edd5d008e1d7ca1d64
Lines 1001–2000 of 4,752
if (m->creds.mask == 0)
return NULL;
return &m->creds;
}
_public_ int sd_bus_message_is_signal(
sd_bus_message *m,
const char *interface,
const char *member) {
assert_return(m, -EINVAL);
if (m->header->type != SD_BUS_MESSAGE_SIGNAL)
return 0;
if (interface && !streq_ptr(m->interface, interface))
return 0;
if (member && !streq_ptr(m->member, member))
return 0;
return 1;
}
_public_ int sd_bus_message_is_method_call(
sd_bus_message *m,
const char *interface,
const char *member) {
assert_return(m, -EINVAL);
if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
return 0;
if (interface && !streq_ptr(m->interface, interface))
return 0;
if (member && !streq_ptr(m->member, member))
return 0;
return 1;
}
_public_ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
assert_return(m, -EINVAL);
if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
return 0;
if (name && !streq_ptr(m->error.name, name))
return 0;
return 1;
}
_public_ int sd_bus_message_set_expect_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);
SET_FLAG(m->header->flags, BUS_MESSAGE_NO_REPLY_EXPECTED, !b);
return 0;
}
_public_ int sd_bus_message_set_auto_start(sd_bus_message *m, int b) {
assert_return(m, -EINVAL);
assert_return(!m->sealed, -EPERM);
SET_FLAG(m->header->flags, BUS_MESSAGE_NO_AUTO_START, !b);
return 0;
}
_public_ int sd_bus_message_set_allow_interactive_authorization(sd_bus_message *m, int b) {
assert_return(m, -EINVAL);
assert_return(!m->sealed, -EPERM);
SET_FLAG(m->header->flags, BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION, b);
return 0;
}
static BusMessageBodyPart* message_append_part(sd_bus_message *m) {
BusMessageBodyPart *part;
assert(m);
if (m->poisoned)
return NULL;
if (m->n_body_parts <= 0) {
part = &m->body;
zero(*part);
} else {
assert(m->body_end);
part = new0(BusMessageBodyPart, 1);
if (!part) {
m->poisoned = true;
return NULL;
}
m->body_end->next = part;
}
part->memfd = -EBADF;
m->body_end = part;
m->n_body_parts++;
return part;
}
static void part_zero(BusMessageBodyPart *part, size_t sz) {
assert(part);
assert(sz > 0);
assert(sz < 8);
/* All other fields can be left in their defaults */
assert(!part->data);
assert(part->memfd < 0);
part->size = sz;
part->is_zero = true;
part->sealed = true;
}
static int part_make_space(
struct sd_bus_message *m,
BusMessageBodyPart *part,
size_t sz,
void **q) {
void *n;
assert(m);
assert(part);
assert(!part->sealed);
if (m->poisoned)
return -ENOMEM;
if (part->allocated == 0 || sz > part->allocated) {
size_t new_allocated;
new_allocated = sz > 0 ? 2 * sz : 64;
n = realloc(part->data, new_allocated);
if (!n) {
m->poisoned = true;
return -ENOMEM;
}
part->data = n;
part->allocated = new_allocated;
part->free_this = true;
}
if (q)
*q = part->data ? (uint8_t*) part->data + part->size : NULL;
part->size = sz;
return 0;
}
static void message_extend_containers(sd_bus_message *m, size_t expand) {
assert(m);
if (expand <= 0)
return;
if (m->n_containers <= 0)
return;
/* Update counters */
for (BusMessageContainer *c = m->containers; c < m->containers + m->n_containers; c++)
if (c->array_size)
*c->array_size += expand;
}
static void* message_extend_body(
sd_bus_message *m,
size_t align,
size_t sz) {
size_t start_body, end_body, padding, added;
void *p;
int r;
assert(m);
assert(align > 0);
assert(!m->sealed);
if (m->poisoned)
return NULL;
start_body = ALIGN_TO(m->body_size, align);
end_body = start_body + sz;
padding = start_body - m->body_size;
added = padding + sz;
/* Check for 32-bit overflows */
if (end_body < start_body || end_body > UINT32_MAX) {
m->poisoned = true;
return NULL;
}
if (added > 0) {
BusMessageBodyPart *part = NULL;
bool add_new_part;
add_new_part =
m->n_body_parts <= 0 ||
m->body_end->sealed ||
(padding != ALIGN_TO(m->body_end->size, align) - m->body_end->size);
/* If this must be an inlined extension, let's create a new part if
* the previous part is large enough to be inlined. */
if (add_new_part) {
if (padding > 0) {
part = message_append_part(m);
if (!part)
return NULL;
part_zero(part, padding);
}
part = message_append_part(m);
if (!part)
return NULL;
r = part_make_space(m, part, sz, &p);
if (r < 0)
return NULL;
} else {
void *op;
size_t os, start_part, end_part;
part = m->body_end;
op = part->data;
os = part->size;
start_part = ALIGN_TO(part->size, align);
end_part = start_part + sz;
r = part_make_space(m, part, end_part, &p);
if (r < 0)
return NULL;
if (padding > 0) {
memzero(p, padding);
p = (uint8_t*) p + padding;
}
/* Readjust pointers */
if (m->n_containers > 0)
for (BusMessageContainer *c = m->containers; c < m->containers + m->n_containers; c++)
c->array_size = adjust_pointer(c->array_size, op, os, part->data);
m->error.message = (const char*) adjust_pointer(m->error.message, op, os, part->data);
}
} else
/* Return something that is not NULL and is aligned */
p = (uint8_t*) align;
m->body_size = end_body;
message_extend_containers(m, added);
return p;
}
static int message_push_fd(sd_bus_message *m, int fd) {
int copy;
assert(m);
if (fd < 0)
return -EINVAL;
if (!m->allow_fds)
return -EOPNOTSUPP;
copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
if (copy < 0)
return -errno;
if (!GREEDY_REALLOC(m->fds, m->n_fds + 1)) {
m->poisoned = true;
safe_close(copy);
return -ENOMEM;
}
m->fds[m->n_fds] = copy; /* m->n_fds will be incremented by the caller later */
m->free_fds = true;
return copy;
}
int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) {
_cleanup_close_ int fd = -EBADF;
BusMessageContainer *c;
ssize_t align, sz;
uint32_t u32;
void *a;
assert_return(m, -EINVAL);
assert_return(!m->sealed, -EPERM);
assert_return(bus_type_is_basic(type), -EINVAL);
assert_return(!m->poisoned, -ESTALE);
c = message_get_last_container(m);
if (c->signature && c->signature[c->index]) {
/* Container signature is already set */
if (c->signature[c->index] != type)
return -ENXIO;
} else {
char *e;
/* Maybe we can append to the signature? But only if this is the top-level container */
if (c->enclosing != 0)
return -ENXIO;
e = strextend(&c->signature, CHAR_TO_STR(type));
if (!e) {
m->poisoned = true;
return -ENOMEM;
}
}
switch (type) {
case SD_BUS_TYPE_STRING:
/* To make things easy we'll serialize a NULL string
* into the empty string */
p = strempty(p);
if (!utf8_is_valid(p))
return -EINVAL;
align = 4;
sz = 4 + strlen(p) + 1;
break;
case SD_BUS_TYPE_OBJECT_PATH:
if (!p)
return -EINVAL;
if (!object_path_is_valid(p))
return -EINVAL;
align = 4;
sz = 4 + strlen(p) + 1;
break;
case SD_BUS_TYPE_SIGNATURE:
p = strempty(p);
if (!signature_is_valid(p, /* allow_dict_entry= */ true))
return -EINVAL;
align = 1;
sz = 1 + strlen(p) + 1;
break;
case SD_BUS_TYPE_BOOLEAN:
u32 = p && *(int*) p;
p = &u32;
align = sz = 4;
break;
case SD_BUS_TYPE_UNIX_FD:
if (!p)
return -EINVAL;
fd = message_push_fd(m, *(int*) p);
if (fd < 0)
return fd;
u32 = m->n_fds;
p = &u32;
align = sz = 4;
break;
default:
align = bus_type_get_alignment(type);
sz = bus_type_get_size(type);
}
assert(align > 0);
assert(sz > 0);
a = message_extend_body(m, align, sz);
if (!a)
return -ENOMEM;
if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH)) {
*(uint32_t*) a = sz - 5;
memcpy((uint8_t*) a + 4, p, sz - 4);
if (stored)
*stored = (const uint8_t*) a + 4;
} else if (type == SD_BUS_TYPE_SIGNATURE) {
*(uint8_t*) a = sz - 2;
memcpy((uint8_t*) a + 1, p, sz - 1);
if (stored)
*stored = (const uint8_t*) a + 1;
} else {
memcpy(a, p, sz);
if (stored)
*stored = a;
}
if (type == SD_BUS_TYPE_UNIX_FD)
m->n_fds++;
if (c->enclosing != SD_BUS_TYPE_ARRAY)
c->index++;
fd = -EBADF;
return 0;
}
_public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) {
return message_append_basic(m, type, p, NULL);
}
_public_ int sd_bus_message_append_string_space(
sd_bus_message *m,
size_t size,
char **ret) {
BusMessageContainer *c;
void *a;
assert_return(m, -EINVAL);
assert_return(!m->sealed, -EPERM);
assert_return(!m->poisoned, -ESTALE);
assert_return(ret, -EINVAL);
c = message_get_last_container(m);
if (c->signature && c->signature[c->index]) {
/* Container signature is already set */
if (c->signature[c->index] != SD_BUS_TYPE_STRING)
return -ENXIO;
} else {
char *e;
/* Maybe we can append to the signature? But only if this is the top-level container */
if (c->enclosing != 0)
return -ENXIO;
e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING));
if (!e) {
m->poisoned = true;
return -ENOMEM;
}
}
a = message_extend_body(m, 4, 4 + size + 1);
if (!a)
return -ENOMEM;
*(uint32_t*) a = size;
*ret = (char*) a + 4;
(*ret)[size] = 0;
if (c->enclosing != SD_BUS_TYPE_ARRAY)
c->index++;
return 0;
}
_public_ int sd_bus_message_append_string_iovec(
sd_bus_message *m,
const struct iovec *iov,
unsigned n /* should be size_t, but is API now… 😞 */) {
int r;
assert_return(m, -EINVAL);
assert_return(!m->sealed, -EPERM);
assert_return(iov || n == 0, -EINVAL);
assert_return(!m->poisoned, -ESTALE);
size_t size = iovec_total_size(iov, n);
if (size == SIZE_MAX)
return -ENOBUFS;
char *p;
r = sd_bus_message_append_string_space(m, size, &p);
if (r < 0)
return r;
for (unsigned i = 0; i < n; i++) {
if (iov[i].iov_base)
memcpy(p, iov[i].iov_base, iov[i].iov_len);
else
memset(p, ' ', iov[i].iov_len);
p += iov[i].iov_len;
}
return 0;
}
static int bus_message_open_array(
sd_bus_message *m,
BusMessageContainer *c,
const char *contents,
uint32_t **ret_array_size) {
unsigned nindex;
int alignment;
void *a, *op;
size_t os;
BusMessageBodyPart *o;
assert(m);
assert(c);
assert(contents);
assert(ret_array_size);
if (!signature_is_single(contents, true))
return -EINVAL;
if (c->signature && c->signature[c->index]) {
/* Verify the existing signature */
if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
return -ENXIO;
if (!startswith(c->signature + c->index + 1, contents))
return -ENXIO;
nindex = c->index + 1 + strlen(contents);
} else {
char *e;
if (c->enclosing != 0)
return -ENXIO;
/* Extend the existing signature */
e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_ARRAY), contents);
if (!e) {
m->poisoned = true;
return -ENOMEM;
}
nindex = e - c->signature;
}
alignment = bus_type_get_alignment(contents[0]);
if (alignment < 0)
return alignment;
a = message_extend_body(m, 4, 4);
if (!a)
return -ENOMEM;
o = m->body_end;
op = m->body_end->data;
os = m->body_end->size;
/* Add alignment between size and first element */
if (!message_extend_body(m, alignment, 0))
return -ENOMEM;
/* location of array size might have changed so let's readjust a */
if (o == m->body_end)
a = adjust_pointer(a, op, os, m->body_end->data);
*(uint32_t*) a = 0;
*ret_array_size = a;
if (c->enclosing != SD_BUS_TYPE_ARRAY)
c->index = nindex;
return 0;
}
static int bus_message_open_variant(
sd_bus_message *m,
BusMessageContainer *c,
const char *contents) {
size_t l;
void *a;
assert(m);
assert(c);
assert(contents);
if (!signature_is_single(contents, false))
return -EINVAL;
if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
return -EINVAL;
if (c->signature && c->signature[c->index]) {
if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
return -ENXIO;
} else {
char *e;
if (c->enclosing != 0)
return -ENXIO;
e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_VARIANT));
if (!e) {
m->poisoned = true;
return -ENOMEM;
}
}
l = strlen(contents);
a = message_extend_body(m, 1, 1 + l + 1);
if (!a)
return -ENOMEM;
*(uint8_t*) a = l;
memcpy((uint8_t*) a + 1, contents, l + 1);
if (c->enclosing != SD_BUS_TYPE_ARRAY)
c->index++;
return 0;
}
static int bus_message_open_struct(
sd_bus_message *m,
BusMessageContainer *c,
const char *contents) {
size_t nindex;
assert(m);
assert(c);
assert(contents);
if (!signature_is_valid(contents, false))
return -EINVAL;
if (c->signature && c->signature[c->index]) {
size_t l;
l = strlen(contents);
if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
!startswith(c->signature + c->index + 1, contents) ||
c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
return -ENXIO;
nindex = c->index + 1 + l + 1;
} else {
char *e;
if (c->enclosing != 0)
return -ENXIO;
e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END));
if (!e) {
m->poisoned = true;
return -ENOMEM;
}
nindex = e - c->signature;
}
/* Align contents to 8 byte boundary */
if (!message_extend_body(m, 8, 0))
return -ENOMEM;
if (c->enclosing != SD_BUS_TYPE_ARRAY)
c->index = nindex;
return 0;
}
static int bus_message_open_dict_entry(
sd_bus_message *m,
BusMessageContainer *c,
const char *contents) {
assert(m);
assert(c);
assert(contents);
if (!signature_is_pair(contents))
return -EINVAL;
if (c->enclosing != SD_BUS_TYPE_ARRAY)
return -ENXIO;
if (c->signature && c->signature[c->index]) {
size_t l;
l = strlen(contents);
if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
!startswith(c->signature + c->index + 1, contents) ||
c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
return -ENXIO;
} else
return -ENXIO;
/* Align contents to 8 byte boundary */
if (!message_extend_body(m, 8, 0))
return -ENOMEM;
return 0;
}
_public_ int sd_bus_message_open_container(
sd_bus_message *m,
char type,
const char *contents) {
BusMessageContainer *c;
uint32_t *array_size = NULL;
_cleanup_free_ char *signature = NULL;
size_t before;
int r;
assert_return(m, -EINVAL);
assert_return(!m->sealed, -EPERM);
assert_return(contents, -EINVAL);
assert_return(!m->poisoned, -ESTALE);
/* Make sure we have space for one more container */
if (!GREEDY_REALLOC(m->containers, m->n_containers + 1)) {
m->poisoned = true;
return -ENOMEM;
}
c = message_get_last_container(m);
signature = strdup(contents);
if (!signature) {
m->poisoned = true;
return -ENOMEM;
}
/* Save old index in the parent container, in case we have to
* abort this container */
c->saved_index = c->index;
before = m->body_size;
if (type == SD_BUS_TYPE_ARRAY)
r = bus_message_open_array(m, c, contents, &array_size);
else if (type == SD_BUS_TYPE_VARIANT)
r = bus_message_open_variant(m, c, contents);
else if (type == SD_BUS_TYPE_STRUCT)
r = bus_message_open_struct(m, c, contents);
else if (type == SD_BUS_TYPE_DICT_ENTRY)
r = bus_message_open_dict_entry(m, c, contents);
else
r = -EINVAL;
if (r < 0)
return r;
/* OK, let's fill it in */
m->containers[m->n_containers++] = (BusMessageContainer) {
.enclosing = type,
.signature = TAKE_PTR(signature),
.array_size = array_size,
.before = before,
};
return 0;
}
_public_ int sd_bus_message_close_container(sd_bus_message *m) {
BusMessageContainer *c;
assert_return(m, -EINVAL);
assert_return(!m->sealed, -EPERM);
assert_return(m->n_containers > 0, -EINVAL);
assert_return(!m->poisoned, -ESTALE);
c = message_get_last_container(m);
if (c->enclosing != SD_BUS_TYPE_ARRAY)
if (c->signature && c->signature[c->index] != 0)
return -EINVAL;
m->n_containers--;
free(c->signature);
return 0;
}
typedef struct BusTypeStack {
const char *types;
unsigned n_struct;
unsigned n_array;
} BusTypeStack;
static int type_stack_push(
BusTypeStack *stack,
unsigned max,
unsigned *i,
const char *types,
unsigned n_struct,
unsigned n_array) {
assert(stack);
assert(max > 0);
assert(i);
if (*i >= max)
return -EINVAL;
stack[*i].types = types;
stack[*i].n_struct = n_struct;
stack[*i].n_array = n_array;
(*i)++;
return 0;
}
static int type_stack_pop(
BusTypeStack *stack,
unsigned max,
unsigned *i,
const char **ret_types,
unsigned *ret_n_struct,
unsigned *ret_n_array) {
assert(stack);
assert(max > 0);
assert(i);
assert(ret_types);
assert(ret_n_struct);
assert(ret_n_array);
if (*i <= 0)
return 0;
(*i)--;
*ret_types = stack[*i].types;
*ret_n_struct = stack[*i].n_struct;
*ret_n_array = stack[*i].n_array;
return 1;
}
_public_ int sd_bus_message_appendv(
sd_bus_message *m,
const char *types,
va_list ap) {
unsigned n_array, n_struct;
BusTypeStack stack[BUS_CONTAINER_DEPTH];
unsigned stack_ptr = 0;
int r;
assert_return(m, -EINVAL);
assert_return(types, -EINVAL);
assert_return(!m->sealed, -EPERM);
assert_return(!m->poisoned, -ESTALE);
n_array = UINT_MAX;
n_struct = strlen(types);
for (;;) {
const char *t;
if (n_array == 0 || (n_array == UINT_MAX && n_struct == 0)) {
r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
if (r < 0)
return r;
if (r == 0)
break;
r = sd_bus_message_close_container(m);
if (r < 0)
return r;
continue;
}
t = types;
if (n_array != UINT_MAX)
n_array--;
else {
types++;
n_struct--;
}
switch (*t) {
case SD_BUS_TYPE_BYTE: {
uint8_t x;
x = (uint8_t) va_arg(ap, int);
r = sd_bus_message_append_basic(m, *t, &x);
break;
}
case SD_BUS_TYPE_BOOLEAN:
case SD_BUS_TYPE_INT32:
case SD_BUS_TYPE_UINT32:
case SD_BUS_TYPE_UNIX_FD: {
uint32_t x;
/* We assume a boolean is the same as int32_t */
assert_cc(sizeof(int32_t) == sizeof(int));
x = va_arg(ap, uint32_t);
r = sd_bus_message_append_basic(m, *t, &x);
break;
}
case SD_BUS_TYPE_INT16:
case SD_BUS_TYPE_UINT16: {
uint16_t x;
x = (uint16_t) va_arg(ap, int);
r = sd_bus_message_append_basic(m, *t, &x);
break;
}
case SD_BUS_TYPE_INT64:
case SD_BUS_TYPE_UINT64: {
uint64_t x;
x = va_arg(ap, uint64_t);
r = sd_bus_message_append_basic(m, *t, &x);
break;
}
case SD_BUS_TYPE_DOUBLE: {
double x;
x = va_arg(ap, double);
r = sd_bus_message_append_basic(m, *t, &x);
break;
}
case SD_BUS_TYPE_STRING:
case SD_BUS_TYPE_OBJECT_PATH:
case SD_BUS_TYPE_SIGNATURE: {
const char *x;
x = va_arg(ap, const char*);
r = sd_bus_message_append_basic(m, *t, x);
break;
}
case SD_BUS_TYPE_ARRAY: {
size_t k;
r = signature_element_length(t + 1, &k);
if (r < 0)
return r;
{
char s[k + 1];
memcpy(s, t + 1, k);
s[k] = 0;
r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
if (r < 0)
return r;
}
if (n_array == UINT_MAX) {
types += k;
n_struct -= k;
}
r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
if (r < 0)
return r;
types = t + 1;
n_struct = k;
n_array = va_arg(ap, unsigned);