static void sprintf_key(const struct ubifs_info *c, const union ubifs_key *key,
char *buffer)
{
char *p = buffer;
int type = key_type(c, key);
if (c->key_fmt == UBIFS_SIMPLE_KEY_FMT) {
switch (type) {
case UBIFS_INO_KEY:
sprintf(p, "(%lu, %s)", (unsigned long)key_inum(c, key),
get_key_type(type));
break;
case UBIFS_DENT_KEY:
case UBIFS_XENT_KEY:
sprintf(p, "(%lu, %s, %#08x)",
(unsigned long)key_inum(c, key),
get_key_type(type), key_hash(c, key));
break;
case UBIFS_DATA_KEY:
sprintf(p, "(%lu, %s, %u)",
(unsigned long)key_inum(c, key),
get_key_type(type), key_block(c, key));
break;
case UBIFS_TRUN_KEY:
sprintf(p, "(%lu, %s)",
(unsigned long)key_inum(c, key),
get_key_type(type));
break;
default:
sprintf(p, "(bad key type: %#08x, %#08x)",
key->u32[0], key->u32[1]);
}
} else
sprintf(p, "bad key format %d", c->key_fmt);
}
/* return true if name is not completely encoded in @key */
int is_longname_key(const reiser4_key * key)
{
__u64 highpart;
assert("nikita-2863", key != NULL);
if (get_key_type(key) != KEY_FILE_NAME_MINOR)
reiser4_print_key("oops", key);
assert("nikita-2864", get_key_type(key) == KEY_FILE_NAME_MINOR);
if (REISER4_LARGE_KEY)
highpart = get_key_ordering(key);
else
highpart = get_key_objectid(key);
return (highpart & longname_mark) ? 1 : 0;
}
void migrate_key2(redis_instance* src, redis_instance* dst, char* key, size_t len)
{
long long size = 0;
int flag = get_key_type(src, key, len);
switch (flag) {
case KSTRING: {
redisReply* kv = (redisReply*)redisCommand(src->cxt, "get %b", key, len);
assert(kv != nil);
assert(kv->type == REDIS_REPLY_STRING);
assert(kv->len != 0);
redisReply* reply = (redisReply*)redisCommand(
dst->cxt, "set %b %b", key, len, kv->str, (size_t)(kv->len));
freeReplyObject(reply);
freeReplyObject(kv);
}
break;
case KHASH: {
migrate_hashtable2(src, dst, key, len);
}
break;
case KLIST: {
migrate_list(src, dst, key, len);
}
break;
case KSET: {
migrate_set2(src, dst, key, len);
}
break;
case KSSET: {
migrate_sset2(src, dst, key, len);
}
break;
case KNONE: {
FATAL("none type of key:%s", key);
}
break;
case KUNKOWN: {
FATAL("unknown type of key:%s", key);
}
}
}
CK_RV rsa_funcs()
{
int i, generate_key;
CK_RV rv = CKR_OK;
generate_key = get_key_type(); // true if slot requires generated
// (secure) keys
if (generate_key == -1){
testcase_error("Could not get token info.");
return -1;
}
// published (known answer) tests
for (i = 0; i < NUM_OF_PUBLISHED_TESTSUITES; i++) {
if (!generate_key) {
rv = do_SignRSA(&published_test_suites[i]);
if (rv != CKR_OK && (!no_stop))
break;
rv = do_VerifyRSA(&published_test_suites[i]);
if (rv != CKR_OK && (!no_stop))
break;
}
}
// generated sign verify tests
for (i = 0; i < NUM_OF_GENERATED_SIGVER_TESTSUITES; i++) {
rv = do_SignVerifyRSA(&generated_sigver_test_suites[i]);
if (rv != CKR_OK && (!no_stop))
break;
}
// generated crypto tests
for (i = 0; i < NUM_OF_GENERATED_CRYPTO_TESTSUITES; i++) {
rv = do_EncryptDecryptRSA(&generated_crypto_test_suites[i]);
if (rv != CKR_OK && (!no_stop))
break;
}
// generated keywrap tests
for ( i = 0; i < NUM_OF_GENERATED_KEYWRAP_TESTSUITES; i++) {
rv = do_WrapUnwrapRSA(&generated_keywrap_test_suites[i]);
if (rv != CKR_OK && (!no_stop))
break;
}
return rv;
}
void print_key2(redis_instance* inst, char* key, size_t len)
{
long long size = 0;
int flag = get_key_type(inst, key, len);
long long pttl = get_key_pttl(inst, key, len);
printf("{key:%s, type:%s, pttl:%lldms, db:%lu,",
key, type_name[flag], pttl, inst->db);
switch (flag) {
case KSTRING: {
redisReply* kv = (redisReply*)redisCommand(inst->cxt, "get %b", key, len);
assert(kv != nil);
assert(kv->type == REDIS_REPLY_STRING);
assert(kv->len != 0);
pline(" value:%s}", kv->str);
freeReplyObject(kv);
}
break;
case KHASH: {
size = get_hashtable_size(inst, key, len);
printf(" size:%lld", size);
if (size) {
printf(",\n kvs:[");
print_hashtable2(inst, key, len);
pline("\b \n ]");
}
pline("}");
}
break;
case KLIST: {
size = get_list_size(inst, key, len);
printf(" size:%lld", size);
if (size) {
printf(",\n values:[");
print_list(inst, key, len);
pline("\b \n ]");
}
pline("}");
}
break;
case KSET: {
size = get_set_size(inst, key, len);
printf(" size:%lld", size);
if (size) {
printf(",\n values:[");
print_set2(inst, key, len);
pline("\b \n ]");
}
pline("}");
}
break;
case KSSET: {
size = get_sset_size(inst, key, len);
printf(" size:%lld", size);
if (size) {
printf(",\n values:[");
print_sset2(inst, key, len);
pline("\b \n ]");
}
pline("}");
}
break;
case KNONE: {
FATAL("none type of key:%s", key);
}
break;
case KUNKOWN: {
FATAL("unknown type of key:%s", key);
}
}
}
