#include "utf8.h"
#include "strv.h"
#include "time-util.h"
+#include "cgroup-util.h"
#include "sd-bus.h"
#include "bus-message.h"
free(m->root_container.signature);
free(m->peeked_signature);
+
+ free(m->unit);
+ free(m->user_unit);
+ free(m->session);
free(m);
}
int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) {
if (!m)
return -EINVAL;
+ if (!uid)
+ return -EINVAL;
if (!m->uid_valid)
- return -ENOENT;
+ return -ESRCH;
*uid = m->uid;
return 0;
int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) {
if (!m)
return -EINVAL;
+ if (!gid)
+ return -EINVAL;
if (!m->gid_valid)
- return -ENOENT;
+ return -ESRCH;
*gid = m->gid;
return 0;
int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) {
if (!m)
return -EINVAL;
+ if (!pid)
+ return -EINVAL;
if (m->pid <= 0)
- return -ENOENT;
+ return -ESRCH;
*pid = m->pid;
return 0;
int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) {
if (!m)
return -EINVAL;
+ if (!tid)
+ return -EINVAL;
if (m->tid <= 0)
- return -ENOENT;
+ return -ESRCH;
*tid = m->tid;
return 0;
int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) {
if (!m)
return -EINVAL;
+ if (!usec)
+ return -EINVAL;
if (m->pid_starttime <= 0)
- return -ENOENT;
+ return -ESRCH;
*usec = m->pid_starttime;
return 0;
}
-const char *sd_bus_message_get_selinux_context(sd_bus_message *m) {
+int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
if (!m)
- return NULL;
+ return -EINVAL;
+ if (!m->label)
+ return -ESRCH;
- return m->label;
+ *ret = m->label;
+ return 0;
}
int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
if (!m)
return -EINVAL;
-
+ if (!usec)
+ return -EINVAL;
if (m->monotonic <= 0)
- return -ENOENT;
+ return -ESRCH;
*usec = m->monotonic;
return 0;
int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
if (!m)
return -EINVAL;
-
+ if (!usec)
+ return -EINVAL;
if (m->realtime <= 0)
- return -ENOENT;
+ return -ESRCH;
*usec = m->realtime;
return 0;
}
-const char *sd_bus_message_get_comm(sd_bus_message *m) {
+int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) {
if (!m)
- return NULL;
+ return -EINVAL;
+ if (!ret)
+ return -EINVAL;
+ if (!m->comm)
+ return -ESRCH;
- return m->comm;
+ *ret = m->comm;
+ return 0;
}
-const char *sd_bus_message_get_tid_comm(sd_bus_message *m) {
+int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) {
if (!m)
- return NULL;
+ return -EINVAL;
+ if (!ret)
+ return -EINVAL;
+ if (!m->tid_comm)
+ return -ESRCH;
- return m->tid_comm;
+ *ret = m->tid_comm;
+ return 0;
}
-const char *sd_bus_message_get_exe(sd_bus_message *m) {
+int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) {
if (!m)
- return NULL;
+ return -EINVAL;
+ if (!ret)
+ return -EINVAL;
+ if (!m->exe)
+ return -ESRCH;
+
+ *ret = m->exe;
+ return 0;
+}
+
+int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) {
+ if (!m)
+ return -EINVAL;
+ if (!ret)
+ return -EINVAL;
+ if (!m->cgroup)
+ return -ESRCH;
- return m->exe;
+ *ret = m->cgroup;
+ return 0;
+}
+
+int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
+ int r;
+
+ if (!m)
+ return -EINVAL;
+ if (!ret)
+ return -EINVAL;
+ if (!m->cgroup)
+ return -ESRCH;
+
+ if (!m->unit) {
+ r = cg_path_get_unit(m->cgroup, &m->unit);
+ if (r < 0)
+ return r;
+ }
+
+ *ret = m->unit;
+ return 0;
+}
+
+int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
+ int r;
+
+ if (!m)
+ return -EINVAL;
+ if (!ret)
+ return -EINVAL;
+ if (!m->cgroup)
+ return -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;
+}
+
+int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
+ int r;
+
+ if (!m)
+ return -EINVAL;
+ if (!ret)
+ return -EINVAL;
+ if (!m->cgroup)
+ return -ESRCH;
+
+ if (!m->session) {
+ r = cg_path_get_session(m->cgroup, &m->session);
+ if (r < 0)
+ return r;
+ }
+
+ *ret = m->session;
+ return 0;
+}
+
+int sd_bus_message_get_owner_uid(sd_bus_message *m, uid_t *uid) {
+ if (!m)
+ return -EINVAL;
+ if (!uid)
+ return -EINVAL;
+ if (!m->cgroup)
+ return -ESRCH;
+
+ return cg_path_get_owner_uid(m->cgroup, uid);
}
int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
return 0;
}
+int sd_bus_message_get_audit_sessionid(sd_bus_message *m, uint32_t *sessionid) {
+ if (!m)
+ return -EINVAL;
+ if (!sessionid)
+ return -EINVAL;
+ if (!m->audit)
+ return -ESRCH;
+
+ *sessionid = m->audit->sessionid;
+ return 0;
+}
+
+int sd_bus_message_get_audit_loginuid(sd_bus_message *m, uid_t *uid) {
+ if (!m)
+ return -EINVAL;
+ if (!uid)
+ return -EINVAL;
+ if (!m->audit)
+ return -ESRCH;
+
+ *uid = m->audit->loginuid;
+ return 0;
+}
+
+int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) {
+ unsigned sz;
+
+ if (!m)
+ return -EINVAL;
+ if (capability < 0)
+ return -EINVAL;
+ if (!m->capability)
+ return -ESRCH;
+
+ sz = m->capability_size / 4;
+ if ((unsigned) capability >= sz*8)
+ return 0;
+
+ return !!(m->capability[2 * sz + (capability / 8)] & (1 << (capability % 8)));
+}
+
int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member) {
if (!m)
return -EINVAL;
struct bus_container *c, *w;
uint32_t *array_size = NULL;
char *signature;
+ size_t before;
int r;
if (!m)
if (!signature)
return -ENOMEM;
+ /* Save old index in the parent container, in case we have to
+ * abort this container */
+ c->saved_index = c->index;
+ before = m->header->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)
w->signature = signature;
w->index = 0;
w->array_size = array_size;
- w->begin = 0;
+ w->before = before;
+ w->begin = m->rindex;
return 0;
}
return 0;
}
+static void message_abort_container(sd_bus_message *m) {
+ struct bus_container *c;
+ size_t delta;
+
+ assert(m);
+ assert(!m->sealed);
+ assert(m->n_containers > 0);
+
+ c = message_get_container(m);
+
+ /* Undo appends */
+ assert(m->header->body_size >= c->before);
+ delta = m->header->body_size - c->before;
+ m->header->body_size = c->before;
+
+ /* Free container */
+ free(c->signature);
+ m->n_containers--;
+
+ /* Correct index of new top-level container */
+ c = message_get_container(m);
+ c->index = c->saved_index;
+
+ /* Correct array sizes all the way up */
+ for (c = m->containers; c < m->containers + m->n_containers; c++)
+ if (c->array_size) {
+ assert(*c->array_size >= delta);
+ *c->array_size -= delta;
+ }
+}
typedef struct {
const char *types;
return r;
}
+int sd_bus_message_append_array_ptr(sd_bus_message *m, char type, size_t size, void **ptr) {
+ ssize_t align, sz;
+ void *a;
+ int r;
+
+ if (!m)
+ return -EINVAL;
+ if (m->sealed)
+ return -EPERM;
+ if (!bus_type_is_trivial(type))
+ return -EINVAL;
+ if (!ptr && size > 0)
+ return -EINVAL;
+
+ align = bus_type_get_alignment(type);
+ sz = bus_type_get_size(type);
+
+ assert_se(align > 0);
+ assert_se(sz > 0);
+
+ if (size % sz != 0)
+ return -EINVAL;
+
+ r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
+ if (r < 0)
+ return r;
+
+ a = message_extend_body(m, align, size);
+ if (!a) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ r = sd_bus_message_close_container(m);
+ if (r < 0)
+ goto fail;
+
+ *ptr = a;
+ return 0;
+
+fail:
+ message_abort_container(m);
+ return r;
+}
+
+int sd_bus_message_append_array(sd_bus_message *m, char type, const void *ptr, size_t size) {
+ int r;
+ void *p;
+
+ if (!ptr && size > 0)
+ return -EINVAL;
+
+ r = sd_bus_message_append_array_ptr(m, type, size, &p);
+ if (r < 0)
+ return r;
+
+ if (size > 0)
+ memcpy(p, ptr, size);
+
+ return 0;
+}
+
static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, size_t nbytes, void **r) {
size_t k, start, n;
assert_not_reached("Unknown basic type...");
}
- m->rindex = rindex;
+ m->rindex = rindex;
break;
}
struct bus_container *c, *w;
uint32_t *array_size = NULL;
char *signature;
+ size_t before;
int r;
if (!m)
if (!signature)
return -ENOMEM;
+ c->saved_index = c->index;
+ before = m->rindex;
+
if (type == SD_BUS_TYPE_ARRAY)
r = bus_message_enter_array(m, c, contents, &array_size);
else if (type == SD_BUS_TYPE_VARIANT)
w->signature = signature;
w->index = 0;
w->array_size = array_size;
+ w->before = before;
w->begin = m->rindex;
return 1;
return 1;
}
+static void message_quit_container(sd_bus_message *m) {
+ struct bus_container *c;
+
+ assert(m);
+ assert(m->sealed);
+ assert(m->n_containers > 0);
+
+ c = message_get_container(m);
+
+ /* Undo seeks */
+ assert(m->rindex >= c->before);
+ m->rindex = c->before;
+
+ /* Free container */
+ free(c->signature);
+ m->n_containers--;
+
+ /* Correct index of new top-level container */
+ c = message_get_container(m);
+ c->index = c->saved_index;
+}
+
int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) {
struct bus_container *c;
int r;
return r;
}
+int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ptr, size_t *size) {
+ struct bus_container *c;
+ void *p;
+ size_t sz;
+ ssize_t align;
+ int r;
+
+ if (!m)
+ return -EINVAL;
+ if (!m->sealed)
+ return -EPERM;
+ if (!bus_type_is_trivial(type))
+ return -EINVAL;
+ if (!ptr)
+ return -EINVAL;
+ if (!size)
+ return -EINVAL;
+ if (BUS_MESSAGE_NEED_BSWAP(m))
+ return -ENOTSUP;
+
+ align = bus_type_get_alignment(type);
+ if (align < 0)
+ return align;
+
+ r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
+ if (r < 0)
+ return r;
+
+ c = message_get_container(m);
+ sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
+
+ r = message_peek_body(m, &m->rindex, align, sz, &p);
+ if (r < 0)
+ goto fail;
+ if (r == 0) {
+ r = -EBADMSG;
+ goto fail;
+ }
+
+ r = sd_bus_message_exit_container(m);
+ if (r < 0)
+ goto fail;
+
+ *ptr = (const void*) p;
+ *size = sz;
+
+ return 1;
+
+fail:
+ message_quit_container(m);
+ return r;
+}
+
static int message_peek_fields(
sd_bus_message *m,
size_t *rindex,
}
int bus_message_dump(sd_bus_message *m) {
+ 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);
printf("\ttid_comm=[%s]\n", m->tid_comm);
if (m->label)
printf("\tlabel=[%s]\n", m->label);
+ if (m->cgroup)
+ printf("\tcgroup=[%s]\n", m->cgroup);
+
+ sd_bus_message_get_unit(m, &u);
+ if (u)
+ printf("\tunit=[%s]\n", u);
+ sd_bus_message_get_user_unit(m, &uu);
+ if (uu)
+ printf("\tuser_unit=[%s]\n", uu);
+ sd_bus_message_get_session(m, &s);
+ if (s)
+ printf("\tsession=[%s]\n", s);
+ if (sd_bus_message_get_owner_uid(m, &owner) >= 0)
+ printf("\towner_uid=%lu\n", (unsigned long) owner);
+ if (sd_bus_message_get_audit_loginuid(m, &audit_loginuid) >= 0)
+ printf("\taudit_loginuid=%lu\n", (unsigned long) audit_loginuid);
+ if (sd_bus_message_get_audit_sessionid(m, &audit_sessionid) >= 0)
+ printf("\taudit_sessionid=%lu\n", (unsigned long) audit_sessionid);
+
+ printf("\tCAP_KILL=%i\n", sd_bus_message_has_effective_cap(m, 5));
if (sd_bus_message_get_cmdline(m, &cmdline) >= 0) {
char **c;
~ianmdlvl / elogind.git / blobdiff