* requested metadata on object is missing → -ENODATA
*/
-_public_ int sd_pid_get_session(pid_t pid, char **session) {
+_public_ int sd_pid_get_session(pid_t pid, char **ret_session) {
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(session, -EINVAL);
- r = cg_pid_get_session(pid, session);
+ r = cg_pid_get_session(pid, ret_session);
return IN_SET(r, -ENXIO, -ENOMEDIUM) ? -ENODATA : r;
}
-_public_ int sd_pid_get_unit(pid_t pid, char **unit) {
+_public_ int sd_pid_get_unit(pid_t pid, char **ret_unit) {
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(unit, -EINVAL);
- r = cg_pid_get_unit(pid, unit);
+ r = cg_pid_get_unit(pid, ret_unit);
return IN_SET(r, -ENXIO, -ENOMEDIUM) ? -ENODATA : r;
}
-_public_ int sd_pid_get_user_unit(pid_t pid, char **unit) {
+_public_ int sd_pid_get_user_unit(pid_t pid, char **ret_unit) {
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(unit, -EINVAL);
- r = cg_pid_get_user_unit(pid, unit);
+ r = cg_pid_get_user_unit(pid, ret_unit);
return IN_SET(r, -ENXIO, -ENOMEDIUM) ? -ENODATA : r;
}
-_public_ int sd_pid_get_machine_name(pid_t pid, char **name) {
+_public_ int sd_pid_get_machine_name(pid_t pid, char **ret_name) {
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(name, -EINVAL);
- r = cg_pid_get_machine_name(pid, name);
+ r = cg_pid_get_machine_name(pid, ret_name);
return IN_SET(r, -ENXIO, -ENOMEDIUM) ? -ENODATA : r;
}
-_public_ int sd_pid_get_slice(pid_t pid, char **slice) {
+_public_ int sd_pid_get_slice(pid_t pid, char **ret_slice) {
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(slice, -EINVAL);
- r = cg_pid_get_slice(pid, slice);
+ r = cg_pid_get_slice(pid, ret_slice);
return IN_SET(r, -ENXIO, -ENOMEDIUM) ? -ENODATA : r;
}
-_public_ int sd_pid_get_user_slice(pid_t pid, char **slice) {
+_public_ int sd_pid_get_user_slice(pid_t pid, char **ret_slice) {
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(slice, -EINVAL);
- r = cg_pid_get_user_slice(pid, slice);
+ r = cg_pid_get_user_slice(pid, ret_slice);
return IN_SET(r, -ENXIO, -ENOMEDIUM) ? -ENODATA : r;
}
-_public_ int sd_pid_get_owner_uid(pid_t pid, uid_t *uid) {
+_public_ int sd_pid_get_owner_uid(pid_t pid, uid_t *ret_uid) {
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(uid, -EINVAL);
- r = cg_pid_get_owner_uid(pid, uid);
+ r = cg_pid_get_owner_uid(pid, ret_uid);
return IN_SET(r, -ENXIO, -ENOMEDIUM) ? -ENODATA : r;
}
-_public_ int sd_pid_get_cgroup(pid_t pid, char **cgroup) {
- char *c;
+_public_ int sd_pid_get_cgroup(pid_t pid, char **ret_cgroup) {
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(cgroup, -EINVAL);
+ _cleanup_free_ char *c = NULL;
r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, pid, &c);
if (r < 0)
return r;
- /* The internal APIs return the empty string for the root
- * cgroup, let's return the "/" in the public APIs instead, as
- * that's easier and less ambiguous for people to grok. */
- if (isempty(c)) {
- r = free_and_strdup(&c, "/");
- if (r < 0)
- return r;
+ if (ret_cgroup) {
+ /* The internal APIs return the empty string for the root cgroup, let's return the "/" in the
+ * public APIs instead, as that's easier and less ambiguous for people to grok. */
+ if (isempty(c)) {
+ r = free_and_strdup(&c, "/");
+ if (r < 0)
+ return r;
+ }
+ *ret_cgroup = TAKE_PTR(c);
}
- *cgroup = c;
return 0;
}
int r;
assert_return(pidfd >= 0, -EBADF);
- assert_return(ret_session, -EINVAL);
r = pidfd_get_pid(pidfd, &pid);
if (r < 0)
if (r < 0)
return r;
- *ret_session = TAKE_PTR(session);
-
+ if (ret_session)
+ *ret_session = TAKE_PTR(session);
return 0;
}
int r;
assert_return(pidfd >= 0, -EBADF);
- assert_return(ret_unit, -EINVAL);
r = pidfd_get_pid(pidfd, &pid);
if (r < 0)
if (r < 0)
return r;
- *ret_unit = TAKE_PTR(unit);
-
+ if (ret_unit)
+ *ret_unit = TAKE_PTR(unit);
return 0;
}
int r;
assert_return(pidfd >= 0, -EBADF);
- assert_return(ret_unit, -EINVAL);
r = pidfd_get_pid(pidfd, &pid);
if (r < 0)
if (r < 0)
return r;
- *ret_unit = TAKE_PTR(unit);
-
+ if (ret_unit)
+ *ret_unit = TAKE_PTR(unit);
return 0;
}
int r;
assert_return(pidfd >= 0, -EBADF);
- assert_return(ret_name, -EINVAL);
r = pidfd_get_pid(pidfd, &pid);
if (r < 0)
if (r < 0)
return r;
- *ret_name = TAKE_PTR(name);
-
+ if (ret_name)
+ *ret_name = TAKE_PTR(name);
return 0;
}
int r;
assert_return(pidfd >= 0, -EBADF);
- assert_return(ret_slice, -EINVAL);
r = pidfd_get_pid(pidfd, &pid);
if (r < 0)
if (r < 0)
return r;
- *ret_slice = TAKE_PTR(slice);
-
+ if (ret_slice)
+ *ret_slice = TAKE_PTR(slice);
return 0;
}
int r;
assert_return(pidfd >= 0, -EBADF);
- assert_return(ret_slice, -EINVAL);
r = pidfd_get_pid(pidfd, &pid);
if (r < 0)
if (r < 0)
return r;
- *ret_slice = TAKE_PTR(slice);
-
+ if (ret_slice)
+ *ret_slice = TAKE_PTR(slice);
return 0;
}
int r;
assert_return(pidfd >= 0, -EINVAL);
- assert_return(ret_uid, -EINVAL);
r = pidfd_get_pid(pidfd, &pid);
if (r < 0)
if (r < 0)
return r;
- *ret_uid = uid;
-
+ if (ret_uid)
+ *ret_uid = uid;
return 0;
}
int r;
assert_return(pidfd >= 0, -EBADF);
- assert_return(ret_cgroup, -EINVAL);
r = pidfd_get_pid(pidfd, &pid);
if (r < 0)
if (r < 0)
return r;
- *ret_cgroup = TAKE_PTR(cgroup);
-
+ if (ret_cgroup)
+ *ret_cgroup = TAKE_PTR(cgroup);
return 0;
}
-_public_ int sd_peer_get_session(int fd, char **ret) {
+_public_ int sd_peer_get_session(int fd, char **ret_session) {
int r;
assert_return(fd >= 0, -EBADF);
- assert_return(ret, -EINVAL);
_cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
r = getpeerpidref(fd, &pidref);
if (r < 0)
return r;
- return cg_pidref_get_session(&pidref, ret);
+ return cg_pidref_get_session(&pidref, ret_session);
}
-_public_ int sd_peer_get_owner_uid(int fd, uid_t *ret) {
+_public_ int sd_peer_get_owner_uid(int fd, uid_t *ret_uid) {
int r;
assert_return(fd >= 0, -EBADF);
- assert_return(ret, -EINVAL);
_cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
r = getpeerpidref(fd, &pidref);
if (r < 0)
return r;
- return cg_pidref_get_owner_uid(&pidref, ret);
+ return cg_pidref_get_owner_uid(&pidref, ret_uid);
}
-_public_ int sd_peer_get_unit(int fd, char **ret) {
+_public_ int sd_peer_get_unit(int fd, char **ret_unit) {
int r;
assert_return(fd >= 0, -EBADF);
- assert_return(ret, -EINVAL);
_cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
r = getpeerpidref(fd, &pidref);
if (r < 0)
return r;
- return cg_pidref_get_unit(&pidref, ret);
+ return cg_pidref_get_unit(&pidref, ret_unit);
}
-_public_ int sd_peer_get_user_unit(int fd, char **unit) {
+_public_ int sd_peer_get_user_unit(int fd, char **ret_unit) {
struct ucred ucred;
int r;
assert_return(fd >= 0, -EBADF);
- assert_return(unit, -EINVAL);
r = getpeercred(fd, &ucred);
if (r < 0)
return r;
- return cg_pid_get_user_unit(ucred.pid, unit);
+ return cg_pid_get_user_unit(ucred.pid, ret_unit);
}
-_public_ int sd_peer_get_machine_name(int fd, char **machine) {
+_public_ int sd_peer_get_machine_name(int fd, char **ret_machine) {
struct ucred ucred;
int r;
assert_return(fd >= 0, -EBADF);
- assert_return(machine, -EINVAL);
r = getpeercred(fd, &ucred);
if (r < 0)
return r;
- return cg_pid_get_machine_name(ucred.pid, machine);
+ return cg_pid_get_machine_name(ucred.pid, ret_machine);
}
-_public_ int sd_peer_get_slice(int fd, char **slice) {
+_public_ int sd_peer_get_slice(int fd, char **ret_slice) {
struct ucred ucred;
int r;
assert_return(fd >= 0, -EBADF);
- assert_return(slice, -EINVAL);
r = getpeercred(fd, &ucred);
if (r < 0)
return r;
- return cg_pid_get_slice(ucred.pid, slice);
+ return cg_pid_get_slice(ucred.pid, ret_slice);
}
-_public_ int sd_peer_get_user_slice(int fd, char **slice) {
+_public_ int sd_peer_get_user_slice(int fd, char **ret_slice) {
struct ucred ucred;
int r;
assert_return(fd >= 0, -EBADF);
- assert_return(slice, -EINVAL);
r = getpeercred(fd, &ucred);
if (r < 0)
return r;
- return cg_pid_get_user_slice(ucred.pid, slice);
+ return cg_pid_get_user_slice(ucred.pid, ret_slice);
}
-_public_ int sd_peer_get_cgroup(int fd, char **cgroup) {
+_public_ int sd_peer_get_cgroup(int fd, char **ret_cgroup) {
struct ucred ucred;
int r;
assert_return(fd >= 0, -EBADF);
- assert_return(cgroup, -EINVAL);
r = getpeercred(fd, &ucred);
if (r < 0)
return r;
- return sd_pid_get_cgroup(ucred.pid, cgroup);
+ return sd_pid_get_cgroup(ucred.pid, ret_cgroup);
}
-static int file_of_uid(uid_t uid, char **p) {
+static int file_of_uid(uid_t uid, char **ret) {
assert_return(uid_is_valid(uid), -EINVAL);
- assert(p);
+ assert(ret);
- if (asprintf(p, "/run/systemd/users/" UID_FMT, uid) < 0)
+ if (asprintf(ret, "/run/systemd/users/" UID_FMT, uid) < 0)
return -ENOMEM;
return 0;
}
-_public_ int sd_uid_get_state(uid_t uid, char**state) {
+_public_ int sd_uid_get_state(uid_t uid, char **ret_state) {
_cleanup_free_ char *p = NULL, *s = NULL;
int r;
- assert_return(state, -EINVAL);
-
r = file_of_uid(uid, &p);
if (r < 0)
return r;
- r = parse_env_file(NULL, p, "STATE", &s);
+ r = parse_env_file(/* f= */ NULL, p, "STATE", &s);
if (r == -ENOENT)
r = free_and_strdup(&s, "offline");
if (r < 0)
if (isempty(s))
return -EIO;
- *state = TAKE_PTR(s);
+ if (ret_state)
+ *ret_state = TAKE_PTR(s);
return 0;
}
-_public_ int sd_uid_get_display(uid_t uid, char **session) {
+_public_ int sd_uid_get_display(uid_t uid, char **ret_session) {
_cleanup_free_ char *p = NULL, *s = NULL;
int r;
- assert_return(session, -EINVAL);
-
r = file_of_uid(uid, &p);
if (r < 0)
return r;
- r = parse_env_file(NULL, p, "DISPLAY", &s);
+ r = parse_env_file(/* f= */ NULL, p, "DISPLAY", &s);
if (r == -ENOENT)
return -ENODATA;
if (r < 0)
if (isempty(s))
return -ENODATA;
- *session = TAKE_PTR(s);
-
+ if (ret_session)
+ *ret_session = TAKE_PTR(s);
return 0;
}
-_public_ int sd_uid_get_login_time(uid_t uid, uint64_t *usec) {
+_public_ int sd_uid_get_login_time(uid_t uid, uint64_t *ret_usec) {
_cleanup_free_ char *p = NULL, *s = NULL, *rt = NULL;
- usec_t t;
int r;
- assert_return(usec, -EINVAL);
-
r = file_of_uid(uid, &p);
if (r < 0)
return r;
- r = parse_env_file(NULL, p, "STATE", &s, "REALTIME", &rt);
+ r = parse_env_file(/* f= */ NULL, p, "STATE", &s, "REALTIME", &rt);
if (r == -ENOENT)
return -ENXIO;
if (r < 0)
if (!STR_IN_SET(s, "active", "online"))
return -ENXIO;
- r = safe_atou64(rt, &t);
- if (r < 0)
- return r;
-
- *usec = t;
- return 0;
+ return safe_atou64(rt, ret_usec);
}
-static int file_of_seat(const char *seat, char **_p) {
+static int file_of_seat(const char *seat, char **ret) {
char *p;
int r;
- assert(_p);
+ assert(ret);
if (seat) {
if (!filename_is_valid(seat))
if (!p)
return -ENOMEM;
- *_p = TAKE_PTR(p);
+ *ret = TAKE_PTR(p);
return 0;
}
if (r < 0)
return r;
- r = parse_env_file(NULL, filename,
+ r = parse_env_file(/* f= */ NULL, filename,
require_active ? "ACTIVE_UID" : "UIDS",
&content);
if (r == -ENOENT)
return string_contains_word(content, NULL, FORMAT_UID(uid));
}
-static int uid_get_array(uid_t uid, const char *variable, char ***array) {
+static int uid_get_array(uid_t uid, const char *variable, char ***ret_array) {
_cleanup_free_ char *p = NULL, *s = NULL;
- char **a;
int r;
assert(variable);
if (r < 0)
return r;
- r = parse_env_file(NULL, p, variable, &s);
+ r = parse_env_file(/* f= */ NULL, p, variable, &s);
if (r == -ENOENT || (r >= 0 && isempty(s))) {
- if (array)
- *array = NULL;
+ if (ret_array)
+ *ret_array = NULL;
return 0;
}
if (r < 0)
return r;
- a = strv_split(s, NULL);
+ _cleanup_strv_free_ char **a = strv_split(s, NULL);
if (!a)
return -ENOMEM;
strv_uniq(a);
r = (int) strv_length(a);
- if (array)
- *array = a;
- else
- strv_free(a);
+ if (ret_array)
+ *ret_array = TAKE_PTR(a);
return r;
}
-_public_ int sd_uid_get_sessions(uid_t uid, int require_active, char ***sessions) {
+_public_ int sd_uid_get_sessions(uid_t uid, int require_active, char ***ret_sessions) {
return uid_get_array(
uid,
require_active == 0 ? "ONLINE_SESSIONS" :
require_active > 0 ? "ACTIVE_SESSIONS" :
"SESSIONS",
- sessions);
+ ret_sessions);
}
-_public_ int sd_uid_get_seats(uid_t uid, int require_active, char ***seats) {
+_public_ int sd_uid_get_seats(uid_t uid, int require_active, char ***ret_seats) {
return uid_get_array(
uid,
require_active == 0 ? "ONLINE_SEATS" :
require_active > 0 ? "ACTIVE_SEATS" :
"SEATS",
- seats);
+ ret_seats);
}
-static int file_of_session(const char *session, char **_p) {
+static int file_of_session(const char *session, char **ret) {
char *p;
int r;
- assert(_p);
+ assert(ret);
if (session) {
if (!session_id_valid(session))
p = path_join("/run/systemd/sessions", buf);
}
-
if (!p)
return -ENOMEM;
- *_p = p;
+ *ret = p;
return 0;
}
if (r < 0)
return r;
- r = parse_env_file(NULL, p, "ACTIVE", &s);
+ r = parse_env_file(/* f= */ NULL, p, "ACTIVE", &s);
if (r == -ENOENT)
return -ENXIO;
if (r < 0)
if (r < 0)
return r;
- r = parse_env_file(NULL, p, "REMOTE", &s);
+ r = parse_env_file(/* f= */ NULL, p, "REMOTE", &s);
if (r == -ENOENT)
return -ENXIO;
if (r < 0)
return parse_boolean(s);
}
-_public_ int sd_session_get_state(const char *session, char **state) {
+_public_ int sd_session_get_state(const char *session, char **ret_state) {
_cleanup_free_ char *p = NULL, *s = NULL;
int r;
- assert_return(state, -EINVAL);
-
r = file_of_session(session, &p);
if (r < 0)
return r;
- r = parse_env_file(NULL, p, "STATE", &s);
+ r = parse_env_file(/* f= */ NULL, p, "STATE", &s);
if (r == -ENOENT)
return -ENXIO;
if (r < 0)
if (isempty(s))
return -EIO;
- *state = TAKE_PTR(s);
-
+ if (ret_state)
+ *ret_state = TAKE_PTR(s);
return 0;
}
-_public_ int sd_session_get_uid(const char *session, uid_t *uid) {
+_public_ int sd_session_get_uid(const char *session, uid_t *ret_uid) {
int r;
_cleanup_free_ char *p = NULL, *s = NULL;
- assert_return(uid, -EINVAL);
-
r = file_of_session(session, &p);
if (r < 0)
return r;
- r = parse_env_file(NULL, p, "UID", &s);
+ r = parse_env_file(/* f= */ NULL, p, "UID", &s);
if (r == -ENOENT)
return -ENXIO;
if (r < 0)
if (isempty(s))
return -EIO;
- return parse_uid(s, uid);
+ return parse_uid(s, ret_uid);
}
-static int session_get_string(const char *session, const char *field, char **value) {
+static int session_get_string(const char *session, const char *field, char **ret_value) {
_cleanup_free_ char *p = NULL, *s = NULL;
int r;
- assert_return(value, -EINVAL);
assert(field);
r = file_of_session(session, &p);
if (r < 0)
return r;
- r = parse_env_file(NULL, p, field, &s);
+ r = parse_env_file(/* f= */ NULL, p, field, &s);
if (r == -ENOENT)
return -ENXIO;
if (r < 0)
if (isempty(s))
return -ENODATA;
- *value = TAKE_PTR(s);
+ if (ret_value)
+ *ret_value = TAKE_PTR(s);
return 0;
}
-_public_ int sd_session_get_username(const char *session, char **username) {
- return session_get_string(session, "USER", username);
+_public_ int sd_session_get_username(const char *session, char **ret_username) {
+ return session_get_string(session, "USER", ret_username);
}
-_public_ int sd_session_get_seat(const char *session, char **seat) {
- return session_get_string(session, "SEAT", seat);
+_public_ int sd_session_get_seat(const char *session, char **ret_seat) {
+ return session_get_string(session, "SEAT", ret_seat);
}
-_public_ int sd_session_get_start_time(const char *session, uint64_t *usec) {
+_public_ int sd_session_get_start_time(const char *session, uint64_t *ret_usec) {
_cleanup_free_ char *p = NULL, *s = NULL;
- usec_t t;
int r;
- assert_return(usec, -EINVAL);
-
r = file_of_session(session, &p);
if (r < 0)
return r;
- r = parse_env_file(NULL, p, "REALTIME", &s);
+ r = parse_env_file(/* f= */ NULL, p, "REALTIME", &s);
if (r == -ENOENT)
return -ENXIO;
if (r < 0)
if (isempty(s))
return -EIO;
- r = safe_atou64(s, &t);
- if (r < 0)
- return r;
-
- *usec = t;
- return 0;
+ return safe_atou64(s, ret_usec);
}
-_public_ int sd_session_get_tty(const char *session, char **tty) {
- return session_get_string(session, "TTY", tty);
+_public_ int sd_session_get_tty(const char *session, char **ret_tty) {
+ return session_get_string(session, "TTY", ret_tty);
}
-_public_ int sd_session_get_vt(const char *session, unsigned *vtnr) {
+_public_ int sd_session_get_vt(const char *session, unsigned *ret_vtnr) {
_cleanup_free_ char *vtnr_string = NULL;
- unsigned u;
int r;
- assert_return(vtnr, -EINVAL);
-
r = session_get_string(session, "VTNR", &vtnr_string);
if (r < 0)
return r;
- r = safe_atou(vtnr_string, &u);
- if (r < 0)
- return r;
-
- *vtnr = u;
- return 0;
+ return safe_atou(vtnr_string, ret_vtnr);
}
-_public_ int sd_session_get_service(const char *session, char **service) {
- return session_get_string(session, "SERVICE", service);
+_public_ int sd_session_get_service(const char *session, char **ret_service) {
+ return session_get_string(session, "SERVICE", ret_service);
}
-_public_ int sd_session_get_type(const char *session, char **type) {
- return session_get_string(session, "TYPE", type);
+_public_ int sd_session_get_type(const char *session, char **ret_type) {
+ return session_get_string(session, "TYPE", ret_type);
}
-_public_ int sd_session_get_class(const char *session, char **class) {
- return session_get_string(session, "CLASS", class);
+_public_ int sd_session_get_class(const char *session, char **ret_class) {
+ return session_get_string(session, "CLASS", ret_class);
}
-_public_ int sd_session_get_desktop(const char *session, char **desktop) {
- return session_get_string(session, "DESKTOP", desktop);
+_public_ int sd_session_get_desktop(const char *session, char **ret_desktop) {
+ return session_get_string(session, "DESKTOP", ret_desktop);
}
-_public_ int sd_session_get_display(const char *session, char **display) {
- return session_get_string(session, "DISPLAY", display);
+_public_ int sd_session_get_display(const char *session, char **ret_display) {
+ return session_get_string(session, "DISPLAY", ret_display);
}
-_public_ int sd_session_get_remote_user(const char *session, char **remote_user) {
- return session_get_string(session, "REMOTE_USER", remote_user);
+_public_ int sd_session_get_remote_user(const char *session, char **ret_remote_user) {
+ return session_get_string(session, "REMOTE_USER", ret_remote_user);
}
-_public_ int sd_session_get_remote_host(const char *session, char **remote_host) {
- return session_get_string(session, "REMOTE_HOST", remote_host);
+_public_ int sd_session_get_remote_host(const char *session, char **ret_remote_host) {
+ return session_get_string(session, "REMOTE_HOST", ret_remote_host);
}
-_public_ int sd_session_get_leader(const char *session, pid_t *leader) {
+_public_ int sd_session_get_leader(const char *session, pid_t *ret_leader) {
_cleanup_free_ char *leader_string = NULL;
- pid_t pid;
int r;
- assert_return(leader, -EINVAL);
-
r = session_get_string(session, "LEADER", &leader_string);
if (r < 0)
return r;
- r = parse_pid(leader_string, &pid);
- if (r < 0)
- return r;
-
- *leader = pid;
- return 0;
+ return parse_pid(leader_string, ret_leader);
}
_public_ int sd_seat_get_active(const char *seat, char **ret_session, uid_t *ret_uid) {
_cleanup_free_ char *p = NULL, *s = NULL, *t = NULL;
int r;
- assert_return(ret_session || ret_uid, -EINVAL);
-
r = file_of_seat(seat, &p);
if (r < 0)
return r;
- r = parse_env_file(NULL, p,
+ r = parse_env_file(/* f= */ NULL, p,
"ACTIVE", &s,
"ACTIVE_UID", &t);
if (r == -ENOENT)
if (r < 0)
return r;
- r = parse_env_file(NULL, fname,
+ r = parse_env_file(/* f= */ NULL, fname,
"SESSIONS", &session_line,
"UIDS", &uid_line);
if (r == -ENOENT)
if (r < 0)
return r;
- r = parse_env_file(NULL, p,
+ r = parse_env_file(/* f= */ NULL, p,
variable, &s);
if (r == -ENOENT)
return -ENXIO;
return seat_get_can(seat, "CAN_GRAPHICAL");
}
-_public_ int sd_get_seats(char ***seats) {
+_public_ int sd_get_seats(char ***ret_seats) {
int r;
- r = get_files_in_directory("/run/systemd/seats/", seats);
+ r = get_files_in_directory("/run/systemd/seats/", ret_seats);
if (r == -ENOENT) {
- if (seats)
- *seats = NULL;
+ if (ret_seats)
+ *ret_seats = NULL;
return 0;
}
return r;
}
-_public_ int sd_get_sessions(char ***sessions) {
+_public_ int sd_get_sessions(char ***ret_sessions) {
int r;
- r = get_files_in_directory("/run/systemd/sessions/", sessions);
+ r = get_files_in_directory("/run/systemd/sessions/", ret_sessions);
if (r == -ENOENT) {
- if (sessions)
- *sessions = NULL;
+ if (ret_sessions)
+ *ret_sessions = NULL;
return 0;
}
return r;
}
-_public_ int sd_get_uids(uid_t **users) {
+_public_ int sd_get_uids(uid_t **ret_users) {
_cleanup_closedir_ DIR *d = NULL;
_cleanup_free_ uid_t *l = NULL;
size_t n = 0;
d = opendir("/run/systemd/users/");
if (!d) {
if (errno == ENOENT) {
- if (users)
- *users = NULL;
+ if (ret_users)
+ *ret_users = NULL;
return 0;
}
return -errno;
if (parse_uid(de->d_name, &uid) < 0)
continue;
- if (users) {
+ if (ret_users) {
if (!GREEDY_REALLOC(l, n + 1))
return -ENOMEM;
if (n > INT_MAX)
return -EOVERFLOW;
- if (users)
- *users = TAKE_PTR(l);
+ if (ret_users)
+ *ret_users = TAKE_PTR(l);
return (int) n;
}
-_public_ int sd_get_machine_names(char ***machines) {
+_public_ int sd_get_machine_names(char ***ret_machines) {
_cleanup_strv_free_ char **l = NULL;
char **a, **b;
int r;
r = get_files_in_directory("/run/systemd/machines/", &l);
if (r == -ENOENT) {
- if (machines)
- *machines = NULL;
+ if (ret_machines)
+ *ret_machines = NULL;
return 0;
}
if (r < 0)
*b = NULL;
}
- if (machines)
- *machines = TAKE_PTR(l);
+ if (ret_machines)
+ *ret_machines = TAKE_PTR(l);
return r;
}
-_public_ int sd_machine_get_class(const char *machine, char **class) {
+_public_ int sd_machine_get_class(const char *machine, char **ret_class) {
_cleanup_free_ char *c = NULL;
- const char *p;
int r;
- assert_return(class, -EINVAL);
-
- if (streq(machine, ".host")) {
+ if (streq_ptr(machine, ".host")) {
c = strdup("host");
if (!c)
return -ENOMEM;
if (!hostname_is_valid(machine, 0))
return -EINVAL;
- p = strjoina("/run/systemd/machines/", machine);
- r = parse_env_file(NULL, p, "CLASS", &c);
+ _cleanup_free_ char *p = path_join("/run/systemd/machines/", machine);
+ if (!p)
+ return -ENOMEM;
+
+ r = parse_env_file(/* f= */ NULL, p, "CLASS", &c);
if (r == -ENOENT)
return -ENXIO;
if (r < 0)
return -EIO;
}
- *class = TAKE_PTR(c);
+ if (ret_class)
+ *ret_class = TAKE_PTR(c);
+
return 0;
}
_public_ int sd_machine_get_ifindices(const char *machine, int **ret_ifindices) {
- _cleanup_free_ char *netif_line = NULL;
- const char *p;
+ _cleanup_free_ char *netif_line = NULL, *p = NULL;
int r;
assert_return(hostname_is_valid(machine, 0), -EINVAL);
- p = strjoina("/run/systemd/machines/", machine);
- r = parse_env_file(NULL, p, "NETIF", &netif_line);
+ p = path_join("/run/systemd/machines/", machine);
+ if (!p)
+ return -ENOMEM;
+
+ r = parse_env_file(/* f= */ NULL, p, "NETIF", &netif_line);
if (r == -ENOENT)
return -ENXIO;
if (r < 0)
return r;
if (!netif_line) {
- *ret_ifindices = NULL;
+ if (ret_ifindices)
+ *ret_ifindices = NULL;
return 0;
}
return (sd_login_monitor*) (unsigned long) (fd + 1);
}
-_public_ int sd_login_monitor_new(const char *category, sd_login_monitor **m) {
+_public_ int sd_login_monitor_new(const char *category, sd_login_monitor **ret) {
_cleanup_close_ int fd = -EBADF;
bool good = false;
int k;
- assert_return(m, -EINVAL);
+ assert_return(ret, -EINVAL);
fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
if (fd < 0)
if (!good)
return -EINVAL;
- *m = FD_TO_MONITOR(TAKE_FD(fd));
+ *ret = FD_TO_MONITOR(TAKE_FD(fd));
return 0;
}
return POLLIN;
}
-_public_ int sd_login_monitor_get_timeout(sd_login_monitor *m, uint64_t *timeout_usec) {
+_public_ int sd_login_monitor_get_timeout(sd_login_monitor *m, uint64_t *ret_timeout_usec) {
assert_return(m, -EINVAL);
- assert_return(timeout_usec, -EINVAL);
+ assert_return(ret_timeout_usec, -EINVAL);
/* For now we will only return UINT64_MAX, since we don't
* need any timeout. However, let's have this API to keep our
* options open should we later on need it. */
- *timeout_usec = UINT64_MAX;
+ *ret_timeout_usec = UINT64_MAX;
return 0;
}
* not attached to a session, but only attached to a user. This will
* return an error for system processes and 'shared' processes of a
* user. */
-int sd_pid_get_session(pid_t pid, char **session);
+int sd_pid_get_session(pid_t pid, char **ret_session);
/* Get UID of the owner of the session of the PID (or in case the
* process is a 'shared' user process, the UID of that user is
* returned). This will not return the UID of the process, but rather
* the UID of the owner of the cgroup that the process is in. This will
* return an error for system processes. */
-int sd_pid_get_owner_uid(pid_t pid, uid_t *uid);
+int sd_pid_get_owner_uid(pid_t pid, uid_t *ret_uid);
/* Get systemd non-slice unit (i.e. service) name from PID, for system
* services. This will return an error for non-service processes. */
-int sd_pid_get_unit(pid_t pid, char **unit);
+int sd_pid_get_unit(pid_t pid, char **ret_unit);
/* Get systemd non-slice unit (i.e. service) name from PID, for user
* services. This will return an error for non-user-service
* processes. */
-int sd_pid_get_user_unit(pid_t pid, char **unit);
+int sd_pid_get_user_unit(pid_t pid, char **ret_unit);
/* Get slice name from PID. */
-int sd_pid_get_slice(pid_t pid, char **slice);
+int sd_pid_get_slice(pid_t pid, char **ret_slice);
/* Get user slice name from PID. */
-int sd_pid_get_user_slice(pid_t pid, char **slice);
+int sd_pid_get_user_slice(pid_t pid, char **ret_slice);
/* Get machine name from PID, for processes assigned to a VM or
* container. This will return an error for non-machine processes. */
-int sd_pid_get_machine_name(pid_t pid, char **machine);
+int sd_pid_get_machine_name(pid_t pid, char **ret_machine);
/* Get the control group from a PID, relative to the root of the
* hierarchy. */
-int sd_pid_get_cgroup(pid_t pid, char **cgroup);
+int sd_pid_get_cgroup(pid_t pid, char **ret_cgroup);
/* Equivalent to the corresponding sd_pid_get* functions, but take a
* PIDFD instead of a PID, to ensure there can be no possible PID
* recycle issues before/after the calls. */
-int sd_pidfd_get_session(int pidfd, char **session);
-int sd_pidfd_get_owner_uid(int pidfd, uid_t *uid);
-int sd_pidfd_get_unit(int pidfd, char **unit);
-int sd_pidfd_get_user_unit(int pidfd, char **unit);
-int sd_pidfd_get_slice(int pidfd, char **slice);
-int sd_pidfd_get_user_slice(int pidfd, char **slice);
-int sd_pidfd_get_machine_name(int pidfd, char **machine);
-int sd_pidfd_get_cgroup(int pidfd, char **cgroup);
+int sd_pidfd_get_session(int pidfd, char **ret_session);
+int sd_pidfd_get_owner_uid(int pidfd, uid_t *ret_uid);
+int sd_pidfd_get_unit(int pidfd, char **ret_unit);
+int sd_pidfd_get_user_unit(int pidfd, char **ret_unit);
+int sd_pidfd_get_slice(int pidfd, char **ret_slice);
+int sd_pidfd_get_user_slice(int pidfd, char **ret_slice);
+int sd_pidfd_get_machine_name(int pidfd, char **ret_machine);
+int sd_pidfd_get_cgroup(int pidfd, char **ret_cgroup);
/* Similar to sd_pid_get_session(), but retrieves data about the peer
* of a connected AF_UNIX socket */
-int sd_peer_get_session(int fd, char **session);
+int sd_peer_get_session(int fd, char **ret_session);
/* Similar to sd_pid_get_owner_uid(), but retrieves data about the peer of
* a connected AF_UNIX socket */
-int sd_peer_get_owner_uid(int fd, uid_t *uid);
+int sd_peer_get_owner_uid(int fd, uid_t *ret_uid);
/* Similar to sd_pid_get_unit(), but retrieves data about the peer of
* a connected AF_UNIX socket */
-int sd_peer_get_unit(int fd, char **unit);
+int sd_peer_get_unit(int fd, char **ret_unit);
/* Similar to sd_pid_get_user_unit(), but retrieves data about the peer of
* a connected AF_UNIX socket */
-int sd_peer_get_user_unit(int fd, char **unit);
+int sd_peer_get_user_unit(int fd, char **ret_unit);
/* Similar to sd_pid_get_slice(), but retrieves data about the peer of
* a connected AF_UNIX socket */
-int sd_peer_get_slice(int fd, char **slice);
+int sd_peer_get_slice(int fd, char **ret_slice);
/* Similar to sd_pid_get_user_slice(), but retrieves data about the peer of
* a connected AF_UNIX socket */
-int sd_peer_get_user_slice(int fd, char **slice);
+int sd_peer_get_user_slice(int fd, char **ret_slice);
/* Similar to sd_pid_get_machine_name(), but retrieves data about the
* peer of a connected AF_UNIX socket */
-int sd_peer_get_machine_name(int fd, char **machine);
+int sd_peer_get_machine_name(int fd, char **ret_machine);
/* Similar to sd_pid_get_cgroup(), but retrieves data about the peer
* of a connected AF_UNIX socket. */
-int sd_peer_get_cgroup(int fd, char **cgroup);
+int sd_peer_get_cgroup(int fd, char **ret_cgroup);
/* Get state from UID. Possible states: offline, lingering, online, active, closing */
-int sd_uid_get_state(uid_t uid, char **state);
+int sd_uid_get_state(uid_t uid, char **ret_state);
/* Return primary session of user, if there is any */
-int sd_uid_get_display(uid_t uid, char **session);
+int sd_uid_get_display(uid_t uid, char **ret_display);
/* Determine the login time of user */
-int sd_uid_get_login_time(uid_t uid, uint64_t *usec);
+int sd_uid_get_login_time(uid_t uid, uint64_t *ret_usec);
/* Return 1 if UID has session on seat. If require_active is true, this will
* look for active sessions only. */
/* Return sessions of user. If require_active is true, this will look for
* active sessions only. Returns the number of sessions.
* If sessions is NULL, this will just return the number of sessions. */
-int sd_uid_get_sessions(uid_t uid, int require_active, char ***sessions);
+int sd_uid_get_sessions(uid_t uid, int require_active, char ***ret_sessions);
/* Return seats of user is on. If require_active is true, this will look for
* active seats only. Returns the number of seats.
* If seats is NULL, this will just return the number of seats. */
-int sd_uid_get_seats(uid_t uid, int require_active, char ***seats);
+int sd_uid_get_seats(uid_t uid, int require_active, char ***ret_seats);
/* Return 1 if the session is active. */
int sd_session_is_active(const char *session);
/* Get state from session. Possible states: online, active, closing.
* This function is a more generic version of sd_session_is_active(). */
-int sd_session_get_state(const char *session, char **state);
+int sd_session_get_state(const char *session, char **ret_state);
/* Determine user ID of session */
-int sd_session_get_uid(const char *session, uid_t *uid);
+int sd_session_get_uid(const char *session, uid_t *ret_uid);
/* Determine username of session */
-int sd_session_get_username(const char *session, char **username);
+int sd_session_get_username(const char *session, char **ret_username);
/* Determine seat of session */
-int sd_session_get_seat(const char *session, char **seat);
+int sd_session_get_seat(const char *session, char **ret_seat);
/* Determine the start time of session */
-int sd_session_get_start_time(const char *session, uint64_t *usec);
+int sd_session_get_start_time(const char *session, uint64_t *ret_usec);
/* Determine the (PAM) service name this session was registered by. */
-int sd_session_get_service(const char *session, char **service);
+int sd_session_get_service(const char *session, char **ret_service);
/* Determine the type of this session, i.e. one of "tty", "x11", "wayland", "mir", "web", or "unspecified". */
-int sd_session_get_type(const char *session, char **type);
+int sd_session_get_type(const char *session, char **ret_type);
/* Determine the class of this session, i.e. one of "user", "greeter" or "lock-screen". */
-int sd_session_get_class(const char *session, char **clazz);
+int sd_session_get_class(const char *session, char **ret_clazz);
/* Determine the desktop brand of this session, i.e. something like "GNOME", "KDE" or "systemd-console". */
-int sd_session_get_desktop(const char *session, char **desktop);
+int sd_session_get_desktop(const char *session, char **ret_desktop);
/* Determine the X11 display of this session. */
-int sd_session_get_display(const char *session, char **display);
+int sd_session_get_display(const char *session, char **ret_display);
/* Determine the leader process of this session. */
-int sd_session_get_leader(const char *session, pid_t *leader);
+int sd_session_get_leader(const char *session, pid_t *ret_leader);
/* Determine the remote host of this session. */
-int sd_session_get_remote_host(const char *session, char **remote_host);
+int sd_session_get_remote_host(const char *session, char **ret_remote_host);
/* Determine the remote user of this session (if provided by PAM). */
-int sd_session_get_remote_user(const char *session, char **remote_user);
+int sd_session_get_remote_user(const char *session, char **tre_remote_user);
/* Determine the TTY of this session. */
-int sd_session_get_tty(const char *session, char **display);
+int sd_session_get_tty(const char *session, char **ret_tty);
/* Determine the VT number of this session. */
-int sd_session_get_vt(const char *session, unsigned *vtnr);
+int sd_session_get_vt(const char *session, unsigned *ret_vtnr);
/* Return active session and user of seat */
int sd_seat_get_active(const char *seat, char **ret_session, uid_t *ret_uid);
int sd_seat_can_graphical(const char *seat);
/* Return the class of machine */
-int sd_machine_get_class(const char *machine, char **clazz);
+int sd_machine_get_class(const char *machine, char **ret_clazz);
/* Return the list if host-side network interface indices of a machine */
int sd_machine_get_ifindices(const char *machine, int **ret_ifindices);
/* Get all seats, store in *seats. Returns the number of seats. If
* seats is NULL, this only returns the number of seats. */
-int sd_get_seats(char ***seats);
+int sd_get_seats(char ***ret_seats);
/* Get all sessions, store in *sessions. Returns the number of
* sessions. If sessions is NULL, this only returns the number of sessions. */
-int sd_get_sessions(char ***sessions);
+int sd_get_sessions(char ***ret_sessions);
/* Get all logged in users, store in *users. Returns the number of
* users. If users is NULL, this only returns the number of users. */
-int sd_get_uids(uid_t **users);
+int sd_get_uids(uid_t **ret_users);
/* Get all running virtual machines/containers */
-int sd_get_machine_names(char ***machines);
+int sd_get_machine_names(char ***ret_machines);
/* Monitor object */
typedef struct sd_login_monitor sd_login_monitor;
/* Create a new monitor. Category must be NULL, "seat", "session",
* "uid", or "machine" to get monitor events for the specific category
* (or all). */
-int sd_login_monitor_new(const char *category, sd_login_monitor** ret);
+int sd_login_monitor_new(const char *category, sd_login_monitor **ret);
/* Destroys the passed monitor. Returns NULL. */
sd_login_monitor* sd_login_monitor_unref(sd_login_monitor *m);
int sd_login_monitor_get_events(sd_login_monitor *m);
/* Get timeout for poll(), as usec value relative to CLOCK_MONOTONIC's epoch */
-int sd_login_monitor_get_timeout(sd_login_monitor *m, uint64_t *timeout_usec);
+int sd_login_monitor_get_timeout(sd_login_monitor *m, uint64_t *ret_timeout_usec);
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_login_monitor, sd_login_monitor_unref);
projects / thirdparty / systemd.git / commitdiff
