localkdb.c

/***************************************************************************
            localkdb.c  -  Methods for accessing the Key Database
                             -------------------
    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 GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/



/***************************************************************************
 *                                                                         *
 *   This is the implementation of a filesystem backend for the            *
 *   Elektra Project. Each Key is a file in the filesystem.                *
 *   It is as secure as filesystem security. It is as reliable             *
 *   as filesystem. It uses only standards C calls, which makes it         *
 *   usable by very low level or early boot stage software, like           *
 *   /sbin/init.                                                           *
 *                                                                         *
 ***************************************************************************/


/* Subversion stuff

$Id: localkdb.c 54 2004-08-31 10:40:22Z aviram $
$LastChangedBy: aviram $

*/


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


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <pwd.h>
#include <dirent.h>
#include <errno.h>
#include <stdio.h>
#include <iconv.h>
#include <locale.h>
#include <langinfo.h>
#include <ctype.h>
#include <string.h>


#define UTF8_TO   1
#define UTF8_FROM 0

extern int errno;




/*
 * @defgroup internals Elektra internals
 * @brief These methods are not to be used by your application.
 *
 */



int kdbOpen() {
    return 0;
}

int kdbClose() {
    return 0;
}

size_t keyGetSerializedSize(const Key *key) {
    size_t size,tmp;


    size=5+sizeof(u_int8_t)+1; /* RG000\nT\n */
    if (key->comment) size+=strblen(key->comment);
    size++;
    tmp=keyGetDataSize(key);
    size+=tmp;
    return size;
}

size_t unencode(char *encoded,void *returned) {
    char byteInHexa[5]="0x";
    char *readCursor=encoded;
    char *writeCursor=returned;

    if (!encoded) {
        if (returned) *(char *)returned=0;
        return 0;
    }

    byteInHexa[4]=0;
    while (*readCursor) {
        if (isspace((int)*readCursor)) readCursor++;
        if (isxdigit((int)*readCursor)) {
            long int converted;
            byteInHexa[2]=readCursor[0];
            byteInHexa[3]=readCursor[1];
            converted=strtol(byteInHexa,0,16); /* convert from hexa to a byte */
            *writeCursor=(unsigned char)converted;

            readCursor+=2;
            writeCursor++;
        } else {
            /* This is suposed to be a hex-digit stream. But is not, so return. */
            errno=KDB_RET_TYPEMISMATCH;
            return 0;
        }
    }
    return (long int)writeCursor-(long int)returned;
}

int kdbNeedsUTF8Conversion() {
    setlocale(LC_ALL,0);
    return strcmp(nl_langinfo(CODESET),"UTF-8");
}


int UTF8Engine(int direction, char **string, size_t *inputByteSize) {
    char *currentCharset=0;
    char *converted=0;
    char *readCursor, *writeCursor;
    size_t bufferSize;
    iconv_t converter;

    if (kdbNeedsUTF8Conversion()) currentCharset=nl_langinfo(CODESET);
    else return 0;

    if (direction) converter=iconv_open("UTF-8",currentCharset);
    else converter=iconv_open(currentCharset,"UTF-8");

    if (converter == (iconv_t)(-1)) return -1;

    bufferSize=*inputByteSize*2; /* work with worst case */
    converted=malloc(bufferSize);
    if (!converted) return -1;

    readCursor=*string;
    writeCursor=converted;
    if (iconv(converter,
            &readCursor,inputByteSize,
            &writeCursor,&bufferSize) == (size_t)(-1)) {
        free(converted);
        iconv_close(converter);
        return -1;
    }

    /* calculate the UTF-8 string byte size, that will be returned */
    *inputByteSize=writeCursor-converted;
    /* store the current unencoded string for future free */
    readCursor=*string;
    /* allocate an optimal size area to store the converted string */
    *string=malloc(*inputByteSize);
    /* copy all that matters for returning */
    memcpy(*string,converted,*inputByteSize);
    /* release memory used by passed string */
    free(readCursor);
    /* release buffer memory */
    free(converted);
    /* release the conversor engine */
    iconv_close(converter);

    return 0;
}




int handleOldKeyFileVersion(Key *key,FILE *input,u_int16_t nversion) {
    char generalBuffer[100];
    size_t currentBufferSize;

    char type[5];
    char *data=0;
    size_t dataSize=0;
    char *comment=0;
    size_t commentSize=0;

    int readComment=1;
    int eof=0;

    /*
        This is a very dirty helper.
        It has the parsing code for old version of key files.
        If your editor doesn't have code folding it will be a pain.
    */


    switch (nversion) {
        case 1: {
            if (!fgets(type,    sizeof(type),    input)) return -1;

            while (readComment) {
                if (fgets(generalBuffer,sizeof(generalBuffer),input)) {
                    if (memcmp(generalBuffer,"<DATA>\n\0",8)) {
                        /* This is not the begining of the data part so it is part of comment */
                        currentBufferSize=strblen(generalBuffer);
                        if (!comment) {
                            comment=(char *)malloc(commentSize=currentBufferSize);
                            strcpy(comment,generalBuffer);
                        } else {
                            char *buffer=0;

                            buffer=malloc(commentSize+currentBufferSize);
                            strcpy(buffer,comment);
                            strcat(buffer,generalBuffer);
                            comment=realloc(comment,commentSize+=currentBufferSize);
                            strcpy(comment,buffer);
                            free(buffer);
                        }
                    } else readComment=0;
                } else {
                    readComment=0;
                    eof=1;
                }
            }

            /* Remove last \n */
            if (commentSize > 1 && (*(comment+commentSize-2) == '\n')) {
                *(comment+commentSize-2)=0;
                --commentSize;
            }


            if (comment && UTF8Engine(UTF8_FROM,&comment,&commentSize)) {
                free(comment);
                return -1;
            }

            /* Now read the data section */
            if (!eof) {
                while (fgets(generalBuffer,sizeof(generalBuffer),input)) {
                    currentBufferSize=strlen(generalBuffer);
                    if (!data) {
                        data=(char *)malloc(dataSize=(currentBufferSize+1));
                        strcpy(data,generalBuffer);
                    } else {
                        char *buffer=0;

                        buffer=malloc(dataSize+currentBufferSize);
                        strcpy(buffer,data);
                        strcat(buffer,generalBuffer);
                        data=realloc(data,dataSize+=currentBufferSize);
                        strcpy(data,buffer);
                        free(buffer);
                    }
                }
            }

            /* Put in the Key object */
            keySetComment(key,comment);
            if (comment) free(comment);

            /* This is what changed from version 1 to
               version 2 format: key type numbers */
            {
                u_int8_t oldVersion=atoi(type);
                switch (oldVersion) {
                    case 1: keySetType(key,KEY_TYPE_BINARY); break;
                    case 2: keySetType(key,KEY_TYPE_STRING); break;
                    default: keySetType(key,oldVersion);
                }
            }
            if (!dataSize) {
                keySetRaw(key,0,0);
                return 0;
            }

            if (keyGetType(key) <= KEY_TYPE_BINARY) {
                /* Binary data. Unencode. */
                char *unencoded=0;
                size_t unencodedSize;

                /* raw data is maximum half the size of text-encoded data */
                unencodedSize=dataSize/2;

                unencoded=malloc(unencodedSize);
                if (!(unencodedSize=unencode(data,unencoded))) return -1;
                keySetRaw(key,unencoded,unencodedSize);
                free(unencoded);
            } else {
                if (UTF8Engine(UTF8_FROM,&data,&dataSize)) {
                    free(data);
                    return -1;
                }
                keySetRaw(key,data,dataSize);
            }

            free(data);

            return 0;
        } /* version 1 */
    } /* switch */
    return -1;
}





int keyFileUnserialize(Key *key,FILE *input) {
    char generalBuffer[100];
    size_t currentBufferSize;

    char version[10];
    u_int16_t nversion=0;
    char type[5];
    char *data=0;
    size_t dataSize=0;
    char *comment=0;
    size_t commentSize=0;

    int readComment=1;
    int eof=0;

    /* The serialized format is
       -------------------------
       RG001\n
       type\n
       comment (with newlines)\n
       <DATA>\n
       The data encoded as text
       -------------------------
    */

    if (!fgets(version, sizeof(version), input)) return -1;
    if (strncmp(version,"RG",2)) {
        /* Doesn't look like a key file */
        errno=KDB_RET_INVALIDKEY;
        return -1;
    }

    nversion=atoi(version+2);
    if (!nversion || nversion > RG_KEY_FORMAT_VERSION) {
        errno=KDB_RET_INVALIDKEY;
        return -1;
    }

    if (nversion != RG_KEY_FORMAT_VERSION)
        return handleOldKeyFileVersion(key,input,nversion);

    if (!fgets(type,    sizeof(type),    input)) return -1;

    while (readComment) {
        if (fgets(generalBuffer,sizeof(generalBuffer),input)) {
            if (memcmp(generalBuffer,"<DATA>\n\0",8)) {
                /* This is not the begining of the data part so it is part of comment */
                currentBufferSize=strblen(generalBuffer);
                if (!comment) {
                    comment=(char *)malloc(commentSize=currentBufferSize);
                    strcpy(comment,generalBuffer);
                } else {
                    char *buffer=0;

                    buffer=malloc(commentSize+currentBufferSize);
                    strcpy(buffer,comment);
                    strcat(buffer,generalBuffer);
                    comment=realloc(comment,commentSize+=currentBufferSize);
                    strcpy(comment,buffer);
                    free(buffer);
                }
            } else readComment=0;
        } else {
            readComment=0;
            eof=1;
        }
    }

    /* Remove last \n */
    if (commentSize > 1 && (*(comment+commentSize-2) == '\n')) {
        *(comment+commentSize-2)=0;
        --commentSize;
    }

    if (comment && UTF8Engine(UTF8_FROM,&comment,&commentSize)) {
        free(comment);
        return -1;
    }

    /* Now read the data section */
    if (!eof) {
        while (fgets(generalBuffer,sizeof(generalBuffer),input)) {
            currentBufferSize=strlen(generalBuffer);
            if (!data) {
                data=(char *)malloc(dataSize=(currentBufferSize+1));
                strcpy(data,generalBuffer);
            } else {
                char *buffer=0;

                buffer=malloc(dataSize+currentBufferSize);
                strcpy(buffer,data);
                strcat(buffer,generalBuffer);
                data=realloc(data,dataSize+=currentBufferSize);
                strcpy(data,buffer);
                free(buffer);
            }
        }
    }

    /* Put in the Key object */
    keySetComment(key,comment);
    if (comment) free(comment);
    keySetType(key,atoi(type));
    if (!dataSize) {
        keySetRaw(key,0,0);
        return 0;
    }

    if (keyGetType(key) <= KEY_TYPE_BINARY) {
        /* Binary data. Unencode. */
        char *unencoded=0;
        size_t unencodedSize;

        /* raw data is maximum half the size of text-encoded data */
        unencodedSize=dataSize/2;

        unencoded=malloc(unencodedSize);
        if (!(unencodedSize=unencode(data,unencoded))) return -1;
        keySetRaw(key,unencoded,unencodedSize);
        free(unencoded);
    } else {
        if (UTF8Engine(UTF8_FROM,&data,&dataSize)) {
            free(data);
            return -1;
        }
        keySetRaw(key,data,dataSize);
    }

    free(data);

    return 0;
}



size_t encode(void *unencoded, size_t size, char *returned) {
    void *readCursor=unencoded;
    void *writeCursor=returned;
    int blockStep=4; /* 4 bytes per block */
    int lineStep=8*blockStep; /* 8 blocks per line */
    int currentInBlock=0;
    int currentInLine=0;

    while ((readCursor-unencoded)<size) {
        sprintf(writeCursor,"%01x",*(u_int8_t *)readCursor);
        readCursor++;
        writeCursor+=2;
        currentInBlock++;
        currentInLine++;
        if (currentInLine==lineStep) {
            *(char *)writeCursor='\n'; writeCursor++;
            currentInLine=0;
            currentInBlock=0;
        }
        if (currentInBlock==blockStep) {
            *(char *)writeCursor=' '; writeCursor++;
            currentInBlock=0;
        }
    }
    *(char *)writeCursor='\n';
    *(char *)++writeCursor=0;
    return (writeCursor)-(void *)returned;
}





int keyFileSerialize(Key *key, FILE *output) {
    /* The serialized format is
       -------------------------
       RG001\n
       type\n
       comment (with newlines)\n
       <DATA>\n
       The data encoded as text
       -------------------------
    */

    size_t dataSize;

    fprintf(output,"RG%03d\n",RG_KEY_FORMAT_VERSION);
    fprintf(output,"%d\n",key->type);
    if (key->comment) {
        if (kdbNeedsUTF8Conversion()) {
            size_t convertedCommentSize=key->commentSize;
            char *convertedComment=malloc(convertedCommentSize);

            memcpy(convertedComment,key->comment,key->commentSize);
            if (UTF8Engine(UTF8_TO,&convertedComment,&convertedCommentSize)) {
                free(convertedComment);
                return -1;
            }
            fprintf(output,"%s\n",convertedComment);
            free(convertedComment);
        } else fprintf(output,"%s\n",key->comment);
    }

    fputs("<DATA>\n",output);
    fflush(output);

    dataSize=keyGetDataSize(key);
    if (dataSize) {
        /* There is some data to write */
        if (keyGetType(key) > KEY_TYPE_BINARY) {
            if (kdbNeedsUTF8Conversion()) {
                size_t convertedDataSize=key->dataSize;
                char *convertedData=malloc(convertedDataSize);

                memcpy(convertedData,key->data,key->dataSize);
                if (UTF8Engine(UTF8_TO,&convertedData,&convertedDataSize)) {
                    free(convertedData);
                    return -1;
                }
                fprintf(output,"%s",convertedData);
                free(convertedData);
            } else fputs(key->data,output);
        } else {
            char *encoded=malloc(3*dataSize);
            size_t encodedSize;

            encodedSize=encode(key->data,dataSize,encoded);
            fwrite(encoded,encodedSize,1,output);
            free(encoded);
        }
    }
    return 0;
}


size_t keyCalcRelativeFileName(Key *key,char *relativeFileName,size_t maxSize) {
    if (!key || !keyIsInitialized(key)) {
        errno=KDB_RET_UNINITIALIZED;
        return 0;
    }
    if (!key->key) {
        errno=KDB_RET_NOKEY;
        return 0;
    }

//  cursor=key->key;
//  while (*cursor) {
//      if (pos+1 > maxSize) {
//          errno=E2BIG;
//          return -1;
//      }
//      switch (*cursor) {
//          case '\\':
//              cursor++;
//              relativeFileName[pos]=*cursor;
//              break;
//          case '.':
//              relativeFileName[pos]='/';
//              break;
//          default:
//              relativeFileName[pos]=*cursor;
//      }
//      cursor++;
//      pos++;
//  }
//  relativeFileName[pos]=0;
//  pos++;

    if (kdbNeedsUTF8Conversion()) {
        char *converted;
        size_t size;

        if (!(size=keyGetNameSize(key))) return 0;

        converted=malloc(size);
        keyGetName(key,converted,size);

//      memcpy(converted,relativeFileName,convertedSize);

        if (UTF8Engine(UTF8_TO,&converted,&size)) {
            free(converted);
            return 0;
        }

        if (size>maxSize) {
            free(converted);
            errno=E2BIG;
            return 0;
        }

        memcpy(relativeFileName,converted,size);
        free(converted);

        return size;
    } else return keyGetName(key,relativeFileName,maxSize);

    return 0;
}






int keyFromStat(Key *key,struct stat *stat) {
    if (!key) {
        errno=KDB_RET_NULLKEY;
        return -1;
    }

    keySetAccess(key,stat->st_mode);
    keySetUID(key,stat->st_uid);
    keySetGID(key,stat->st_gid);
    if (S_ISDIR(stat->st_mode)) keySetType(key,KEY_TYPE_DIR);
    key->atime=stat->st_atime;
    key->mtime=stat->st_mtime;
    key->ctime=stat->st_ctime;
    key->recordSize=stat->st_size;
    return 0;
}




size_t kdbGetFilename(Key *forKey,char *returned,size_t maxSize) {
    size_t length=0;

    switch (keyGetNamespace(forKey)) {
        case KEY_NS_SYSTEM: {
            /* Prepare to use the 'system/ *' database */
            strncpy(returned,RG_DB_SYSTEM,maxSize);
            length=strlen(returned);
            break;
        }
        case KEY_NS_USER: {
            /* Prepare to use the 'user:????/ *' database */
            struct passwd *user=0;
            char userName[100];

            length=keyGetOwner(forKey,userName,sizeof(userName));
            if (!length) strncpy(userName,getenv("USER"),sizeof(userName));

            user=getpwnam(userName);
                        if (!user) return 0; /* propagate errno */
            length=snprintf(returned,maxSize,"%s/%s",user->pw_dir,RG_DB_USER);
            break;
        }
        default: {
            errno=KDB_RET_INVALIDKEY;
            return 0;
        }
    }

    returned[length]='/'; length++;
    length+=keyCalcRelativeFileName(forKey,returned+length,maxSize-length);

    return length;
}



int kdbGetValue(const char *keyname, char *returned,size_t maxSize) {
    Key key;
    int rc=0;

    keyInit(&key);
    keySetName(&key,keyname);
    rc=kdbGetKey(&key);
    if (rc == 0) keyGetString(&key,returned,maxSize);
    else rc=errno; /* store errno before a possible change */
    keyClose(&key);
    errno=rc;
    return rc;
}



int kdbSetValue(const char *keyname, const char *value) {
    Key key;
    int rc;

/* TODO: check key type first */
    keySetName(&key,keyname);
    rc=kdbGetKey(&key);
    keySetString(&key,value);
    rc=kdbSetKey(&key);
    keyClose(&key);
    return rc;
}



int kdbGetValueByParent(const char *parentName, const char *baseName, char *returned, size_t maxSize) {
    char name[strblen(parentName)+strblen(baseName)];

    sprintf(name,"%s/%s",parentName,baseName);
    return kdbGetValue(name,returned,maxSize);
}



int kdbSetValueByParent(const char *parentName, const char *baseName, const char *value) {
    char name[strblen(parentName)+strblen(baseName)];

    sprintf(name,"%s/%s",parentName,baseName);
    return kdbSetValue(name,value);
}



int kdbGetKeyByParent(const char *parentName, const char *baseName, Key *returned) {
    char name[strblen(parentName)+strblen(baseName)];

    sprintf(name,"%s/%s",parentName,baseName);
    keySetName(returned,name);

    return kdbGetKey(returned);
}


int kdbGetKeyByParentKey(const Key *parent, const char *baseName, Key *returned) {
    size_t size=keyGetFullNameSize(parent);
    char name[size+strblen(baseName)];

    keyGetFullName(parent,name,size);
    name[size-1]='/';
    strcpy((char *)(parent+size),baseName);

    keySetName(returned,name);

    return kdbGetKey(returned);
}




/* Used by the qsort() function */
int keyCompareByName(const void *p1, const void *p2) {
    Key *key1=*(Key **)p1;
    Key *key2=*(Key **)p2;

    return strcmp(key1->key, key2->key);
}



int kdbGetChildKeys(const char *parentName, KeySet *returned, unsigned long options) {
    char *realParentName=0;
    size_t parentNameSize;
    DIR *parentDir;
    Key parentKey;
    char buffer[800];
    struct dirent *entry;

    /*
        - Convert parent key name into a real filename
        - Check if it is a directory. Open it
        - Browse, read and include in the KeySet
    */
    keyInit(&parentKey);
    keySetName(&parentKey,parentName);
    kdbGetFilename(&parentKey,buffer,sizeof(buffer));
    parentDir=opendir(buffer);

    /* Check if Key is not a directory or doesn't exist.
     * Propagate errno */
    if (!parentDir) return -1;

    parentNameSize=keyGetFullNameSize(&parentKey);
    realParentName=realloc(realParentName,parentNameSize);
    keyGetFullName(&parentKey,realParentName,parentNameSize);

    while ((entry=readdir(parentDir))) {
        Key *keyEntry;
        char *transformedName=0;
        size_t keyNameSize=0;

        /* Ignore '.' and '..' directory entries */
        if (!strcmp(entry->d_name,".") || !strcmp(entry->d_name,"..")) continue;

        /* If key name starts with '.', and don't want INACTIVE keys, ignore it */
        if ((*entry->d_name == '.') && !(options & KDB_O_INACTIVE)) continue;

        /* Next 2 ifs are required to transform filename from UTF-8 */
        if (!transformedName) {
            transformedName=
                realloc(transformedName,keyNameSize=strblen(entry->d_name));
            strcpy(transformedName,entry->d_name);
        }
        if (UTF8Engine(UTF8_FROM,&transformedName,&keyNameSize)) {
            free(transformedName);
            return -1;
        }

        /* Copy the entire transformed key name to our final buffer */
        sprintf(buffer,"%s/%s",realParentName,transformedName);
        free(transformedName); /* don't need it anymore */

        keyEntry=(Key *)malloc(sizeof(Key)); keyInit(keyEntry);
        keySetName(keyEntry,buffer);

        if (options & KDB_O_STATONLY) kdbStatKey(keyEntry);
        else if (options & KDB_O_NFOLLOWLINK) {
            kdbStatKey(keyEntry);
            if (!keyIsLink(keyEntry)) kdbGetKey(keyEntry);
        } else {
            int rc=kdbGetKey(keyEntry);
            /* If this is a permission problem, at least stat the key */
            if (rc && errno==KDB_RET_NOCRED) kdbStatKey(keyEntry);
        }

        if (S_ISDIR(keyEntry->access)) {
            if (options & KDB_O_RECURSIVE) {
                KeySet children;
                char *fullName;
                size_t fullNameSize;

                fullName=malloc(fullNameSize=keyGetFullNameSize(keyEntry));
                keyGetFullName(keyEntry,fullName,fullNameSize);

                ksInit(&children);
                /* Act recursively, without sorting. Sort in the end, once */
                kdbGetChildKeys(fullName,&children, ~(KDB_O_SORT) & options);

                /* Insert the current directory key in the returned list before its children */
                if (options & KDB_O_DIR) ksAppend(returned,keyEntry);
                else {
                    keyClose(keyEntry);
                    free(keyEntry);
                }

                /* Insert the children */
                ksAppendKeys(returned,&children);
                free(fullName);
            } else if (options & KDB_O_DIR) ksAppend(returned,keyEntry);
                else {
                    keyClose(keyEntry);
                    free(keyEntry);
                }
        } else if (options & KDB_O_NOVALUE) {
            keyClose(keyEntry);
            free(keyEntry);
        } else ksAppend(returned,keyEntry);
    } /* while(readdir) */
    keyClose(&parentKey);
    free(realParentName);

    if ((options & (KDB_O_SORT)) && (returned->size > 1)) {
        Key *keys[returned->size];
        Key *cursor;
        size_t c=0;

        for (cursor=returned->start; cursor; cursor=cursor->next, c++)
            keys[c]=cursor;

        qsort(keys,returned->size,sizeof(Key *),keyCompareByName);

        returned->start=cursor=keys[0];
        for (c=1; c<returned->size; c++) {
            cursor->next=keys[c];
            cursor=cursor->next;
        }
        cursor->next=0;
        returned->end=cursor;
    }

    return 0;
}








int kdbGetRootKeys(KeySet *returned) {
    Key *system=0,*user=0;

    system=malloc(sizeof(Key));
    keyInit(system);
    keySetName(system,"system");
    if (kdbGetKey(system)) {
        free(system);
        system=0;
    }

    user=malloc(sizeof(Key));
    keyInit(user);
    keySetName(user,"user");
    if (kdbGetKey(user)) {
        free(user);
        user=0;
    }

    if (system) ksInsert(returned,system);
    if (user) ksAppend(returned,user);

    return 0;
}



int kdbStatKey(Key *key) {
    char keyFileName[800];
    struct stat keyFileNameInfo;
    size_t pos;
    u_int32_t semiflag;

    pos=kdbGetFilename(key,keyFileName,sizeof(keyFileName));
    if (!pos) return -1; /* something is wrong */

    if (lstat(keyFileName,&keyFileNameInfo)) return -1;
    keyFromStat(key,&keyFileNameInfo);

    if (keyIsLink(key) && key->recordSize) {
        char *data=malloc(key->recordSize+1); /* Add 1 byte for ending 0 */

        readlink(keyFileName,data,key->recordSize);
        data[key->recordSize]=0; /* null terminate it */
        keySetLink(key,data);
        free(data);
    }

    /* Remove the NEEDSYNC flag */
    semiflag=KEY_FLAG_NEEDSYNC;
    semiflag=~semiflag;
    key->flags &= semiflag;
    key->flags |= KEY_FLAG_ACTIVE;

    return 0;
}



int kdbGetKey(Key *key) {
    char keyFileName[500];
    struct stat keyFileNameInfo;
    int fd;
    size_t pos;
    u_int32_t semiflag;

    pos=kdbGetFilename(key,keyFileName,sizeof(keyFileName));
    if (!pos) return -1; /* something is wrong */

    if ((fd=open(keyFileName,O_RDONLY))==-1) return -1;
    /* TODO: lock at this point */
    fstat(fd,&keyFileNameInfo);
    keyFromStat(key,&keyFileNameInfo);
    if (!keyIsDir(key)) {
        FILE *input;

        input=fdopen(fd,"r");
        if (keyFileUnserialize(key,input)) {
            fclose(input);
            return -1;
        }
        /* TODO: unlock at this point */
        fclose(input);
    } else close(fd);

    /* Remove the NEEDSYNC flag */
    semiflag=KEY_FLAG_NEEDSYNC;
    semiflag=~semiflag;
    key->flags &= semiflag;

    return 0;
}



int kdbSetKeys(KeySet *ks) {
    Key *current;

    for (current=ks->start; current; current=current->next) {
        if (keyNeedsSync(current)) {
            kdbSetKey(current);
        }
    }

    return 0;
}



int kdbSetKey(Key *key) {
    char keyFileName[800];
    char folderMaker[800];
    char *cursor, *last;
    int fd;
    FILE *output=0;
    size_t pos;
    u_int32_t semiflag;
    struct stat stated;

    pos=kdbGetFilename(key,keyFileName,sizeof(keyFileName));
    if (!pos) return -1; /* Something is wrong. Propagate errno. */

    if (stat(keyFileName,&stated))
        if (errno==ENOENT) {
            /* check if parent dir already exists */
            last=rindex(keyFileName,'/');
            strncpy(folderMaker,keyFileName,last-keyFileName);
            folderMaker[last-keyFileName]=0;
            if (stat(folderMaker,&stated)) {
                /* create all path recursively until before our basename */
                last   =rindex(keyFileName,'/');
                cursor = index(keyFileName,'/'); cursor++; /* skip first occurence */
                if (!last || !cursor) { /* bizarre key name */
                    errno=KDB_RET_INVALIDKEY;
                    return -1;
                }
                for (cursor=index(cursor,'/');
                        cursor && (cursor <= last);
                        cursor=index(cursor,'/')) {
                    strncpy(folderMaker,keyFileName,cursor-keyFileName);
                    folderMaker[cursor-keyFileName]=0;
                    if (mkdir(folderMaker,0775)<0 && errno!=EEXIST) return -1;
                    cursor++;
                }
            }
        } else return -1; /* propagate errno */
    else { /* A file or dir or link is already there. Lets check details */
        /* TODO: Check for existing link */
        if ( S_ISDIR(stated.st_mode) && !keyIsDir(key)) {
            errno=EISDIR;
            return -1;
        }
        if (!S_ISDIR(stated.st_mode) &&  keyIsDir(key)) {
            errno=ENOTDIR;
            return -1;
        }
    }

    /* Enough of checking. Now real write stuff, with a bit other checks :-)  */

    if (keyIsLink(key)) {
        char *targetName=0;
        Key target;
        int rc;

        /*
            If targetName starts with:
            - "system" | "user" | any future root name: Convert to a FS path,
              and symlink it
            - other: It is an absolute FS path, or relative inside-kdb
              namespace path, and symlink it
        */

        keyInit(&target);
        if (key->data) targetName=malloc(key->dataSize);
        keyGetLink(key,targetName,key->dataSize);

        /* Setting the name will let us know if this is a valid keyname */
        if (keySetName(&target,targetName)) {
            /* target has a valid key name */
            targetName=realloc(targetName,800);
            kdbGetFilename(&target,targetName,800);
            keyClose(&target);
        } else if (errno==KDB_RET_INVALIDKEY) {
            /* Is an invalid key name. So treat it as a regular file */
            keyClose(&target); /* get rid of invalid stuff */
        } else {
            keyClose(&target); /* get rid of invalid stuff */
            return -1; /* propagate errno from keySetName() */
        }


        /* Now, targetName has the real destination of our link */

        /* TODO: handle null targetName */
        rc=symlink(targetName,keyFileName);
        free(targetName);

        return rc; /* propagate errno */
    } else if (keyIsDir(key)) {
        if (mkdir(keyFileName,keyGetAccess(key))<0 &&
                errno!=EEXIST) return -1;
    } else {
        /* Try to open key file with its full file name */
        /* TODO: Make it more "transactional" without truncating */
        fd=open(keyFileName,O_CREAT | O_RDWR | O_TRUNC, keyGetAccess(key));
        /* TODO: lock file here */
        if (fd==-1) return -1;
        if (getuid() == 0) fchown(fd,keyGetUID(key),keyGetGID(key));
        if (!(output=fdopen(fd,"w+"))) return -1;
        if (keyFileSerialize(key,output)) {
            fclose(output);
            return -1;
        }
        /* TODO: unlock file here */
        fclose(output);
    }

    /* Remove the NEEDSYNC flag */
    semiflag=KEY_FLAG_NEEDSYNC;
    semiflag=~semiflag;
    key->flags &= semiflag;

    return 0;
}






int kdbRemove(const char *keyName) {
    Key key;
    char fileName[800];
    off_t rc;

    keyInit(&key);
    rc=keySetName(&key,keyName);
    if (rc==-1) return -1;
    rc=kdbGetFilename(&key,fileName,sizeof(fileName));
    keyClose(&key);
    if (!rc) return -1;

    return remove(fileName);
}





int kdbLink(const char *oldPath, const char *newKeyName) {
    Key key;
    int rc;

    keyInit(&key);
    keySetName(&key,newKeyName);
    keySetLink(&key,oldPath);

    rc=kdbSetKey(&key);
    keyClose(&key);

    return rc;
}





u_int32_t kdbMonitorKeys(KeySet *interests, u_int32_t diffMask,
        unsigned long iterations, unsigned sleep) {
    Key *start,*current;
    u_int32_t diff;
    int infinitum=0;

    if (!interests || !interests->size) return 0;

    /* Unacceptable 0 usecs sleep. Defaults to 1 second */
    if (!sleep) sleep=1000;

    if (!iterations) infinitum=1;
    else infinitum=0;

    current=start=ksCurrent(interests);

    while (infinitum || --iterations) {
        do {
            diff=kdbMonitorKey(current,diffMask,1,0);
            if (diff) return diff;
            current=ksNext(interests);
        } while (current!=start);

        /* Test if some iterations left . . . */
        if (infinitum || iterations) usleep(sleep);
    }
    return 0;
}



u_int32_t kdbMonitorKey(Key *interest, u_int32_t diffMask,
        unsigned long iterations, unsigned sleep) {
    Key tested;
    int rc;
    u_int32_t diff;
    int infinitum=0;

    /* consistency */
    if (!interest || !keyGetNameSize(interest)) return 0;

    /* Unacceptable 0 usecs sleep. Defaults to 1 second */
    if (!sleep) sleep=1000;

    if (!iterations) infinitum=1;
    else infinitum=0;

    /* Work with a copy of the key */
    keyInit(&tested);
    keyDup(interest,&tested);

    while (infinitum || --iterations) {
        rc=kdbGetKey(&tested);
        if (rc) {
            /* check what type of problem happened.... */
            switch (errno) {
                case KDB_RET_NOCRED:
                    return KEY_FLAG_NEEDSYNC;
                case KDB_RET_NOTFOUND:
                    return KEY_FLAG_FLAG;
            }
        }
        diff=keyCompare(&tested,interest);
        if (diff & diffMask) {
            /* If differences are in the diff mask...*/
            keyDup(&tested,interest);
            keyClose(&tested);
            return diff;
        }
        /* Test if some iterations left . . . */
        if (infinitum || iterations) usleep(sleep);
    }

    return 0;
}

---