void test_resolve ()
{
int pathLen = tempHomeLen + 1 + strlen (KDB_DB_USER) + 12 + 1;
char * path = elektraMalloc (pathLen);
exit_if_fail (path != 0, "elektraMalloc failed");
snprintf (path, pathLen, "%s/%s/elektra.ecf", tempHome, KDB_DB_USER);
printf ("Resolve Filename\n");
KeySet * modules = ksNew (0, KS_END);
elektraModulesInit (modules, 0);
Key * parentKey = keyNew ("system", KEY_END);
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 (!strncmp (plugin->name, "resolver", strlen ("resolver")), "got wrong name");
resolverHandles * h = elektraPluginGetData (plugin);
exit_if_fail (h != 0, "no plugin handle");
succeed_if (!strcmp (h->system.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp (h->system.filename, KDB_DB_SYSTEM "/elektra.ecf"), "resulting filename not correct");
succeed_if_same_string (h->user.path, "elektra.ecf");
succeed_if_same_string (h->user.filename, path);
plugin->kdbClose (plugin, parentKey);
// reinit with system path only
plugin->kdbOpen (plugin, parentKey);
h = elektraPluginGetData (plugin);
exit_if_fail (h != 0, "no plugin handle");
succeed_if (!strcmp (h->system.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp (h->system.filename, KDB_DB_SYSTEM "/elektra.ecf"), "resulting filename not correct");
succeed_if (h->user.filename == NULL, "user was initialized, but is not needed");
plugin->kdbClose (plugin, parentKey);
keyDel (parentKey);
elektraPluginClose (plugin, 0);
elektraModulesClose (modules, 0);
ksDel (modules);
elektraFree (path);
}
int elektraDbusGet (Plugin * handle, KeySet * returned, Key * parentKey)
{
if (!strcmp (keyName (parentKey), "system/elektra/modules/dbus"))
{
KeySet * contract =
ksNew (30, keyNew ("system/elektra/modules/dbus", KEY_VALUE, "dbus plugin waits for your orders", KEY_END),
keyNew ("system/elektra/modules/dbus/exports", KEY_END),
keyNew ("system/elektra/modules/dbus/exports/get", KEY_FUNC, elektraDbusGet, KEY_END),
keyNew ("system/elektra/modules/dbus/exports/set", KEY_FUNC, elektraDbusSet, KEY_END),
keyNew ("system/elektra/modules/dbus/exports/close", KEY_FUNC, elektraDbusClose, KEY_END),
#include ELEKTRA_README (dbus)
keyNew ("system/elektra/modules/dbus/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END), KS_END);
ksAppend (returned, contract);
ksDel (contract);
return 1; /* success */
}
// remember all keys
KeySet * ks = (KeySet *)elektraPluginGetData (handle);
if (ks) ksDel (ks);
elektraPluginSetData (handle, ksDup (returned));
return 1; /* success */
}
static resolverHandle * elektraGetResolverHandle (Plugin * handle, Key * parentKey)
{
resolverHandles * pks = elektraPluginGetData (handle);
ELEKTRA_ASSERT (pks != NULL, "Unable to retrieve plugin data for handle %p with parentKey %s", (void *) handle,
keyName (parentKey));
switch (keyGetNamespace (parentKey))
{
case KEY_NS_SPEC:
return &pks->spec;
case KEY_NS_DIR:
return &pks->dir;
case KEY_NS_USER:
return &pks->user;
case KEY_NS_SYSTEM:
return &pks->system;
case KEY_NS_PROC:
case KEY_NS_EMPTY:
case KEY_NS_NONE:
case KEY_NS_META:
case KEY_NS_CASCADING:
return 0;
}
return 0;
}
/**
* @internal
* Call kdbGet if there are registrations below the changed key.
*
* On kdbGet this plugin implicitly updates registered keys.
*
* @see ElektraNotificationChangeCallback (kdbnotificationinternal.h)
* @param key changed key
* @param context callback context
*/
void elektraInternalnotificationDoUpdate (Key * changedKey, ElektraNotificationCallbackContext * context)
{
ELEKTRA_NOT_NULL (changedKey);
ELEKTRA_NOT_NULL (context);
Plugin * plugin = context->notificationPlugin;
PluginState * pluginState = elektraPluginGetData (plugin);
ELEKTRA_NOT_NULL (pluginState);
int kdbChanged = 0;
KeyRegistration * keyRegistration = pluginState->head;
while (keyRegistration != NULL)
{
Key * registeredKey = keyNew (keyRegistration->name, KEY_END);
// check if registered key is same or below changed/commit key
kdbChanged |= checkKeyIsBelowOrSame (changedKey, registeredKey);
if (keyRegistration->sameOrBelow)
{
// check if registered key is also above changed/commit key
kdbChanged |= checkKeyIsBelowOrSame (registeredKey, changedKey);
}
keyRegistration = keyRegistration->next;
keyDel (registeredKey);
}
if (kdbChanged)
{
context->kdbUpdate (context->kdb, changedKey);
}
keyDel (changedKey);
}
/**
* @see ElektraNotificationOpenNotification (kdbnotificationinternal.h)
*/
void elektraZeroMqRecvOpenNotification (Plugin * handle, KeySet * parameters)
{
ELEKTRA_NOT_NULL (handle);
ElektraZeroMqRecvPluginData * pluginData = elektraPluginGetData (handle);
ELEKTRA_NOT_NULL (pluginData);
ElektraNotificationCallback callback;
Key * callbackKey = ksLookupByName (parameters, "/callback", 0);
ELEKTRA_NOT_NULL (callbackKey);
callback = *(ElektraNotificationCallback *) keyValue (callbackKey);
ElektraNotificationCallbackContext * context;
Key * contextKey = ksLookupByName (parameters, "/context", 0);
if (contextKey != NULL)
{
context = *(ElektraNotificationCallbackContext **) keyValue (contextKey);
}
else
{
context = NULL;
}
pluginData->notificationCallback = callback;
pluginData->notificationContext = context;
// init dbus connections
if (pluginData->ioBinding)
{
elektraZeroMqRecvSetup (pluginData);
}
else
{
ELEKTRA_LOG_DEBUG ("no I/O binding present. plugin in noop mode");
}
}
/**
* @see kdbnotificationinternal.h ::ElektraNotificationSetConversionErrorCallback
*/
static void elektraInternalnotificationSetConversionErrorCallback (Plugin * handle, ElektraNotificationConversionErrorCallback callback,
void * context)
{
ELEKTRA_NOT_NULL (handle);
ELEKTRA_NOT_NULL (callback);
PluginState * data = elektraPluginGetData (handle);
ELEKTRA_NOT_NULL (data);
data->conversionErrorCallback = callback;
data->conversionErrorCallbackContext = context;
}
int elektraDbusSet (Plugin * handle, KeySet * returned, Key * parentKey)
{
KeySet * oldKeys = (KeySet *)elektraPluginGetData (handle);
// because elektraLogchangeGet will always be executed before elektraLogchangeSet
// we know that oldKeys must exist here!
ksRewind (oldKeys);
ksRewind (returned);
KeySet * addedKeys = ksDup (returned);
KeySet * changedKeys = ksNew (0, KS_END);
KeySet * removedKeys = ksNew (0, KS_END);
Key * k = 0;
while ((k = ksNext (oldKeys)) != 0)
{
Key * p = ksLookup (addedKeys, k, KDB_O_POP);
// Note: keyDel not needed, because at least two references exist
if (p)
{
if (keyNeedSync (p))
{
ksAppendKey (changedKeys, p);
}
}
else
{
ksAppendKey (removedKeys, k);
}
}
if (!strncmp (keyName (parentKey), "user", 4))
{
announceKeys (addedKeys, "KeyAdded", DBUS_BUS_SESSION);
announceKeys (changedKeys, "KeyChanged", DBUS_BUS_SESSION);
announceKeys (removedKeys, "KeyDeleted", DBUS_BUS_SESSION);
}
else if (!strncmp (keyName (parentKey), "system", 6))
{
announceKeys (addedKeys, "KeyAdded", DBUS_BUS_SYSTEM);
announceKeys (changedKeys, "KeyChanged", DBUS_BUS_SYSTEM);
announceKeys (removedKeys, "KeyDeleted", DBUS_BUS_SYSTEM);
}
ksDel (oldKeys);
ksDel (addedKeys);
ksDel (changedKeys);
ksDel (removedKeys);
// for next invocation of elektraLogchangeSet, remember our current keyset
elektraPluginSetData (handle, ksDup (returned));
return 1; /* success */
}
/**
* @see ElektraIoPluginSetBinding (kdbioplugin.h)
*/
void elektraZeroMqRecvSetIoBinding (Plugin * handle, KeySet * parameters)
{
ELEKTRA_NOT_NULL (handle);
ELEKTRA_NOT_NULL (parameters);
ElektraZeroMqRecvPluginData * data = elektraPluginGetData (handle);
ELEKTRA_NOT_NULL (data);
Key * ioBindingKey = ksLookupByName (parameters, "/ioBinding", 0);
ELEKTRA_NOT_NULL (ioBindingKey);
ElektraIoInterface * binding = *(ElektraIoInterface **) keyValue (ioBindingKey);
data->ioBinding = binding;
}
/**
* @see kdbnotificationinternal.h ::ElektraNotificationPluginRegisterCallback
*/
int elektraInternalnotificationRegisterCallback (Plugin * handle, Key * key, ElektraNotificationChangeCallback callback, void * context)
{
PluginState * pluginState = elektraPluginGetData (handle);
ELEKTRA_ASSERT (pluginState != NULL, "plugin state was not initialized properly");
KeyRegistration * registeredKey = elektraInternalnotificationAddNewRegistration (pluginState, key, callback, context, 0);
if (registeredKey == NULL)
{
return 0;
}
return 1;
}
int elektraSpecloadClose (Plugin * handle, Key * errorKey)
{
Specload * specload = elektraPluginGetData (handle);
if (specload != NULL)
{
elektraInvokeClose (specload->quickDump, errorKey);
ksDel (specload->quickDumpConfig);
elektraFree (specload->app);
freeArgv (specload->argv);
elektraFree (specload);
elektraPluginSetData (handle, NULL);
}
return ELEKTRA_PLUGIN_STATUS_SUCCESS;
}
int elektraHexcodeGet (Plugin * handle, KeySet * returned, Key * parentKey)
{
/* get all keys */
if (!strcmp (keyName (parentKey), "system/elektra/modules/hexcode"))
{
KeySet * pluginConfig =
ksNew (30, keyNew ("system/elektra/modules/hexcode", KEY_VALUE, "hexcode plugin waits for your orders", KEY_END),
keyNew ("system/elektra/modules/hexcode/exports", KEY_END),
keyNew ("system/elektra/modules/hexcode/exports/get", KEY_FUNC, elektraHexcodeGet, KEY_END),
keyNew ("system/elektra/modules/hexcode/exports/set", KEY_FUNC, elektraHexcodeSet, KEY_END),
keyNew ("system/elektra/modules/hexcode/exports/open", KEY_FUNC, elektraHexcodeOpen, KEY_END),
keyNew ("system/elektra/modules/hexcode/exports/close", KEY_FUNC, elektraHexcodeClose, KEY_END),
#include "readme_hexcode.c"
keyNew ("system/elektra/modules/hexcode/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END), KS_END);
ksAppend (returned, pluginConfig);
ksDel (pluginConfig);
return 1;
}
CHexData * hd = elektraPluginGetData (handle);
if (!hd->buf)
{
hd->buf = elektraMalloc (1000);
hd->bufalloc = 1000;
}
Key * cur;
ksRewind (returned);
while ((cur = ksNext (returned)) != 0)
{
size_t valsize = keyGetValueSize (cur);
if (valsize > hd->bufalloc)
{
hd->bufalloc = valsize;
hd->buf = realloc (hd->buf, hd->bufalloc);
}
elektraHexcodeDecode (cur, hd);
}
return 1; /* success */
}
void test_tempname()
{
printf ("Resolve Tempname\n");
KeySet *modules = ksNew(0);
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 (!strncmp(h->system.tempfile, KDB_DB_SYSTEM "/elektra.ecf", sizeof(KDB_DB_SYSTEM)),
"resulting filename not correct");
keySetName(parentKey, "user");
plugin->kdbGet(plugin, 0, parentKey);
succeed_if (!strncmp(h->user.tempfile, KDB_DB_HOME "/" KDB_DB_USER "/elektra.ecf.tmp", sizeof(KDB_DB_HOME "/" KDB_DB_USER)),
"resulting filename not correct");
keyDel (parentKey);
elektraPluginClose(plugin, 0);
elektraModulesClose(modules, 0);
ksDel (modules);
}
static resolverHandle * elektraGetResolverHandle (Plugin * handle, Key * parentKey)
{
resolverHandles * pks = elektraPluginGetData (handle);
switch (keyGetNamespace (parentKey))
{
case KEY_NS_SPEC:
return &pks->spec;
case KEY_NS_DIR:
return &pks->dir;
case KEY_NS_USER:
return &pks->user;
case KEY_NS_SYSTEM:
return &pks->system;
case KEY_NS_PROC:
case KEY_NS_EMPTY:
case KEY_NS_NONE:
case KEY_NS_META:
case KEY_NS_CASCADING:
return 0;
}
return 0;
}
static resolverHandle * elektraGetResolverHandle (Plugin * handle, Key * parentKey)
{
resolverHandles * pks = elektraPluginGetData (handle);
switch (keyGetNamespace (parentKey))
{
case KEY_NS_SPEC:
return &pks->spec;
case KEY_NS_DIR:
return &pks->dir;
case KEY_NS_USER:
return &pks->user;
case KEY_NS_SYSTEM:
return &pks->system;
case KEY_NS_PROC:
case KEY_NS_EMPTY:
case KEY_NS_NONE:
case KEY_NS_META:
case KEY_NS_CASCADING:
break;
}
ELEKTRA_ASSERT (0, "namespace %d not valid for resolving", keyGetNamespace (parentKey));
return 0;
}
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 (!strncmp (plugin->name, "resolver", strlen ("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_same_string (keyString (parentKey), KDB_DB_SYSTEM "/elektra.ecf");
keyDel (parentKey);
elektraPluginClose (plugin, 0);
elektraModulesClose (modules, 0);
ksDel (modules);
}
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 */
}
int elektraWresolverClose (Plugin * handle, Key * errorKey ELEKTRA_UNUSED)
{
resolverHandles * ps = elektraPluginGetData (handle);
if (ps)
{
switch (KEY_NS_SPEC)
{
case KEY_NS_SPEC:
resolverClose (&ps->spec);
case KEY_NS_DIR:
resolverClose (&ps->dir);
case KEY_NS_USER:
resolverClose (&ps->user);
case KEY_NS_SYSTEM:
resolverClose (&ps->system);
case KEY_NS_PROC:
case KEY_NS_EMPTY:
/**
* Updates all KeyRegistrations according to data from the given KeySet
* @internal
*
* @param plugin internal plugin handle
* @param keySet key set retrieved from hooks
* e.g. elektraInternalnotificationGet or elektraInternalnotificationSet)
*
*/
void elektraInternalnotificationUpdateRegisteredKeys (Plugin * plugin, KeySet * keySet)
{
PluginState * pluginState = elektraPluginGetData (plugin);
ELEKTRA_ASSERT (pluginState != NULL, "plugin state was not initialized properly");
KeyRegistration * registeredKey = pluginState->head;
while (registeredKey != NULL)
{
int changed = 0;
Key * key;
if (registeredKey->sameOrBelow)
{
Key * checkKey = keyNew (registeredKey->name, KEY_END);
if (keySetContainsSameOrBelow (checkKey, keySet))
{
changed = 1;
key = checkKey;
}
else
{
keyDel (checkKey);
}
}
else
{
key = ksLookupByName (keySet, registeredKey->name, 0);
if (key != NULL)
{
// Detect changes for string keys
if (!keyIsString (key))
{
// always notify for binary keys
changed = 1;
}
else
{
const char * currentValue = keyString (key);
changed = registeredKey->lastValue == NULL || strcmp (currentValue, registeredKey->lastValue) != 0;
if (changed)
{
// Save last value
char * buffer = elektraStrDup (currentValue);
if (buffer)
{
if (registeredKey->lastValue != NULL)
{
// Free previous value
elektraFree (registeredKey->lastValue);
}
registeredKey->lastValue = buffer;
}
}
}
}
}
if (changed)
{
ELEKTRA_LOG_DEBUG ("found changed registeredKey=%s with string value \"%s\". using context or variable=%p",
registeredKey->name, keyString (key), registeredKey->context);
// Invoke callback
ElektraNotificationChangeCallback callback = *(ElektraNotificationChangeCallback) registeredKey->callback;
callback (key, registeredKey->context);
if (registeredKey->sameOrBelow)
{
keyDel (key);
}
}
// proceed with next registered key
registeredKey = registeredKey->next;
}
}
{
char *errormessage;
asprintf (&errormessage, "Unable to initialize augeas: %s",
aug_error_message (augeasHandle));
ELEKTRA_SET_ERROR(85, parentKey, errormessage);
free (errormessage);
return -1;
}
elektraPluginSetData (handle, augeasHandle);
return 0;
}
int elektraAugeasClose(Plugin *handle, Key *parentKey ELEKTRA_UNUSED)
{
augeas *augeasHandle = elektraPluginGetData (handle);
if (augeasHandle) aug_close (augeasHandle);
return 0;
}
int elektraAugeasGet(Plugin *handle, KeySet *returned, Key *parentKey)
{
int errnosave = errno;
int ret = 0;
if (!strcmp (keyName (parentKey), "system/elektra/modules/augeas"))
{
KeySet *info =
#include "contract.h"
void test_resolve()
{
char *path;
int pathLen;
printf ("Resolve Filename\n");
KeySet *modules = ksNew(0);
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");
resolverClose(&h->system);
resolverClose(&h->user);
Key *forKey = keyNew("system", KEY_END);
succeed_if (resolveFilename(forKey, &h->system, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->system.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->system.filename, KDB_DB_SYSTEM "/elektra.ecf"), "resulting filename not correct");
resolverClose(&h->system);
keySetName(forKey, "user");
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
pathLen = tempHomeLen + 1 + strlen (KDB_DB_USER) + 12 + 1;
path = malloc (pathLen);
succeed_if (path != 0, "malloc failed");
snprintf (path, pathLen, "%s/%s/elektra.ecf", tempHome, KDB_DB_USER);
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, path), "filename not set correctly");
resolverClose(&h->user);
#ifdef HAVE_SETENV
unsetenv("USER");
unsetenv("HOME");
keySetName(forKey, "system");
succeed_if (resolveFilename(forKey, &h->system, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->system.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->system.filename, KDB_DB_SYSTEM "/elektra.ecf"), "resulting filename not correct");
resolverClose(&h->system);
keySetName(forKey, "user");
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, KDB_DB_HOME "/" KDB_DB_USER "/elektra.ecf"), "filename not set correctly");
resolverClose(&h->user);
setenv("USER","other",1);
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, KDB_DB_HOME "/other/" KDB_DB_USER "/elektra.ecf"), "filename not set correctly");
resolverClose(&h->user);
setenv("HOME","/nfshome//max//",1);
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, "/nfshome/max/" KDB_DB_USER "/elektra.ecf"), "filename not set correctly");
resolverClose(&h->user);
unsetenv("HOME");
unsetenv("USER");
#endif
keySetName(forKey, "user");
succeed_if (resolveFilename(forKey, &h->user, forKey) != -1,
"could not resolve filename");
succeed_if (!strcmp(h->user.path, "elektra.ecf"), "path not set correctly");
succeed_if (!strcmp(h->user.filename, KDB_DB_HOME "/" KDB_DB_USER "/elektra.ecf"), "filename not set correctly");
resolverClose(&h->user);
keyDel (forKey);
elektraPluginClose(plugin, 0);
elektraModulesClose(modules, 0);
ksDel (modules);
free (path);
}
}
ksDel (oldKeys);
ksDel (addedKeys);
ksDel (changedKeys);
ksDel (removedKeys);
// for next invocation of elektraLogchangeSet, remember our current keyset
elektraPluginSetData (handle, ksDup (returned));
return 1; /* success */
}
int elektraDbusClose (Plugin * handle, Key * parentKey ELEKTRA_UNUSED)
{
KeySet * ks = (KeySet *)elektraPluginGetData (handle);
if (ks) ksDel (ks);
return 1; /* success */
}
Plugin * ELEKTRA_PLUGIN_EXPORT (dbus)
{
// clang-format off
return elektraPluginExport("dbus",
ELEKTRA_PLUGIN_GET, &elektraDbusGet,
ELEKTRA_PLUGIN_SET, &elektraDbusSet,
ELEKTRA_PLUGIN_CLOSE, &elektraDbusClose,
ELEKTRA_PLUGIN_END);
}
if (pluginData->ioBinding)
{
elektraZeroMqRecvSetup (pluginData);
}
else
{
ELEKTRA_LOG_DEBUG ("no I/O binding present. plugin in noop mode");
}
}
/**
* @see ElektraNotificationCloseNotification (kdbnotificationinternal.h)
*/
void elektraZeroMqRecvCloseNotification (Plugin * handle, KeySet * parameters ELEKTRA_UNUSED)
{
ElektraZeroMqRecvPluginData * pluginData = elektraPluginGetData (handle);
pluginData->notificationCallback = NULL;
pluginData->notificationContext = NULL;
elektraZeroMqRecvTeardown (pluginData);
}
int elektraZeroMqRecvOpen (Plugin * handle, Key * errorKey ELEKTRA_UNUSED)
{
Key * endpointKey = ksLookupByName (elektraPluginGetConfig (handle), "/endpoint", 0);
const char * endpoint;
if (endpointKey)
{
endpoint = keyString (endpointKey);
}
else
hd->buf[out] = val[in];
// advance out cursor
out++;
}
}
hd->buf[out] = 0; // null termination for keyString()
keySetRaw (cur, hd->buf, out + 1);
}
int elektraHexcodeSet (Plugin * handle, KeySet * returned, Key * parentKey ELEKTRA_UNUSED)
{
/* set all keys */
CHexData * hd = elektraPluginGetData (handle);
if (!hd->buf)
{
hd->buf = elektraMalloc (1000);
hd->bufalloc = 1000;
}
Key * cur;
ksRewind (returned);
while ((cur = ksNext (returned)) != 0)
{
size_t valsize = keyGetValueSize (cur);
if (valsize * 3 > hd->bufalloc)
{
hd->bufalloc = valsize * 3;
hd->buf = realloc (hd->buf, hd->bufalloc);
RESOLVE_FAILED:
elektraInvokeClose (handle, 0);
return rc;
}
int elektraCurlgetCheckFile (const char * filename)
{
if (filename[0] == '/') return 0;
return 1;
}
int elektraCurlgetClose (Plugin * handle ELEKTRA_UNUSED, Key * errorKey ELEKTRA_UNUSED)
{
Data * data = elektraPluginGetData (handle);
if (!data) return 0;
if (data->tmpFile)
{
unlink (data->tmpFile);
data->tmpFile = NULL;
}
if (!data->useLocalCopy && data->path)
{
unlink (data->path);
elektraFree (data->path);
data->path = NULL;
}
else if (data->path)
{
elektraFree (data->path);
inline static Delegated * get (ckdb::Plugin * handle)
{
return static_cast<Delegated *> (elektraPluginGetData (handle));
}
rc = 1;
ksAppendKey (placements->errKS[errPlacement], keyDup (cur));
}
++errPlacement;
}
}
keyDel (lookup);
}
ksDel (cutKS);
return rc;
}
int elektraListOpen (Plugin * handle, Key * errorKey ELEKTRA_UNUSED)
{
Placements * placements = (Placements *)elektraPluginGetData (handle);
if (!placements)
{
placements = (Placements *)elektraMalloc (sizeof (Placements));
memset (placements, 0, sizeof (Placements));
placements->errCurrent = preRollback;
placements->setCurrent = preSetStorage;
placements->getCurrent = preGetStorage;
placements->getKS[0] = ksNew (0, KS_END);
placements->getKS[1] = ksNew (0, KS_END);
placements->getKS[2] = ksNew (0, KS_END);
placements->setKS[0] = ksNew (0, KS_END);
placements->setKS[1] = ksNew (0, KS_END);
placements->setKS[2] = ksNew (0, KS_END);
placements->setKS[3] = ksNew (0, KS_END);
placements->errKS[0] = ksNew (0, KS_END);