Fix some problems found by Coverity static analysis.

[platform/upstream/cryptsetup.git] / lib / setup.c

diff --git a/lib/setup.c b/lib/setup.c
index b9e43af..ee9e9ad 100644 (file)
--- a/lib/setup.c
+++ b/lib/setup.c
@@ -344,10 +344,10 @@ int PLAIN_activate(struct crypt_device *cd,
        log_dbg("Trying to activate PLAIN device %s using cipher %s.",
                name, dmd.u.crypt.cipher);
 
-       r = dm_create_device(name, CRYPT_PLAIN, &dmd, 0);
+       r = dm_create_device(cd, name, CRYPT_PLAIN, &dmd, 0);
 
        // FIXME
-       if (!cd->plain_uuid && dm_query_device(name, DM_ACTIVE_UUID, &dmd) >= 0)
+       if (!cd->plain_uuid && dm_query_device(cd, name, DM_ACTIVE_UUID, &dmd) >= 0)
                cd->plain_uuid = CONST_CAST(char*)dmd.uuid;
 
        free(dm_cipher);
@@ -530,10 +530,7 @@ int crypt_init(struct crypt_device **cd, const char *device)
        if (r < 0)
                goto bad;
 
-       if (dm_init(h, 1) < 0) {
-               r = -ENOSYS;
-               goto bad;
-       }
+       dm_backend_init();
 
        h->iteration_time = 1000;
        h->password_verify = 0;
@@ -628,7 +625,7 @@ static int _crypt_load_verity(struct crypt_device *cd, struct crypt_params_verit
        if (r < 0)
                return r;
 
-       if (params->flags & CRYPT_VERITY_NO_HEADER)
+       if (params && params->flags & CRYPT_VERITY_NO_HEADER)
                return -EINVAL;
 
        if (params)
@@ -662,10 +659,11 @@ static int _init_by_name_crypt(struct crypt_device *cd, const char *name)
        char cipher[MAX_CIPHER_LEN], cipher_mode[MAX_CIPHER_LEN];
        int key_nums, r;
 
-       r = dm_query_device(name, DM_ACTIVE_DEVICE |
-                                  DM_ACTIVE_UUID |
-                                  DM_ACTIVE_CRYPT_CIPHER |
-                                  DM_ACTIVE_CRYPT_KEYSIZE, &dmd);
+       r = dm_query_device(cd, name,
+                       DM_ACTIVE_DEVICE |
+                       DM_ACTIVE_UUID |
+                       DM_ACTIVE_CRYPT_CIPHER |
+                       DM_ACTIVE_CRYPT_KEYSIZE, &dmd);
        if (r < 0)
                goto out;
 
@@ -734,10 +732,11 @@ static int _init_by_name_verity(struct crypt_device *cd, const char *name)
        };
        int r;
 
-       r = dm_query_device(name, DM_ACTIVE_DEVICE |
-                                  DM_ACTIVE_UUID |
-                                  DM_ACTIVE_VERITY_HASH_DEVICE |
-                                  DM_ACTIVE_VERITY_PARAMS, &dmd);
+       r = dm_query_device(cd, name,
+                               DM_ACTIVE_DEVICE |
+                               DM_ACTIVE_UUID |
+                               DM_ACTIVE_VERITY_HASH_DEVICE |
+                               DM_ACTIVE_VERITY_PARAMS, &dmd);
        if (r < 0)
                goto out;
 
@@ -784,7 +783,7 @@ int crypt_init_by_name_and_header(struct crypt_device **cd,
                return -ENODEV;
        }
 
-       r = dm_query_device(name, DM_ACTIVE_DEVICE | DM_ACTIVE_UUID, &dmd);
+       r = dm_query_device(NULL, name, DM_ACTIVE_DEVICE | DM_ACTIVE_UUID, &dmd);
        if (r < 0)
                goto out;
 
@@ -938,6 +937,11 @@ static int _crypt_format_luks1(struct crypt_device *cd,
                                       &required_alignment,
                                       &alignment_offset, DEFAULT_DISK_ALIGNMENT);
 
+       /* Check early if we cannot allocate block device for key slot access */
+       r = device_block_adjust(cd, cd->device, DEV_OK, 0, NULL, NULL);
+       if(r < 0)
+               return r;
+
        r = LUKS_generate_phdr(&cd->hdr, cd->volume_key, cipher, cipher_mode,
                               (params && params->hash) ? params->hash : "sha1",
                               uuid, LUKS_STRIPES,
@@ -954,7 +958,11 @@ static int _crypt_format_luks1(struct crypt_device *cd,
                if (r == -EBUSY)
                        log_err(cd, _("Cannot format device %s which is still in use.\n"),
                                mdata_device_path(cd));
-               else
+               else if (r == -EACCES) {
+                       log_err(cd, _("Cannot format device %s, permission denied.\n"),
+                               mdata_device_path(cd));
+                       r = -EINVAL;
+               } else
                        log_err(cd, _("Cannot wipe header on device %s.\n"),
                                mdata_device_path(cd));
 
@@ -1060,7 +1068,8 @@ static int _crypt_format_verity(struct crypt_device *cd,
                return -ENOMEM;
 
        cd->verity_hdr.flags = params->flags;
-       cd->verity_hdr.hash_name = strdup(params->hash_name);
+       if (!(cd->verity_hdr.hash_name = strdup(params->hash_name)))
+               return -ENOMEM;
        cd->verity_hdr.data_device = NULL;
        cd->verity_hdr.data_block_size = params->data_block_size;
        cd->verity_hdr.hash_block_size = params->hash_block_size;
@@ -1068,7 +1077,9 @@ static int _crypt_format_verity(struct crypt_device *cd,
        cd->verity_hdr.hash_type = params->hash_type;
        cd->verity_hdr.flags = params->flags;
        cd->verity_hdr.salt_size = params->salt_size;
-       cd->verity_hdr.salt = malloc(params->salt_size);
+       if (!(cd->verity_hdr.salt = malloc(params->salt_size)))
+               return -ENOMEM;
+
        if (params->salt)
                memcpy(CONST_CAST(char*)cd->verity_hdr.salt, params->salt,
                       params->salt_size);
@@ -1224,7 +1235,7 @@ int crypt_resize(struct crypt_device *cd, const char *name, uint64_t new_size)
 
        log_dbg("Resizing device %s to %" PRIu64 " sectors.", name, new_size);
 
-       r = dm_query_device(name, DM_ACTIVE_DEVICE | DM_ACTIVE_CRYPT_CIPHER |
+       r = dm_query_device(cd, name, DM_ACTIVE_DEVICE | DM_ACTIVE_CRYPT_CIPHER |
                                  DM_ACTIVE_UUID | DM_ACTIVE_CRYPT_KEYSIZE |
                                  DM_ACTIVE_CRYPT_KEY, &dmd);
        if (r < 0) {
@@ -1248,7 +1259,7 @@ int crypt_resize(struct crypt_device *cd, const char *name, uint64_t new_size)
                r = 0;
        } else {
                dmd.size = new_size;
-               r = dm_create_device(name, cd->type, &dmd, 1);
+               r = dm_create_device(cd, name, cd->type, &dmd, 1);
        }
 out:
        if (dmd.target == DM_CRYPT) {
@@ -1328,7 +1339,7 @@ void crypt_free(struct crypt_device *cd)
        if (cd) {
                log_dbg("Releasing crypt device %s context.", mdata_device_path(cd));
 
-               dm_exit();
+               dm_backend_exit();
                crypt_free_volume_key(cd->volume_key);
 
                device_free(cd->device);
@@ -1364,7 +1375,7 @@ int crypt_suspend(struct crypt_device *cd,
 
        log_dbg("Suspending volume %s.", name);
 
-       if (!isLUKS(cd->type)) {
+       if (!cd || !isLUKS(cd->type)) {
                log_err(cd, _("This operation is supported only for LUKS device.\n"));
                r = -EINVAL;
                goto out;
@@ -1376,10 +1387,9 @@ int crypt_suspend(struct crypt_device *cd,
                return -EINVAL;
        }
 
-       if (!cd && dm_init(NULL, 1) < 0)
-               return -ENOSYS;
+       dm_backend_init();
 
-       r = dm_status_suspended(name);
+       r = dm_status_suspended(cd, name);
        if (r < 0)
                goto out;
 
@@ -1389,14 +1399,13 @@ int crypt_suspend(struct crypt_device *cd,
                goto out;
        }
 
-       r = dm_suspend_and_wipe_key(name);
+       r = dm_suspend_and_wipe_key(cd, name);
        if (r == -ENOTSUP)
                log_err(cd, "Suspend is not supported for device %s.\n", name);
        else if (r)
                log_err(cd, "Error during suspending device %s.\n", name);
 out:
-       if (!cd)
-               dm_exit();
+       dm_backend_exit();
        return r;
 }
 
@@ -1417,7 +1426,7 @@ int crypt_resume_by_passphrase(struct crypt_device *cd,
                goto out;
        }
 
-       r = dm_status_suspended(name);
+       r = dm_status_suspended(cd, name);
        if (r < 0)
                return r;
 
@@ -1434,7 +1443,7 @@ int crypt_resume_by_passphrase(struct crypt_device *cd,
 
        if (r >= 0) {
                keyslot = r;
-               r = dm_resume_and_reinstate_key(name, vk->keylength, vk->key);
+               r = dm_resume_and_reinstate_key(cd, name, vk->keylength, vk->key);
                if (r == -ENOTSUP)
                        log_err(cd, "Resume is not supported for device %s.\n", name);
                else if (r)
@@ -1466,7 +1475,7 @@ int crypt_resume_by_keyfile_offset(struct crypt_device *cd,
                goto out;
        }
 
-       r = dm_status_suspended(name);
+       r = dm_status_suspended(cd, name);
        if (r < 0)
                return r;
 
@@ -1490,7 +1499,7 @@ int crypt_resume_by_keyfile_offset(struct crypt_device *cd,
                goto out;
 
        keyslot = r;
-       r = dm_resume_and_reinstate_key(name, vk->keylength, vk->key);
+       r = dm_resume_and_reinstate_key(cd, name, vk->keylength, vk->key);
        if (r)
                log_err(cd, "Error during resuming device %s.\n", name);
 out:
@@ -2013,13 +2022,13 @@ int crypt_deactivate(struct crypt_device *cd, const char *name)
 
        log_dbg("Deactivating volume %s.", name);
 
-       if (!cd && dm_init(NULL, 1) < 0)
-               return -ENOSYS;
+       if (!cd)
+               dm_backend_init();
 
        switch (crypt_status(cd, name)) {
                case CRYPT_ACTIVE:
                case CRYPT_BUSY:
-                       r = dm_remove_device(name, 0, 0);
+                       r = dm_remove_device(cd, name, 0, 0);
                        break;
                case CRYPT_INACTIVE:
                        log_err(cd, _("Device %s is not active.\n"), name);
@@ -2031,7 +2040,7 @@ int crypt_deactivate(struct crypt_device *cd, const char *name)
        }
 
        if (!cd)
-               dm_exit();
+               dm_backend_exit();
 
        return r;
 }
@@ -2161,13 +2170,13 @@ crypt_status_info crypt_status(struct crypt_device *cd, const char *name)
 {
        int r;
 
-       if (!cd && dm_init(NULL, 1) < 0)
-               return CRYPT_INVALID;
+       if (!cd)
+               dm_backend_init();
 
-       r = dm_status_device(name);
+       r = dm_status_device(cd, name);
 
        if (!cd)
-               dm_exit();
+               dm_backend_exit();
 
        if (r < 0 && r != -ENODEV)
                return CRYPT_INVALID;
@@ -2385,6 +2394,17 @@ int crypt_keyslot_max(const char *type)
        return -EINVAL;
 }
 
+int crypt_keyslot_area(struct crypt_device *cd,
+       int keyslot,
+       uint64_t *offset,
+       uint64_t *length)
+{
+       if (!isLUKS(cd->type))
+               return -EINVAL;
+
+       return LUKS_keyslot_area(&cd->hdr, keyslot, offset, length);
+}
+
 const char *crypt_get_type(struct crypt_device *cd)
 {
        return cd->type;
@@ -2417,7 +2437,7 @@ int crypt_get_active_device(struct crypt_device *cd __attribute__((unused)),
        struct crypt_dm_active_device dmd;
        int r;
 
-       r = dm_query_device(name, 0, &dmd);
+       r = dm_query_device(cd, name, 0, &dmd);
        if (r < 0)
                return r;