key.c

/***************************************************************************
                          key.c  -  Methods for Key manipulation
                             -------------------
    begin                : Mon Dec 29 2003
    copyright            : (C) 2003 by Avi Alkalay
    email                : avi@unix.sh
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the BSD License (revised).                      *
 *                                                                         *
 ***************************************************************************/

/* Subversion stuff

$Id: key.c 610 2006-02-16 03:05:24Z aviram $

*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <stdarg.h>
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <errno.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef WIN32
#include <io.h>
#endif
#include <sys/types.h>
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#ifdef HAVE_GRP_H
#include <grp.h>
#endif

#ifdef HAVE_LANGINFO_H
#include <langinfo.h>
#endif

#include "kdb.h"
#include "kdbprivate.h"

size_t strblen(const char *s) {
    char *found=strchr(s,0);
    if (found) return found-s+1;
    return 0;
}



Key *keyNew(const char *keyName, ...) {
    va_list va;
    Key *key;
    uint32_t action=0;
    uint8_t keyType=KEY_TYPE_UNDEFINED;
    uint8_t keyTypeBinary=0; /* a boolean shortcut */
    size_t valueSize=0;
    
    key=(Key *)malloc(sizeof(Key));
    if (!key) return 0;
    keyInit(key);
    
    if (keyName) {
        size_t nameSize;
        
        nameSize=keySetName(key,keyName);
        if (! nameSize) {
            free(key);
            return 0;
        }
        
        va_start(va,keyName);
        
        action=va_arg(va,uint32_t);
        while (action) {
            switch (action) {
                case KEY_SWITCH_TYPE:
                    /* We are waiting for 1 or 2 parameters
                     * following this action */
                    
                    /* First is the type */
                    keyType=(uint8_t)va_arg(va,unsigned int);
                    
                    keyTypeBinary=(KEY_TYPE_BINARY <= keyType &&
                        keyType < KEY_TYPE_STRING);
                    
                    keySetType(key,keyType);
                    
                    break;
                case KEY_SWITCH_VALUE:
                    if (keyType == KEY_TYPE_UNDEFINED)
                        keyType=KEY_TYPE_STRING;

                    if (!keyTypeBinary) {
                        /* most popular cases */
                        keySetString(key,va_arg(va,char *));
                        /* reset the type due to the
                         * above keySetString override */
                        keySetType(key,keyType);
                    } else {
                        /* Binary val: we need first the size of the value */
                        valueSize=va_arg(va,size_t);
                        keySetRaw(key,va_arg(va,void *),valueSize);
                    }

                    break;
                case KEY_SWITCH_UID:
                    keySetUID(key,va_arg(va,uid_t));
                    break;
                case KEY_SWITCH_GID:
                    keySetGID(key,va_arg(va,gid_t));
                    break;
                case KEY_SWITCH_MODE:
                    keySetAccess(key,va_arg(va,mode_t));
                    break;
                case KEY_SWITCH_DOMAIN:
                    keySetOwner(key,va_arg(va,char *));
                    break;
                case KEY_SWITCH_COMMENT:
                    keySetComment(key,va_arg(va,char *));
                    break;
                case KEY_SWITCH_NEEDSYNC: {
                    int rc=0;
                    rc=kdbGetKey(key);
                    if (rc)
                        /* Flag the key to indicate an error in
                         * kdbGetKey(). Propagated errno will indicate
                         * the error ocurred. */
                        key->flags|=KEY_SWITCH_FLAG; /* same as keySetFlag(key) */
                } break;
            }
            action=va_arg(va,uint32_t);
        }
        va_end(va);
    }
    return key;
}
 
 
 
 
int keyDel(Key *key) {
    int rc;
    
    rc=keyClose(key);
    free(key);
    
    return rc;
 }

 



int keyIsInitialized(const Key *key) {
    /* if (!key) return 0; */ /* removing to activate stupid mode */
    return ((key->flags & KEY_SWITCH_INITMASK)==KEY_SWITCH_INITIALIZED);
}


/******************************************* 
 *    General name manipulation methods    *
 *******************************************/


ssize_t keySetName(Key *key, const char *newName) {
    size_t length;
    size_t rootLength, userLength, systemLength, userDomainLength;
    size_t keyNameSize=1; /* equal to length plus a space for \0 */
    char *p;

/*
    if (!key) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    }
    if (!keyIsInitialized(key)) keyInit(key); */ /* commented for stupidity */

    /* handle null new key name, removing the old key */
    if (!newName || !(length=strblen(newName)-1)) {
        if (key->key) {
            free(key->key);
            key->key=0;
        }
        key->flags &= ~(KEY_SWITCH_NAME | KEY_SWITCH_NEEDSYNC |
                        KEY_SWITCH_ISSYSTEM | KEY_SWITCH_ISUSER);
        return 0;
    }

    /* Remove trailing  '/' if caller passed some */
    while (length && newName[length]==RG_KEY_DELIM) {
        length--;
    }

    rootLength=keyNameGetRootNameSize(newName);
    if (!rootLength) {
        errno=KDB_RET_INVALIDKEY;
        return -1;
    }
    userLength=sizeof("user")-1;
    systemLength=sizeof("system")-1;
    userDomainLength=rootLength-userLength-1;
    if (userDomainLength<0) userDomainLength=0;

    if (!strncmp("user",newName,userLength<length?userLength:length)) {
        /* handle "user*" */
        if (length > userLength) {
            /* handle "user?*" */
            if (*(newName+userLength)==':') {
                /* handle "user:*" */
                if (userDomainLength > 0) {
                                        p=realloc(key->userDomain,userDomainLength+1);
                                        if (NULL==p) goto error_mem;
                    key->userDomain=p;
                    strncpy(key->userDomain,newName+userLength+1,userDomainLength);
                    key->userDomain[userDomainLength]=0;
                }
                keyNameSize+=length-userDomainLength-1;  /* -1 is for the ':' */
            } else if (*(newName+userLength)!=RG_KEY_DELIM) {
                /* handle when != "user/ *" */
                errno=KDB_RET_INVALIDKEY;
                return -1;
            } else {
                /* handle regular "user/ *" */
                keyNameSize+=length;
            }
        } else {
            /* handle "user" */
            keyNameSize+=userLength;
        }

        p=realloc(key->key,keyNameSize);
        if (NULL==p) goto error_mem;
        key->key=p;

        /* here key->key must have a correct size allocated buffer */
        if (!key->key) return -1;

        strcpy(key->key,"user");
        strncpy(key->key+userLength,newName+rootLength,length-rootLength);
        key->key[keyNameSize-1]=0;

        if (!key->userDomain) {
            size_t bsize=strblen(getenv("USER"));

            if (!bsize) {}
            else {
                key->userDomain=malloc(bsize);
                strncpy(key->userDomain,getenv("USER"),bsize);
            }
        }
        key->flags |= KEY_SWITCH_ISUSER;
        key->flags &= ~KEY_SWITCH_ISSYSTEM;
    } else if (!strncmp("system",newName,systemLength<length?systemLength:length)) {
        /* handle "system*" */
        if (length > systemLength && *(newName+systemLength)!=RG_KEY_DELIM) {
            /* handle when != "system/ *" */
            errno=KDB_RET_INVALIDKEY;
            return -1;
        }
        keyNameSize+=length;
        p=realloc(key->key,keyNameSize);
        if (NULL==p) goto error_mem;
        key->key=p;


        /* here key->key must have a correct size allocated buffer */
        if (!key->key) return -1;

        strncpy(key->key,newName,length);
        key->key[keyNameSize-1]=0;
        
        key->flags |= KEY_SWITCH_ISSYSTEM;
        key->flags &= ~KEY_SWITCH_ISUSER;
    } else {
        /* Passed name is neither "system" or "user" */
        errno=KDB_RET_INVALIDKEY;
        return -1;
    }

    key->flags |= KEY_SWITCH_NAME | KEY_SWITCH_NEEDSYNC;

    return keyNameSize;

    error_mem:
        errno=KDB_RET_NOMEM;
        return -1;
}



ssize_t keyAddBaseName(Key *key,const char *baseName) {
    size_t nameSize=0;
    size_t newSize=0;
    int ndelim=0;
    char *p;

    if (key->key) nameSize=strblen(key->key)-1;
    if (baseName) newSize=strblen(baseName);
    else return nameSize;
    
    if (newSize==0) return nameSize;
    
    if (key->key) {
        /* Remove trailing '/' if caller passed some */
        while (nameSize-2 && key->key[nameSize-1]==RG_KEY_DELIM &&
               key->key[nameSize-2]!=RG_KEY_DELIM) {
            key->key[--nameSize]=0;
        }
        
        if (key->key[nameSize-1] != RG_KEY_DELIM) nameSize++;
        
        /* Remove all '/' in the begining of baseName */
        while (baseName[ndelim] && baseName[ndelim] == RG_KEY_DELIM) {
            newSize--;
            ndelim++;
        }
        
        /* Now we know the final key size */
        newSize+=nameSize;
        p=realloc(key->key,newSize);
        if (NULL == p) {
            errno=KDB_RET_NOMEM;
            return -1;
        }
        key->key=p;

        if (key->key[nameSize-1] != RG_KEY_DELIM && baseName[ndelim])
            strcat(key->key,"/");
        
        strcat(key->key,baseName+ndelim);
        
    } else return keySetName(key,baseName);
    
    return newSize;
}




ssize_t keySetBaseName(Key *key, const char *baseName) {
    size_t newSize=strblen(baseName);
    char *end;
    char *p;
    
    end=strrchr(key->key,'/');
    
    if (end) {
        newSize+=end-key->key;
        end[1]=0;
        p=realloc(key->key,newSize);
        if (NULL == p) {
            errno=KDB_RET_NOMEM;
            return -1;
        }
        key->key=p;
        strcat(key->key,baseName);
        return newSize;
    } else return keySetName(key,baseName);
}




ssize_t keyGetNameSize(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (key->key) return strblen(key->key);
    else return 0;
}




ssize_t keyGetName(const Key *key, char *returnedName, size_t maxSize) {
    size_t bytes;

    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->key) {
        errno=KDB_RET_NOKEY;
        returnedName[0]=0;
        return 0;
    }

    bytes=strblen(strncpy(returnedName,key->key,maxSize));
    if (maxSize < strblen(key->key)) {
        errno=KDB_RET_TRUNC;
        return -1;
    }
    return bytes;
}



char *keyStealName(const Key *key) {
    return key->key;
}






ssize_t keyGetFullNameSize(const Key *key) {
    size_t returnedSize;

    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */

    if (!key->key) return 0;

    returnedSize=strblen(key->key);

    if (!strncmp("user",key->key,sizeof("user")-1) && key->userDomain)
        returnedSize+=strblen(key->userDomain);

    return returnedSize;
}




ssize_t keyGetFullName(const Key *key, char *returnedName, size_t maxSize) {
    size_t userSize=sizeof("user")-1;
    size_t userDomainSize;
    ssize_t length;
    char *cursor;

    length=keyGetFullNameSize(key);
    if (length == 0) {
        errno=KDB_RET_NOKEY;
        returnedName[0]=0;
        return length;
    }
    if (length < 0) return length;
    if (length > maxSize) {
        errno=KDB_RET_TRUNC;
        return -1;
    }

    cursor=returnedName;
    if (!strncmp("user",key->key,userSize)) {
        strncpy(cursor,key->key,userSize);
        cursor+=userSize;
        if (key->userDomain) {
            *cursor=':'; ++cursor;
            userDomainSize=strblen(key->userDomain)-1;
            strcpy(cursor,key->userDomain);
            cursor+=userDomainSize;
        }
        strcpy(cursor,key->key+userSize);
    } else strcpy(cursor,key->key);

    return length;
}





int keyNameGetNamespace(const char *keyName) {
    if (keyNameIsSystem(keyName)) return KEY_NS_SYSTEM;
    if (keyNameIsUser(keyName)) return KEY_NS_USER;
    return 0;
}



int keyGetNamespace(const Key *key) {
    /* if (!key) return 0;
    if (!keyIsInitialized(key)) return 0; */

    if (key->flags & KEY_SWITCH_ISSYSTEM) return KEY_NS_SYSTEM;
    if (key->flags & KEY_SWITCH_ISUSER) return KEY_NS_USER;
    return 0;
}



int keyNameIsSystem(const char *keyName) {
    /* if (!keyName) return 0;
    if (!strlen(keyName)) return 0; */

    if (!strncmp("system",keyName,sizeof("system")-1)) return 1;
    return 0;
}



int keyIsSystem(const Key *key) {
    /* if (!key) return 0;
    if (!keyIsInitialized(key)) return 0; */

    return (key->flags & KEY_SWITCH_ISSYSTEM)?1:0;
}



int keyNameIsUser(const char *keyName) {
    /* if (!keyName) return 0;
    if (!strlen(keyName)) return 0; */

    if (!strncmp("user",keyName,sizeof("user")-1)) return 1;
    return 0;
}



int keyIsUser(const Key *key) {
    /* if (!key) return 0;
    if (!keyIsInitialized(key)) return 0; */

    return (key->flags & KEY_SWITCH_ISUSER)?1:0;
}



ssize_t keyNameGetRootNameSize(const char *keyName) {
    char *end;
    int length=strlen(keyName);

    if (!length) return 0;

    /*
        Possible situations:
        user:someuser
        user:someuser/
        user:someuser/key/name
        user:some.user/key/name
        .
        \.
        (empty)
    */
    end=strchr(keyName,RG_KEY_DELIM);
    if (!end) /* Reached end of string. Root is entire key. */
        end = (char *)keyName + length;

    return end-keyName;
}



ssize_t keyGetRootNameSize(const Key *key) {
    /* if (!key) return 0;
    if (!keyIsInitialized(key)) return 0; */
    if (!key->key) return 0;

    return keyNameGetRootNameSize(key->key);
}



ssize_t keyGetRootName(const Key *key, char *returned, size_t maxSize) {
    size_t size;

    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */

    if (!key->key) {
        errno=KDB_RET_NOKEY;
        return -1;
    }

    if (!(size=keyGetRootNameSize(key))) {
        errno=KDB_RET_NOKEY;
        return -1;
    }

    if (maxSize < size) {
        errno=KDB_RET_TRUNC;
        return -1;
    } else strncpy(returned,key->key,size);
    return size;
}



ssize_t keyGetFullRootNameSize(const Key *key) {
    size_t size=0;

    if (keyIsUser(key)) {
        if (key->userDomain) size=strblen(key->userDomain);
        else size=strblen(getenv("USER"));
    }

    return size+keyNameGetRootNameSize(key->key);
}


ssize_t keyGetFullRootName(const Key *key, char *returned, size_t maxSize) {
    size_t size;
    size_t userSize;
    char *cursor;

    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->key) {
        errno=KDB_RET_NOKEY;
        return 0;
    }

    if (!(size=keyGetFullRootNameSize(key))) {
        errno=KDB_RET_NOKEY;
        return 0;
    }

    if (maxSize < size) {
        errno=KDB_RET_TRUNC;
        return -1;
    }
    
    userSize = keyGetRootNameSize(key);
    strncpy(returned,key->key, userSize); /* copy "user" or "system" */
    if (keyIsUser(key)) {
        cursor = returned + userSize;
        *cursor = ':'; cursor++;
        if (key->userDomain)
            strncpy (cursor, key->userDomain, size - userSize);
        else
            strncpy (cursor, getenv("USER"),  size - userSize);
    }

    return size;
}






ssize_t keyGetParentNameSize(const Key *key) {
    char *parentNameEnd;

    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->key) {
        errno=KDB_RET_NOKEY;
        return 0;
    }

    /*
        user   (size=0)
        user/parent/base
        user/parent/base/ (size=sizeof("user/parent"))
    */

    parentNameEnd=strrchr(key->key,RG_KEY_DELIM);

    if (!parentNameEnd || parentNameEnd==key->key) {
        /* handle NULL or /something */
        return 0;
    }

    /* handle system/parent/base/ */
    if ((parentNameEnd-key->key) == (strblen(key->key)-2)) {
        parentNameEnd--;
        while (*parentNameEnd!=RG_KEY_DELIM) parentNameEnd--;
    }

    return parentNameEnd - key->key;
}



ssize_t keyGetParentName(const Key *key, char *returnedParent, size_t maxSize) {
    ssize_t parentSize;

    parentSize=keyGetParentNameSize(key);

    if (parentSize+1 > maxSize) {
        errno=KDB_RET_TRUNC;
        return 0;
    } else strncpy(returnedParent,key->key,parentSize);

    returnedParent[parentSize]=0; /* ending NULL */
    
    return parentSize;
}






ssize_t keyNameGetBaseNameSize(const char *keyName) {
    char *end;

    end=strrchr(keyName,RG_KEY_DELIM);
    if (end) return keyName+strblen(keyName)-1-end;
    else return 0;
}



ssize_t keyGetBaseNameSize(const Key *key) {
    /* if (!key) return 0;
    if (!keyIsInitialized(key)) return 0; */
    if (!key->key) return 0;

    return keyNameGetBaseNameSize(key->key);
}



ssize_t keyGetBaseName(const Key *key, char *returned, size_t maxSize) {
    ssize_t size;
    size_t keySize;

    /* if (!key) {
        errno=KDB_RET_NULLKEY;
        return 0;
    }

    if (!keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!(size=keyGetBaseNameSize(key))) {
        errno=KDB_RET_NOKEY;
        return 0;
    }

    keySize=strblen(key->key);

    if (maxSize < size) {
        strncpy(returned,key->key+keySize-size,maxSize);
        errno=KDB_RET_TRUNC;
        return size;
    } else strncpy(returned,key->key+keySize-size,size);

    return size;
}


char *keyStealBaseName(const Key *key) {
    char *end=strrchr(key->key,RG_KEY_DELIM);
    
    if (++end) return end;
    else return 0;
}


/******************************************* 
 *    General value manipulation methods   *
 *******************************************/




ssize_t keyGetDataSize(const Key *key) {
    return keyGetValueSize(key);
}



ssize_t keyGetValueSize(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */

    return key->dataSize;
}



ssize_t keySetString(Key *key, const char *newStringValue) {
    ssize_t ret=newStringValue?strblen(newStringValue):0;

    if (!newStringValue || !ret) ret=keySetRaw(key,0,0);
    else ret=keySetRaw(key,newStringValue,ret);

    keySetType(key,KEY_TYPE_STRING);

    return ret;
}



ssize_t keyGetString(const Key *key, char *returnedString, size_t maxSize) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->data) {
        *returnedString=0;
        errno=KDB_RET_NODATA;
        return 0;
    }

    if (key->dataSize > maxSize) {
        errno=KDB_RET_TRUNC;
        return -1;
    }

    if (key->type < KEY_TYPE_STRING) {
        errno=KDB_RET_TYPEMISMATCH;
        return -1;
    }

    strcpy(returnedString,key->data);
    return key->dataSize;
}






void *keyStealValue(const Key *key) {
    return key->data;
}








ssize_t keySetLink(Key *key, const char *target) {
    ssize_t ret=target?strblen(target):0;

    if (!target || !ret) ret=keySetRaw(key,0,0);
    else ret=keySetRaw(key,target,ret);

    keySetType(key,KEY_TYPE_LINK);

    return ret;
}



ssize_t keyGetLink(const Key *key, char *returnedTarget, size_t maxSize) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->data) {
        errno=KDB_RET_NODATA;
        return 0;
    }

    if (key->type != KEY_TYPE_LINK) {
        errno=KDB_RET_TYPEMISMATCH;
        return -1;
    }

    if (key->dataSize > maxSize) {
        errno=KDB_RET_TRUNC;
        return -1;
    }

    strcpy(returnedTarget,key->data);
    return key->dataSize;
}



int keyIsLink(const Key *key) {
  /* Shouldn't we completely get rid of the following two lines? -Jens */
    /* if (!key) return 0;
    if (!keyIsInitialized(key)) return 0; */

    return (key->type==KEY_TYPE_LINK);
}



int keyIsDir(const Key *key) {
    /* if (!key) return 0;
    if (!keyIsInitialized(key)) return 0; */

  return key->type==KEY_TYPE_DIR;
}



int keyIsBin(const Key *key) {
    /* if (!key) return 0;
    if (!keyIsInitialized(key)) return 0; */

    return (KEY_TYPE_BINARY <= key->type && key->type < KEY_TYPE_STRING);
}


int keyIsString(const Key *key) {
    /* if (!key) return 0;
    if (!keyIsInitialized(key)) return 0; */

    return (key->type >= KEY_TYPE_STRING);
}




ssize_t keyGetBinary(const Key *key, void *returnedValue, size_t maxSize) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->data) {
        errno=KDB_RET_NODATA;
        return 0;
    }

    if (key->dataSize > maxSize) {
        errno=KDB_RET_TRUNC;
        return -1;
    }

    memcpy(returnedValue,key->data,key->dataSize);
    return key->dataSize;
}



ssize_t keySetBinary(Key *key, const void *newBinary, size_t dataSize) {
    ssize_t ret=keySetRaw(key,newBinary,dataSize);

    keySetType(key,KEY_TYPE_BINARY);

    return ret;
}



int keyNeedsSync(const Key *key) {
    /* if (!key) return 0; */
    return (key->flags & KEY_SWITCH_NEEDSYNC);
}



uint8_t keyGetType(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return KEY_TYPE_UNDEFINED;
    } */

    return key->type;
}



uint8_t keySetType(Key *key,uint8_t newType) {
    mode_t dirSwitch=0111;

    /* if (!key) {
        errno=KDB_RET_UNINITIALIZED;
        return KEY_TYPE_UNDEFINED;
    }
    if (!keyIsInitialized(key)) keyInit(key); */

    switch (newType) {
        case KEY_TYPE_DIR:
            key->type=KEY_TYPE_DIR;
            dirSwitch=umask(0); umask(dirSwitch);
            dirSwitch=0111 & ~dirSwitch;
            key->access|=dirSwitch | 0040000; /*S_IFDIR (is directory)*/
            keySetRaw(key,0,0); /* remove data */
            break;
        default:
            key->type=newType;
            key->access &= ~(0040000 | dirSwitch);
            /*remove bits directory and dirSwitch*/
            key->flags |= KEY_SWITCH_NEEDSYNC;
    }
    return key->type;
}



ssize_t keySetRaw(Key *key, const void *newBinary, size_t dataSize) {
    /* if (!key) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    }
    if (!keyIsInitialized(key)) keyInit(key); */

    if (!dataSize || !newBinary) {
        if (key->data) {
            free(key->data);
            key->data=0;
        }
        key->flags &= ~(KEY_SWITCH_VALUE);
        key->flags |= KEY_SWITCH_NEEDSYNC;
        return 0;
    }

    key->dataSize=dataSize;
    if (key->data) {
        char *p;
        p=realloc(key->data,key->dataSize);
        if (NULL==p) return -1;
        key->data=p;
    } else {
        key->data=malloc(key->dataSize);
        }

    if (!key->data) return -1;

    memcpy(key->data,newBinary,key->dataSize);
    key->flags |= KEY_SWITCH_VALUE | KEY_SWITCH_NEEDSYNC;
    return key->dataSize;
}








/***************************************************** 
 *    General owner or domain manipulation methods   *
 *****************************************************/



ssize_t keySetOwner(Key *key, const char *userDomain) {
    ssize_t size;

    /* if (!key) {
        errno=KDB_RET_UNINITIALIZED; // KDB_RET_NULLKEY
        return -1;
    }
    if (!keyIsInitialized(key)) keyInit(key); */
    
    if (userDomain == 0) {
        if (key->userDomain) {
            free(key->userDomain);
            key->userDomain=0;
        }
        return 0;
    }

    if ((size=strblen(userDomain)) > 0) {
        if (key->userDomain) {
            char *p;
            p=realloc(key->userDomain,size);
            if (NULL==p) {
                errno=KDB_RET_NOMEM;
                return -1;
            }
            key->userDomain=p;
        } else {
            key->userDomain=malloc(size);
        }
        if (!key->userDomain) return -1; /* propagate errno */

        strcpy(key->userDomain,userDomain);
        key->flags |= KEY_SWITCH_DOMAIN | KEY_SWITCH_NEEDSYNC;
        return size;
    } else if (key->userDomain) {
        free(key->userDomain);
        key->userDomain=0;
        key->flags &= ~(KEY_SWITCH_DOMAIN | KEY_SWITCH_NEEDSYNC);
    }
    return 0;
}



ssize_t keyGetOwnerSize(const Key *key) {
    
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->userDomain) {
        errno=KDB_RET_NODOMAIN;
        return 0;
    }

    return strblen(key->userDomain);
}



ssize_t keyGetOwner(const Key *key, char *returned, size_t maxSize) {
    ssize_t bytes;

    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->userDomain) {
        errno=KDB_RET_NODOMAIN;
        return 0;
    }

    if (maxSize < (bytes=strblen(key->userDomain))) {
        errno=KDB_RET_TRUNC;
        return -1;
    } else strcpy(returned,key->userDomain);
    return bytes;
}




char *keyStealOwner(const Key *key) {
    return key->userDomain;
}






/********************************************* 
 *    General comment manipulation methods   *
 *********************************************/



ssize_t keySetComment(Key *key, const char *newComment) {
    ssize_t size;

    /* if (!key) {
        errno=KDB_RET_UNINITIALIZED; // KDB_RET_NULLKEY 
        return 0;
    } 
    if (!keyIsInitialized(key)) keyInit(key); */

    if (newComment && (size=strblen(newComment)) > 0) {
        if (key->flags & KEY_SWITCH_COMMENT) {
            char *p;
            p=realloc(key->comment,size);
            if (NULL==p) {
                errno=KDB_RET_NOMEM;
                return -1;
            }
            key->comment=p;
        } else {
            key->comment=malloc(size);
        }
        if (!key->comment) return -1;

        strcpy(key->comment,newComment);
        key->flags |= KEY_SWITCH_COMMENT | KEY_SWITCH_NEEDSYNC;
        return key->commentSize=size;
    } else if (key->flags & KEY_SWITCH_COMMENT) {
        free(key->comment);
        key->comment=0;
        key->flags &= ~(KEY_SWITCH_COMMENT | KEY_SWITCH_NEEDSYNC);
    }
    return key->commentSize=0;
}



ssize_t keyGetCommentSize(const Key *key) {
    /*  if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->comment) {
        errno=KDB_RET_NODESC;
        return 0;
    }

    return strblen(key->comment);
}



ssize_t keyGetComment(const Key *key, char *returnedDesc, size_t maxSize) {
    ssize_t bytes;

    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    if (!key->comment) {
        errno=KDB_RET_NODESC;
        return 0;
    }

    bytes=strblen(strncpy(returnedDesc,key->comment,maxSize));
    if (maxSize < strblen(key->comment)) {
        errno=KDB_RET_TRUNC;
        return -1;
    }
    return bytes;
}


char *keyStealComment(const Key *key) {
    return key->comment;
}






ssize_t keyGetRecordSize(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */

    return key->recordSize;
}


Key *keyNext(Key *key) {
    return key->next;
}








int keyDup(const Key *source, Key *dest) {
    
    /* Copy the struct data, including the "next" pointer */
    *dest=*source;

    /* prepare to set dynamic properties */
    dest->key=
    dest->comment=
    dest->userDomain=
    dest->data=0;

    /* Set properties that need memory allocation */
    keySetName(dest,source->key);
    keySetComment(dest,source->comment);
    keySetOwner(dest,source->userDomain);
    keySetRaw(dest,source->data,source->dataSize);

    dest->flags=source->flags;

    return 0;
}



uid_t keyGetUID(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */

    /*if (!(key->flags & KEY_SWITCH_UID)) return KDB_RET_NOCRED;*/

    return key->uid;
}



int keySetUID(Key *key, uid_t uid) {
    /* if (!key) return errno=KDB_RET_UNINITIALIZED;
    if (!keyIsInitialized(key)) keyInit(key); */

    key->uid=uid;
    key->flags |= KEY_SWITCH_UID | KEY_SWITCH_NEEDSYNC;

    return 0;
}



gid_t keyGetGID(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */

    /*if (!(key->flags & KEY_SWITCH_GID)) return KDB_RET_NOCRED;*/

    return key->gid;
}



int keySetGID(Key *key, gid_t gid) {
    /* if (!key) return errno=KDB_RET_UNINITIALIZED;
    if (!keyIsInitialized(key)) keyInit(key); */

    key->gid=gid;
    key->flags |= KEY_SWITCH_GID | KEY_SWITCH_NEEDSYNC;

    return 0;
}



mode_t keyGetAccess(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */

    /*if (!(key->flags & KEY_SWITCH_MODE)) return KDB_RET_NOCRED;*/

    return key->access;
}



int keySetAccess(Key *key, mode_t mode) {
    /* if (!key) return errno=KDB_RET_UNINITIALIZED;
    if (!keyIsInitialized(key)) keyInit(key); */

    key->access=mode;
    key->flags |= KEY_SWITCH_MODE | KEY_SWITCH_NEEDSYNC;

    return 0;
}



time_t keyGetMTime(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */
    /*if (!(key->flags & KEY_SWITCH_TIME)) return KDB_RET_NOTIME;*/

    return key->mtime;
}



time_t keyGetATime(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */
    /*if (!(key->flags & KEY_SWITCH_TIME)) return KDB_RET_NOTIME;*/

    return key->atime;
}



time_t keyGetCTime(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */
    /*if (!(key->flags & KEY_SWITCH_TIME)) return KDB_RET_NOTIME;*/

    return key->ctime;
}



uint32_t keyCompare(const Key *key1, const Key *key2) {
    uint32_t ret=0;


    /* Compare these numeric properties */
    if (key1->uid != key2->uid)                    ret|=KEY_SWITCH_UID;
    if (key1->gid != key2->gid)                    ret|=KEY_SWITCH_GID;
    if (key1->type != key2->type)                  ret|=KEY_SWITCH_TYPE;
#if defined(S_IRWXU) && defined(S_IRWXG) && defined(S_IRWXO)
    if ((key1->access & (S_IRWXU|S_IRWXG|S_IRWXO)) !=
        (key2->access & (S_IRWXU|S_IRWXG|S_IRWXO))) ret|=KEY_SWITCH_MODE;
#else
    if ((key1->access) !=
        (key2->access)) ret|=KEY_SWITCH_MODE;
#endif

    /* Compare these string properties.
       A lot of decisions because strcmp can't handle NULL pointers */
    if (key1->key && key2->key) {
        if (strcmp(key1->key,key2->key))            ret|=KEY_SWITCH_NAME;
    } else {
        if (key1->key)                              ret|=KEY_SWITCH_NAME;
        else if (key2->key)                         ret|=KEY_SWITCH_NAME;
    }

    if (key1->comment && key2->comment) {
        if (strcmp(key1->comment,key2->comment))    ret|=KEY_SWITCH_COMMENT;
    } else {
        if (key1->comment)                          ret|=KEY_SWITCH_COMMENT;
        else if (key2->comment)                     ret|=KEY_SWITCH_COMMENT;
    }

    if (key1->userDomain && key2->userDomain) {
        if (strcmp(key1->userDomain,key2->userDomain)) ret|=KEY_SWITCH_DOMAIN;
    } else {
        if (key1->userDomain)                       ret|=KEY_SWITCH_DOMAIN;
        else if (key2->comment)                     ret|=KEY_SWITCH_DOMAIN;
    }

    /* compare and select some flags */
    ret|=(key1->flags ^ key2->flags) & (KEY_SWITCH_FLAG | KEY_SWITCH_NEEDSYNC);
    
    /* Compare data */
    if (key1->dataSize != key2->dataSize)          ret|=KEY_SWITCH_VALUE;
    else if (memcmp(key1->data,key2->data,
            (key1->dataSize<=key2->dataSize?key1->dataSize:key2->dataSize)))
                                                    ret|=KEY_SWITCH_VALUE;

    return ret;
}






ssize_t keyToStream(const Key *key, FILE* stream, unsigned long options) {
    return keyToStreamBasename(key,stream,0,0,options);
}





ssize_t keyToStreamBasename(const Key *key, FILE *stream, const char *parent,
        const size_t parentSize, unsigned long options) {
    ssize_t written=0;
    char buffer[800];
    struct passwd *pwd=0;
    struct group *grp=0;

    /* Write key name */
    if (parent) {
        /* some logic to see if we should print only the relative basename */
        int found;
        size_t skip=parentSize ? parentSize : strblen(parent)-1;

        found=memcmp(parent,key->key,skip);
        if (found == 0) {
            while (*(key->key+skip) == RG_KEY_DELIM) ++skip;

            if (*(key->key+skip) != 0) /* we don't want a null basename */
                written+=fprintf(stream,"<key basename=\"%s\"",
                    key->key+skip);
        }
    }

    if (written == 0) { /* no "<key basename=..." was written so far */
        if (options & KDB_O_FULLNAME) {
            keyGetFullName(key,buffer,sizeof(buffer));
            written+=fprintf(stream,"<key name=\"%s\"", buffer);
        } else written+=fprintf(stream,"<key name=\"%s\"", key->key);
    }


    if (options & KDB_O_CONDENSED) written+=fprintf(stream," ");
    else written+=fprintf(stream,"\n     ");



    /* Key type */
    if (options & KDB_O_NUMBERS) {
        written+=fprintf(stream,"type=\"%d\"", key->type);
    } else {
        buffer[0]=0;

        switch (key->type) {
            case KEY_TYPE_STRING:
                strcpy(buffer,"string");
                break;
            case KEY_TYPE_BINARY:
                strcpy(buffer,"binary");
                break;
            case KEY_TYPE_LINK:
                strcpy(buffer,"link");
                break;
            case KEY_TYPE_DIR:
                strcpy(buffer,"directory");
                break;
            case KEY_TYPE_UNDEFINED:
                strcpy(buffer,"undefined");
                break;
        }
        if (buffer[0]) written+=fprintf(stream,"type=\"%s\"", buffer);
        else written+=fprintf(stream,"type=\"%d\"", key->type);
    }

#ifdef HAVE_PWD_H
    if (keyIsUser(key)) {
        struct passwd *domainPwd=0;
        int uidMatch,gidMatch;
        
        domainPwd=getpwnam(key->userDomain);
        pwd=getpwuid(key->uid);
        grp=getgrgid(key->gid);
        
        uidMatch=(key->uid == domainPwd->pw_uid);
        gidMatch=(key->gid == domainPwd->pw_gid);
        
        if (options & KDB_O_FULLUGID) {
            if (pwd && !(options & KDB_O_NUMBERS))
                written+=fprintf(stream," uid=\"%s\"",pwd->pw_name);
            else written+=fprintf(stream,   " uid=\"%d\"",key->uid);
        
            if (grp && !(options & KDB_O_NUMBERS))
                written+=fprintf(stream," gid=\"%s\"",grp->gr_name);
            else written+=fprintf(stream," gid=\"%d\"",key->gid);
        } else {
            if (!uidMatch) {
                if (pwd && !(options & KDB_O_NUMBERS))
                    written+=fprintf(stream," uid=\"%s\"",pwd->pw_name);
                else written+=fprintf(stream,   " uid=\"%d\"",key->uid);
            }

            if (!gidMatch) {
                if (grp && !(options & KDB_O_NUMBERS))
                    written+=fprintf(stream," gid=\"%s\"",grp->gr_name);
                else written+=fprintf(stream,   " gid=\"%d\"",key->gid);
            }
        }
    } else {
        if (!(options & KDB_O_NUMBERS)) {
            pwd=getpwuid(key->uid);
            grp=getgrgid(key->gid);
        }

        /* UID, GID, mode */
        if (pwd) written+=fprintf(stream," uid=\"%s\"",pwd->pw_name);
        else  written+=fprintf(stream,   " uid=\"%d\"",key->uid);

        if (grp) written+=fprintf(stream," gid=\"%s\"",grp->gr_name);
        else  written+=fprintf(stream,   " gid=\"%d\"",key->gid);
    }
#endif
    written+=fprintf(stream," mode=\"0%o\"",
#if defined(S_IRWXU) && defined(S_IRWXG) && defined(S_IRWXO)
        key->access & (S_IRWXU|S_IRWXG|S_IRWXO));
#else
        key->access);
#endif


    if (!key->data && !key->comment) { /* no data AND no comment */
        written+=fprintf(stream,"/>");
        if (!(options & KDB_O_CONDENSED))
            written+=fprintf(stream,"\n\n\n\n\n\n");
        
        return written; /* end of <key/> */
    } else {
        if (key->data) {
            if ((key->dataSize <= 16) &&
                    key->type >= KEY_TYPE_STRING &&
                    !strchr(key->data,'\n')) {

                /* we'll use a "value" attribute instead of a <value> node,
                   for readability, so the cut size will be 16, which is
                   the maximum size of an IPv4 address */

                if (options & KDB_O_CONDENSED) written+=fprintf(stream," ");
                else written+=fprintf(stream,"\n     ");
                
                written+=fprintf(stream,"value=\"%s\"",key->data);
                
                if (key->comment) written+=fprintf(stream,">\n");
                else {
                    written+=fprintf(stream,"/>");
                    if (!(options & KDB_O_CONDENSED))
                        written+=fprintf(stream,"\n\n\n\n\n\n");
                
                    return written;
                }
            } else { /* value is bigger than 16 bytes: deserves own <value> */
                written+=fprintf(stream,">");
                if (!(options & KDB_O_CONDENSED)) written+=fprintf(stream,"\n\n     ");
                
                written+=fprintf(stream,"<value>");
                if (key->type >= KEY_TYPE_STRING || key->type < KEY_TYPE_BINARY) {
                    written+=fprintf(stream,"<![CDATA[");
                    fflush(stream);
                    /* must chop ending \0 */
                    written+=write(fileno(stream),key->data,key->dataSize-1);
                    written+=fprintf(stream,"]]>");
                } else {
                    /* Binary values */
                    char *encoded=malloc(3*key->dataSize);
                    size_t encodedSize;

                    written+=fprintf(stream,"\n");
                    encodedSize=encode(key->data,key->dataSize,encoded);
                    fflush(stream);
                    written+=write(fileno(stream),encoded,encodedSize);
                    free(encoded);
                    written+=fprintf(stream,"\n");
                }
                /* fflush(stream); */
                written+=fprintf(stream,"</value>");
            }
        } else { /* we have no data */
            if (key->comment) {
                written+=fprintf(stream,">");
                if (!(options & KDB_O_CONDENSED))
                    written+=fprintf(stream,"\n");
            } else {
                written+=fprintf(stream,"/>");
                if (!(options & KDB_O_CONDENSED))
                    written+=fprintf(stream,"\n\n\n\n\n\n");
            
                return written;
            }
        }
    }

    if (!(options & KDB_O_CONDENSED)) {
        written+=fprintf(stream,"\n");
        if (key->comment) written+=fprintf(stream,"     ");
    }

    if (key->comment) {
        written+=fprintf(stream,"<comment><![CDATA[%s]]></comment>", key->comment);
        if (!(options & KDB_O_CONDENSED))
            written+=fprintf(stream,"\n");
    }

    written+=fprintf(stream,"</key>");

    if (!(options & KDB_O_CONDENSED))
        written+=fprintf(stream,"\n\n\n\n\n\n");

    return written;
}


/*
size_t keyGetSerializedSizeWithoutName(Key *key) {
    return sizeof(KeyInfo)+
        key->dataSize+
        key->groupSize+
        key->commentSize;
}
*/

/*
size_t keyGetSerializedSize(Key *key) {
    size_t totalSize;

    totalSize=(key->key)+1+keyGetSerializedSizeWithoutName(key);
    if (key->userDomain) totalSize+=strlen(key->userDomain)+1;
    return totalSize;
}*/






int keySetFlag(Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */

    key->flags|=KEY_SWITCH_FLAG;

    return 0;
}



int keyClearFlag(Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return -1;
    } */

    key->flags &= ~KEY_SWITCH_FLAG;

    return 0;
}



int keyGetFlag(const Key *key) {
    /* if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    } */

    return (key->flags & KEY_SWITCH_FLAG) ? 1:0;
}





int keyInit(Key *key) {
    /* if (!key) return errno=KDB_RET_NULLKEY; */

    memset(key,0,sizeof(Key));
    key->type=KEY_TYPE_UNDEFINED;
    /* If we lack the getuid() and getgid() functions we leave uid and gid at 0 */
    #if defined(HAVE_GETUID) && defined(HAVE_GETGID)
    key->uid=getuid();
    key->gid=getgid();
    #endif
    key->access=umask(0); 
    umask(key->access);
    key->access=DEFFILEMODE & ~key->access;

    key->flags = KEY_SWITCH_INITIALIZED;

    return 0;
}




int keyClose(Key *key) {
    /* if (!key) return errno=KDB_RET_NULLKEY;
    if (!keyIsInitialized(key)) return 0; */

    if (key->key) free(key->key);
    if (key->data) free(key->data);
    if (key->comment) free(key->comment);
    if (key->userDomain) free(key->userDomain);
    memset(key,0,sizeof(Key));
    return 0;
}

---