---

keyfile.c

Go to the documentation of this file.

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "keyfile.h"

typedef struct _keyval {
    char *key;  
    char *val;  
    void *next; 
} KeyVal;

KeyVal *kv_add(KeyVal * kv, char *k, char *v);
void kv_free(KeyVal * kv);
char *kv_getval(KeyVal * kv, char *k);
KeyVal *kv_new(char *k, char *v);
void kv_setval(KeyVal * kv, char *k, char *v);

/* Key file functions   */
char *kf_getvalue(void *kf, char *k);
void kf_load(void *kf, char *fn);
void *kf_new(char sep);
void kf_save(void *kf, char *fn);
void kf_setvalue(void *kf, char *k, char *v);
char *trim(char *s);

/* Implementation   */
KeyVal *kv_add(KeyVal * kv, char *k, char *v)
{
    /* If no kv passed, just allocate a new one */
    if (!kv)
        return kv_new(k, v);

    /* If the passed kv is not end of the list, pass on the request to it */
    if (kv->next)
        return kv_add(kv->next, k, v);

    /* Otherwise, add a new one to the passed KeyVal */
    kv->next = kv_new(k, v);
    return kv;
}

void kv_free(KeyVal * kv)
{
    if (!kv)
        return;

    if (kv->next)
        kv_free(kv->next);

    if (kv) {
        if (kv->key)
            free(kv->key);
        if (kv->val)
            free(kv->val);
        free(kv);
    }
}

char *kv_getval(KeyVal * kv, char *k)
{
    if (!kv)
        return NULL;

    if (strcmp(kv->key, k) == 0)
        return kv->val;
    else if (kv->next)
        return kv_getval(kv->next, k);

    return NULL;
}


KeyVal *kv_new(char *k, char *v)
{
    KeyVal *kv = malloc(sizeof(KeyVal));
    if (kv) {
        kv->key = k;
        kv->val = v;
        kv->next = NULL;
    }
    return kv;
}

void kv_setval(KeyVal * kv, char *k, char *v)
{
    if (!kv)
        return;

    if (strcmp(kv->key, k) == 0) {
        if (kv->val)
            free(kv->val);
        kv->val = strdup(v);
        return;
    }

    if (kv->next)
        kv_setval(kv->next, k, v);
    else                               /* end of list and hasnt been found */
        kv_add(kv, k, v);
}

void kv_write(KeyVal * kv, char sep, FILE * f)
{
    if (!kv)
        return;

    if (kv->key) {
        if (kv->val)
            fprintf(f, "%s%c%s\n", kv->key, sep, kv->val);
        else
            fprintf(f, "%s\n", kv->key);
    }
    else
        fprintf(f, "\n");

    if (kv->next)
        kv_write(kv->next, sep, f);
}

typedef struct _keyfile {
    int changed;                
    char separator;             
    KeyVal *keys;               
} KeyFile;

char *kf_getvalue(void *kf, char *k)
{
    KeyFile *kff = (KeyFile *) kf;
    if (!kff)
        return NULL;

    return kv_getval(kff->keys, k);
}

void kf_load(void *kf, char *fn)
{
    char *p;
    FILE *f;
    char *s;
    char buf[2048];
    KeyFile *kff = (KeyFile *) kf;
    if (!kff)
        return;

    f = fopen(fn, "r+");
    while (fgets(buf, sizeof(buf), f)) {
        p = strchr(buf, kff->separator);
        if (p) {
            *p = '\0';
            s = trim(buf);
            *p = kff->separator;
            p++;
            p = trim(p);
            kff->keys = kv_add(kff->keys, s, p);
            free(p);
            free(s);
        }
        else {                         /* separator not found */
            kff->keys = kv_add(kff->keys, buf, NULL);
        }
    }
    fclose(f);
    kff->changed = 0;
}

void *kf_new(char sep)
{
    KeyFile *kf = malloc(sizeof(KeyFile));
    if (kf) {
        kf->changed = 0;
        kf->separator = sep;
        kf->keys = NULL;
    }
    return kf;
}

void kf_save(void *kf, char *fn)
{
    FILE *f;
    KeyFile *kff = (KeyFile *) kf;
    if (!kff)
        return;

    f = fopen(fn, "w");
    kv_write(kff->keys, kff->separator, f);
    fclose(f);
    kff->changed = 0;
}

void kf_setvalue(void *kf, char *k, char *v)
{
    KeyFile *kff = (KeyFile *) kf;
    if (!kff)
        return;

    kv_setval(kff->keys, k, v);
}

char *trim(char *s)
{
    char *end;
    char *start = s;

    while (isspace(*start) && (*start != '\0')) {
        start++;
    }
    end = start;
    /* find end */
    while (*end != '\0')
        end++;

    /* now work back, dropping space chars */
    while ((isspace(*end)) && (end >= start))
        *end = '\0';

    return strdup(start);
}

---