#include "bus-message.h"
#include "bus-util.h"
#include "time-util.h"
+#include "strv.h"
#include "bus-creds.h"
enum {
free(c->user_unit);
free(c->slice);
- free(c->cmdline_array);
+ strv_free(c->cmdline_array);
+ strv_free(c->well_known_names);
}
_public_ sd_bus_creds *sd_bus_creds_ref(sd_bus_creds *c) {
}
_public_ sd_bus_creds *sd_bus_creds_unref(sd_bus_creds *c) {
- assert_return(c, NULL);
+
+ if (!c)
+ return NULL;
if (c->allocated) {
assert(c->n_ref > 0);
free(c->cgroup);
free(c->capability);
free(c->label);
+ free(c->unique_name);
+ free(c->cgroup_root);
free(c);
}
} else {
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(mask <= _SD_BUS_CREDS_MAX, -ENOTSUP);
+ assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
assert_return(ret, -EINVAL);
if (pid == 0)
_public_ int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid) {
assert_return(c, -EINVAL);
assert_return(uid, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_UID, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_UID))
+ return -ENODATA;
*uid = c->uid;
return 0;
_public_ int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid) {
assert_return(c, -EINVAL);
assert_return(gid, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_UID, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_UID))
+ return -ENODATA;
*gid = c->gid;
return 0;
_public_ int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid) {
assert_return(c, -EINVAL);
assert_return(pid, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_PID, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_PID))
+ return -ENODATA;
assert(c->pid > 0);
*pid = c->pid;
_public_ int sd_bus_creds_get_tid(sd_bus_creds *c, pid_t *tid) {
assert_return(c, -EINVAL);
assert_return(tid, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_TID, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_TID))
+ return -ENODATA;
assert(c->tid > 0);
*tid = c->tid;
_public_ int sd_bus_creds_get_pid_starttime(sd_bus_creds *c, uint64_t *usec) {
assert_return(c, -EINVAL);
assert_return(usec, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_PID_STARTTIME, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_PID_STARTTIME))
+ return -ENODATA;
assert(c->pid_starttime > 0);
*usec = c->pid_starttime;
_public_ int sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **ret) {
assert_return(c, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_SELINUX_CONTEXT, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_SELINUX_CONTEXT))
+ return -ENODATA;
assert(c->label);
*ret = c->label;
_public_ int sd_bus_creds_get_comm(sd_bus_creds *c, const char **ret) {
assert_return(c, -EINVAL);
assert_return(ret, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_COMM, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_COMM))
+ return -ENODATA;
assert(c->comm);
*ret = c->comm;
_public_ int sd_bus_creds_get_tid_comm(sd_bus_creds *c, const char **ret) {
assert_return(c, -EINVAL);
assert_return(ret, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_TID_COMM, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_TID_COMM))
+ return -ENODATA;
assert(c->tid_comm);
*ret = c->tid_comm;
_public_ int sd_bus_creds_get_exe(sd_bus_creds *c, const char **ret) {
assert_return(c, -EINVAL);
assert_return(ret, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_EXE, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_EXE))
+ return -ENODATA;
assert(c->exe);
*ret = c->exe;
_public_ int sd_bus_creds_get_cgroup(sd_bus_creds *c, const char **ret) {
assert_return(c, -EINVAL);
assert_return(ret, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_CGROUP, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_CGROUP))
+ return -ENODATA;
assert(c->cgroup);
*ret = c->cgroup;
assert_return(c, -EINVAL);
assert_return(ret, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_UNIT, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_UNIT))
+ return -ENODATA;
assert(c->cgroup);
if (!c->unit) {
- r = cg_path_get_unit(c->cgroup, (char**) &c->unit);
+ const char *shifted;
+
+ r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
+ if (r < 0)
+ return r;
+
+ r = cg_path_get_unit(shifted, (char**) &c->unit);
if (r < 0)
return r;
}
assert_return(c, -EINVAL);
assert_return(ret, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_USER_UNIT, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_USER_UNIT))
+ return -ENODATA;
assert(c->cgroup);
if (!c->user_unit) {
- r = cg_path_get_user_unit(c->cgroup, (char**) &c->user_unit);
+ const char *shifted;
+
+ r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
+ if (r < 0)
+ return r;
+
+ r = cg_path_get_user_unit(shifted, (char**) &c->user_unit);
if (r < 0)
return r;
}
assert_return(c, -EINVAL);
assert_return(ret, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_SLICE, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_SLICE))
+ return -ENODATA;
assert(c->cgroup);
if (!c->slice) {
- r = cg_path_get_slice(c->cgroup, (char**) &c->slice);
+ const char *shifted;
+
+ r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
+ if (r < 0)
+ return r;
+
+ r = cg_path_get_slice(shifted, (char**) &c->slice);
if (r < 0)
return r;
}
assert_return(c, -EINVAL);
assert_return(ret, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_SESSION, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_SESSION))
+ return -ENODATA;
assert(c->cgroup);
if (!c->session) {
- r = cg_path_get_session(c->cgroup, (char**) &c->session);
+ const char *shifted;
+
+ r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
+ if (r < 0)
+ return r;
+
+ r = cg_path_get_session(shifted, (char**) &c->session);
if (r < 0)
return r;
}
}
_public_ int sd_bus_creds_get_owner_uid(sd_bus_creds *c, uid_t *uid) {
+ const char *shifted;
+ int r;
+
assert_return(c, -EINVAL);
assert_return(uid, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_OWNER_UID, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_OWNER_UID))
+ return -ENODATA;
assert(c->cgroup);
- return cg_path_get_owner_uid(c->cgroup, uid);
+ r = cg_shift_path(c->cgroup, c->cgroup_root, &shifted);
+ if (r < 0)
+ return r;
+
+ return cg_path_get_owner_uid(shifted, uid);
}
_public_ int sd_bus_creds_get_cmdline(sd_bus_creds *c, char ***cmdline) {
- size_t n, i;
- const char *p;
- bool first;
-
assert_return(c, -EINVAL);
- assert_return(c->cmdline, -ESRCH);
- assert_return(c->mask & SD_BUS_CREDS_CMDLINE, -ENODATA);
-
- assert(c->cmdline);
- for (p = c->cmdline, n = 0; p < c->cmdline + c->cmdline_length; p++)
- if (*p == 0)
- n++;
-
- *(char***) &c->cmdline_array = new(char*, n + 1);
- if (!c->cmdline_array)
- return -ENOMEM;
+ if (!(c->mask & SD_BUS_CREDS_CMDLINE))
+ return -ENODATA;
- for (p = c->cmdline, i = 0, first = true; p < c->cmdline + c->cmdline_length; p++) {
- if (first)
- c->cmdline_array[i++] = (char*) p;
+ assert_return(c->cmdline, -ESRCH);
+ assert(c->cmdline);
- first = *p == 0;
+ if (!c->cmdline_array) {
+ c->cmdline_array = strv_parse_nulstr(c->cmdline, c->cmdline_size);
+ if (!c->cmdline_array)
+ return -ENOMEM;
}
- c->cmdline_array[i] = NULL;
*cmdline = c->cmdline_array;
-
return 0;
}
_public_ int sd_bus_creds_get_audit_session_id(sd_bus_creds *c, uint32_t *sessionid) {
assert_return(c, -EINVAL);
assert_return(sessionid, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_AUDIT_SESSION_ID, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_AUDIT_SESSION_ID))
+ return -ENODATA;
*sessionid = c->audit_session_id;
return 0;
_public_ int sd_bus_creds_get_audit_login_uid(sd_bus_creds *c, uid_t *uid) {
assert_return(c, -EINVAL);
assert_return(uid, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_AUDIT_LOGIN_UID, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_AUDIT_LOGIN_UID))
+ return -ENODATA;
*uid = c->audit_login_uid;
return 0;
}
+_public_ int sd_bus_creds_get_unique_name(sd_bus_creds *c, const char **unique_name) {
+ assert_return(c, -EINVAL);
+ assert_return(unique_name, -EINVAL);
+
+ if (!(c->mask & SD_BUS_CREDS_UNIQUE_NAME))
+ return -ENODATA;
+
+ *unique_name = c->unique_name;
+ return 0;
+}
+
+_public_ int sd_bus_creds_get_well_known_names(sd_bus_creds *c, char ***well_known_names) {
+ assert_return(c, -EINVAL);
+ assert_return(well_known_names, -EINVAL);
+
+ if (!(c->mask & SD_BUS_CREDS_WELL_KNOWN_NAMES))
+ return -ENODATA;
+
+ *well_known_names = c->well_known_names;
+ return 0;
+}
+
static int has_cap(sd_bus_creds *c, unsigned offset, int capability) {
size_t sz;
_public_ int sd_bus_creds_has_effective_cap(sd_bus_creds *c, int capability) {
assert_return(c, -EINVAL);
assert_return(capability >= 0, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_EFFECTIVE_CAPS, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_EFFECTIVE_CAPS))
+ return -ENODATA;
return has_cap(c, CAP_OFFSET_EFFECTIVE, capability);
}
_public_ int sd_bus_creds_has_permitted_cap(sd_bus_creds *c, int capability) {
assert_return(c, -EINVAL);
assert_return(capability >= 0, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_PERMITTED_CAPS, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_PERMITTED_CAPS))
+ return -ENODATA;
return has_cap(c, CAP_OFFSET_PERMITTED, capability);
}
_public_ int sd_bus_creds_has_inheritable_cap(sd_bus_creds *c, int capability) {
assert_return(c, -EINVAL);
assert_return(capability >= 0, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_INHERITABLE_CAPS, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_INHERITABLE_CAPS))
+ return -ENODATA;
return has_cap(c, CAP_OFFSET_INHERITABLE, capability);
}
_public_ int sd_bus_creds_has_bounding_cap(sd_bus_creds *c, int capability) {
assert_return(c, -EINVAL);
assert_return(capability >= 0, -EINVAL);
- assert_return(c->mask & SD_BUS_CREDS_BOUNDING_CAPS, -ENODATA);
+
+ if (!(c->mask & SD_BUS_CREDS_BOUNDING_CAPS))
+ return -ENODATA;
return has_cap(c, CAP_OFFSET_BOUNDING, capability);
}
if (missing & SD_BUS_CREDS_COMM) {
r = get_process_comm(pid, &c->comm);
- if (r < 0 && r != -ESRCH)
+ if (r < 0)
return r;
- else if (r >= 0)
- c->mask |= SD_BUS_CREDS_COMM;
+
+ c->mask |= SD_BUS_CREDS_COMM;
}
if (missing & SD_BUS_CREDS_EXE) {
const char *p;
p = procfs_file_alloca(pid, "cmdline");
- r = read_full_file(p, &c->cmdline, &c->cmdline_length);
+ r = read_full_file(p, &c->cmdline, &c->cmdline_size);
if (r < 0)
return r;
- if (c->cmdline_length == 0) {
+ if (c->cmdline_size == 0) {
free(c->cmdline);
c->cmdline = NULL;
} else
return -ENOMEM;
r = read_one_line_file(p, &c->tid_comm);
- if (r < 0 && r != -ENOENT)
+ if (r < 0)
return r == -ENOENT ? -ESRCH : r;
- else if (r >= 0)
- c->mask |= SD_BUS_CREDS_TID_COMM;
+
+ c->mask |= SD_BUS_CREDS_TID_COMM;
}
if (missing & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID)) {
r = cg_pid_get_path(NULL, pid, &c->cgroup);
- if (r < 0 && r != -ESRCH)
+ if (r < 0)
return r;
- else if (r >= 0)
- c->mask |= missing & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID);
+
+ r = cg_get_root_path(&c->cgroup_root);
+ if (r < 0)
+ return r;
+
+ c->mask |= missing & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID);
}
if (missing & SD_BUS_CREDS_AUDIT_SESSION_ID) {
return 0;
}
-_public_ int sd_bus_creds_extend(sd_bus_creds *c, uint64_t mask, sd_bus_creds **ret) {
+int bus_creds_extend_by_pid(sd_bus_creds *c, uint64_t mask, sd_bus_creds **ret) {
_cleanup_bus_creds_unref_ sd_bus_creds *n = NULL;
int r;
- assert_return(c, -EINVAL);
- assert_return(ret, -EINVAL);
+ assert(c);
+ assert(ret);
if ((mask & ~c->mask) == 0) {
/* There's already all data we need. */
}
if (c->mask & mask & SD_BUS_CREDS_CMDLINE) {
- n->cmdline = memdup(c->cmdline, c->cmdline_length);
+ n->cmdline = memdup(c->cmdline, c->cmdline_size);
if (!n->cmdline)
return -ENOMEM;
- n->cmdline_length = c->cmdline_length;
+ n->cmdline_size = c->cmdline_size;
n->mask |= SD_BUS_CREDS_CMDLINE;
}
if (!n->cgroup)
return -ENOMEM;
+ n->cgroup_root = strdup(c->cgroup_root);
+ if (!n->cgroup_root)
+ return -ENOMEM;
+
n->mask |= mask & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_OWNER_UID);
}
n->mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID;
}
+ if (c->mask & mask & SD_BUS_CREDS_UNIQUE_NAME) {
+ n->unique_name = strdup(c->unique_name);
+ if (!n->unique_name)
+ return -ENOMEM;
+ }
+
+ if (c->mask & mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
+ n->well_known_names = strv_copy(c->well_known_names);
+ if (!n->well_known_names)
+ return -ENOMEM;
+ }
+
/* Get more data */
r = bus_creds_add_more(n, mask,
~ianmdlvl / elogind.git / blobdiff