// typical usage of Elektra
int main()
{
Key * error_key = keyNew(KEY_END);
KDB * kdb_handle = kdbOpen(error_key);
Key * top = keyNew(KEY_END);
keySetName(top, "user/sw/MyApp");
KeySet * ks = ksNew(0);
kdbGet(kdb_handle, ks, top);
Key * key = keyNew(KEY_END);
keySetName(key, "user/sw/MyApp/Tests/TestKey1"); // == 31
keySetString(key, "NULLTestValue"); // == 14
keySetMeta(key, "comment", "NULLTestComment"); // == 16
ksAppendKey(ks, key); // == 1
keyNeedSync(key);
kdbSet(kdb_handle, ks, top); // == -1
print_warnings(top);
keyDel(top);
ksDel(ks);
kdbClose(kdb_handle, error_key);
keyDel(error_key);
check_key();
return 0;
}
/**
* Splits up the keysets and search for a sync bit in every key.
*
* It does not check if there were removed keys,
* see elektraSplitSync() for the next step.
*
* It does not create new backends, this has to be
* done by buildup before.
*
* @pre elektraSplitBuildup() need to be executed before.
*
* @param split the split object to work with
* @param handle to get information where the individual keys belong
* @param ks the keyset to divide
*
* @retval 0 if there were no sync bits
* @retval 1 if there were sync bits
* @retval -1 if no backend was found for any key
* @ingroup split
*/
int elektraSplitDivide (Split * split, KDB * handle, KeySet * ks)
{
ssize_t curFound = 0; /* If key could be appended to any of the existing split keysets */
int needsSync = 0;
Key * curKey = 0;
Backend * curHandle = 0;
ksRewind (ks);
while ((curKey = ksNext (ks)) != 0)
{
// TODO: handle keys in wrong namespaces
curHandle = elektraMountGetBackend (handle, curKey);
if (!curHandle) return -1;
curFound = elektraSplitSearchBackend (split, curHandle, curKey);
if (curFound == -1) continue; // key not relevant in this kdbSet
ksAppendKey (split->keysets[curFound], curKey);
if (keyNeedSync (curKey) == 1)
{
split->syncbits[curFound] |= 1;
needsSync = 1;
}
}
return needsSync;
}
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 */
}
/**
* 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;
}
