static void validateArrayRange (Key * parent, long validCount, Key * specKey)
{
const Key * arrayRange = keyGetMeta (specKey, "array");
if (arrayRange != NULL)
{
char * rangeString = elektraMalloc (keyGetValueSize (arrayRange));
keyGetString (arrayRange, rangeString, keyGetValueSize (arrayRange));
char * delimPtr = strchr (rangeString, '-');
long min = 0;
long max = 0;
if (delimPtr)
{
char * maxString = delimPtr + 1;
*delimPtr = '\0';
char * minString = rangeString;
min = atoi (minString);
max = atoi (maxString);
}
else
{
min = max = atoi (rangeString);
}
if (validCount < min || validCount > max)
{
char buffer[MAX_CHARS_IN_LONG + 1];
snprintf (buffer, sizeof (buffer), "%ld", validCount);
keySetMeta (parent, "conflict/range", buffer);
}
elektraFree (rangeString);
}
}
static void test_enc_and_dec_with_string()
{
elektraCryptoHandle *handle;
KeySet *config;
Key *errorKey = keyNew(KEY_END);
const char original[] = "Short";
char content[64] = "";
getWorkingConfiguration(&config);
succeed_if( elektraCryptoInit(errorKey) == 1, "crypto initialization failed" );
Key *k = keyNew("user/plugins/crypto/gcrypt/test-enc-dec-string", KEY_END);
keySetString(k, original);
// 1. encryption
succeed_if( elektraCryptoHandleCreate(&handle, config, errorKey) == 1, "handle initialization with compliant config failed" );
succeed_if( elektraCryptoEncrypt(handle, k, errorKey) == 1, "encryption failed" );
elektraCryptoHandleDestroy(handle);
// 2. decryption
succeed_if( elektraCryptoHandleCreate(&handle, config, errorKey) == 1, "handle initialization with compliant config failed" );
succeed_if( elektraCryptoDecrypt(handle, k, errorKey) == 1, "decryption failed" );
elektraCryptoHandleDestroy(handle);
// 3. check result
succeed_if( keyIsString(k) == 1, "key is of non-string type");
succeed_if( keyGetString(k, content, sizeof(content)) > 0, "could not retrieve the value of the key" );
succeed_if( strcmp(original, content) == 0, "decrypted value differs from original");
keyDel(k);
keyDel(errorKey);
ksDel(config);
elektraCryptoTeardown();
}
static void test_keyGetString (const size_t storagePlugin, const char * tmpFile)
{
Key * parentKey = keyNew (TEST_ROOT_KEY, KEY_VALUE, tmpFile, KEY_END);
open_storage_plugin (storagePlugin);
Plugin * plugin = plugins[storagePlugin];
KeySet * ks = metaTestKeySet ();
const char * name = "user/tests/storage/specialkey";
const char * value = "special value";
size_t realValueSize = elektraStrLen (value);
Key * key = keyNew (name, KEY_VALUE, value, KEY_END);
ksAppendKey (ks, key);
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "kdbSet was not successful");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
Key * found = ksLookupByName (ks, name, 0);
succeed_if (found, "did not find key");
ssize_t apiValueSize = keyGetValueSize (found);
char * apiString = elektraMalloc (apiValueSize);
succeed_if (keyGetString (found, apiString, apiValueSize) == (ssize_t) realValueSize, "Key string has wrong size");
succeed_if (elektraStrNCmp (value, apiString, realValueSize) == 0, "Key string value is wrong");
elektraFree (apiString);
keyDel (parentKey);
ksDel (ks);
closeStoragePlugin (storagePlugin);
}
/**
* Generate a C-Style key and stream it.
*
* This keyset can be used to include as c-code for
* applikations using elektra.
*
* @param key the key object to work with
* @param stream the file pointer where to send the stream
* @param options KDB_O_SHOWINDICES, KDB_O_IGNORE_COMMENT, KDB_O_SHOWINFO
* @retval 1 on success
* @ingroup stream
*/
int keyGenerate(const Key * key, FILE *stream, option_t options)
{
size_t s;
char * str;
size_t c;
char * com;
size_t n;
char * nam;
n = keyGetNameSize (key);
if (n>1)
{
nam = (char*) elektraMalloc (n);
if (nam == NULL) return -1;
keyGetName (key, nam, n);
fprintf(stream,"\tkeyNew (\"%s\"", nam);
elektraFree (nam);
}
s = keyGetValueSize (key);
if (s>1)
{
str = (char*) elektraMalloc (s);
if (str == NULL) return -1;
if (keyIsBinary(key)) keyGetBinary(key, str, s);
else keyGetString (key, str, s);
fprintf(stream,", KEY_VALUE, \"%s\"", str);
elektraFree (str);
}
c = keyGetCommentSize (key);
if (c>1)
{
com = (char*) elektraMalloc (c);
if (com == NULL) return -1;
keyGetComment (key, com, c);
fprintf(stream,", KEY_COMMENT, \"%s\"", com);
elektraFree (com);
}
if (! (keyGetMode(key) == 0664 || (keyGetMode(key) == 0775)))
{
fprintf(stream,", KEY_MODE, 0%3o", keyGetMode(key));
}
fprintf(stream,", KEY_END)");
if (options == 0) return 1; /* dummy to make icc happy */
return 1;
}
// TODO: this is very similar to elektraKeyAppendMetaLine in keytometa
static int elektraKeyAppendLine (Key *target, const char *line)
{
if (!target) return 0;
if (!line) return 0;
char *buffer = elektraMalloc (keyGetValueSize(target) + strlen (line) + 1);
if (!buffer) return 0;
keyGetString(target, buffer, keyGetValueSize(target));
strcat (buffer, "\n");
strncat (buffer, line, strlen (line));
keySetString(target, buffer);
elektraFree (buffer);
return keyGetValueSize(target);
}
/**
* Generate a C-Style key and stream it.
*
* This keyset can be used to include as c-code for
* applikations using elektra.
*
* @param key the key object to work with
* @param stream the file pointer where to send the stream
* @param options KDB_O_SHOWINDICES, KDB_O_IGNORE_COMMENT, KDB_O_SHOWINFO
* @retval 1 on success
* @ingroup stream
*/
int keyGenerate (const Key * key, FILE * stream, option_t options)
{
size_t n = keyGetNameSize (key);
if (n > 1)
{
char * nam = (char *) elektraMalloc (n);
if (nam == NULL) return -1;
keyGetName (key, nam, n);
fprintf (stream, "\tkeyNew (\"%s\"", nam);
elektraFree (nam);
}
size_t s = keyGetValueSize (key);
if (s > 1)
{
char * str = (char *) elektraMalloc (s);
if (str == NULL) return -1;
if (keyIsBinary (key))
{
keyGetBinary (key, str, s);
fprintf (stream, ", KEY_SIZE, \"%zd\"", keyGetValueSize (key));
}
else
{
keyGetString (key, str, s);
}
fprintf (stream, ", KEY_VALUE, \"%s\"", str);
elektraFree (str);
}
const Key * meta;
Key * dup = keyDup (key);
keyRewindMeta (dup);
while ((meta = keyNextMeta (dup)))
{
fprintf (stream, ", KEY_META, \"%s\", \"%s\"", keyName (meta), keyString (meta));
}
keyDel (dup);
fprintf (stream, ", KEY_END)");
if (options == 0) return 1; /* dummy to make icc happy */
return 1;
}
/*
* Appends a line to the MetaKey of the supplied Key
* If no MetaKey with the given name exists yet, a new
* one is created containing the supplied line. If
* the MetaKey exists, the supplied line is added as
* a new line to the value of the MetaKey (i.e. a newline
* followed by the given line is appended to the metadata)
*
* @param target the Key whose MetaKey is to be modified
* @param metaName the name of the MetaKey which is to be modified
* @param line the line to be appended to the matadata
* @return the new value size of the modified MetaKey
* @retval -1 on NULL pointers or if a memory allocation error occurs
*
* @see keyGetValueSize(Key *key)
*
*/
int elektraKeyAppendMetaLine (Key * target, const char * metaName, const char * line)
{
if (!target) return 0;
if (!metaName) return 0;
if (!line) return 0;
if (!keyGetMeta (target, metaName))
{
keySetMeta (target, metaName, line);
return keyGetValueSize (keyGetMeta (target, metaName));
}
const Key * existingMeta = keyGetMeta (target, metaName);
char * buffer = elektraMalloc (keyGetValueSize (existingMeta) + strlen (line) + 1);
if (!buffer) return 0;
keyGetString (existingMeta, buffer, keyGetValueSize (existingMeta));
strcat (buffer, "\n");
strncat (buffer, line, strlen (line));
keySetMeta (target, metaName, buffer);
elektraFree (buffer);
return keyGetValueSize (keyGetMeta (target, metaName));
}
void test_size()
{
Key *key;
char *buffer;
key = keyNew ("user/test", KEY_END);
exit_if_fail (key, "could not create new key");
succeed_if (keyValue(keyGetMeta(key, "hello")) == 0, "hello was not set up to now");
succeed_if (keyGetValueSize (keyGetMeta(key, "hello")) == -1,
"got wrong size for empty meta value");
keySetMeta(key, "hello", "hello_world");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "hello")), "hello_world"),
"could not receive previously set meta information");
succeed_if (keyGetValueSize (keyGetMeta(key, "hello")) == sizeof("hello_world"),
"got wrong size");
keySetMeta(key, "mode", "0644");
keySetMeta(key, "time", "1271234264");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "hello")), "hello_world"),
"meta info changed unexpectly");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "mode")), "0644"), "mode not set correctly");
succeed_if (keyGetValueSize (keyGetMeta(key, "mode")) == sizeof("0644"),
"got wrong size");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "time")), "1271234264"), "time not set correctly");
succeed_if (keyGetValueSize (keyGetMeta(key, "time")) == sizeof("1271234264"),
"got wrong size");
keySetMeta(key, "hello", "between");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "hello")), "between"),
"could not set meta information again");
succeed_if (keyGetValueSize (keyGetMeta(key, "hello")) == sizeof("between"),
"got wrong size");
buffer = calloc (1, keyGetValueSize (keyGetMeta(key, "hello")));
succeed_if (keyGetString (keyGetMeta(key, "hello"), buffer,
keyGetValueSize (keyGetMeta(key, "hello"))) == keyGetValueSize (keyGetMeta(key, "hello")),
"could not get meta");
succeed_if (!strcmp(buffer, "between"), "buffer was not set correctly");
free (buffer);
keySetMeta(key, "hello", 0);
succeed_if (keyValue(keyGetMeta(key, "hello")) == 0, "could not remove meta data");
succeed_if (keyGetValueSize (keyGetMeta(key, "hello")) == -1,
"got wrong size");
keySetMeta(key, "hello", "goodbye");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "hello")), "goodbye"),
"could not set meta information again (2x)");
succeed_if (keyGetValueSize (keyGetMeta(key, "hello")) == sizeof("goodbye"),
"got wrong size");
buffer = calloc (1, keyGetValueSize (keyGetMeta(key, "hello")));
succeed_if (keyGetString (keyGetMeta(key, "hello"), buffer,
keyGetValueSize (keyGetMeta(key, "hello"))) == keyGetValueSize (keyGetMeta(key, "hello")),
"could not get meta");
succeed_if (!strcmp(buffer, "goodbye"), "buffer was not set correctly");
free (buffer);
keySetMeta(key, "empty", "");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "empty")), ""), "Problem with empty meta string");
succeed_if (keyGetValueSize (keyGetMeta(key, "empty")) == sizeof(""),
"got wrong size");
buffer = calloc (1, keyGetValueSize (keyGetMeta(key, "empty")));
succeed_if (keyGetString (keyGetMeta(key, "empty"), buffer,
keyGetValueSize (keyGetMeta(key, "empty"))) == keyGetValueSize (keyGetMeta(key, "empty")),
"could not get meta");
succeed_if (!strcmp(buffer, ""), "buffer was not set correctly");
free (buffer);
keySetMeta(key, "", "empty");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "")), "empty"), "Problem with empty name");
succeed_if (keyGetValueSize (keyGetMeta(key, "")) == sizeof("empty"),
"got wrong size");
buffer = calloc (1, keyGetValueSize (keyGetMeta(key, "")));
succeed_if (keyGetString (keyGetMeta(key, ""), buffer,
keyGetValueSize (keyGetMeta(key, ""))) == keyGetValueSize (keyGetMeta(key, "")),
"could not get meta");
succeed_if (!strcmp(buffer, "empty"), "buffer was not set correctly");
free (buffer);
keySetMeta(key, "", "");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "")), ""), "Problem with empty name and string");
succeed_if (keyGetValueSize (keyGetMeta(key, "")) == sizeof(""),
"got wrong size");
buffer = calloc (1, keyGetValueSize (keyGetMeta(key, "")));
succeed_if (keyGetString (keyGetMeta(key, ""), buffer,
keyGetValueSize (keyGetMeta(key, ""))) == keyGetValueSize (keyGetMeta(key, "")),
"could not get meta");
succeed_if (!strcmp(buffer, ""), "buffer was not set correctly");
free (buffer);
keySetMeta(key, "", 0);
succeed_if (keyValue(keyGetMeta(key, "")) == 0, "could not remove empty meta data");
succeed_if (keyGetValueSize (keyGetMeta(key, "")) == -1,
"got wrong size");
keyDel (key);
}
/**
* Output every information of a single key depending on options.
*
* The format is not very strict and only intend to be read
* by human eyes for debugging purposes. Don't rely on the
* format in your applications.
*
* @param k the key object to work with
* @param stream the file pointer where to send the stream
* @param options see text above
* @see ksOutput()
* @retval 1 on success
* @retval -1 on allocation errors
* @ingroup stream
*/
int keyOutput (const Key * k, FILE *stream, option_t options)
{
time_t t;
size_t s;
char * tmc;
char * str;
size_t c;
char * com;
size_t n;
char * nam;
n = keyGetNameSize (k);
if (n>1)
{
nam = (char*) elektraMalloc (n);
if (nam == NULL) return -1;
keyGetName (k, nam, n);
fprintf(stream,"Name[%d]: %s : ", (int)n, nam);
elektraFree (nam);
}
s = keyGetValueSize (k);
if (options & KEY_VALUE && s>1)
{
str = (char*) elektraMalloc (s);
if (str == NULL) return -1;
if (keyIsBinary(k))
{
/*
char * bin;
bin = (char*) elektraMalloc (s*3+1);
keyGetBinary(k, str, s);
kdbbEncode (str, s, bin);
elektraFree (bin);
*/
keyGetBinary (k, str, s);
fprintf(stream,"Binary[%d]: %s : ", (int)s, str);
} else {
keyGetString (k, str, s);
fprintf(stream,"String[%d]: %s : ", (int)s, str);
}
elektraFree (str);
}
c = keyGetCommentSize (k);
if (options & KEY_COMMENT && c>1)
{
com = (char*) elektraMalloc (c);
if (com == NULL) return -1;
keyGetComment (k, com, c);
fprintf(stream,"Comment[%d]: %s : ", (int)c, com);
elektraFree (com);
}
if (options & KDB_O_SHOWMETA) fprintf(stream," : ");
if (options & KEY_UID) fprintf(stream,"UID: %d : ", (int)keyGetUID (k));
if (options & KEY_GID) fprintf(stream,"GID: %d : ", (int)keyGetGID (k));
if (options & KEY_MODE) fprintf(stream,"Mode: %o : ", (int)keyGetMode (k));
if (options & KEY_ATIME)
{
t=keyGetATime(k);
tmc = ctime (& t);
tmc[24] = '\0';
fprintf(stream,"ATime: %s : ", tmc);
}
if (options & KEY_MTIME)
{
t=keyGetMTime(k);
tmc = ctime (& t);
tmc[24] = '\0';
fprintf(stream,"MTime: %s : ", tmc);
}
if (options & KEY_CTIME)
{
t=keyGetCTime(k);
tmc = ctime (& t);
tmc[24] = '\0';
fprintf(stream,"CTime: %s : ", tmc);
}
if (options & KDB_O_SHOWFLAGS)
{
if (!(options & KDB_O_SHOWMETA)) fprintf(stream, " ");
fprintf (stream,"Flags: ");
if (keyIsBinary(k)) fprintf(stream,"b");
if (keyIsString(k)) fprintf(stream,"s");
if (keyIsInactive(k)) fprintf(stream,"i");
if (keyNeedSync(k)) fprintf(stream,"s");
}
fprintf(stream,"\n");
return 1;
}
