HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/ask-password-api.c

40,553 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: a6f7136a305bbed932fcbe20188e6ab3c1b0647b

Lines 1001–1188 of 1,188

 
                r = ppoll_usec(pollfd, n_pollfd, timeout);
                if (r == -EINTR)
                        continue;
                if (r < 0)
                        return r;
                if (r == 0)
                        return -ETIME;
 
                if (pollfd[POLL_SIGNAL].revents & POLLIN)
                        return -EINTR;
 
                if (req->hup_fd >= 0 && pollfd[hup_fd_idx].revents & POLLHUP)
                        return -ECONNRESET;
 
                if (inotify_fd >= 0 && pollfd[inotify_idx].revents != 0) {
                        (void) flush_fd(inotify_fd);
 
                        if (req->keyring) {
                                r = ask_password_keyring(req, flags, ret);
                                if (r != -ENOKEY)
                                        return r;
                        }
                }
 
                if (pollfd[POLL_SOCKET].revents == 0)
                        continue;
                if (pollfd[POLL_SOCKET].revents != POLLIN)
                        return -EIO;
 
                char passphrase[LINE_MAX+1];
                struct iovec iovec = IOVEC_MAKE(passphrase, sizeof(passphrase));
                CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct ucred))) control;
                struct msghdr msghdr = {
                        .msg_iov = &iovec,
                        .msg_iovlen = 1,
                        .msg_control = &control,
                        .msg_controllen = sizeof(control),
                };
 
                ssize_t n = recvmsg_safe(socket_fd, &msghdr, 0);
                if (ERRNO_IS_NEG_TRANSIENT(n))
                        continue;
                if (n == -ECHRNG) {
                        log_debug_errno(n, "Got message with truncated control data (unexpected fds sent?), ignoring.");
                        continue;
                }
                if (n == -EXFULL) {
                        log_debug_errno(n, "Got message with truncated payload data, ignoring.");
                        continue;
                }
                if (n < 0)
                        return n;
 
                CLEANUP_ERASE(passphrase);
 
                cmsg_close_all(&msghdr);
 
                if (n == 0) {
                        log_debug("Got empty reply from ask-password agent, ignoring.");
                        continue;
                }
 
                struct ucred *ucred = CMSG_FIND_DATA(&msghdr, SOL_SOCKET, SCM_CREDENTIALS, struct ucred);
                if (!ucred) {
                        log_debug("Received message without credentials, ignoring.");
                        continue;
                }
                if (ucred->uid != getuid() && ucred->uid != 0) {
                        log_debug("Got password response from bad user, ignoring.");
                        continue;
                }
 
                if (passphrase[0] == '-')
                        return -ECANCELED;
 
                if (passphrase[0] == '+') {
                        /* An empty message refers to the empty password */
                        if (n == 1)
                                l = strv_new("");
                        else
                                l = strv_parse_nulstr(passphrase+1, n-1);
                        if (!l)
                                return -ENOMEM;
 
                        if (!strv_isempty(l))
                                break;
 
                        l = strv_free(l);
                }
 
                log_debug("Got invalid response from ask-password agent, ignoring.");
        }
 
        if (req->keyring)
                (void) add_to_keyring_and_log(req->keyring, flags, l);
 
        *ret = TAKE_PTR(l);
        return 0;
}
 
static int ask_password_credential(const AskPasswordRequest *req, AskPasswordFlags flags, char ***ret) {
        _cleanup_(erase_and_freep) char *buffer = NULL;
        _cleanup_strv_free_erase_ char **l = NULL;
        size_t size;
        int r;
 
        assert(req);
        assert(req->credential);
        assert(ret);
 
        r = read_credential(req->credential, (void**) &buffer, &size);
        if (IN_SET(r, -ENXIO, -ENOENT)) /* No credentials passed or this credential not defined? */
                return -ENOKEY;
        if (r < 0)
                return r;
 
        l = strv_parse_nulstr(buffer, size);
        if (!l)
                return -ENOMEM;
 
        if (strv_isempty(l))
                return log_debug_errno(SYNTHETIC_ERRNO(ENOKEY), "Found an empty password in credential.");
 
        *ret = TAKE_PTR(l);
        return 0;
}
 
int ask_password_auto(
                const AskPasswordRequest *req,
                AskPasswordFlags flags,
                char ***ret) {
 
        int r;
 
        assert(req);
        assert(ret);
 
        /* Returns the following well-known errors:
         *
         *      -ETIME → a timeout was specified and hit
         *    -EUNATCH → couldn't ask interactively and no cached password available either
         *     -ENOENT → the specified flag file disappeared
         *  -ECANCELED → the user explicitly cancelled the request
         *      -EINTR → SIGINT/SIGTERM where received during the query
         *    -ENOEXEC → headless mode was requested but no password could be acquired non-interactively
         * -ECONNRESET → a POLLHUP has been seen on the specified hup_fd
         */
 
        if (!FLAGS_SET(flags, ASK_PASSWORD_NO_CREDENTIAL) && req->credential) {
                r = ask_password_credential(req, flags, ret);
                if (r != -ENOKEY)
                        return r;
        }
 
        if (FLAGS_SET(flags, ASK_PASSWORD_ACCEPT_CACHED) &&
            req->keyring &&
            (FLAGS_SET(flags, ASK_PASSWORD_NO_TTY) || !isatty_safe(STDIN_FILENO)) &&
            FLAGS_SET(flags, ASK_PASSWORD_NO_AGENT)) {
                r = ask_password_keyring(req, flags, ret);
                if (r != -ENOKEY)
                        return r;
        }
 
        if (!FLAGS_SET(flags, ASK_PASSWORD_NO_TTY) && isatty_safe(STDIN_FILENO))
                return ask_password_tty(req, flags, ret);
 
        if (!FLAGS_SET(flags, ASK_PASSWORD_NO_AGENT))
                return ask_password_agent(req, flags, ret);
 
        return -EUNATCH;
}
 
int acquire_user_ask_password_directory(char **ret) {
        int r;
 
        r = xdg_user_runtime_dir("systemd/ask-password", ret);
        if (r == -ENXIO) {
                if (ret)
                        *ret = NULL;
                return 0;
        }
        if (r < 0)
                return r;
 
        return 1;
}