HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/home/homework.c

85,525 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 08762a8022b92d5d0a385a5d1e46006ec7b4494c

Lines 2001–2182 of 2,182

static int run(int argc, char *argv[]) {
        _cleanup_(user_record_unrefp) UserRecord *home = NULL, *new_home = NULL;
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        _cleanup_fclose_ FILE *opened_file = NULL;
        _cleanup_hashmap_free_ Hashmap *blobs = NULL;
        const char *json_path = NULL, *blob_filename;
        FILE *json_file;
        usec_t start;
        sd_json_variant *fdmap, *blob_fd_variant;
        int r;
 
        LIBBLKID_NOTE(recommended);
        LIBCRYPT_NOTE(recommended);
        LIBCRYPTO_NOTE(recommended);
        LIBCRYPTSETUP_NOTE(recommended);
        LIBFDISK_NOTE(recommended);
        LIBFIDO2_NOTE(suggested);
        LIBMOUNT_NOTE(recommended);
        LIBP11KIT_NOTE(suggested);
        LIBSELINUX_NOTE(recommended);
 
        start = now(CLOCK_MONOTONIC);
 
        log_setup();
 
        umask(0022);
 
        if (argc < 2 || argc > 3)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "This program takes one or two arguments.");
 
        if (argc > 2) {
                json_path = argv[2];
 
                opened_file = fopen(json_path, "re");
                if (!opened_file)
                        return log_error_errno(errno, "Failed to open %s: %m", json_path);
 
                json_file = opened_file;
        } else {
                json_path = "<stdin>";
                json_file = stdin;
        }
 
        unsigned line = 0, column = 0;
        r = sd_json_parse_file(json_file, json_path, SD_JSON_PARSE_MUST_BE_OBJECT|SD_JSON_PARSE_SENSITIVE, &v, &line, &column);
        if (r < 0)
                return log_error_errno(r, "[%s:%u:%u] Failed to parse JSON data: %m", json_path, line, column);
 
        fdmap = sd_json_variant_by_key(v, HOMEWORK_BLOB_FDMAP_FIELD);
        if (fdmap) {
                r = hashmap_ensure_allocated(&blobs, &blob_fd_hash_ops);
                if (r < 0)
                        return log_oom();
 
                JSON_VARIANT_OBJECT_FOREACH(blob_filename, blob_fd_variant, fdmap) {
                        _cleanup_free_ char *filename = NULL;
                        _cleanup_close_ int fd = -EBADF;
 
                        assert(sd_json_variant_is_integer(blob_fd_variant));
                        assert(sd_json_variant_integer(blob_fd_variant) >= 0);
                        assert(sd_json_variant_integer(blob_fd_variant) <= INT_MAX - SD_LISTEN_FDS_START);
                        fd = SD_LISTEN_FDS_START + (int) sd_json_variant_integer(blob_fd_variant);
 
                        if (DEBUG_LOGGING) {
                                _cleanup_free_ char *resolved = NULL;
                                r = fd_get_path(fd, &resolved);
                                log_debug("Got blob from daemon: %s (%d) → %s",
                                          blob_filename, fd, resolved ?: STRERROR(r));
                        }
 
                        filename = strdup(blob_filename);
                        if (!filename)
                                return log_oom();
 
                        r = fd_cloexec(fd, true);
                        if (r < 0)
                                return log_error_errno(r, "Failed to enable O_CLOEXEC on blob %s: %m", filename);
 
                        r = hashmap_put(blobs, filename, FD_TO_PTR(fd));
                        if (r < 0)
                                return log_error_errno(r, "Failed to insert blob %s into map: %m", filename);
                        TAKE_PTR(filename); /* Ownership transfers to hashmap */
                        TAKE_FD(fd);
                }
 
                r = sd_json_variant_filter(&v, STRV_MAKE(HOMEWORK_BLOB_FDMAP_FIELD));
                if (r < 0)
                        return log_error_errno(r, "Failed to strip internal fdmap from JSON: %m");
        }
 
        home = user_record_new();
        if (!home)
                return log_oom();
 
        r = user_record_load(home, v, USER_RECORD_LOAD_FULL|USER_RECORD_LOG|USER_RECORD_PERMISSIVE);
        if (r < 0)
                return r;
 
        /* Well known return values of these operations, that systemd-homed knows and converts to proper D-Bus errors:
         *
         * EMSGSIZE        → file systems of this type cannot be shrunk
         * ETXTBSY         → file systems of this type can only be shrunk offline
         * ERANGE          → file system size too small
         * ENOLINK         → system does not support selected storage backend
         * EPROTONOSUPPORT → system does not support selected file system
         * ENOTTY          → operation not support on this storage
         * ESOCKTNOSUPPORT → operation not support on this file system
         * ENOKEY          → password incorrect (or not sufficient, or not supplied)
         * EREMOTEIO       → recovery key incorrect (or not sufficeint, or not supplied — only if no passwords defined)
         * EBADSLT         → similar, but PKCS#11 device is defined and might be able to provide password, if it was plugged in which it is not
         * ENOANO          → suitable PKCS#11/FIDO2 device found, but PIN is missing to unlock it
         * ERFKILL         → suitable PKCS#11 device found, but OK to ask for on-device interactive authentication not given
         * EMEDIUMTYPE     → suitable FIDO2 device found, but OK to ask for user presence not given
         * ENOCSI          → suitable FIDO2 device found, but OK to ask for user verification not given
         * ENOSTR          → suitable FIDO2 device found, but user didn't react to action request on token quickly enough
         * EOWNERDEAD      → suitable PKCS#11/FIDO2 device found, but its PIN is locked
         * ENOLCK          → suitable PKCS#11/FIDO2 device found, but PIN incorrect
         * ETOOMANYREFS    → suitable PKCS#11 device found, but PIN incorrect, and only few tries left
         * EUCLEAN         → suitable PKCS#11 device found, but PIN incorrect, and only one try left
         * EBUSY           → file system is currently active
         * ENOEXEC         → file system is currently not active
         * ENOSPC          → not enough disk space for operation
         * EKEYREVOKED     → user record has not suitable hashed password or pkcs#11 entry, we cannot authenticate
         * EADDRINUSE      → home image is already used elsewhere (lock taken)
         * ENETUNREACH     → backing storage is currently not (image is ENOENT, or AF_UNIX socket to connect to is ENOENT)
         */
 
        if (streq(argv[1], "activate"))
                r = home_activate(home, &new_home);
        else if (streq(argv[1], "deactivate"))
                r = home_deactivate(home, false);
        else if (streq(argv[1], "deactivate-force"))
                r = home_deactivate(home, true);
        else if (streq(argv[1], "create"))
                r = home_create(home, blobs, &new_home);
        else if (streq(argv[1], "remove"))
                r = home_remove(home);
        else if (streq(argv[1], "update"))
                r = home_update(home, blobs, &new_home);
        else if (streq(argv[1], "resize"))
                r = home_resize(home, &new_home);
        else if (streq(argv[1], "passwd"))
                r = home_passwd(home, &new_home);
        else if (streq(argv[1], "inspect"))
                r = home_inspect(home, &new_home);
        else if (streq(argv[1], "lock"))
                r = home_lock(home);
        else if (streq(argv[1], "unlock"))
                r = home_unlock(home);
        else
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown verb '%s'.", argv[1]);
        if (IN_SET(r, -ENOKEY, -EREMOTEIO) && !strv_isempty(home->password) ) { /* There were passwords specified but they were incorrect */
                usec_t end, n, d;
 
                /* Make sure bad password replies always take at least 3s, and if longer multiples of 3s, so
                 * that it's not clear how long we actually needed for our calculations. */
                n = now(CLOCK_MONOTONIC);
                assert(n >= start);
 
                d = usec_sub_unsigned(n, start);
                if (d > BAD_PASSWORD_DELAY_USEC)
                        end = start + DIV_ROUND_UP(d, BAD_PASSWORD_DELAY_USEC) * BAD_PASSWORD_DELAY_USEC;
                else
                        end = start + BAD_PASSWORD_DELAY_USEC;
 
                if (n < end)
                        (void) usleep_safe(usec_sub_unsigned(end, n));
        }
        if (r < 0)
                return r;
 
        /* We always pass the new record back, regardless if it changed or not. This allows our caller to
         * prepare a fresh record, send to us, and only if it works use it without having to keep a local
         * copy. */
        if (new_home)
                sd_json_variant_dump(new_home->json, SD_JSON_FORMAT_NEWLINE, stdout, NULL);
 
        return 0;
}
 
DEFINE_MAIN_FUNCTION(run);