eessppeelllloo/cryptsetup
1
0
Fork 0
mirror of https://gitlab.com/cryptsetup/cryptsetup.git synced 2025-12-11 19:00:02 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add CRYPT_ prefix to enum defined in libcryptsetup.h.

Browse Source 
(Avoid collision with other defines.)

git-svn-id: https://cryptsetup.googlecode.com/svn/trunk@136 36d66b0a-2a48-0410-832c-cd162a569da5
This commit is contained in:
Milan Broz
2009-11-14 21:33:16 +00:00
parent 70606301ef
commit e698843420
5 changed files with 79 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
ChangeLog
View File

@@ -1,3 +1,6 @@
2009-11-14 Milan Broz <mbroz@redhat.com>
* Add CRYPT_ prefix to enum defined in libcryptsetup.h.
2009-09-30 Milan Broz <mbroz@redhat.com> 2009-09-30 Milan Broz <mbroz@redhat.com>
* Fix exported symbols and versions in libcryptsetup. * Fix exported symbols and versions in libcryptsetup.
* Do not use internal lib functions in cryptsetup. * Do not use internal lib functions in cryptsetup.

20
lib/libcryptsetup.h
View File

@@ -407,11 +407,16 @@ int crypt_volume_key_verify(struct crypt_device *cd,
* @cd - crypt device handle, can be NULL * @cd - crypt device handle, can be NULL
* @name -crypt device name * @name -crypt device name
* *
* INACTIVE - no such mapped device * CRYPT_INACTIVE - no such mapped device
* ACTIVE - device is active * CRYPT_ACTIVE - device is active
* BUSY - device is active and has open count > 0 * CRYPT_BUSY - device is active and has open count > 0
*/ */
typedef enum { INVALID, INACTIVE, ACTIVE, BUSY } crypt_status_info; typedef enum {
CRYPT_INVALID,
CRYPT_INACTIVE,
CRYPT_ACTIVE,
CRYPT_BUSY
} crypt_status_info;
crypt_status_info crypt_status(struct crypt_device *cd, const char *name); crypt_status_info crypt_status(struct crypt_device *cd, const char *name);
/** /**
@@ -448,7 +453,12 @@ int crypt_get_volume_key_size(struct crypt_device *cd);
* @cd - crypt device handle * @cd - crypt device handle
* @keyslot - requested keyslot to check or CRYPT_ANY_SLOT * @keyslot - requested keyslot to check or CRYPT_ANY_SLOT
*/ */
typedef enum { SLOT_INVALID, SLOT_INACTIVE, SLOT_ACTIVE, SLOT_ACTIVE_LAST } crypt_keyslot_info; typedef enum {
CRYPT_SLOT_INVALID,
CRYPT_SLOT_INACTIVE,
CRYPT_SLOT_ACTIVE,
CRYPT_SLOT_ACTIVE_LAST
} crypt_keyslot_info;
crypt_keyslot_info crypt_keyslot_status(struct crypt_device *cd, int keyslot); crypt_keyslot_info crypt_keyslot_status(struct crypt_device *cd, int keyslot);
/** /**

78
lib/setup.c
View File

@@ -167,11 +167,11 @@ static int keyslot_verify_or_find_empty(struct crypt_device *cd, int *keyslot)
} }
switch (LUKS_keyslot_info(&cd->hdr, *keyslot)) { switch (LUKS_keyslot_info(&cd->hdr, *keyslot)) {
case SLOT_INVALID: case CRYPT_SLOT_INVALID:
log_err(cd, _("Key slot %d is invalid, please select between 0 and %d.\n"), log_err(cd, _("Key slot %d is invalid, please select between 0 and %d.\n"),
*keyslot, LUKS_NUMKEYS - 1); *keyslot, LUKS_NUMKEYS - 1);
return -EINVAL; return -EINVAL;
case SLOT_INACTIVE: case CRYPT_SLOT_INACTIVE:
break; break;
default: default:
log_err(cd, _("Key slot %d is full, please select another one.\n"), log_err(cd, _("Key slot %d is full, please select another one.\n"),
@@ -199,14 +199,14 @@ static int verify_other_keyslot(struct crypt_device *cd,
return -EINVAL; return -EINVAL;
ki = crypt_keyslot_status(cd, keyIndex); ki = crypt_keyslot_status(cd, keyIndex);
if (ki == SLOT_ACTIVE) /* Not last slot */ if (ki == CRYPT_SLOT_ACTIVE) /* Not last slot */
LUKS_keyslot_set(&cd->hdr, keyIndex, 0); LUKS_keyslot_set(&cd->hdr, keyIndex, 0);
openedIndex = LUKS_open_key_with_hdr(cd->device, CRYPT_ANY_SLOT, openedIndex = LUKS_open_key_with_hdr(cd->device, CRYPT_ANY_SLOT,
password, passwordLen, password, passwordLen,
&cd->hdr, &mk, cd); &cd->hdr, &mk, cd);
if (ki == SLOT_ACTIVE) if (ki == CRYPT_SLOT_ACTIVE)
LUKS_keyslot_set(&cd->hdr, keyIndex, 1); LUKS_keyslot_set(&cd->hdr, keyIndex, 1);
LUKS_dealloc_masterkey(mk); LUKS_dealloc_masterkey(mk);
safe_free(password); safe_free(password);
@@ -295,19 +295,19 @@ static int luks_remove_helper(struct crypt_device *cd,
} }
ki = crypt_keyslot_status(cd, key_slot); ki = crypt_keyslot_status(cd, key_slot);
if (ki == SLOT_INVALID) { if (ki == CRYPT_SLOT_INVALID) {
log_err(cd, _("Key slot %d is invalid, please select between 0 and %d.\n"), log_err(cd, _("Key slot %d is invalid, please select between 0 and %d.\n"),
key_slot, LUKS_NUMKEYS - 1); key_slot, LUKS_NUMKEYS - 1);
r = -EINVAL; r = -EINVAL;
goto out; goto out;
} }
if (ki <= SLOT_INACTIVE) { if (ki <= CRYPT_SLOT_INACTIVE) {
log_err(cd, _("Key %d not active. Can't wipe.\n"), key_slot); log_err(cd, _("Key %d not active. Can't wipe.\n"), key_slot);
r = -EINVAL; r = -EINVAL;
goto out; goto out;
} }
if (ki == SLOT_ACTIVE_LAST && cd->confirm && if (ki == CRYPT_SLOT_ACTIVE_LAST && cd->confirm &&
!(cd->confirm(_("This is the last keyslot." !(cd->confirm(_("This is the last keyslot."
" Device will become unusable after purging this key."), " Device will become unusable after purging this key."),
cd->confirm_usrptr))) { cd->confirm_usrptr))) {
@@ -349,13 +349,13 @@ static int create_device_helper(struct crypt_device *cd,
int r; int r;
ci = crypt_status(cd, name); ci = crypt_status(cd, name);
if (ci == INVALID) if (ci == CRYPT_INVALID)
return -EINVAL; return -EINVAL;
if (reload && ci < ACTIVE) if (reload && ci < CRYPT_ACTIVE)
return -EINVAL; return -EINVAL;
if (!reload && ci >= ACTIVE) { if (!reload && ci >= CRYPT_ACTIVE) {
log_err(cd, _("Device %s already exists.\n"), name); log_err(cd, _("Device %s already exists.\n"), name);
return -EEXIST; return -EEXIST;
} }
@@ -1028,10 +1028,10 @@ int crypt_init_by_name(struct crypt_device **cd, const char *name)
log_dbg("Allocating crypt device context by device %s.", name); log_dbg("Allocating crypt device context by device %s.", name);
ci = crypt_status(NULL, name); ci = crypt_status(NULL, name);
if (ci == INVALID) if (ci == CRYPT_INVALID)
return -ENODEV; return -ENODEV;
if (ci < ACTIVE) { if (ci < CRYPT_ACTIVE) {
log_err(NULL, _("Device %s is not active.\n"), name); log_err(NULL, _("Device %s is not active.\n"), name);
return -ENODEV; return -ENODEV;
} }
@@ -1251,7 +1251,7 @@ int crypt_suspend(struct crypt_device *cd,
log_dbg("Suspending volume %s.", name); log_dbg("Suspending volume %s.", name);
ci = crypt_status(NULL, name); ci = crypt_status(NULL, name);
if (ci < ACTIVE) { if (ci < CRYPT_ACTIVE) {
log_err(cd, _("Volume %s is not active.\n"), name); log_err(cd, _("Volume %s is not active.\n"), name);
return -EINVAL; return -EINVAL;
} }
@@ -1597,12 +1597,12 @@ int crypt_keyslot_destroy(struct crypt_device *cd, int keyslot)
} }
ki = crypt_keyslot_status(cd, keyslot); ki = crypt_keyslot_status(cd, keyslot);
if (ki == SLOT_INVALID) { if (ki == CRYPT_SLOT_INVALID) {
log_err(cd, _("Key slot %d is invalid.\n"), keyslot); log_err(cd, _("Key slot %d is invalid.\n"), keyslot);
return -EINVAL; return -EINVAL;
} }
if (ki == SLOT_INACTIVE) { if (ki == CRYPT_SLOT_INACTIVE) {
log_err(cd, _("Key slot %d is not used.\n"), keyslot); log_err(cd, _("Key slot %d is not used.\n"), keyslot);
return -EINVAL; return -EINVAL;
} }
@@ -1639,9 +1639,9 @@ int crypt_activate_by_passphrase(struct crypt_device *cd,
if (name) { if (name) {
ci = crypt_status(NULL, name); ci = crypt_status(NULL, name);
if (ci == INVALID) if (ci == CRYPT_INVALID)
return -EINVAL; return -EINVAL;
else if (ci >= ACTIVE) { else if (ci >= CRYPT_ACTIVE) {
log_err(cd, _("Device %s already exists.\n"), name); log_err(cd, _("Device %s already exists.\n"), name);
return -EEXIST; return -EEXIST;
} }
@@ -1692,9 +1692,9 @@ int crypt_activate_by_keyfile(struct crypt_device *cd,
if (name) { if (name) {
ci = crypt_status(NULL, name); ci = crypt_status(NULL, name);
if (ci == INVALID) if (ci == CRYPT_INVALID)
return -EINVAL; return -EINVAL;
else if (ci >= ACTIVE) { else if (ci >= CRYPT_ACTIVE) {
log_err(cd, _("Device %s already exists.\n"), name); log_err(cd, _("Device %s already exists.\n"), name);
return -EEXIST; return -EEXIST;
} }
@@ -1749,9 +1749,9 @@ int crypt_activate_by_volume_key(struct crypt_device *cd,
if (name) { if (name) {
ci = crypt_status(NULL, name); ci = crypt_status(NULL, name);
if (ci == INVALID) if (ci == CRYPT_INVALID)
return -EINVAL; return -EINVAL;
else if (ci >= ACTIVE) { else if (ci >= CRYPT_ACTIVE) {
log_err(cd, _("Device %s already exists.\n"), name); log_err(cd, _("Device %s already exists.\n"), name);
return -EEXIST; return -EEXIST;
} }
@@ -1786,16 +1786,20 @@ int crypt_deactivate(struct crypt_device *cd, const char *name)
return -ENOSYS; return -ENOSYS;
switch (crypt_status(cd, name)) { switch (crypt_status(cd, name)) {
case ACTIVE: r = dm_remove_device(name, 0, 0); case CRYPT_ACTIVE:
break; r = dm_remove_device(name, 0, 0);
case BUSY: log_err(cd, _("Device %s is busy.\n"), name); break;
r = -EBUSY; case CRYPT_BUSY:
break; log_err(cd, _("Device %s is busy.\n"), name);
case INACTIVE: log_err(cd, _("Device %s is not active.\n"), name); r = -EBUSY;
r = -ENODEV; break;
break; case CRYPT_INACTIVE:
default: log_err(cd, _("Invalid device %s.\n"), name); log_err(cd, _("Device %s is not active.\n"), name);
r = -EINVAL; r = -ENODEV;
break;
default:
log_err(cd, _("Invalid device %s.\n"), name);
r = -EINVAL;
} }
if (!cd) if (!cd)
@@ -1913,7 +1917,7 @@ crypt_status_info crypt_status(struct crypt_device *cd, const char *name)
int r; int r;
if (!cd && dm_init(NULL, 1) < 0) if (!cd && dm_init(NULL, 1) < 0)
return INVALID; return CRYPT_INVALID;
r = dm_status_device(name); r = dm_status_device(name);
@@ -1921,15 +1925,15 @@ crypt_status_info crypt_status(struct crypt_device *cd, const char *name)
dm_exit(); dm_exit();
if (r < 0 && r != -ENODEV) if (r < 0 && r != -ENODEV)
return INVALID; return CRYPT_INVALID;
if (r == 0) if (r == 0)
return ACTIVE; return CRYPT_ACTIVE;
if (r > 0) if (r > 0)
return BUSY; return CRYPT_BUSY;
return INACTIVE; return CRYPT_INACTIVE;
} }
static void hexprintICB(struct crypt_device *cd, char *d, int n) static void hexprintICB(struct crypt_device *cd, char *d, int n)
@@ -2044,7 +2048,7 @@ crypt_keyslot_info crypt_keyslot_status(struct crypt_device *cd, int keyslot)
{ {
if (!isLUKS(cd->type)) { if (!isLUKS(cd->type)) {
log_err(cd, _("This operation is supported only for LUKS device.\n")); log_err(cd, _("This operation is supported only for LUKS device.\n"));
return SLOT_INVALID; return CRYPT_SLOT_INVALID;
} }
return LUKS_keyslot_info(&cd->hdr, keyslot); return LUKS_keyslot_info(&cd->hdr, keyslot);

14
luks/keymanage.c
View File

@@ -585,7 +585,7 @@ int LUKS_open_key(const char *device,
log_dbg("Trying to open key slot %d [%d].", keyIndex, (int)ki); log_dbg("Trying to open key slot %d [%d].", keyIndex, (int)ki);
if (ki < SLOT_ACTIVE) if (ki < CRYPT_SLOT_ACTIVE)
return -ENOENT; return -ENOENT;
// assert((mk->keyLength % TWOFISH_BLOCKSIZE) == 0); FIXME // assert((mk->keyLength % TWOFISH_BLOCKSIZE) == 0); FIXME
@@ -755,19 +755,19 @@ crypt_keyslot_info LUKS_keyslot_info(struct luks_phdr *hdr, int keyslot)
int i; int i;
if(keyslot >= LUKS_NUMKEYS || keyslot < 0) if(keyslot >= LUKS_NUMKEYS || keyslot < 0)
return SLOT_INVALID; return CRYPT_SLOT_INVALID;
if (hdr->keyblock[keyslot].active == LUKS_KEY_DISABLED) if (hdr->keyblock[keyslot].active == LUKS_KEY_DISABLED)
return SLOT_INACTIVE; return CRYPT_SLOT_INACTIVE;
if (hdr->keyblock[keyslot].active != LUKS_KEY_ENABLED) if (hdr->keyblock[keyslot].active != LUKS_KEY_ENABLED)
return SLOT_INVALID; return CRYPT_SLOT_INVALID;
for(i = 0; i < LUKS_NUMKEYS; i++) for(i = 0; i < LUKS_NUMKEYS; i++)
if(i != keyslot && hdr->keyblock[i].active == LUKS_KEY_ENABLED) if(i != keyslot && hdr->keyblock[i].active == LUKS_KEY_ENABLED)
return SLOT_ACTIVE; return CRYPT_SLOT_ACTIVE;
return SLOT_ACTIVE_LAST; return CRYPT_SLOT_ACTIVE_LAST;
} }
int LUKS_keyslot_find_empty(struct luks_phdr *hdr) int LUKS_keyslot_find_empty(struct luks_phdr *hdr)
@@ -799,7 +799,7 @@ int LUKS_keyslot_set(struct luks_phdr *hdr, int keyslot, int enable)
{ {
crypt_keyslot_info ki = LUKS_keyslot_info(hdr, keyslot); crypt_keyslot_info ki = LUKS_keyslot_info(hdr, keyslot);
if (ki == SLOT_INVALID) if (ki == CRYPT_SLOT_INVALID)
return -EINVAL; return -EINVAL;
hdr->keyblock[keyslot].active = enable ? LUKS_KEY_ENABLED : LUKS_KEY_DISABLED; hdr->keyblock[keyslot].active = enable ? LUKS_KEY_ENABLED : LUKS_KEY_DISABLED;

26
tests/apitest.c
View File

@@ -518,17 +518,17 @@ static void AddDevicePlain(void)
OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0)); OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0));
// device status check // device status check
EQ_(crypt_status(cd, CDEVICE_1), ACTIVE); EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
snprintf(path, sizeof(path), "%s/%s", crypt_get_dir(), CDEVICE_1); snprintf(path, sizeof(path), "%s/%s", crypt_get_dir(), CDEVICE_1);
fd = open(path, O_RDONLY); fd = open(path, O_RDONLY);
EQ_(crypt_status(cd, CDEVICE_1), BUSY); EQ_(crypt_status(cd, CDEVICE_1), CRYPT_BUSY);
FAIL_(crypt_deactivate(cd, CDEVICE_1), "Device is busy"); FAIL_(crypt_deactivate(cd, CDEVICE_1), "Device is busy");
close(fd); close(fd);
OK_(crypt_deactivate(cd, CDEVICE_1)); OK_(crypt_deactivate(cd, CDEVICE_1));
EQ_(crypt_status(cd, CDEVICE_1), INACTIVE); EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0)); OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
EQ_(crypt_status(cd, CDEVICE_1), ACTIVE); EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
// retrieve volume key check // retrieve volume key check
memset(key2, 0, key_size); memset(key2, 0, key_size);
@@ -556,10 +556,10 @@ static void UseLuksDevice(void)
OK_(crypt_init(&cd, DEVICE_1)); OK_(crypt_init(&cd, DEVICE_1));
OK_(crypt_load(cd, CRYPT_LUKS1, NULL)); OK_(crypt_load(cd, CRYPT_LUKS1, NULL));
EQ_(crypt_status(cd, CDEVICE_1), INACTIVE); EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1), 0)); OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1), 0));
FAIL_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1), 0), "already open"); FAIL_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1), 0), "already open");
EQ_(crypt_status(cd, CDEVICE_1), ACTIVE); EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
OK_(crypt_deactivate(cd, CDEVICE_1)); OK_(crypt_deactivate(cd, CDEVICE_1));
FAIL_(crypt_deactivate(cd, CDEVICE_1), "no such device"); FAIL_(crypt_deactivate(cd, CDEVICE_1), "no such device");
@@ -573,7 +573,7 @@ static void UseLuksDevice(void)
EQ_(0, crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key, &key_size, KEY1, strlen(KEY1))); EQ_(0, crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key, &key_size, KEY1, strlen(KEY1)));
OK_(crypt_volume_key_verify(cd, key, key_size)); OK_(crypt_volume_key_verify(cd, key, key_size));
OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0)); OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
EQ_(crypt_status(cd, CDEVICE_1), ACTIVE); EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
OK_(crypt_deactivate(cd, CDEVICE_1)); OK_(crypt_deactivate(cd, CDEVICE_1));
key[1] = ~key[1]; key[1] = ~key[1];
@@ -635,14 +635,14 @@ static void AddDeviceLuks(void)
// even with no keyslots defined it can be activated by volume key // even with no keyslots defined it can be activated by volume key
OK_(crypt_volume_key_verify(cd, key, key_size)); OK_(crypt_volume_key_verify(cd, key, key_size));
OK_(crypt_activate_by_volume_key(cd, CDEVICE_2, key, key_size, 0)); OK_(crypt_activate_by_volume_key(cd, CDEVICE_2, key, key_size, 0));
EQ_(crypt_status(cd, CDEVICE_2), ACTIVE); EQ_(crypt_status(cd, CDEVICE_2), CRYPT_ACTIVE);
OK_(crypt_deactivate(cd, CDEVICE_2)); OK_(crypt_deactivate(cd, CDEVICE_2));
// now with keyslot // now with keyslot
EQ_(7, crypt_keyslot_add_by_volume_key(cd, 7, key, key_size, passphrase, strlen(passphrase))); EQ_(7, crypt_keyslot_add_by_volume_key(cd, 7, key, key_size, passphrase, strlen(passphrase)));
EQ_(SLOT_ACTIVE_LAST, crypt_keyslot_status(cd, 7)); EQ_(CRYPT_SLOT_ACTIVE_LAST, crypt_keyslot_status(cd, 7));
EQ_(7, crypt_activate_by_passphrase(cd, CDEVICE_2, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0)); EQ_(7, crypt_activate_by_passphrase(cd, CDEVICE_2, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0));
EQ_(crypt_status(cd, CDEVICE_2), ACTIVE); EQ_(crypt_status(cd, CDEVICE_2), CRYPT_ACTIVE);
OK_(crypt_deactivate(cd, CDEVICE_2)); OK_(crypt_deactivate(cd, CDEVICE_2));
FAIL_(crypt_keyslot_add_by_volume_key(cd, 7, key, key_size, passphrase, strlen(passphrase)), "slot used"); FAIL_(crypt_keyslot_add_by_volume_key(cd, 7, key, key_size, passphrase, strlen(passphrase)), "slot used");
@@ -650,14 +650,14 @@ static void AddDeviceLuks(void)
FAIL_(crypt_keyslot_add_by_volume_key(cd, 6, key, key_size, passphrase, strlen(passphrase)), "key mismatch"); FAIL_(crypt_keyslot_add_by_volume_key(cd, 6, key, key_size, passphrase, strlen(passphrase)), "key mismatch");
key[1] = ~key[1]; key[1] = ~key[1];
EQ_(6, crypt_keyslot_add_by_volume_key(cd, 6, key, key_size, passphrase, strlen(passphrase))); EQ_(6, crypt_keyslot_add_by_volume_key(cd, 6, key, key_size, passphrase, strlen(passphrase)));
EQ_(SLOT_ACTIVE, crypt_keyslot_status(cd, 6)); EQ_(CRYPT_SLOT_ACTIVE, crypt_keyslot_status(cd, 6));
FAIL_(crypt_keyslot_destroy(cd, 8), "invalid keyslot"); FAIL_(crypt_keyslot_destroy(cd, 8), "invalid keyslot");
FAIL_(crypt_keyslot_destroy(cd, CRYPT_ANY_SLOT), "invalid keyslot"); FAIL_(crypt_keyslot_destroy(cd, CRYPT_ANY_SLOT), "invalid keyslot");
FAIL_(crypt_keyslot_destroy(cd, 0), "keyslot not used"); FAIL_(crypt_keyslot_destroy(cd, 0), "keyslot not used");
OK_(crypt_keyslot_destroy(cd, 7)); OK_(crypt_keyslot_destroy(cd, 7));
EQ_(SLOT_INACTIVE, crypt_keyslot_status(cd, 7)); EQ_(CRYPT_SLOT_INACTIVE, crypt_keyslot_status(cd, 7));
EQ_(SLOT_ACTIVE_LAST, crypt_keyslot_status(cd, 6)); EQ_(CRYPT_SLOT_ACTIVE_LAST, crypt_keyslot_status(cd, 6));
EQ_(6, crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key2, &key_size, passphrase, strlen(passphrase))); EQ_(6, crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key2, &key_size, passphrase, strlen(passphrase)));
OK_(crypt_volume_key_verify(cd, key2, key_size)); OK_(crypt_volume_key_verify(cd, key2, key_size));