chiark / gitweb /
cryptsetup: call static variables parsed from command line arg_XYZ like in all other...
authorLennart Poettering <lennart@poettering.net>
Wed, 12 Mar 2014 23:46:58 +0000 (00:46 +0100)
committerLennart Poettering <lennart@poettering.net>
Wed, 12 Mar 2014 23:46:58 +0000 (00:46 +0100)
src/cryptsetup/cryptsetup.c

index 033c0cd..4dc2b08 100644 (file)
 #include "libudev.h"
 #include "udev-util.h"
 
-static const char *opt_type = NULL; /* CRYPT_LUKS1, CRYPT_TCRYPT or CRYPT_PLAIN */
-static char *opt_cipher = NULL;
-static unsigned opt_key_size = 0;
-static int opt_key_slot = CRYPT_ANY_SLOT;
-static unsigned opt_keyfile_size = 0;
-static unsigned opt_keyfile_offset = 0;
-static char *opt_hash = NULL;
-static unsigned opt_tries = 3;
-static bool opt_readonly = false;
-static bool opt_verify = false;
-static bool opt_discards = false;
-static bool opt_tcrypt_hidden = false;
-static bool opt_tcrypt_system = false;
-static char **opt_tcrypt_keyfiles = NULL;
-static usec_t opt_timeout = 0;
+static const char *arg_type = NULL; /* CRYPT_LUKS1, CRYPT_TCRYPT or CRYPT_PLAIN */
+static char *arg_cipher = NULL;
+static unsigned arg_key_size = 0;
+static int arg_key_slot = CRYPT_ANY_SLOT;
+static unsigned arg_keyfile_size = 0;
+static unsigned arg_keyfile_offset = 0;
+static char *arg_hash = NULL;
+static unsigned arg_tries = 3;
+static bool arg_readonly = false;
+static bool arg_verify = false;
+static bool arg_discards = false;
+static bool arg_tcrypt_hidden = false;
+static bool arg_tcrypt_system = false;
+static char **arg_tcrypt_keyfiles = NULL;
+static usec_t arg_timeout = 0;
 
 /* Options Debian's crypttab knows we don't:
 
@@ -78,43 +78,43 @@ static int parse_one_option(const char *option) {
                 if (!t)
                         return log_oom();
 
-                free(opt_cipher);
-                opt_cipher = t;
+                free(arg_cipher);
+                arg_cipher = t;
 
         } else if (startswith(option, "size=")) {
 
-                if (safe_atou(option+5, &opt_key_size) < 0) {
+                if (safe_atou(option+5, &arg_key_size) < 0) {
                         log_error("size= parse failure, ignoring.");
                         return 0;
                 }
 
         } else if (startswith(option, "key-slot=")) {
 
-                opt_type = CRYPT_LUKS1;
-                if (safe_atoi(option+9, &opt_key_slot) < 0) {
+                arg_type = CRYPT_LUKS1;
+                if (safe_atoi(option+9, &arg_key_slot) < 0) {
                         log_error("key-slot= parse failure, ignoring.");
                         return 0;
                 }
 
         } else if (startswith(option, "tcrypt-keyfile=")) {
 
-                opt_type = CRYPT_TCRYPT;
+                arg_type = CRYPT_TCRYPT;
                 if (path_is_absolute(option+15)) {
-                        if (strv_extend(&opt_tcrypt_keyfiles, option + 15) < 0)
+                        if (strv_extend(&arg_tcrypt_keyfiles, option + 15) < 0)
                                 return log_oom();
                 } else
                         log_error("Key file path '%s' is not absolute. Ignoring.", option+15);
 
         } else if (startswith(option, "keyfile-size=")) {
 
-                if (safe_atou(option+13, &opt_keyfile_size) < 0) {
+                if (safe_atou(option+13, &arg_keyfile_size) < 0) {
                         log_error("keyfile-size= parse failure, ignoring.");
                         return 0;
                 }
 
         } else if (startswith(option, "keyfile-offset=")) {
 
-                if (safe_atou(option+15, &opt_keyfile_offset) < 0) {
+                if (safe_atou(option+15, &arg_keyfile_offset) < 0) {
                         log_error("keyfile-offset= parse failure, ignoring.");
                         return 0;
                 }
@@ -126,39 +126,37 @@ static int parse_one_option(const char *option) {
                 if (!t)
                         return log_oom();
 
-                free(opt_hash);
-                opt_hash = t;
+                free(arg_hash);
+                arg_hash = t;
 
         } else if (startswith(option, "tries=")) {
 
-                if (safe_atou(option+6, &opt_tries) < 0) {
+                if (safe_atou(option+6, &arg_tries) < 0) {
                         log_error("tries= parse failure, ignoring.");
                         return 0;
                 }
 
-        } else if (streq(option, "readonly") || streq(option, "read-only"))
-                opt_readonly = true;
+        } else if (STR_IN_SET(option, "readonly", "read-only"))
+                arg_readonly = true;
         else if (streq(option, "verify"))
-                opt_verify = true;
-        else if (streq(option, "allow-discards") || streq(option, "discard"))
-                opt_discards = true;
+                arg_verify = true;
+        else if (STR_IN_SET(option, "allow-discards", "discard"))
+                arg_discards = true;
         else if (streq(option, "luks"))
-                opt_type = CRYPT_LUKS1;
+                arg_type = CRYPT_LUKS1;
         else if (streq(option, "tcrypt"))
-                opt_type = CRYPT_TCRYPT;
+                arg_type = CRYPT_TCRYPT;
         else if (streq(option, "tcrypt-hidden")) {
-                opt_type = CRYPT_TCRYPT;
-                opt_tcrypt_hidden = true;
+                arg_type = CRYPT_TCRYPT;
+                arg_tcrypt_hidden = true;
         } else if (streq(option, "tcrypt-system")) {
-                opt_type = CRYPT_TCRYPT;
-                opt_tcrypt_system = true;
-        } else if (streq(option, "plain") ||
-                 streq(option, "swap") ||
-                 streq(option, "tmp"))
-                opt_type = CRYPT_PLAIN;
+                arg_type = CRYPT_TCRYPT;
+                arg_tcrypt_system = true;
+        } else if (STR_IN_SET(option, "plain", "swap", "tmp"))
+                arg_type = CRYPT_PLAIN;
         else if (startswith(option, "timeout=")) {
 
-                if (parse_sec(option+8, &opt_timeout) < 0) {
+                if (parse_sec(option+8, &arg_timeout) < 0) {
                         log_error("timeout= parse failure, ignoring.");
                         return 0;
                 }
@@ -196,12 +194,11 @@ static void log_glue(int level, const char *msg, void *usrptr) {
 
 static char* disk_description(const char *path) {
 
-        static const char name_fields[] = {
+        static const char name_fields[] =
                 "ID_PART_ENTRY_NAME\0"
                 "DM_NAME\0"
                 "ID_MODEL_FROM_DATABASE\0"
-                "ID_MODEL\0"
-        };
+                "ID_MODEL\0";
 
         _cleanup_udev_unref_ struct udev *udev = NULL;
         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
@@ -273,7 +270,7 @@ static int get_password(const char *name, usec_t until, bool accept_cached, char
                 return r;
         }
 
-        if (opt_verify) {
+        if (arg_verify) {
                 _cleanup_strv_free_ char **passwords2 = NULL;
 
                 assert(strv_length(*passwords) == 1);
@@ -300,14 +297,14 @@ static int get_password(const char *name, usec_t until, bool accept_cached, char
         STRV_FOREACH(p, *passwords) {
                 char *c;
 
-                if (strlen(*p)+1 >= opt_key_size)
+                if (strlen(*p)+1 >= arg_key_size)
                         continue;
 
                 /* Pad password if necessary */
-                if (!(c = new(char, opt_key_size)))
+                if (!(c = new(char, arg_key_size)))
                         return log_oom();
 
-                strncpy(c, *p, opt_key_size);
+                strncpy(c, *p, arg_key_size);
                 free(*p);
                 *p = c;
         }
@@ -324,18 +321,18 @@ static int attach_tcrypt(struct crypt_device *cd,
         _cleanup_free_ char *passphrase = NULL;
         struct crypt_params_tcrypt params = {
                 .flags = CRYPT_TCRYPT_LEGACY_MODES,
-                .keyfiles = (const char **)opt_tcrypt_keyfiles,
-                .keyfiles_count = strv_length(opt_tcrypt_keyfiles)
+                .keyfiles = (const char **)arg_tcrypt_keyfiles,
+                .keyfiles_count = strv_length(arg_tcrypt_keyfiles)
         };
 
         assert(cd);
         assert(name);
         assert(key_file || passwords);
 
-        if (opt_tcrypt_hidden)
+        if (arg_tcrypt_hidden)
                 params.flags |= CRYPT_TCRYPT_HIDDEN_HEADER;
 
-        if (opt_tcrypt_system)
+        if (arg_tcrypt_system)
                 params.flags |= CRYPT_TCRYPT_SYSTEM_HEADER;
 
         if (key_file) {
@@ -374,31 +371,31 @@ static int attach_luks_or_plain(struct crypt_device *cd,
         assert(name);
         assert(key_file || passwords);
 
-        if (!opt_type || streq(opt_type, CRYPT_LUKS1))
+        if (!arg_type || streq(arg_type, CRYPT_LUKS1))
                 r = crypt_load(cd, CRYPT_LUKS1, NULL);
 
-        if ((!opt_type && r < 0) || streq_ptr(opt_type, CRYPT_PLAIN)) {
+        if ((!arg_type && r < 0) || streq_ptr(arg_type, CRYPT_PLAIN)) {
                 struct crypt_params_plain params = {};
                 const char *cipher, *cipher_mode;
                 _cleanup_free_ char *truncated_cipher = NULL;
 
-                if (opt_hash) {
+                if (arg_hash) {
                         /* plain isn't a real hash type. it just means "use no hash" */
-                        if (!streq(opt_hash, "plain"))
-                                params.hash = opt_hash;
+                        if (!streq(arg_hash, "plain"))
+                                params.hash = arg_hash;
                 } else
                         params.hash = "ripemd160";
 
-                if (opt_cipher) {
+                if (arg_cipher) {
                         size_t l;
 
-                        l = strcspn(opt_cipher, "-");
-                        truncated_cipher = strndup(opt_cipher, l);
+                        l = strcspn(arg_cipher, "-");
+                        truncated_cipher = strndup(arg_cipher, l);
                         if (!truncated_cipher)
                                 return log_oom();
 
                         cipher = truncated_cipher;
-                        cipher_mode = opt_cipher[l] ? opt_cipher+l+1 : "plain";
+                        cipher_mode = arg_cipher[l] ? arg_cipher+l+1 : "plain";
                 } else {
                         cipher = "aes";
                         cipher_mode = "cbc-essiv:sha256";
@@ -407,7 +404,7 @@ static int attach_luks_or_plain(struct crypt_device *cd,
                 /* for CRYPT_PLAIN limit reads
                  * from keyfile to key length, and
                  * ignore keyfile-size */
-                opt_keyfile_size = opt_key_size / 8;
+                arg_keyfile_size = arg_key_size / 8;
 
                 /* In contrast to what the name
                  * crypt_setup() might suggest this
@@ -416,7 +413,7 @@ static int attach_luks_or_plain(struct crypt_device *cd,
                  * parameters when used for plain
                  * mode. */
                 r = crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode,
-                                 NULL, NULL, opt_keyfile_size, &params);
+                                 NULL, NULL, arg_keyfile_size, &params);
 
                 /* hash == NULL implies the user passed "plain" */
                 pass_volume_key = (params.hash == NULL);
@@ -434,9 +431,9 @@ static int attach_luks_or_plain(struct crypt_device *cd,
                  crypt_get_device_name(cd));
 
         if (key_file) {
-                r = crypt_activate_by_keyfile_offset(cd, name, opt_key_slot,
-                                                     key_file, opt_keyfile_size,
-                                                     opt_keyfile_offset, flags);
+                r = crypt_activate_by_keyfile_offset(cd, name, arg_key_slot,
+                                                     key_file, arg_keyfile_size,
+                                                     arg_keyfile_offset, flags);
                 if (r < 0) {
                         log_error("Failed to activate with key file '%s': %s", key_file, strerror(-r));
                         return -EAGAIN;
@@ -446,9 +443,9 @@ static int attach_luks_or_plain(struct crypt_device *cd,
 
                 STRV_FOREACH(p, passwords) {
                         if (pass_volume_key)
-                                r = crypt_activate_by_volume_key(cd, name, *p, opt_key_size, flags);
+                                r = crypt_activate_by_volume_key(cd, name, *p, arg_key_size, flags);
                         else
-                                r = crypt_activate_by_passphrase(cd, name, opt_key_slot, *p, strlen(*p), flags);
+                                r = crypt_activate_by_passphrase(cd, name, arg_key_slot, *p, strlen(*p), flags);
 
                         if (r >= 0)
                                 break;
@@ -559,18 +556,18 @@ int main(int argc, char *argv[]) {
                         goto finish;
                 }
 
-                if (opt_readonly)
+                if (arg_readonly)
                         flags |= CRYPT_ACTIVATE_READONLY;
 
-                if (opt_discards)
+                if (arg_discards)
                         flags |= CRYPT_ACTIVATE_ALLOW_DISCARDS;
 
-                if (opt_timeout > 0)
-                        until = now(CLOCK_MONOTONIC) + opt_timeout;
+                if (arg_timeout > 0)
+                        until = now(CLOCK_MONOTONIC) + arg_timeout;
                 else
                         until = 0;
 
-                opt_key_size = (opt_key_size > 0 ? opt_key_size : 256);
+                arg_key_size = (arg_key_size > 0 ? arg_key_size : 256);
 
                 if (key_file) {
                         struct stat st;
@@ -581,18 +578,18 @@ int main(int argc, char *argv[]) {
                                 log_warning("Key file %s is world-readable. This is not a good idea!", key_file);
                 }
 
-                for (tries = 0; opt_tries == 0 || tries < opt_tries; tries++) {
+                for (tries = 0; arg_tries == 0 || tries < arg_tries; tries++) {
                         _cleanup_strv_free_ char **passwords = NULL;
 
                         if (!key_file) {
-                                k = get_password(name, until, tries == 0 && !opt_verify, &passwords);
+                                k = get_password(name, until, tries == 0 && !arg_verify, &passwords);
                                 if (k == -EAGAIN)
                                         continue;
                                 else if (k < 0)
                                         goto finish;
                         }
 
-                        if (streq_ptr(opt_type, CRYPT_TCRYPT))
+                        if (streq_ptr(arg_type, CRYPT_TCRYPT))
                                 k = attach_tcrypt(cd, argv[2], key_file, passwords, flags);
                         else
                                 k = attach_luks_or_plain(cd, argv[2], key_file, passwords, flags);
@@ -609,7 +606,7 @@ int main(int argc, char *argv[]) {
                         log_warning("Invalid passphrase.");
                 }
 
-                if (opt_tries != 0 && tries >= opt_tries) {
+                if (arg_tries != 0 && tries >= arg_tries) {
                         log_error("Too many attempts; giving up.");
                         r = EXIT_FAILURE;
                         goto finish;
@@ -644,9 +641,9 @@ finish:
         if (cd)
                 crypt_free(cd);
 
-        free(opt_cipher);
-        free(opt_hash);
-        strv_free(opt_tcrypt_keyfiles);
+        free(arg_cipher);
+        free(arg_hash);
+        strv_free(arg_tcrypt_keyfiles);
 
         return r;
 }