/**
* 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;
}
static void test_readFormat (const char * format, const char * fileContent, int numKeys, const char ** keys, const char ** values)
{
const char * tmpFile = elektraFilename ();
FILE * fh = fopen (tmpFile, "w");
if (fh)
{
fputs (fileContent, fh);
fclose (fh);
}
Key * parentKey = keyNew ("user/tests/simpleini", KEY_VALUE, tmpFile, KEY_END);
KeySet * conf = 0;
if (format)
{
conf = ksNew (1, keyNew ("system/format", KEY_VALUE, format, KEY_END), KS_END);
}
else
{
conf = ksNew (0, KS_END);
}
PLUGIN_OPEN ("simpleini");
KeySet * ks = ksNew (numKeys, KS_END);
Key * key = 0;
succeed_if (plugin->kdbGet (plugin, ks, parentKey) == 1, "kdbGet was not successful");
Key * lookup = 0;
for (int i = 0; i < numKeys; i++)
{
lookup = keyNew ("user/tests/simpleini", KEY_END);
keyAddBaseName (lookup, keys[i]);
printf ("testing key '%s'\n", keyBaseName (lookup));
succeed_if ((key = ksLookup (ks, lookup, 0)) != NULL, "key not found");
succeed_if (strcmp (values[i], keyString (key)) == 0, "value of key did not match");
keyDel (lookup);
}
keyDel (key);
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
FREObject LNLeapDevice::getConfigType(uint32_t len, const uint8_t* key) {
std::string keyString( key, key+len );
int type;
switch (controller->config().type(keyString)) {
case Config::TYPE_UNKNOWN:
{
type = 0;
break;
}
case Config::TYPE_BOOLEAN:
{
type = 1;
break;
}
case Config::TYPE_INT32:
{
type = 2;
break;
}
case Config::TYPE_FLOAT:
{
type = 6;
break;
}
case Config::TYPE_STRING:
{
type = 8;
break;
}
default:
{
type = 0;
break;
}
}
FREObject freReturnValue;
FRENewObjectFromInt32(type, &freReturnValue);
return freReturnValue;
}
/**
* @brief read the desired iteration count from config
* @param errorKey may hold a warning if an invalid configuration is provided
* @param config KeySet holding the plugin configuration
* @returns the number of iterations for the key derivation function
*/
kdb_unsigned_long_t CRYPTO_PLUGIN_FUNCTION (getIterationCount) (Key * errorKey, KeySet * config)
{
Key * k = ksLookupByName (config, ELEKTRA_CRYPTO_PARAM_ITERATION_COUNT, 0);
if (k)
{
const kdb_unsigned_long_t iterations = strtoul (keyString (k), NULL, 10);
if (iterations > 0)
{
return iterations;
}
else
{
ELEKTRA_ADD_WARNING (ELEKTRA_WARNING_CRYPTO_CONFIG, errorKey,
"iteration count provided at " ELEKTRA_CRYPTO_PARAM_ITERATION_COUNT
" is invalid. Using default value instead.");
}
}
return ELEKTRA_CRYPTO_DEFAULT_ITERATION_COUNT;
}
/**
* @internal
*
* @brief Check if an update is needed at all
*
* @retval -1 an error occurred
* @retval 0 no update needed
* @retval number of plugins which need update
*/
static int elektraGetCheckUpdateNeeded (Split * split, Key * parentKey)
{
int updateNeededOccurred = 0;
for (size_t i = 0; i < split->size; i++)
{
int ret = -1;
Backend * backend = split->handles[i];
clear_bit (split->syncbits[i], 1);
if (backend->getplugins[RESOLVER_PLUGIN] && backend->getplugins[RESOLVER_PLUGIN]->kdbGet)
{
ksRewind (split->keysets[i]);
keySetName (parentKey, keyName (split->parents[i]));
keySetString (parentKey, "");
ret = backend->getplugins[RESOLVER_PLUGIN]->kdbGet (backend->getplugins[RESOLVER_PLUGIN], split->keysets[i],
parentKey);
// store resolved filename
keySetString (split->parents[i], keyString (parentKey));
// no keys in that backend
backendUpdateSize (backend, split->parents[i], 0);
}
// TODO: set error in else case!
switch (ret)
{
case 1:
// Seems like we need to sync that
set_bit (split->syncbits[i], SPLIT_FLAG_SYNC);
++updateNeededOccurred;
break;
case 0:
// Nothing to do here
break;
default:
ELEKTRA_ASSERT (0, "resolver did not return 1 0 -1, but %d", ret);
case -1:
// Ohh, an error occurred, lets stop the
// process.
return -1;
}
}
return updateNeededOccurred;
}
int elektraWresolverOpen (Plugin * handle, Key * errorKey)
{
KeySet * resolverConfig = elektraPluginGetConfig (handle);
const char * path = keyString (ksLookupByName (resolverConfig, "/path", 0));
if (!path)
{
ELEKTRA_SET_ERROR (34, errorKey, "Could not find file configuration");
return -1;
}
resolverHandles * p = elektraMalloc (sizeof (resolverHandles));
// switch is only present to forget no namespace and to get
// a warning whenever a new namespace is present.
// (also used below in close)
// In fact its linear code executed:
switch (KEY_NS_SPEC)
{
case KEY_NS_SPEC:
resolverInit (&p->spec, path);
elektraResolveSpec (&p->spec, errorKey);
case KEY_NS_DIR:
resolverInit (&p->dir, path);
elektraResolveDir (&p->dir, errorKey);
case KEY_NS_USER:
resolverInit (&p->user, path);
elektraResolveUser (&p->user, errorKey);
case KEY_NS_SYSTEM:
resolverInit (&p->system, path);
elektraResolveSystem (&p->system, errorKey);
case KEY_NS_PROC:
case KEY_NS_EMPTY:
case KEY_NS_NONE:
case KEY_NS_META:
case KEY_NS_CASCADING:
break;
}
elektraPluginSetData (handle, p);
return 0; /* success */
}
static void test_emptySectionBug (char * fileName)
{
Key * parentKey = keyNew ("user/tests/ini-write", KEY_VALUE, elektraFilename (), KEY_END);
KeySet * conf = ksNew (0, KS_END);
KeySet * ks = ksNew (30, keyNew ("user/tests/ini-write/MyApp/mykey", KEY_VALUE, "new_value", KEY_END),
keyNew ("user/tests/ini-write/binarytest", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-write/debienna/test", KEY_VALUE, "value", KEY_END), KS_END);
PLUGIN_OPEN ("ini");
succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
succeed_if (output_error (parentKey), "error in kdbSet");
succeed_if (output_warnings (parentKey), "warnings in kdbSet");
succeed_if (compare_line_files (srcdir_file (fileName), keyString (parentKey)), "files do not match as expected");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
Name
IdentityCertificate::certificateNameToPublicKeyName(const Name& certificateName)
{
int i = certificateName.size() - 1;
string idString("ID-CERT");
for (; i >= 0; i--) {
if (certificateName.get(i).toEscapedString() == idString)
break;
}
Name tmpName = certificateName.getSubName(0, i);
string keyString("KEY");
for (i = 0; i < tmpName.size(); i++) {
if (tmpName.get(i).toEscapedString() == keyString)
break;
}
return tmpName.getSubName(0, i).append(tmpName.getSubName(i + 1, tmpName.size() - i - 1));
}
static void test_file_crypto_operations (void)
{
Plugin * plugin = NULL;
Key * parentKey = keyNew ("system", KEY_END);
KeySet * modules = ksNew (0, KS_END);
KeySet * config = newPluginConfiguration ();
elektraModulesInit (modules, 0);
plugin = elektraPluginOpen (PLUGIN_NAME, modules, config, 0);
succeed_if (plugin, "failed to open plugin handle");
if (plugin)
{
KeySet * data = ksNew (0, KS_END);
const char * tmpFile = elektraFilename ();
if (tmpFile)
{
// prepare test file to be encrypted
writeTestFile (tmpFile);
keySetString (parentKey, tmpFile);
// try to encrypt the file
succeed_if (plugin->kdbSet (plugin, data, parentKey) == 1, "kdb set failed");
succeed_if (isTestFileCorrect (tmpFile) == -1, "file content did not change during encryption");
// try to decrypt the file again (simulating the pregetstorage call)
succeed_if (plugin->kdbGet (plugin, data, parentKey) == 1, "kdb get (pregetstorage) failed");
succeed_if (isTestFileCorrect (keyString (parentKey)) == 1, "file content could not be restored during decryption");
// a second call to kdb get (the postgetstorage call) should re-encrypt the file again
succeed_if (plugin->kdbGet (plugin, data, parentKey) == 1, "kdb get (postgetstorage) failed");
succeed_if (isTestFileCorrect (tmpFile) == -1, "postgetstorage did not encrypt the file again");
remove (tmpFile);
}
ksDel (data);
elektraPluginClose (plugin, 0);
}
elektraModulesClose (modules, 0);
ksDel (modules);
keyDel (parentKey);
}
static void test_ifsetthenkey()
{
Key *parentKey = keyNew("user/tests/conditionals", KEY_VALUE, "", KEY_END);
KeySet *ks = ksNew(5,
keyNew("user/tests/conditionals/totest", KEY_VALUE, "", KEY_META, "check/condition", "(totest=='') ? (totest := bla/val1)", KEY_END),
keyNew("user/tests/conditionals/bla/val1", KEY_VALUE, "100", KEY_END),
keyNew("user/tests/conditionals/bla/val2", KEY_VALUE, "50", KEY_END),
keyNew("user/tests/conditionals/bla/val3", KEY_VALUE, "3", KEY_END),
KS_END);
KeySet *conf = ksNew(0, KS_END);
PLUGIN_OPEN("conditionals");
ksRewind(ks);
succeed_if(plugin->kdbGet(plugin, ks, parentKey) == 1, "error");
Key *key = ksLookupByName(ks, "user/tests/conditionals/totest", 0);
succeed_if(strcmp(keyString(key), "100") == 0, "error setting then value");
ksDel(ks);
keyDel(parentKey);
PLUGIN_CLOSE();
}
Name
IdentityManager::getKeyNameFromCertificatePrefix(const Name & certificatePrefix)
{
Name result;
string keyString("KEY");
int i = 0;
for(; i < certificatePrefix.size(); i++) {
if (certificatePrefix.get(i).toEscapedString() == keyString)
break;
}
if (i >= certificatePrefix.size())
throw SecurityException("Identity Certificate Prefix does not have a KEY component");
result.append(certificatePrefix.getSubName(0, i));
result.append(certificatePrefix.getSubName(i + 1, certificatePrefix.size()-i-1));
return result;
}
static OnConflict getConfOption (Key * key)
{
const char * string = keyString (key);
if (!strcmp (string, "ERROR"))
{
return ERROR;
}
else if (!strcmp (string, "WARNING"))
{
return WARNING;
}
else if (!strcmp (string, "INFO"))
{
return INFO;
}
else
{
return IGNORE;
}
}
bool
createTXTRecord(scopedTXTRecord& txtRecord, Local<Object>& object) {
HandleScope scope;
Local<Array> names = object->GetPropertyNames();
uint32_t length = names->Length();
for (uint32_t index = 0; index<length; ++index) {
Local<Value> key = names->Get(index);
if (key->IsString()) {
// Local<Value> buffer = object->Get(key);
Handle<Value> buffer = object->Get(key);
String::Utf8Value string_value( buffer->ToString());
// A DNS-SD key is 7-bit ascii
String::AsciiValue keyString(key);
std::string buf(*keyString, keyString.length());
/* Local<Object> obj;
uint8_t valLen = 0;
const void *value = NULL;
if (Buffer::HasInstance(buffer)) {
obj = buffer->ToObject();
valLen = Buffer::Length(obj);
value = Buffer::Data(obj);
}
if (txtRecord.setValue(buf.c_str(), valLen, value) != kDNSServiceErr_NoError) {
return false;
}
*/
if (txtRecord.setValue(buf.c_str(), buffer->ToString()->Utf8Length(), *string_value) != kDNSServiceErr_NoError) {
return false;
}
} else {
return false;
}
}
return true;
}
void testReadSingleLine (const char * fileName)
{
Key * parentKey = keyNew ("user/tests/file", KEY_VALUE, srcdir_file (fileName), KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("file");
KeySet * ks = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
const Key * key = ksLookupByName (ks, "user/tests/file", KDB_O_NONE);
exit_if_fail (key, "key not found");
succeed_if (!strcmp ("this is a single line testfile\n", keyString (key)), "read single line data doesn't match expected string");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void test_writePref (char * fileName)
{
Key * parentKey = keyNew ("user/tests/pref-write", KEY_VALUE, elektraFilename (), KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("mozprefs");
KeySet * ks = ksNew (
30, keyNew ("user/tests/pref-write/user/a/user/key", KEY_VALUE, "usertest", KEY_META, "type", "string", KEY_END),
keyNew ("user/tests/pref-write/lock/a/lock/key", KEY_VALUE, "true", KEY_META, "type", "boolean", KEY_END),
keyNew ("user/tests/pref-write/pref/a/default/key", KEY_VALUE, "1", KEY_META, "type", "integer", KEY_END),
keyNew ("user/tests/pref-write/sticky/a/sticky/key", KEY_VALUE, "false", KEY_META, "type", "boolean", KEY_END), KS_END);
succeed_if (plugin->kdbSet (plugin, ks, parentKey) >= 1, "call to kdbSet was not successful");
succeed_if (compare_line_files (srcdir_file (fileName), keyString (parentKey)), "files do not match as expected");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void setOrderNumber(Key *parentKey, Key *key)
{
kdb_long_long_t order = 0;
const Key *orderKey = keyGetMeta(parentKey, "order");
if (orderKey != NULL)
{
char *ptr = (char *)keyString(orderKey);
++ptr; //skip #
while (*ptr == '_')
{
++ptr;
}
elektraReadArrayNumber(ptr, &order);
}
++order;
char buffer[ELEKTRA_MAX_ARRAY_SIZE];
elektraWriteArrayNumber(buffer, order);
keySetMeta(key, "order", buffer);
keySetMeta(parentKey, "order", buffer);
}
static void test_getArrayNext (void)
{
printf ("Test get array next");
KeySet * array = ksNew (10, keyNew ("user/test/array/#0", KEY_END), keyNew ("user/test/array/#1", KEY_END),
KS_END);
Key * nextKey = elektraArrayGetNextKey (array);
exit_if_fail (array, "The getnext function did not return a proper key");
succeed_if (!strcmp (keyName (nextKey), "user/test/array/#2"), "The getnext function did not use the correct keyname");
succeed_if (!strcmp (keyString (nextKey), ""), "The getnext function did not return an empty key");
keyDel (nextKey);
ksClear (array);
nextKey = elektraArrayGetNextKey (array);
succeed_if (!nextKey, "The getnext function did not return NULL on an empty array");
keyDel (nextKey);
ksDel (array);
}
void elektraMetaArrayAdd (Key * key, const char * metaName, const char * value)
{
const Key * meta = keyGetMeta (key, metaName);
Key * arrayKey;
if (!meta)
{
keySetMeta (key, metaName, "#0");
arrayKey = keyDup (keyGetMeta (key, metaName));
keySetString (arrayKey, 0);
keyAddBaseName (arrayKey, "#");
}
else
{
arrayKey = keyDup (meta);
keyAddBaseName (arrayKey, keyString (meta));
}
elektraArrayIncName (arrayKey);
keySetMeta (key, keyName (arrayKey), value);
keySetMeta (key, metaName, keyBaseName (arrayKey));
keyDel (arrayKey);
}
static void test_commentIniRead (char * fileName)
{
Key * parentKey = keyNew ("user/tests/ini-read", KEY_VALUE, srcdir_file (fileName), KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("ini");
KeySet * ks = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
succeed_if (output_error (parentKey), "error in kdbGet");
succeed_if (output_warnings (parentKey), "warnings in kdbGet");
Key * key = ksLookupByName (ks, "user/tests/ini-read/nosectionkey", KDB_O_NONE);
exit_if_fail (key, "nosectionkey not found");
const Key * noSectionComment = keyGetMeta (key, "comments/#0");
exit_if_fail (noSectionComment, "nosectionkey contained no comment");
succeed_if (!strcmp (";nosection comment1", keyString (noSectionComment)), "nosectionkey contained an invalid comment");
noSectionComment = keyGetMeta (key, "comments/#1");
exit_if_fail (noSectionComment, "nosectionkey contained no comment");
succeed_if (!strcmp (";nosection comment2", keyString (noSectionComment)), "nosectionkey contained an invalid comment");
key = ksLookupByName (ks, "user/tests/ini-read/section1", KDB_O_NONE);
exit_if_fail (key, "section1 not found");
const Key * sectionComment = keyGetMeta (key, "comments/#0");
exit_if_fail (sectionComment, "sectionkey contained no comment");
succeed_if (!strcmp (";section comment1", keyString (sectionComment)), "sectionkey contained an invalid comment");
sectionComment = keyGetMeta (key, "comments/#1");
exit_if_fail (sectionComment, "sectionkey contained no comment");
succeed_if (!strcmp (";section comment2", keyString (sectionComment)), "sectionkey contained an invalid comment");
key = ksLookupByName (ks, "user/tests/ini-read/section1/key1", KDB_O_NONE);
exit_if_fail (key, "key1 not found");
const Key * keyComment_ = keyGetMeta (key, "comments/#0");
exit_if_fail (keyComment_, "key1 contained no comment");
succeed_if (!strcmp (";key comment1", keyString (keyComment_)), "key1 contained an invalid comment");
keyComment_ = keyGetMeta (key, "comments/#1");
exit_if_fail (keyComment_, "key1 contained no comment");
succeed_if (!strcmp (";key comment2", keyString (keyComment_)), "key1 contained an invalid comment");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
static void insertNewKeyIntoExistendOrder(Key *key, KeySet *ks)
{
if (keyGetMeta(ksLookup(ks, key, KDB_O_NONE), "order"))
return;
ksRewind(ks);
Key *curKey;
Key *prevKey = NULL;
while ((curKey = ksNext(ks)) != NULL)
{
if (!strcmp(keyName(curKey), keyName(key)))
{
const char *oldOrder = "#1";
if (keyGetMeta(prevKey, "order"))
{
oldOrder = keyString(keyGetMeta(prevKey, "order"));
}
setSubOrderNumber(key, oldOrder);
}
prevKey = curKey;
}
}
static void test_get (void)
{
char const * const fileName = "camel/simple.yaml";
printf ("• Parse file “%s”\n", fileName);
char const * const prefix = "user/camel/tests/read";
Key * parentKey = keyNew (prefix, KEY_VALUE, srcdir_file (fileName), KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("camel");
KeySet * keySet = ksNew (0, KS_END);
int status = plugin->kdbGet (plugin, keySet, parentKey);
succeed_if (status == ELEKTRA_PLUGIN_STATUS_SUCCESS || status == ELEKTRA_PLUGIN_STATUS_NO_UPDATE, "Unable to open or parse file");
succeed_if (output_error (parentKey), "Received unexpected error while reading the configuration");
char keyValues[][2][50] = {
{ "hello", "world" },
};
Key * key;
char text[MAX_LENGTH_TEXT];
for (size_t pair = 0; pair < sizeof (keyValues) / sizeof (keyValues[0]); pair++)
{
char * name = keyValues[pair][0];
char * value = keyValues[pair][1];
snprintf (text, MAX_LENGTH_TEXT, "%s/%s", prefix, name);
key = ksLookupByName (keySet, text, KDB_O_NONE);
snprintf (text, MAX_LENGTH_TEXT, "Key “%s” not found", name);
exit_if_fail (key, text);
succeed_if_same_string (keyString (key), value);
}
keyDel (parentKey);
ksDel (keySet);
PLUGIN_CLOSE ();
}
void test_plainIniWrite(char *fileName)
{
Key *parentKey = keyNew ("user/tests/ini-write", KEY_VALUE,
elektraFilename(), KEY_END);
KeySet *conf = ksNew (0);
PLUGIN_OPEN("ini");
KeySet *ks = ksNew (30,
keyNew ("user/tests/ini-write/nosectionkey",
KEY_VALUE, "nosectionvalue",
KEY_END),
keyNew ("user/tests/ini-write/section1", KEY_DIR, KEY_END),
keyNew ("user/tests/ini-write/section1/key1",
KEY_VALUE, "value1",
KEY_END),
keyNew ("user/tests/ini-write/section1/key2",
KEY_VALUE, "value2",
KEY_END),
keyNew ("user/tests/ini-write/section2", KEY_DIR, KEY_END),
keyNew ("user/tests/ini-write/section2/key3",
KEY_VALUE, "value3",
KEY_END),
keyNew ("user/tests/ini-write/section2/emptykey", KEY_END),
KS_END);
succeed_if(plugin->kdbSet (plugin, ks, parentKey) >= 1,
"call to kdbSet was not successful");
succeed_if(output_error (parentKey), "error in kdbSet");
succeed_if(output_warnings (parentKey), "warnings in kdbSet");
succeed_if(
compare_line_files (srcdir_file (fileName), keyString (parentKey)),
"files do not match as expected");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ()
;
}
/**
* @brief Output warnings if present
*
* To check for warnings use:
* succeed_if(output_warnings(parentKey), "warning(s) found");
*
* @param warningKey the key to retrieve metadata from
*
* @see check_for_errors_and_warnings if you want errors to have a test case failed without output
*
* @return 1 if no warnings (can be used within succeed_if)
*/
int output_warnings(Key *warningKey)
{
const Key *metaWarnings = keyGetMeta(warningKey, "warnings");
if (!metaWarnings) return 1; /* There are no current warnings */
int nrWarnings = atoi(keyString(metaWarnings));
char buffer[] = "warnings/#00\0description";
printf ("There are %d warnings\n", nrWarnings+1);
for (int i=0; i<=nrWarnings; ++i)
{
buffer[10] = i/10%10 + '0';
buffer[11] = i%10 + '0';
printf ("buffer is: %s\n", buffer);
strncat(buffer, "/number" , sizeof(buffer) -1);
printf ("number: %s\n", keyString(keyGetMeta(warningKey, buffer)));
buffer[12] = '\0'; strncat(buffer, "/description" , sizeof(buffer) -1);
printf ("description: %s\n", keyString(keyGetMeta(warningKey, buffer)));
buffer[12] = '\0'; strncat(buffer, "/ingroup" , sizeof(buffer) -1);
keyGetMeta(warningKey, buffer);
printf ("ingroup: %s\n", keyString(keyGetMeta(warningKey, buffer)));
buffer[12] = '\0'; strncat(buffer, "/module" , sizeof(buffer) -1);
keyGetMeta(warningKey, buffer);
printf ("module: %s\n", keyString(keyGetMeta(warningKey, buffer)));
buffer[12] = '\0'; strncat(buffer, "/file" , sizeof(buffer) -1);
keyGetMeta(warningKey, buffer);
printf ("file: %s\n", keyString(keyGetMeta(warningKey, buffer)));
buffer[12] = '\0'; strncat(buffer, "/line" , sizeof(buffer) -1);
keyGetMeta(warningKey, buffer);
printf ("line: %s\n", keyString(keyGetMeta(warningKey, buffer)));
buffer[12] = '\0'; strncat(buffer, "/reason" , sizeof(buffer) -1);
keyGetMeta(warningKey, buffer);
printf ("reason: %s\n", keyString(keyGetMeta(warningKey, buffer)));
}
return 0;
}
/**
* Helper function for code generation.
*
* Finds an array element Key from its relative name and index.
* Also checks type metadata, if @p type is not NULL.
*
* @param elektra The Elektra instance to use.
* @param name The relative name of the array.
* @param index The index of the array element.
* @param type The expected type metadata value.
* @return the Key referenced by @p name or NULL, if a fatal error occurs and the fatal error handler returns to this function
*/
Key * elektraFindArrayElementKey (Elektra * elektra, const char * name, size_t index, KDBType type)
{
elektraSetArrayLookupKey (elektra, name, index);
Key * const resultKey = ksLookup (elektra->config, elektra->lookupKey, 0);
if (resultKey == NULL)
{
elektraFatalError (elektra, elektraErrorKeyNotFound (keyName (elektra->lookupKey)));
return NULL;
}
if (type != NULL)
{
const char * actualType = keyString (keyGetMeta (resultKey, "type"));
if (strcmp (actualType, type) != 0)
{
elektraFatalError (elektra, elektraErrorWrongType (keyName (elektra->lookupKey), type, actualType));
return NULL;
}
}
return resultKey;
}
void testRoundTrip (const char * fileName)
{
Key * parentKey = keyNew ("user/tests/file", KEY_VALUE, srcdir_file (fileName), KEY_END);
KeySet * conf = ksNew (0, KS_END);
PLUGIN_OPEN ("file");
KeySet * ks = ksNew (0, KS_END);
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 1, "call to kdbGet was not successful");
keySetString (parentKey, elektraFilename ());
succeed_if (plugin->kdbSet (plugin, ks, parentKey) == 1, "call to kdbSet was not successful");
succeed_if (compare_line_files (srcdir_file (fileName), keyString (parentKey)), "files do not match as expected");
ksDel (ks);
keyDel (parentKey);
PLUGIN_CLOSE ();
}
int main()
{
KeySet *myConfig = ksNew(0, KS_END);
Key *key = keyNew("system/test/myapp",KEY_END);
KDB *handle = kdbOpen(key);
kdbGet(handle, myConfig, key);
keySetName(key, "user/test/myapp");
kdbGet(handle, myConfig, key);
// check for errors in key
keyDel(key);
/*
ksRewind(myConfig);
while ((key = ksNext(myConfig)))
{
printf ("%s\n", keyName(key));
}
*/
key = ksLookupByName(myConfig,"/test/myapp/key", 0);
// check if key is not 0 and work with it...
if (key)
{
printf("%s\n", keyString(key));
}
ksDel (myConfig); // delete the in-memory configuration
// maybe you want kdbSet() myConfig here
kdbClose(handle, 0); // no more affairs with the key database.
return 0;
}
static void test_complexInsert (char * source, char * compare)
{
Key * parentKey = keyNew ("user/tests/ini-write", KEY_VALUE, srcdir_file (source), KEY_END);
Key * writeParentKey = keyNew ("user/tests/ini-write", KEY_VALUE, elektraFilename (), KEY_END);
KeySet * conf = ksNew (0, KS_END);
KeySet * ks = ksNew (30, KS_END);
KeySet * appendKS = ksNew (10, keyNew ("user/tests/ini-write/section/subsection", KEY_BINARY, KEY_END),
keyNew ("user/tests/ini-write/section/subsection/subkey", KEY_VALUE, "subval", KEY_END),
keyNew ("user/tests/ini-write/section/zkey3", KEY_VALUE, "3", KEY_END), KS_END);
PLUGIN_OPEN ("ini");
succeed_if (plugin->kdbGet (plugin, ks, parentKey) >= 0, "call to kdbGet was not successful");
keyDel (ksLookup (ks, parentKey, KDB_O_POP));
keyDel (parentKey);
ksAppend (ks, appendKS);
succeed_if (plugin->kdbSet (plugin, ks, writeParentKey) >= 1, "call to kdbSet was not successful");
succeed_if (compare_line_files (srcdir_file (compare), keyString (writeParentKey)), "files do not match as expected");
keyDel (ksLookup (ks, writeParentKey, KDB_O_POP));
keyDel (writeParentKey);
ksDel (appendKS);
ksDel (ks);
PLUGIN_CLOSE ();
}
Name
IdentityCertificate::certificateNameToPublicKeyName(const Name& certificateName)
{
string idString("ID-CERT");
bool foundIdString = false;
size_t idCertComponentIndex = certificateName.size() - 1;
for (; idCertComponentIndex + 1 > 0; --idCertComponentIndex) {
if (certificateName.get(idCertComponentIndex).toUri() == idString)
{
foundIdString = true;
break;
}
}
if (!foundIdString)
throw Error("Incorrect identity certificate name " + certificateName.toUri());
Name tmpName = certificateName.getSubName(0, idCertComponentIndex);
string keyString("KEY");
bool foundKeyString = false;
size_t keyComponentIndex = 0;
for (; keyComponentIndex < tmpName.size(); keyComponentIndex++) {
if (tmpName.get(keyComponentIndex).toUri() == keyString)
{
foundKeyString = true;
break;
}
}
if (!foundKeyString)
throw Error("Incorrect identity certificate name " + certificateName.toUri());
return tmpName
.getSubName(0, keyComponentIndex)
.append(tmpName.getSubName(keyComponentIndex + 1,
tmpName.size() - keyComponentIndex - 1));
}
void test_name()
{
printf ("Resolve Name\n");
KeySet *modules = ksNew(0, KS_END);
elektraModulesInit (modules, 0);
Plugin *plugin = elektraPluginOpen("resolver", modules, set_pluginconf(), 0);
exit_if_fail (plugin, "could not load resolver plugin");
KeySet *test_config = set_pluginconf();
KeySet *config = elektraPluginGetConfig (plugin);
succeed_if (config != 0, "there should be a config");
compare_keyset(config, test_config);
ksDel (test_config);
succeed_if (plugin->kdbOpen != 0, "no open pointer");
succeed_if (plugin->kdbClose != 0, "no open pointer");
succeed_if (plugin->kdbGet != 0, "no open pointer");
succeed_if (plugin->kdbSet != 0, "no open pointer");
succeed_if (plugin->kdbError!= 0, "no open pointer");
succeed_if (!strcmp(plugin->name, "resolver"), "got wrong name");
resolverHandles *h = elektraPluginGetData(plugin);
succeed_if (h != 0, "no plugin handle");
Key *parentKey= keyNew("system", KEY_END);
plugin->kdbGet(plugin, 0, parentKey);
succeed_if (!strcmp(keyString(parentKey), KDB_DB_SYSTEM "/elektra.ecf"),
"resulting filename not correct");
keyDel (parentKey);
elektraPluginClose(plugin, 0);
elektraModulesClose(modules, 0);
ksDel (modules);
}
STDMETHODIMP CMapiImp::ReadMail(unsigned long aSession, unsigned long ulUIParam, LPTSTR lpszMessageID,
unsigned long flFlags, unsigned long ulReserved, lpnsMapiMessage *lppMessage)
{
PRInt32 irv;
nsCAutoString keyString((char *) lpszMessageID);
PR_LOG(MAPI, PR_LOG_DEBUG, ("CMapiImp::ReadMail asking for key %s\n", (char *) lpszMessageID));
nsMsgKey msgKey = keyString.ToInteger(&irv);
if (irv)
{
NS_ASSERTION(PR_FALSE, "invalid lpszMessageID");
return MAPI_E_INVALID_MESSAGE;
}
MsgMapiListContext *listContext;
LONG ret = InitContext(aSession, &listContext);
if (ret != SUCCESS_SUCCESS)
{
NS_ASSERTION(PR_FALSE, "init context failed in ReadMail");
return ret;
}
*lppMessage = listContext->GetMessage (msgKey, flFlags);
NS_ASSERTION(*lppMessage, "get message failed");
return (*lppMessage) ? SUCCESS_SUCCESS : E_FAIL;
}
