libkdb.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 BSD License (revised).                      *
 *                                                                         *
 ***************************************************************************/




/* Subversion stuff

$Id: libkdb.c 601 2006-02-15 02:32:13Z aviram $

*/


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "kdb.h"
#include "kdbbackend.h"
#include "kdbprivate.h"

#include <stdlib.h>
#include <stdarg.h>
#include "kdbLibLoader.h"

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <errno.h>
#include <stdio.h>
#ifdef HAVE_ICONV
#include <iconv.h>
#endif
#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif
#ifdef HAVE_LANGINFO_H
#include <langinfo.h>
#endif
#include <ctype.h>
#include <string.h>

/* usleep doesn't exist on win32, so we use Sleep() */
#ifdef WIN32
#define usleep(x) Sleep(x)
#endif

/*extern int errno;*/

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




struct _KDBBackend {
    kdbLibHandle dlHandle;
    
    char *name;
    
    /* These are the must-have methods */
    
    kdbOpenPtr kdbOpen;
    kdbClosePtr kdbClose;
    
    kdbGetKeyPtr kdbGetKey;
    kdbSetKeyPtr kdbSetKey;
    kdbStatKeyPtr kdbStatKey;
    kdbRenamePtr kdbRename;
    kdbRemoveKeyPtr kdbRemoveKey;
    kdbGetChildKeysPtr kdbGetKeyChildKeys;
    
    
    /* These are the optional methods */
    
    kdbSetKeysPtr kdbSetKeys;
    kdbMonitorKeyPtr kdbMonitorKey;
    kdbMonitorKeysPtr kdbMonitorKeys;
};




KDBBackend *backend;



int kdbOpen() {
    char *backendName=0;
    
    backendName=getenv("KDB_BACKEND");
    if (backendName) return kdbOpenBackend(backendName);
    else return kdbOpenBackend(DEFAULT_BACKEND);
}



int kdbOpenDefault() {
    return kdbOpenBackend(DEFAULT_BACKEND);
}




int kdbOpenBackend(char *backendName) {
    kdbLibHandle dlhandle=0;
    char backendlib[300];
    KDBBackendFactory kdbBackendNew=0;
    int rc=0;
    
    backend=0;
    
    /* load the environment and make us aware of codeset conversions */
    #ifdef HAVE_SETLOCALE
    setlocale(LC_ALL,"");
    #endif
    
    /* init */
    if ( (rc = kdbLibInit()) ) {
        errno=KDB_RET_NOSYS;
        return 1; /* error */
    }   
    
    sprintf(backendlib,"libelektra-%s",backendName);
    dlhandle=kdbLibLoad(backendlib);
    if (dlhandle == 0) {
        errno=KDB_RET_NOSYS;
        return 1; /* error */
    }
    
    kdbBackendNew=(KDBBackendFactory)kdbLibSym(dlhandle,"kdbBackendFactory");
    if (kdbBackendNew == 0) {
        errno=KDB_RET_NOSYS;
        return 2; /* error */
    }
    
    backend=(*kdbBackendNew)();
    if (backend == 0) {
        fprintf(stderr,"libelektra: Can't initialize \"%s\" backend\n",
            backendName);
        errno=KDB_RET_NOSYS;
        return 3; /* error */
    }

    /* save the handle for future use */
    backend->dlHandle=dlhandle;
    
    /* let the backend initialize itself */
    if (backend->kdbOpen) rc=backend->kdbOpen();
    else {
        errno=KDB_RET_NOSYS;
        rc=4;
    }
    return rc;
}



int kdbClose() {
    int rc=0;
    
    if (backend && backend->kdbClose) rc=backend->kdbClose();
    else {
        errno=KDB_RET_NOSYS;
        return -1;
    }
    
    if (rc == 0) {
        if (backend->name) free(backend->name);
        kdbLibClose(backend->dlHandle);
        free(backend); backend=0;
    }
    
    return rc;
}




ssize_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++;
        continue;
        }
        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 -1;
        }
    }
    return (long int)writeCursor-(long int)returned;
}

int kdbNeedsUTF8Conversion() {
#if defined(HAVE_NL_LANGINFO) && defined(HAVE_ICONV) && defined(CODESET)
    return strcmp(nl_langinfo(CODESET),"UTF-8");
#else
    return 0;     
#endif
}


int UTF8Engine(int direction, char **string, size_t *inputOutputByteSize) {
/* Current solution is not very complete.
 * Iconv might well be available when a usable nl_langinfo is not.
 * In this case we it should be possible to determine charset through other means
 * See http://www.cl.cam.ac.uk/~mgk25/unicode.html#activate for more info on a possible solution */
 
#if defined(HAVE_ICONV_H) && defined(HAVE_NL_LANGINFO) && defined(CODESET)
    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==UTF8_TO) converter=iconv_open("UTF-8",currentCharset);
    else converter=iconv_open(currentCharset,"UTF-8");

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

    /* work with worst case, when all chars are wide */
    bufferSize=*inputOutputByteSize * 4;
    converted=malloc(bufferSize);
    if (!converted) return -1;

    readCursor=*string;
    writeCursor=converted;
    /* On some systems and with libiconv, arg1 is const char **. 
     * ICONV_CONST is defined by configure if the system needs this */
    if (iconv(converter,
            (ICONV_CONST char **)&readCursor,inputOutputByteSize,
            &writeCursor,&bufferSize) == (size_t)(-1)) {
        free(converted);
        iconv_close(converter);
        return -1;
    }

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



ssize_t encode(void *unencoded, size_t size, char *returned) {
    char *readCursor=unencoded;
    char *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-(char *)unencoded)<size) {
        sprintf(writeCursor,"%02x",*(unsigned char *)readCursor);
        readCursor++;
        writeCursor+=2;
        currentInBlock++;
        currentInLine++;
        if (currentInLine==lineStep) {
            *writeCursor='\n'; writeCursor++;
            currentInLine=0;
            currentInBlock=0;
        }
        if (currentInBlock==blockStep) {
            *writeCursor=' '; writeCursor++;
            currentInBlock=0;
        }
    }
    *writeCursor='\n';
    *++writeCursor=0;
    return writeCursor-returned;
}





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

    key=keyNew(keyname,KEY_SWITCH_END);
    rc=kdbGetKey(key);
    if (rc == 0) keyGetString(key,returned,maxSize);
    else rc=errno; /* store errno before a possible change */
    keyDel(key);
    errno=rc;
    return rc;
}



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

/* TODO: check key type first */
    key=keyNew(keyname,KEY_SWITCH_END);
    rc=kdbGetKey(key);
    keySetString(key,value);
    rc=kdbSetKey(key);
    keyDel(key);
    return rc;
}



int kdbGetValueByParent(const char *parentName, const char *baseName, char *returned, size_t maxSize) {
    char *name;
    int retval=0;
    name = (char *)malloc(sizeof(char)*(strblen(parentName)+strblen(baseName)));

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



int kdbSetValueByParent(const char *parentName, const char *baseName, const char *value) {
    char *name;
    int retval=0;
    name = (char *)malloc(sizeof(char)*(strblen(parentName)+strblen(baseName)));

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



int kdbGetKeyByParent(const char *parentName, const char *baseName, Key *returned) {
    char *name;
    name = (char *)malloc(sizeof(char) * (strblen(parentName)+strblen(baseName)));

    sprintf(name,"%s/%s",parentName,baseName);  
    keySetName(returned,name);
  free(name);
    return kdbGetKey(returned);
}


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

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

    keySetName(returned,name);
  free(name);
    return kdbGetKey(returned);
}





ssize_t kdbGetKeyChildKeys(const Key *parentKey, KeySet *returned, unsigned long options) {
    
    if (backend && backend->kdbGetKeyChildKeys)
        return backend->kdbGetKeyChildKeys(parentKey,returned,options);
    else {
        errno=KDB_RET_NOSYS;
        return -1;
    }
}



ssize_t kdbGetChildKeys(const char *parentName, KeySet *returned, unsigned long options) {
    Key *parentKey;
    ssize_t rc;
    
    parentKey=keyNew(parentName,KEY_SWITCH_END);
    rc=kdbGetKeyChildKeys(parentKey,returned,options);
    
    keyDel(parentKey);
    
    return rc;
}



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

    user=keyNew("user",KEY_SWITCH_NEEDSYNC,KEY_SWITCH_END);
    if (user->flags & KEY_SWITCH_FLAG) {
        keyDel(user);
        user=0;
    } else ksInsert(returned,user);

    system=keyNew("system",KEY_SWITCH_NEEDSYNC,KEY_SWITCH_END);
    if (system->flags & KEY_SWITCH_FLAG) {
        keyDel(system);
        system=0;
    } else ksInsert(returned,system);

    return returned->size;
}



int kdbStatKey(Key *key) {
    int rc=0;
    
    if (backend && backend->kdbStatKey)
        rc=backend->kdbStatKey(key);
    else {
        errno=KDB_RET_NOSYS;
        return -1;
    }
    
    return rc;
}



int kdbGetKey(Key *key) {
    int rc=0;
    
    if (backend && backend->kdbGetKey)
        rc=backend->kdbGetKey(key);
    else {
        errno=KDB_RET_NOSYS;
        return -1;
    }
    
    return rc;
}



int kdbSetKeys(KeySet *ks) {
    int rc=0;
    
    if (backend) {
        if(backend->kdbSetKeys)
            rc=backend->kdbSetKeys(ks);
      else 
            /* If backend doesn't provide kdbSetKeys, use the default */
            rc=kdbSetKeys_default(ks);  
    }
    else {
        errno=KDB_RET_NOSYS;
        return -1;
    }
    
    return rc;
}



int kdbSetKeys_default(KeySet *ks) {
    Key *current=ksCurrent(ks);
    int ret;

    if (!current) current=ksNext(ks);
    while (current) {
        if (keyNeedsSync(current))
            if ((ret=kdbSetKey(current))) /* check error */
                return ret;
        
        current=ksNext(ks);
    }

    return 0;
}



int kdbSetKey(Key *key) {
    int rc=0;
    
    if (backend && backend->kdbSetKey)
        rc=backend->kdbSetKey(key);
    else {
        errno=KDB_RET_NOSYS;
        return -1;
    }
    
    return rc;
}




int kdbRename(Key *key, const char *newName) {
    int rc=0;
    
    if (backend && backend->kdbRename)
        rc=backend->kdbRename(key,newName);
    else {
        errno=KDB_RET_NOSYS;
        return -1;
    }
    
    return rc;
}



int kdbRemoveKey(const Key *key) {
    int rc=0;
    
    if (backend && backend->kdbRemoveKey)
        rc=backend->kdbRemoveKey(key);
    else {
        errno=KDB_RET_NOSYS;
        return -1;
    }
    
    return rc;
}



int kdbRemove(const char *keyName) {
    int rc=0;
    Key *key=0;
    
    key=keyNew(KEY_SWITCH_END);
    rc=keySetName(key,keyName);
    if (rc == 0) {
        keyDel(key);
        return -1; /* error */
    }
    
    rc=kdbRemoveKey(key);
    keyDel(key);
    
    return rc;
}





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

    key=keyNew(newKeyName,KEY_SWITCH_END);
    keySetLink(key,oldPath);

    rc=kdbSetKey(key);
    keyDel(key);

    return rc;
}




uint32_t kdbMonitorKeys(KeySet *interests, uint32_t diffMask,
        unsigned long iterations, unsigned sleep) {
    
    uint32_t rc=0;
    
    if (backend) {
        if(backend->kdbMonitorKeys) 
            rc=backend->kdbMonitorKeys(interests,diffMask,iterations,sleep);
        else 
            /* If backend doesn't provide kdbMonitorKeys, then use the default */
            rc = kdbMonitorKeys_default(interests,diffMask,iterations,sleep);
    }
    else {
        errno=KDB_RET_NOSYS;
        return 0;
    }
    
    return rc;
}


uint32_t kdbMonitorKeys_default(KeySet *interests, uint32_t diffMask,
        unsigned long iterations, unsigned sleeptime) {
    Key *start,*current;
    uint32_t diff;
    int infinitum=0;

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

    /* Unacceptable 0 usecs sleep. Defaults to 1 second */
    if (!sleeptime) sleeptime=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(sleeptime);
    }
    return 0;
}



uint32_t kdbMonitorKey(Key *interest, uint32_t diffMask,
        unsigned long iterations, unsigned sleep) {
    
    int rc=0;
    
    if (backend) {
        if(backend->kdbMonitorKey)
          rc=backend->kdbMonitorKey(interest,diffMask,iterations,sleep);
        else
            rc=kdbMonitorKey_default(interest,diffMask,iterations,sleep);
    }
    else {
        errno=KDB_RET_NOSYS;
        return 0;
    }
    
    return rc;
}




uint32_t kdbMonitorKey_default(Key *interest, uint32_t diffMask,
        unsigned long iterations, unsigned sleeptime) {
    Key *tested;
    int rc;
    uint32_t diff;
    int infinitum=0;

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

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

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

    /* Work with a copy of the key */
    tested=keyNew(0);
    keyDup(interest,tested);

    while (infinitum || --iterations) {
        rc=kdbGetKey(tested);
        if (rc) {
            /* check what type of problem happened.... */
            switch (errno) {
                case KDB_RET_NOCRED:
                    keyDel(tested);
                    return KEY_SWITCH_NEEDSYNC;
                case KDB_RET_NOTFOUND:
                    keyDel(tested);
                    return KEY_SWITCH_FLAG;
            }
        }
        
        diff=keyCompare(tested,interest);
        
        if (diff & diffMask) {
            /* If differences interests us, return it, otherwise cycle again.
             * We don't loose the original key context in a KeySet because
             * we worked with a copy of the key.
             */
            keyDup(tested,interest);
            keyDel(tested);
            return diff;
        }
        /* Test if some iterations left . . . */
        if (infinitum || iterations) usleep(sleeptime);
    }
    
    keyDel(tested);

    return 0;
}



KDBBackend *kdbBackendExport(const char *backendName, ...) {
    va_list va;
    KDBBackend *returned;
    uint32_t method=0;

    if (backendName == 0) return 0;
    
    returned=malloc(sizeof(KDBBackend));
    memset(returned,0,sizeof(KDBBackend));
    
    returned->name=(char *)malloc(strblen(backendName));
    strcpy(returned->name,backendName);
    
    /* Start processing parameters */
    
    va_start(va,backendName);

    while ((method=va_arg(va,uint32_t))) {
        switch (method) {
            case KDB_BE_OPEN:
                returned->kdbOpen=va_arg(va,kdbOpenPtr);
                break;
            case KDB_BE_CLOSE:
                returned->kdbClose=va_arg(va,kdbClosePtr);
                break;
            case KDB_BE_STATKEY:
                returned->kdbStatKey=va_arg(va,kdbStatKeyPtr);
                break;
            case KDB_BE_GETKEY:
                returned->kdbGetKey=va_arg(va,kdbGetKeyPtr);
                break;
            case KDB_BE_SETKEY:
                returned->kdbSetKey=va_arg(va,kdbSetKeyPtr);
                break;
            case KDB_BE_RENAME:
                returned->kdbRename=va_arg(va,kdbRenamePtr);
                break;
            case KDB_BE_REMOVEKEY:
                returned->kdbRemoveKey=va_arg(va,kdbRemoveKeyPtr);
                break;
            case KDB_BE_GETCHILD:
                returned->kdbGetKeyChildKeys=
                    va_arg(va,kdbGetChildKeysPtr);
                break;
            case KDB_BE_SETKEYS:
                returned->kdbSetKeys=va_arg(va,kdbSetKeysPtr);
                break;
            case KDB_BE_MONITORKEY:
                returned->kdbMonitorKey=
                    va_arg(va,kdbMonitorKeyPtr);
                break;
            case KDB_BE_MONITORKEYS:
                returned->kdbMonitorKeys=
                    va_arg(va,kdbMonitorKeysPtr);
                break;
        }
    }
    va_end(va);
    
    return returned;
}

KDBInfo *kdbGetInfo(void) {
    KDBInfo *info=0;

    info=malloc(sizeof(struct _KDBInfo));
    memset(info,0,sizeof(struct _KDBInfo));

#ifdef HAVE_CONFIG_H
    info->version=VERSION;
#endif

    if (backend) {
        info->backendName=backend->name;
        info->backendIsOpen=1;
    } else {
        info->backendName=getenv("KDB_BACKEND");
        if (!info->backendName) info->backendName="default";

        info->backendIsOpen=0;
    }

    return info;
}



void kdbFreeInfo(KDBInfo *info) {
    free(info);
    info=0;
}


int kdbInfoToString(KDBInfo *info,char *string,size_t maxSize) {
    if (!info) {
        strncpy(string,"No info",maxSize);
        return -1;
    }

    snprintf(string,maxSize,
        "Elektra version: %s\nBackend name: %s\nBackend open: %s",
        info->version,
        info->backendName,
        info->backendIsOpen?"yes":"no");

    return 0;
}

---