HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-bus/bus-creds.c

37,730 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 0b2a402251cb61262856a1b378c4b332b02857a6

Lines 1001–1166 of 1,166

                                                        return r;
 
                                                c->mask |= SD_BUS_CREDS_INHERITABLE_CAPS;
                                                continue;
                                        }
                                }
 
                                if (missing & SD_BUS_CREDS_BOUNDING_CAPS) {
                                        p = first_word(line, "CapBnd:");
                                        if (p) {
                                                r = parse_caps(c, CAP_OFFSET_BOUNDING, p);
                                                if (r < 0)
                                                        return r;
 
                                                c->mask |= SD_BUS_CREDS_BOUNDING_CAPS;
                                                continue;
                                        }
                                }
                        }
                }
        }
 
        if (missing & SD_BUS_CREDS_SELINUX_CONTEXT) {
                const char *p;
 
                p = procfs_file_alloca(pidref->pid, "attr/current");
                r = read_one_line_file(p, &c->label);
                if (r < 0) {
                        if (!IN_SET(r, -ENOENT, -EINVAL, -EPERM, -EACCES))
                                return r;
                } else
                        c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
        }
 
        if (missing & SD_BUS_CREDS_COMM) {
                r = pid_get_comm(pidref->pid, &c->comm);
                if (r < 0) {
                        if (!ERRNO_IS_PRIVILEGE(r))
                                return r;
                } else
                        c->mask |= SD_BUS_CREDS_COMM;
        }
 
        if (missing & SD_BUS_CREDS_EXE) {
                r = get_process_exe(pidref->pid, &c->exe);
                if (r == -ESRCH) {
                        /* Unfortunately we cannot really distinguish
                         * the case here where the process does not
                         * exist, and /proc/$PID/exe being unreadable
                         * because $PID is a kernel thread. Hence,
                         * assume it is a kernel thread, and rely on
                         * that this case is caught with a later
                         * call. */
                        c->exe = NULL;
                        c->mask |= SD_BUS_CREDS_EXE;
                } else if (r < 0) {
                        if (!ERRNO_IS_PRIVILEGE(r))
                                return r;
                } else
                        c->mask |= SD_BUS_CREDS_EXE;
        }
 
        if (missing & SD_BUS_CREDS_CMDLINE) {
                const char *p;
 
                p = procfs_file_alloca(pidref->pid, "cmdline");
                r = read_full_file(p, &c->cmdline, &c->cmdline_size);
                if (r == -ENOENT)
                        return -ESRCH;
                if (r < 0) {
                        if (!ERRNO_IS_PRIVILEGE(r))
                                return r;
                } else {
                        if (c->cmdline_size == 0)
                                c->cmdline = mfree(c->cmdline);
 
                        c->mask |= SD_BUS_CREDS_CMDLINE;
                }
        }
 
        if (tid > 0 && (missing & SD_BUS_CREDS_TID_COMM)) {
                _cleanup_free_ char *p = NULL;
 
                if (asprintf(&p, "/proc/"PID_FMT"/task/"PID_FMT"/comm", pidref->pid, tid) < 0)
                        return -ENOMEM;
 
                r = read_one_line_file(p, &c->tid_comm);
                if (r == -ENOENT)
                        return -ESRCH;
                if (r < 0) {
                        if (!ERRNO_IS_PRIVILEGE(r))
                                return r;
                } else
                        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_USER_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID)) {
 
                if (!c->cgroup) {
                        r = cg_pid_get_path(pidref->pid, &c->cgroup);
                        if (r < 0 && !ERRNO_IS_NEG_PRIVILEGE(r))
                                return r;
                }
 
                if (!c->cgroup_root) {
                        r = cg_get_root_path(&c->cgroup_root);
                        if (r < 0)
                                return r;
                }
 
                if (c->cgroup)
                        c->mask |= missing & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_USER_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID);
        }
 
        if (missing & SD_BUS_CREDS_AUDIT_SESSION_ID) {
                r = audit_session_from_pid(pidref, &c->audit_session_id);
                if (r == -ENODATA) {
                        /* ENODATA means: no audit session id assigned */
                        c->audit_session_id = AUDIT_SESSION_INVALID;
                        c->mask |= SD_BUS_CREDS_AUDIT_SESSION_ID;
                } else if (r < 0) {
                        if (!IN_SET(r, -EOPNOTSUPP, -ENOENT, -EPERM, -EACCES))
                                return r;
                } else
                        c->mask |= SD_BUS_CREDS_AUDIT_SESSION_ID;
        }
 
        if (missing & SD_BUS_CREDS_AUDIT_LOGIN_UID) {
                r = audit_loginuid_from_pid(pidref, &c->audit_login_uid);
                if (r == -ENODATA) {
                        /* ENODATA means: no audit login uid assigned */
                        c->audit_login_uid = UID_INVALID;
                        c->mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID;
                } else if (r < 0) {
                        if (!IN_SET(r, -EOPNOTSUPP, -ENOENT, -EPERM, -EACCES))
                                return r;
                } else
                        c->mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID;
        }
 
        if (missing & SD_BUS_CREDS_TTY) {
                r = get_ctty(pidref->pid, NULL, &c->tty);
                if (r == -ENXIO) {
                        /* ENXIO means: process has no controlling TTY */
                        c->tty = NULL;
                        c->mask |= SD_BUS_CREDS_TTY;
                } else if (r < 0) {
                        if (!IN_SET(r, -EPERM, -EACCES, -ENOENT))
                                return r;
                } else
                        c->mask |= SD_BUS_CREDS_TTY;
        }
 
        r = pidref_verify(pidref);
        if (r < 0)
                return r;
 
        /* Validate tid is still valid, too */
        if (tid > 0 && tid != pidref->pid && pid_is_unwaited(tid) == 0)
                return -ESRCH;
 
        c->augmented = missing & c->mask;
 
        return 0;
}