void test_owner()
{
Key *key;
succeed_if (key = keyNew(0), "could not create new key");
succeed_if (keyValue(keyGetMeta(key, "owner")) == 0, "owner set for empty key");
succeed_if (!strcmp(keyOwner(key), ""), "owner set for empty key");
succeed_if (keyDel (key) == 0, "could not delete key");
succeed_if (key = keyNew("system/key", KEY_END), "could not create new key");
succeed_if (keyValue(keyGetMeta(key, "owner")) == 0, "owner set for empty key");
succeed_if (!strcmp(keyOwner(key), ""), "owner set for empty key");
succeed_if (keyDel (key) == 0, "could not delete key");
succeed_if (key = keyNew("user/key", KEY_END), "could not create new key");
succeed_if (keyValue(keyGetMeta(key, "owner")) == 0, "owner set for empty key");
succeed_if (!strcmp(keyOwner(key), ""), "owner set for empty key");
succeed_if (keyDel (key) == 0, "could not delete key");
succeed_if (key = keyNew("user/key", KEY_END), "could not create new key");
succeed_if (keySetOwner(key,"markus") == sizeof("markus"), "could not set owner markus");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "owner")), "markus"), "no owner set for key");
succeed_if (!strcmp(keyOwner(key), "markus"), "no owner set for key");
succeed_if (keyDel (key) == 0, "could not delete key");
succeed_if (key = keyNew("user:markus/key", KEY_END), "could not create new key");
succeed_if (keySetOwner(key,"markus") == sizeof("markus"), "could not set owner markus");
succeed_if (!strcmp(keyValue(keyGetMeta(key, "owner")), "markus"), "no owner set for key");
succeed_if (!strcmp(keyOwner(key), "markus"), "no owner set for key");
succeed_if (keyDel (key) == 0, "could not delete key");
setenv ("USER", "markus", 1);
succeed_if (key = keyNew("user/key", KEY_END), "could not create new key with env");
succeed_if (keyValue(keyGetMeta(key, "owner")) == 0, "owner set for empty key with env");
succeed_if (!strcmp(keyOwner(key), ""), "owner set for empty key with env");
succeed_if (keyDel (key) == 0, "could not delete key with env");
}
ssize_t elektraKeySetName(Key *key, const char *newName,
option_t options)
{
if (!key) return -1;
if (test_bit(key->flags, KEY_FLAG_RO_NAME)) return -1;
elektraRemoveKeyName(key);
if (!(options & KEY_META_NAME)) keySetOwner (key, NULL);
switch (keyGetNameNamespace(newName))
{
case KEY_NS_NONE: ELEKTRA_ASSERT(0);
case KEY_NS_EMPTY:
elektraFinalizeEmptyName(key);
return 0; // as documented
case KEY_NS_CASCADING: key->keyUSize=1;key->keySize=sizeof("/"); break;
case KEY_NS_SPEC: key->keyUSize=key->keySize=sizeof("spec"); break;
case KEY_NS_PROC: key->keyUSize=key->keySize=sizeof("proc"); break;
case KEY_NS_DIR: key->keyUSize=key->keySize=sizeof("dir"); break;
case KEY_NS_USER: elektraHandleUserName(key, newName); break;
case KEY_NS_SYSTEM: key->keyUSize=key->keySize=sizeof("system"); break;
case KEY_NS_META:
if (!(options & KEY_META_NAME)) return -1;
keyNameGetOneLevel(newName,&key->keySize);
key->keyUSize = ++ key->keySize; // for null
break;
} // Note that we abused keyUSize for cascading and user:owner
const size_t length = elektraStrLen(newName);
key->key=elektraMalloc(key->keySize*2);
memcpy(key->key, newName, key->keySize);
if (length == key->keyUSize || length == key->keySize)
{ // use || because full length is keyUSize in user, but keySize for /
// newName consisted of root only
elektraFinalizeName(key);
return key->keyUSize;
}
if (elektraOnlySlashes(newName+key->keyUSize-1))
{
elektraFinalizeName(key);
return key->keySize;
}
key->key[key->keySize-1] = '\0';
const ssize_t ret = keyAddName(key, newName+key->keyUSize);
if (ret == -1) elektraRemoveKeyName(key);
else return key->keySize;
return ret;
}
static void elektraHandleUserName (Key * key, const char * newName)
{
const size_t userLength = sizeof ("user");
key->keyUSize = key->keySize = userLength;
const char delim = newName[userLength - 1];
// no owner, we are finished
if (delim == '/' || delim == '\0') return;
ELEKTRA_ASSERT (delim == ':');
// handle owner (compatibility, to be removed)
keyNameGetOneLevel (newName, &key->keyUSize);
const size_t ownerLength = key->keyUSize - userLength;
++key->keyUSize;
char * owner = elektraMalloc (ownerLength + 1);
if (!owner) return; // out of memory, ok for owner
strncpy (owner, newName + userLength, ownerLength);
owner[ownerLength] = 0;
keySetOwner (key, owner);
elektraFree (owner);
}
