ede/eworkpanel/EDE_Config.cpp

// EDE_Config.cpp: implementation of the EDE_Config class.
//
//////////////////////////////////////////////////////////////////////

/*#include "fl_internal.h"

#include <efltk/vsnprintf.h>
#include <efltk/Fl_String_List.h>
#include <efltk/Fl_Exception.h>
#include <efltk/Fl_Config.h>
#include <efltk/filename.h>
#include <efltk/fl_utf8.h>*/

#include "EDE_Config.h"
#include <fltk/filename.h>
#include "NLS.h"
#include <ctype.h>
#include <locale.h>

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>

#ifdef _WIN32_WCE
#include <stdlibx.h>
#endif
//#include <config.h>


#ifdef _WIN32

# include <io.h>
# include <direct.h>
# include <windows.h>
# define access(a,b) _access(a,b)
# define mkdir(a,b) _mkdir(a)
# define R_OK 4

#else

# include <unistd.h>

#endif /* _WIN32 */

// This is used for comment inside config files:
#define EDE_VERSION	2.0

#define LOCALE_TO_C() \
    char *locale = setlocale(LC_ALL, ""); \
    char *restore_locale = locale ? strdup(locale) : strdup("C"); \
    setlocale(LC_ALL, "C")

#define RESTORE_LOCALE() \
    setlocale(LC_ALL, restore_locale); \
    free(restore_locale)

// From Enumerations.h
#ifdef _WIN32
# undef slash
# define slash '\\'
#else
# undef slash
# define slash '/'
#endif
// End Enumerations.h

// From config.h
#define CONFIGDIR "/usr/share/ede"
// End config.h
    
static int is_path_rooted(const char *fn)
{
    /* see if an absolute name was given: */
#ifdef _WIN32
    if (fn[0] == '/' || fn[0] == '.' || fn[0] == '\\' || fn[1]==':')
#else
    if (fn[0] == '/' || fn[0] == '.')
#endif
        return 1;
    return 0;
}

// recursively create a path in the file system
static bool makePath( const char *path ) {
    if(access(path, 0)) {
        const char *s = strrchr( path, slash );
        if ( !s ) return 0;
        int len = s-path;
        char *p = (char*)malloc( len+1 );
        memcpy( p, path, len );
        p[len] = 0;
        makePath( p );
        free( p );
        return ( mkdir( path, 0777 ) == 0 );
    }
    return true;
}

// strip the filename and create a path
static bool makePathForFile( const char *path )
{
    const char *s = strrchr( path, slash );
    if ( !s ) return false;
    int len = s-path;
    char *p = (char*)malloc( len+1 );
    memcpy( p, path, len );
    p[len] = 0;
    bool ret=makePath( p );
    free( p );
    return ret;
}

char *get_sys_dir() {
#ifndef _WIN32
    return CONFIGDIR;
#else
    static char path[PATH_MAX];
    HKEY hKey;
    if(RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion", 0, KEY_READ, &hKey)==ERROR_SUCCESS)
    {
        DWORD size=4096;
        RegQueryValueExW(hKey, L"CommonFilesDir", NULL, NULL, (LPBYTE)path, &size);
        RegCloseKey(hKey);
        return path;
    }
    return "C:\\EDE\\";
#endif
}

char *get_homedir() {
   char *path = new char[PATH_MAX];
	const char *str1;

    str1=getenv("HOME");
    if (str1) {
         memcpy(path, str1, strlen(str1)+1);
         return path;
    }

    return 0;
}


char *EDE_Config::find_config_file(const char *filename, bool create, int mode)
{
    static char path[4096];

    if(is_path_rooted(filename)) {
        strncpy(path, filename, sizeof(path));
        return (create || !access(path, R_OK)) ? path : 0;
    }
    if(mode==USER) {
        char *cptr = get_homedir();
        char *ret=0;
        if(cptr) {
            snprintf(path, sizeof(path)-1, "%s%c%s%c%s", cptr, slash, ".ede", slash, filename);
            if(create || !access(path, R_OK)) {
                ret = path;
            }
            delete []cptr;
            return ret;
        }
		return 0;
    } else {
        snprintf(path, sizeof(path)-1, "%s%c%s", get_sys_dir(), slash, filename);
        return (create || !access(path, R_OK)) ? path : 0;
    }
}


// Vedran - a few string management functions...

// strdupcat() - it's cool to strcat with implied realloc
//  -- NOTE: due to use of realloc *always* use strdupcat return value:
//            dest = strdupcat(dest,src);
// and *never* use it like:
//            strdupcat(dest,src);
char *strdupcat(char *dest, const char *src)
{
	if (!dest) {
		dest=(char*)malloc(strlen(src));
	} else {
		dest=(char*)realloc (dest, strlen(dest)+strlen(src)+1);
	}
	strcat(dest,src);
	return dest;
}


// wstrim() - for trimming characters (used in parser)
// parts of former fl_trimleft and fl_trimright from Fl_Util.cpp
char* wstrim(char *string)
{
    char *start;

    if(string == NULL )
        return NULL;

    if (*string) {
        int len = strlen(string);
        if (len) {
            char *p = string + len;
            do {
                p--;
                if ( !isspace(*p) ) break;
            } while ( p != string );
            
            if ( !isspace(*p) ) p++;
            *p = 0;
        }
    }
    
    for(start = string; *start && isspace (*start); start++);
    memmove(string, start, strlen(start) + 1);

    return string;
}

// hmmmh?
//char* wstrim(const char *string)
//{
//    char *newstring = strdup(string);
//    return wstrim(newstring);
//}


// from_string() - adapted from Fl_String_List to use vector
std::vector<char*> from_string(const char *str, const char *separator)
{
    if(!str) return std::vector<char*> ();

    const char *ptr = str;
    const char *s = strstr(ptr, separator);
    std::vector<char*> retval;
    if(s) {
        unsigned separator_len = strlen(separator);
        do {
            unsigned len = s - ptr;
            if (len) {
                retval.push_back(strndup(ptr,len));
            } else {
                retval.push_back(NULL);
            }

            ptr = s + separator_len;
            s = strstr(ptr, separator);
        }
        while(s);

        if(*ptr) {
            retval.push_back(strdup(ptr));
        }
    } else {
	retval.push_back(strdup(ptr));
    }
    return retval;
}



//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

#define S(item) ((EDE_Config_Section*)item)

EDE_Config::EDE_Config(const char *vendor, const char *application, int mode)
: EDE_Config_Section("","",0)
{
    m_vendor=m_app=m_filename=NULL;
    m_cur_sec = 0;
    m_changed=false;
    m_error = 0;

    if(vendor) m_vendor = strdup(vendor);
    if(application) m_app = strdup(application);

    if(strlen(m_app) > 0) {
        const char *file=0;
        char tmp[PATH_MAX];
#ifdef _WIN32
        if(mode==SYSTEM)
            snprintf(tmp, sizeof(tmp)-1, "%s%c%s.conf", m_app, slash, m_app);
        else
#endif
            snprintf(tmp, sizeof(tmp)-1, "apps%c%s%c%s.conf", slash, m_app, slash, m_app);
        file = find_config_file(tmp, true, mode);
        if(file) {
            bool ret = makePathForFile(file);
            if(ret) {
	        m_filename = strdup(file);
                read_file(true);
            } else
                m_error = CONF_ERR_FILE;
        } else
            m_error = CONF_ERR_FILE;
    } else
        m_error = CONF_ERR_FILE;
}

EDE_Config::EDE_Config(const char *filename, bool read, bool create)
: EDE_Config_Section("","",0)
{
    m_vendor=m_app=m_filename=NULL;
    
    if(filename) m_filename = strdup(filename); else m_filename = strdup("");
// TODO: shouldn't we just return false if there's no filename??
// use case: creating a new file (nonexistant)
    
    m_error = 0;
    m_cur_sec = 0;
    m_changed=false;

    if(create && strlen(m_filename)>0) {
        makePathForFile(m_filename);
    }

    if(read) read_file(create);
}

EDE_Config::~EDE_Config()
{
    flush();
    clear();
    if(m_filename) free(m_filename);
    if(m_vendor) free(m_vendor);
    if(m_app) free(m_app);
}

/* get error string associated with error number */
const char *EDE_Config::strerror(int error)
{
    switch(error)
    {
    case CONF_SUCCESS:     return _("Successful completion");
    case CONF_ERR_FILE:    return _("Could not access config file");
    case CONF_ERR_SECTION: return _("Config file section not found");
    case CONF_ERR_KEY:     return _("Key not found in section");
    case CONF_ERR_MEMORY:  return _("Could not allocate memory");
    case CONF_ERR_NOVALUE: return _("Invalid value associated with key");
    default:               return _("Unknown error");
    }
}

bool EDE_Config::read_file(bool create)
{
    bool error = false;
    if(m_filename && strlen(m_filename)<1) {
        m_error = CONF_ERR_FILE;
        return false;
    }

    if(create && !(access(m_filename, F_OK)==0)) {
        FILE *f = fopen(m_filename, "w+");
        if(f) {
            fputs(" ", f);
            fclose(f);
        } else error=true;
    }

    if(error) {
        m_error = CONF_ERR_FILE;
        return false;
    }

    // If somebody calls this function two times, we
    // need to clean earlier section list...
    clear();

    /////
    struct stat fileStat;
    stat(m_filename, &fileStat);
    unsigned int size = fileStat.st_size;
    if(size == 0) {
        m_error = 0;
        return true;
    }

    FILE *fp = fopen(m_filename, "r");
    if(!fp) {
        //fprintf(stderr, "fp == 0: %s\n", m_filename);
        m_error = CONF_ERR_FILE;
        return false;
    }

    unsigned bsize = size*sizeof(char);
    char *buffer = (char*)malloc(bsize+1);
    buffer[bsize] = 0;
    if(!buffer) {
        m_error = CONF_ERR_MEMORY;
        return false;
    }

    unsigned int readed = fread(buffer, 1, size, fp);
    if(readed <= 0) {
        free((char*)buffer);
        fclose(fp);
        m_error = CONF_ERR_FILE;
        return false;
    }
    fclose(fp);

    /* old parser
    EDE_String_List strings(buffer, "\n");

    free((char*)buffer);

    EDE_Config_Section *section = this;
    for(unsigned n=0; n<strings.size(); n++)
    {
        EDE_String line;
        int comment_pos = strings[n].rpos('#');
        if(comment_pos>=0) {
            line = strings[n].sub_str(comment_pos, strings[n].length()-comment_pos).trim();
        } else {
            line = strings[n].trim();
        }

        if(line[0] == '[')
        {
            int pos = line.pos(']');
            if(pos>=0)
            {
                EDE_String sec(line.sub_str(1, pos-1));
                section = create_section(sec);
            }
        }
        else if(line[0] != '#')
        {
            int pos = line.pos('=');
            if(pos==-1) pos = line.pos(':');
            if(pos>=0) {
                EDE_String key(line.sub_str(0, pos));
                pos++;
                EDE_String value(line.sub_str(pos, line.length()-pos));
                section->add_entry(key, value);
            }
        }
    }
    */
    
    // new parser by Vedran
    // I like writing parsers
    // too bad others don't like me writing parsers...
    // TODO: i did some stupid things here for debugging, need to check
    
    int pos=0;
    bool comment, iskey, issection;
    char *key, *value, *sectionname;
    key=strdup(""); value=strdup(""); sectionname=strdup("");
    EDE_Config_Section *section = this;
    do {
    	int c=buffer[pos];
	if ((c == '\n') || (c == '\0')) {
		comment=false; iskey=true; issection=false;
		sectionname = wstrim(sectionname);
		key = wstrim(key);
		value = wstrim(value);
		if (strlen(sectionname) > 0)
			section = create_section(sectionname);
		if (strlen(key) > 0)
			section->add_entry(key,value);
		free(sectionname); free(key); free(value);
		key=strdup(""); value=strdup(""); sectionname=strdup("");
	}
	else if (c == '#')
		comment = true;
	else if (comment == false) {
		if (c == '[')
			issection = true;
		else if (c == ']')
			issection = false;
		else if ((c == '=') || (c == ':')) 
			iskey = false;
		else {
			if (issection)
				sectionname = strdupcat(sectionname, (const char*) &c);
			else if (iskey)
				key = strdupcat(key, (const char*) &c);
			else
				value = strdupcat(value,(const char*) &c);
		}
	}
	pos++;
    } while (buffer[pos] != '\0');
    
    free(key); free(value); free(sectionname);
    m_error = 0;
    m_changed=false;
    return true;
}

bool EDE_Config::flush()
{
    if(!m_changed) return true;
    if(strlen(m_filename) < 1) return false;

    FILE *file = fopen(m_filename, "w+");
//    if(!file)
//        fl_throw(::strerror(errno));

    LOCALE_TO_C();

    fprintf(file, "# EDE INI Version %f\n", EDE_VERSION);
    if(m_vendor && strlen(m_vendor)>0) fprintf(file, "# Vendor: %s\n", m_vendor);
    if(m_app && strlen(m_app)>0)    fprintf(file, "# Application: %s\n", m_app);

    // Flush sections
    write_section(0, file);

    RESTORE_LOCALE();

    fclose(file);

    m_error = 0;
    m_changed=false;
    return true;
}


EDE_Config_Section *EDE_Config::create_section(const char* name)
{
    if(strlen(name)<1) return 0;

    EDE_Config_Section *section = find_section(name, true);
    if(section) return section;

    char *lastptr = strrchr(name,'/'); // int pos = name.rpos('/')+1;
    int pos;
    if(lastptr) {
        pos = lastptr-name + 1;
    } else {
        section = new EDE_Config_Section(name, "", 0);
        sections().push_back(section);
        return section;
    }

    //char* sec_name(name.sub_str(pos, name.length()-pos));
    char *sec_name = strndup(name+pos, strlen(name)-pos);
    //char* sec_path(name.sub_str(0, pos));
    char *sec_path = strndup(name, pos);

    EDE_Config_Section *parent = find_section(sec_path, false);
    EDE_Config_Sections *list = &sections();

    if(!parent) {
	// Fl_String_List sections;
        std::vector<char*> sections = from_string(sec_path, "/");

        char* path = strdup("");
        for(unsigned n=0; n<sections.size(); n++) {
            if(parent) list = &parent->sections();

            parent = new EDE_Config_Section(sections.at(n), path, parent);
            list->push_back(parent);

            path = strdupcat (path, sections.at(n));
            path = strdupcat (path, (char *)'/');
	}
	free(path);
    }

    if(parent) list = &parent->sections();

    section = new EDE_Config_Section(sec_name, sec_path, parent);
    list->push_back(section);

    free(sec_name); free(sec_path);
    m_error = 0;
    return section;
}

EDE_Config_Section *EDE_Config::find_section(const char *path, bool perfect_match) const
{
    if(!path || !*path) return 0;

    std::vector<char*> sections = from_string(path, "/");

    if(sections.size()==0)
        return find(path, false);

    EDE_Config_Section *section = (EDE_Config_Section *)this;
    for(unsigned n=0; n<sections.size(); n++) {
        EDE_Config_Section *tmp = section->find(sections.at(n), false);
        if(!tmp) {
            if(perfect_match)
                return 0;
            else
                break;
        }
        section = tmp;
    }
    return section;
}

void EDE_Config::remove_key(const char *section, const char *key)
{
    if(key) {
        EDE_Config_Section *sect = find_section(section, true);
        if(sect->remove_entry(key)) {
            m_error = 0;
            m_changed = true;
            return;
        }
    }
    m_error = CONF_ERR_KEY;
}

// finding and removing stuff from deque
void sectremove(EDE_Config_Sections sects, EDE_Config_Section *sect) {
	for (unsigned int n=0; n<sects.size(); n++) {
		EDE_Config_Section *current = (EDE_Config_Section *)sects.at(n);
		if (current == sect)
			sects.erase(sects.begin()+n);
	}
	return;
}

void EDE_Config::remove_sec(const char *section)
{
    if(!section) return;

    EDE_Config_Section *sect;
    if((sect = find_section(section, true)) != 0) {
        if(sect->parent()) {
            sectremove(sect->parent()->sections(),sect);
        } else {
            sectremove(sections(),sect);
        }
        delete sect;
        m_error = 0;
        m_changed = true;
        return;
    }
    m_error = CONF_ERR_SECTION;
}

/*
 *  Read functions
 */

int EDE_Config::_read_string(EDE_Config_Section *s, const char *key, char *ret, const char *def_value, int size)
{
    if(!key || !s) {
        if(def_value) strncpy(ret, def_value, size);
        else ret[0] = '\0';
        m_error = (!key ? CONF_ERR_KEY : CONF_ERR_SECTION);
        return m_error;
    }
    
    char *val = s->find_entry(key);
    if(val) {
        int len = strlen(val); // convert from unsigned... and now:
        len = (len<size) ? len+1 : size;
        memcpy(ret, val, len);
        return (m_error = CONF_SUCCESS);
    }
    free(val);

    if(def_value) strncpy(ret, def_value, size);
    else ret[0] = '\0';

    m_error = CONF_ERR_KEY;
    return m_error;
}

int EDE_Config::_read_string(EDE_Config_Section *s, const char *key, char *&ret, const char *def_value)
{
    if(!key || !s) {
        ret = def_value?strdup(def_value):0;
        m_error = (!key ? CONF_ERR_KEY : CONF_ERR_SECTION);
        return m_error;
    }

    char *val = s->find_entry(key);
    if(val && strlen(val)>0)
    {
        ret = strdup(val);
        return (m_error = CONF_SUCCESS);
    }
    free(val);

    ret = def_value ? strdup(def_value) : 0;
    m_error = CONF_ERR_KEY;
    return m_error;
}

/*int EDE_Config::_read_string(EDE_Config_Section *s, const char *key, Fl_String &ret, const char *def_value)
{
    if(!key || !s) {
        ret = def_value;
        m_error = !key ? CONF_ERR_KEY : CONF_ERR_SECTION;
        return m_error;
    }

    Fl_String *val = s->find_entry(key);
    if(val) {
        ret = (*val);
        return (m_error = CONF_SUCCESS);
    }

    ret = def_value;
    return (m_error = CONF_ERR_KEY);
}*/

int EDE_Config::_read_long(EDE_Config_Section *s, const char *key, long &ret, long def_value)
{
    char* tmp;
    if(!_read_string(s, key, tmp, 0)) {
        ret = tmp[0] ? strtol(tmp, NULL, 10) : def_value;
    } else
        ret = def_value;
    return m_error;
}

int EDE_Config::_read_int(EDE_Config_Section *s, const char *key, int &ret, int def_value)
{
    char* tmp;
    if(!_read_string(s, key, tmp, 0)) {
        ret = atoi(tmp);
	if ((errno = ERANGE) || (ret == 0 && strcmp(tmp,"0") != 0)) ret = def_value;
    } else
        ret = def_value;
    return m_error;
}

int EDE_Config::_read_float (EDE_Config_Section *s, const char *key, float &ret, float def_value)
{
    char* tmp;
    if(!_read_string(s, key, tmp, 0)) {
        LOCALE_TO_C();
        ret = (float)strtod(tmp, 0);
        RESTORE_LOCALE();
    } else
        ret = def_value;
    return m_error;
}

int EDE_Config::_read_double(EDE_Config_Section *s, const char *key, double &ret, double def_value)
{
    char* tmp;
    if(!_read_string(s, key, tmp, 0)) {
        LOCALE_TO_C();
        ret = strtod(tmp, 0);
        RESTORE_LOCALE();
    } else
        ret = def_value;
    return m_error;
}

int EDE_Config::_read_bool(EDE_Config_Section *s, const char *key, bool &ret, bool def_value)
{
    char* tmp;
    if(_read_string(s, key, tmp, 0)) {
        ret = def_value;
        return m_error;
    }
    if ((strncasecmp(tmp,"true",4)) ||
        (strncasecmp(tmp,"yes",3)) ||
        (strncasecmp(tmp,"on",2)) ||
	(strcasecmp(tmp,"1"))) {
        ret = true;
    } else if((strncasecmp(tmp,"false",5)) ||
              (strncasecmp(tmp,"no",2)) ||
              (strncasecmp(tmp,"off",3)) ||
              (strcasecmp(tmp,"0"))) {
        ret = false;
    } else {
        m_error = CONF_ERR_NOVALUE;
        ret = def_value;
    }
    return m_error;
}

int EDE_Config::_read_color(EDE_Config_Section *s, const char *key, fltk::Color &ret, fltk::Color def_value)
{
    char* tmp;
    if(_read_string(s, key, tmp, 0)) {
        ret = def_value;
        return m_error;
    }

    int r=0,g=0,b=0;
    if(sscanf(tmp, "RGB(%d,%d,%d)", &r, &g, &b)!=3) {
        ret = def_value;
        return (m_error = CONF_ERR_NOVALUE);
    }
    ret = fltk::color(r,g,b);
    return m_error;
}

/*
 *  Write functions
 */

/*int EDE_Config::_write_string(EDE_Config_Section *s, const char *key, const char *value)
{
    char* val(value);
    return _write_string(s, key, val);
}*/

int EDE_Config::_write_string(EDE_Config_Section *s, const char *key, const char* value)
{
    if(!s) return (m_error = CONF_ERR_SECTION);
    if(!key) return (m_error = CONF_ERR_KEY);

/*  This logic is now in add_entry, cause we can't pass around pointers into structure

    char *val = s->find_entry(key);
    if(val) {
        strncpy(val, value, strlen(value));
    } else */
    if (value) s->add_entry(key, value); else s->add_entry(key, "");

    m_changed=true;
    return (m_error=CONF_SUCCESS);
}

int EDE_Config::_write_long(EDE_Config_Section *s, const char *key, const long value)
{
    char tmp[128]; snprintf(tmp, sizeof(tmp)-1, "%ld", value);
    return _write_string(s, key, tmp);
}

int EDE_Config::_write_int(EDE_Config_Section *s, const char *key, const int value)
{
    char tmp[128]; snprintf(tmp, sizeof(tmp)-1, "%d", value);
    return _write_string(s, key, tmp);
}

int EDE_Config::_write_float(EDE_Config_Section *s, const char *key, const float value)
{
    LOCALE_TO_C();
    char tmp[32]; snprintf(tmp, sizeof(tmp)-1, "%g", value);
    RESTORE_LOCALE();
    return _write_string(s, key, tmp);
}

int EDE_Config::_write_double(EDE_Config_Section *s, const char *key, const double value)
{
    LOCALE_TO_C();
    char tmp[32]; snprintf(tmp, sizeof(tmp)-1, "%g", value);
    RESTORE_LOCALE();
    return _write_string(s, key, tmp);
}

int EDE_Config::_write_bool(EDE_Config_Section *s, const char *key, const bool value)
{
    if(value) return _write_string(s, key, "1");
    return _write_string(s, key, "0");
}

int EDE_Config::_write_color(EDE_Config_Section *s, const char *key, const fltk::Color value)
{
    unsigned char r,g,b;
    fltk::split_color(value, r,g,b);
    char tmp[32];
    snprintf(tmp, sizeof(tmp)-1, "RGB(%d,%d,%d)", r,g,b);
    return _write_string(s, key, tmp);
}

//////////////////////////////////////
//////////////////////////////////////
//////////////////////////////////////

EDE_Config_Section::EDE_Config_Section(const char* name, const char* path, EDE_Config_Section *par)
: m_parent(par)
{
	m_name=strdup(name);
	m_path=strdup(path);
}

EDE_Config_Section::~EDE_Config_Section()
{
    free(m_name);
    free(m_path);
    clear();
}

void EDE_Config_Section::clear()
{
    for(unsigned n=0; n<sections().size(); n++) {
        EDE_Config_Section *s = (EDE_Config_Section *)sections()[n];
        delete s;
    }
    m_lines.clear();
    m_sections.clear();
}

void EDE_Config_Section::write_section(int indent, FILE *fp) const
{
    for(int a=0; a<indent; a++) fprintf(fp, " ");

    if(strlen(name())>0)
        fprintf(fp, "[%s%s]\n", path(), name());

    for(unsigned n=0; n<m_lines.size(); n++) {
        if(strlen(m_lines.at(n)) > 0) {
            for(int a=0; a<indent; a++) fprintf(fp, " ");
//            fprintf(fp, "  %s=%s\n", it.id().c_str(), it.value().c_str());
            fprintf(fp, "  %s\n", m_lines.at(n));
        }
    }

    fprintf(fp, "\n");

    for(unsigned n=0; n<sections().size(); n++) {
        EDE_Config_Section *child = S(sections()[n]);
        child->write_section(indent+2, fp);
    }
}

void EDE_Config_Section::add_entry(const char* key, const char* value)
{
    int keylen = strlen(key);
    if(!key || keylen<1) return;
    if(!value) return;
    
    char *tmp = strdup(key);
    char *tmp2 = strdup(value);
    tmp = wstrim(tmp);
    tmp2 = wstrim(tmp2);
    tmp = strdupcat(tmp, "=");
    tmp = strdupcat(tmp, tmp2);
    free(tmp2);

    // if key already exists, delete
    bool found = false;
    for (unsigned i=0; i<lines().size(); i++) {
        if (!found && strncmp(lines().at(i), tmp, keylen) == 0) {
            lines().erase(lines().begin()+i);
	    found = true;
	}
    }
    
    lines().push_back(tmp);
}

bool EDE_Config_Section::remove_entry(const char* key)
{
    bool found=false;
    char *tmp = strdup(key);
    tmp = strdupcat (tmp, "=");

    for (unsigned i=0; i<lines().size(); i++) {
	if (strncmp(lines().at(i), tmp, strlen(tmp)) == 0) {
		lines().erase(lines().begin()+i);
		found=true;
        }
    }
    free(tmp);
    return found;
}

char* EDE_Config_Section::find_entry(const char *key) const
{
    bool found=false;
    char *ret;
    char *search = strdup(key);
    search = strdupcat(search, "=");

    for (unsigned i=0; i<lines().size(); i++) {
        if (!found && strncmp(lines().at(i), search, strlen(search)) == 0) {
	    ret = strdup(lines().at(i)+strlen(search));
            found = true;
	}
    }

    free(search);	// this sometimes fails, dunno why....
    if (found) { return ret; } else { return 0; }
}

EDE_Config_Section *EDE_Config_Section::find(const char *name, bool recursive) const
{
    const EDE_Config_Sections *list = &sections();
    

    for(uint n=0; n<list->size(); n++) {
        EDE_Config_Section *s = (EDE_Config_Section*) list->at(n);
        if(strcmp(s->name(), name) == 0) {
            return s;
        }
        if(recursive) {
            s = s->find(name, recursive);
            if(s) return s;
        }
    }
    return 0;
}