trunk/Src/wptGPGParser.cpp

/* wptGPGParser.cpp - Config file parser
 *      Copyright (C) 2002, 2003, 2004, 2006 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT 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.
 *  
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License 
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <string.h>
#include <windows.h>

#include "wptTypes.h"
#include "wptW32API.h"
#include "wptGPG.h"
#include "wptErrors.h"


/* Add the option @n to the linked list @list. */
static void
add_option (conf_option_t *list, conf_option_t n)
{
    conf_option_t t;

    if (!*list)
        *list = n;
    else {
        for (t = *list; t->next; t = t->next)
            ;
        t->next = n;
    }
}

/* Allocate a new option and return it. */
static conf_option_t
new_option (void)
{
    conf_option_t e;

    e = new conf_option_s;
    if (!e)
        BUG (0);
    memset (e, 0, sizeof *e);
    return e;
}


static void
add_opaque_option (config_file_t opt, const char *line, int used)
{
    conf_option_t e;

    e = new_option ();
    e->used = used > 0? 1 : 0;
    e->name = m_strdup (line);
    e->type = ENTRY_OPAQUE;
    add_option (&opt->list, e);
}


static void
add_single_option (config_file_t opt, const char *name, int used)
{
    conf_option_t e;

    e = new_option ();
    e->used = used > 0? 1 : 0;
    e->name = m_strdup (name);
    e->type = ENTRY_SINGLE;
    add_option (&opt->list, e);
}


static int
add_group_option (config_file_t opt, const char *name, int used)
{
    conf_option_t e;

    e = new_option ();
    e->used = used > 0? 1 : 0;
    e->name = m_strdup (name);
    e->type = ENTRY_GROUP;
    add_option (&opt->list, e);
    return 0;
}


static size_t
count_whitespaces (char *line)
{
    size_t i;
    size_t ncount = 0;

    if (!strchr (line, ' '))
        return 0;
    for( i = 0; i < strlen (line); i++) {
        if (line[i] == ' ')
            ncount++;
    }
    return ncount;
}


static int
add_multi_option (config_file_t opt, char *line, int used)
{
    conf_option_t e;
    char *p;
    int state = 0;

    e = new_option ();
    if (count_whitespaces (line) == 1) {
        while ((p = strsep (&line, " ")) && state != 2) {
            switch (state) {
            case 0: e->name = m_strdup (p); break;
            case 1: e->val = m_strdup (p);  break;
            }
            state++;
        }
    }
    else {
        p = strchr (line, ' ');
        if (!p)
            return -1;
        state = p - line;
        e->name = new char[state + 1];
        if (!e->name)
            BUG (NULL);
        memcpy (e->name, line, state);
        e->name[state] = '\0';
        strncpy (e->name, line, state);
        e->val = m_strdup (line + state + 1);
    }
    e->used = used;
    e->type = ENTRY_MULTI;
    add_option (&opt->list, e);

    return 0;
}


static conf_group_t
new_group (conf_group_t *grp, const char *name)
{
    conf_group_t g, t;

    g = new conf_group_s;    
    if (!g)
        BUG (NULL);
    memset (g, 0, sizeof *g);
    g->used = 1;
    g->name = m_strdup (name);
    if (!*grp)
        *grp = g;
    else {
        for (t = *grp; t->next; t = t->next)
            ;
        t->next = g;
    }
    return g;
}


static const char*
group_from_cfgfile (config_file_t opt, const char *line)
{
    char *p, *buf, *buf2, *name = NULL;
    conf_group_t g;
    conf_member_t m = NULL, t;

    p = strchr (line, '=');
    if (!p || strncmp (line, "group ", 6))
        return NULL;
    buf = m_strdup (line + (p - line + 1));
    line += 6;
    p = strchr (line, '=');
    if (p) {
        size_t pos = p - line;
        name = new char[pos + 1];
        if (!name)
            BUG( NULL );
        memset (name, 0, pos+1);
        strncpy (name, line, pos);
    }
    g = new_group (&opt->grp, name);
    buf2 = buf;
    while ((p = strsep (&buf2, " ")) && *p) {
        m = new conf_member_s;
        if (!m)
            BUG (0);
        memset (m, 0, sizeof *m);
        m->used = 1;
        m->name = m_strdup (p);
        if (!g->list)
            g->list = m;
        else {
            for (t=g->list; t->next; t = t->next)
                ;
            t->next = m;
        }
    }
    free_if_alloc (buf);
    if (!m)
        return NULL;
    return g->name;
}


void
conf_release_group (conf_group_t grp)
{
    conf_member_t m, m2;
    
    m = grp->list;
    while (m) {
        m2 = m->next;
        free_if_alloc (m->name);
        free_if_alloc (m);
        m = m2;
    }
}


static void
release_option (conf_option_t opt)
{
    if (!opt)
        return;
    free_if_alloc (opt->name);
    free_if_alloc (opt->val);
    free_if_alloc (opt);
}


void
release_config (config_file_t opt)
{
    conf_option_t e, e2;
    conf_group_t g, g2;

    if (!opt)
        return;
    e = opt->list;
    while (e) {
        e2 = e->next;
        release_option (e);
        e = e2;
    }
    g = opt->grp;
    while (g) {
        g2 = g->next;
        conf_release_group (g);
        g = g2;
    }
    free_if_alloc (opt);
}


int
commit_config (const char *file, config_file_t opt)
{
    FILE *inp;
    conf_option_t e;
    conf_group_t g;
    conf_member_t m;

    inp = fopen (file, "w+b");
    if (!inp)
        return WPTERR_FILE_OPEN;
    for (e = opt->list; e; e = e->next) {
        if (!e->used)
            continue;
        switch (e->type) {
        case ENTRY_OPAQUE:
            fprintf (inp, "%s", e->name);
            break;
            
        case ENTRY_MULTI:
            fprintf (inp, "%s %s\r\n", e->name, e->val);
            break;

        case ENTRY_SINGLE:
            fprintf (inp, "%s\r\n", e->name);
            break;

        case ENTRY_GROUP:
            g = conf_find_group (opt, e->name);
            if (g && g->used) {
                fprintf (inp, "group %s=", g->name);
                for (m = g->list; m; m = m->next) {
                    if (m->used)
                        fprintf (inp, "%s ", m->name);
                }
                fprintf (inp, "\r\n");
            }
            break;
        }
    }
    fclose (inp);
    return 0;
}


void 
new_config (config_file_t *r_opt)
{
    config_file_t opt;

    opt = new conf_file_s;
    if (!opt)
        BUG (NULL);
    memset (opt, 0, sizeof *opt);
    *r_opt = opt;
}


int
parse_config (const char *file, config_file_t *r_opt)
{
    FILE *inp;
    char buf[1024], *p;
    config_file_t opt = NULL;

    if (!r_opt)
        return -1;

    inp = fopen( file, "rb");
    if (!inp) {
        inp = fopen (file, "wb");
        if (inp == NULL)
            return -1;
    }
    opt = new conf_file_s;
    if (!opt)
        BUG (NULL);
    memset (opt, 0, sizeof *opt);
    while (!feof (inp))  {
        p = fgets (buf, DIM (buf) -1, inp);
        if (!p)
            break;
        if (*p == '#' || *p == '\r' || *p == '\n' || *p == '\t') {
            add_opaque_option (opt, p, 1);
            continue;
        }
        if( strstr (p, "\r\n" ))
            p[strlen (p) - 2] = '\0';
        else if (strstr (p, "\n"))
            p[strlen (p) - 1] = '\0';
        if (!strchr( p, ' ' ))
            add_single_option (opt, p, 1);
        else if (!strncmp (p, "group", 5)) {
            const char *s = group_from_cfgfile (opt, p);
            if (s)
                add_group_option (opt, s, 1);
        }
        else
            add_multi_option (opt, p, 1);
    }
    fclose (inp);
    *r_opt = opt;
    return 0;
}


/* Search for an option with the name @str and
   return this option if it exists.
   Return value: NULL if not found. */
conf_option_t
conf_find_option (config_file_t opt, const char *str)
{
    conf_option_t e;

    for (e = opt->list; e; e = e->next) {
        if (e->type == ENTRY_OPAQUE)
            continue;
        if (!stricmp (e->name, str))
            break;
    }

    return e;
}


conf_group_t
conf_find_group (config_file_t opt, const char *str)
{
    conf_group_t g;

    for (g = opt->grp; g; g = g->next) {
        if (!stricmp( g->name, str))
            break;
    }

    return g;
}


conf_member_t
conf_find_member (config_file_t opt, const char *grp, const char *str)
{
    conf_member_t m;
    conf_group_t g = conf_find_group (opt, grp);

    if (!g)
        return NULL;
        
    for (m = g->list; m; m = m->next) {
        if (!stricmp (m->name, str))
            return m;
    }
    return NULL;
}


int
conf_delete_group (config_file_t opt, const char *str)
{
    conf_group_t g = conf_find_group (opt, str);

    if (g)
        g->used = 0;
    return g? 0 : -1;
}


int
conf_delete_member (config_file_t opt, const char *grp, const char *str)
{
    conf_member_t m = conf_find_member (opt, grp, str);

    if (m)
        m->used = 0;
    return m? 0 : -1;
}

    
int
conf_delete_option (config_file_t opt, const char * str)
{
    conf_option_t e = conf_find_option (opt, str);

    if (e)
        e->used = 0;
    return e? 0 : -1;
}


int
conf_add_entry_int (config_file_t opt, int type, const char *name, int val)
{
    char buf[64];

    _snprintf (buf, DIM (buf)-1, "%d", val);
    conf_add_entry (opt, type, name, buf);
    return 0;
}

int
conf_add_entry (config_file_t opt, int type, const char *name, const char *val)
{
    conf_option_t e;

    e = new_option ();
    e->used = 1;
    e->type = type;
    e->name = m_strdup (name);
    e->val = val? m_strdup (val) : NULL;
    add_option (&opt->list, e);
    return 0;
}


/* Modify the value of the entry with the name @name.
   If the entry were not found, add it to the option list. */
int
conf_modify_entry (config_file_t opt, int type, const char *name, const char *val)
{
    conf_option_t e;
    int rc = 0;

    e = conf_find_option (opt, name);
    if (!e)
        rc = conf_add_entry (opt, type, name, val);
    else if (type != ENTRY_SINGLE && val != NULL) {
        free_if_alloc (e->val);
        e->val = m_strdup (val);
        rc = 0;
    }

    return rc;
}

    
int
conf_add_member (config_file_t opt, const char *grp, const char *str)
{
    conf_group_t g = conf_find_group (opt, grp);
    conf_member_t m, t;

    if (!g)
        return -1;
    
    m = new conf_member_s;    
    if (!m)    
        BUG (NULL);
    memset (m, 0, sizeof *m);
    m->used = 1;
    m->name = m_strdup (str);
    if( !g->list )
        g->list = m;
    else {
        for( t = g->list; t->next; t = t->next )
            ;
        t->next = m;    
    }   
    return 0;
}


int
conf_add_group (config_file_t opt, const char *str)
{
    conf_group_t g, t;

    g = new conf_group_s;
    if (!g)
        BUG (NULL);
    memset (g, 0, sizeof *g);
    g->used = 1;
    g->name = m_strdup (str);
    
    if (!opt->grp)
        opt->grp = g;
    else {
        for (t = opt->grp; t->next; t = t->next)
            ;
        t->next = g;
    }
    conf_add_entry (opt, ENTRY_GROUP, str, NULL);
    return 0;
}
1	twoaday	270	/* wptGPGParser.cpp - Config file parser
2	twoaday	211	* Copyright (C) 2002, 2003, 2004, 2006 Timo Schulz
3	werner	36	*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU General Public License
8			* as published by the Free Software Foundation; either version 2
9			* of the License, or (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with WinPT; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#ifdef HAVE_CONFIG_H
22			#include <config.h>
23			#endif
24
25	twoaday	2	#include <stdio.h>
26	werner	36	#include <string.h>
27			#include <windows.h>
28
29			#include "wptTypes.h"
30	twoaday	2	#include "wptW32API.h"
31	werner	36	#include "wptGPG.h"
32			#include "wptErrors.h"
33	twoaday	2
34	twoaday	271
35			/* Add the option @n to the linked list @list. */
36	werner	36	static void
37	twoaday	271	add_option (conf_option_t *list, conf_option_t n)
38	werner	36	{
39	twoaday	271	conf_option_t t;
40	werner	36
41	twoaday	211	if (!*list)
42			*list = n;
43			else {
44			for (t = *list; t->next; t = t->next)
45			;
46			t->next = n;
47			}
48			}
49
50	twoaday	271	/* Allocate a new option and return it. */
51			static conf_option_t
52	twoaday	211	new_option (void)
53			{
54	twoaday	271	conf_option_t e;
55	twoaday	211
56	twoaday	271	e = new conf_option_s;
57	werner	36	if (!e)
58	twoaday	211	BUG (0);
59	twoaday	212	memset (e, 0, sizeof *e);
60	twoaday	211	return e;
61			}
62
63
64			static void
65	twoaday	270	add_opaque_option (config_file_t opt, const char *line, int used)
66	twoaday	211	{
67	twoaday	271	conf_option_t e;
68	twoaday	211
69			e = new_option ();
70	werner	36	e->used = used > 0? 1 : 0;
71			e->name = m_strdup (line);
72			e->type = ENTRY_OPAQUE;
73	twoaday	211	add_option (&opt->list, e);
74			}
75	werner	36
76
77			static void
78	twoaday	270	add_single_option (config_file_t opt, const char *name, int used)
79	werner	36	{
80	twoaday	271	conf_option_t e;
81	werner	36
82	twoaday	211	e = new_option ();
83	werner	36	e->used = used > 0? 1 : 0;
84			e->name = m_strdup (name);
85			e->type = ENTRY_SINGLE;
86	twoaday	211	add_option (&opt->list, e);
87			}
88	werner	36
89
90			static int
91	twoaday	270	add_group_option (config_file_t opt, const char *name, int used)
92	werner	36	{
93	twoaday	271	conf_option_t e;
94	werner	36
95	twoaday	211	e = new_option ();
96	werner	36	e->used = used > 0? 1 : 0;
97	twoaday	211	e->name = m_strdup (name);
98			e->type = ENTRY_GROUP;
99			add_option (&opt->list, e);
100	werner	36	return 0;
101	twoaday	211	}
102	werner	36
103
104			static size_t
105	twoaday	211	count_whitespaces (char *line)
106	werner	36	{
107	twoaday	211	size_t i;
108			size_t ncount = 0;
109	werner	36
110	twoaday	211	if (!strchr (line, ' '))
111	werner	36	return 0;
112	twoaday	211	for( i = 0; i < strlen (line); i++) {
113			if (line[i] == ' ')
114	werner	36	ncount++;
115			}
116			return ncount;
117	twoaday	211	}
118	werner	36
119
120			static int
121	twoaday	270	add_multi_option (config_file_t opt, char *line, int used)
122	werner	36	{
123	twoaday	271	conf_option_t e;
124	werner	36	char *p;
125			int state = 0;
126
127	twoaday	211	e = new_option ();
128			if (count_whitespaces (line) == 1) {
129			while ((p = strsep (&line, " ")) && state != 2) {
130			switch (state) {
131			case 0: e->name = m_strdup (p); break;
132			case 1: e->val = m_strdup (p); break;
133	werner	36	}
134			state++;
135			}
136			}
137			else {
138	twoaday	211	p = strchr (line, ' ');
139			if (!p)
140			return -1;
141	werner	36	state = p - line;
142			e->name = new char[state + 1];
143	twoaday	211	if (!e->name)
144			BUG (NULL);
145			memcpy (e->name, line, state);
146	werner	36	e->name[state] = '\0';
147	twoaday	211	strncpy (e->name, line, state);
148			e->val = m_strdup (line + state + 1);
149	werner	36	}
150			e->used = used;
151			e->type = ENTRY_MULTI;
152	twoaday	211	add_option (&opt->list, e);
153
154	werner	36	return 0;
155	twoaday	211	}
156	werner	36
157
158	twoaday	271	static conf_group_t
159			new_group (conf_group_t grp, const char name)
160	werner	36	{
161	twoaday	271	conf_group_t g, t;
162	werner	36
163	twoaday	271	g = new conf_group_s;
164	twoaday	211	if (!g)
165			BUG (NULL);
166			memset (g, 0, sizeof *g);
167	werner	36	g->used = 1;
168	twoaday	211	g->name = m_strdup (name);
169			if (!*grp)
170	werner	36	*grp = g;
171			else {
172	twoaday	211	for (t = *grp; t->next; t = t->next)
173	werner	36	;
174			t->next = g;
175			}
176			return g;
177	twoaday	211	}
178	werner	36
179
180			static const char*
181	twoaday	270	group_from_cfgfile (config_file_t opt, const char *line)
182	werner	36	{
183			char p, buf, buf2, name = NULL;
184	twoaday	271	conf_group_t g;
185			conf_member_t m = NULL, t;
186	werner	36
187	twoaday	211	p = strchr (line, '=');
188			if (!p \|\| strncmp (line, "group ", 6))
189	werner	36	return NULL;
190	twoaday	211	buf = m_strdup (line + (p - line + 1));
191	werner	36	line += 6;
192	twoaday	211	p = strchr (line, '=');
193			if (p) {
194	werner	36	size_t pos = p - line;
195			name = new char[pos + 1];
196	twoaday	211	if (!name)
197	werner	36	BUG( NULL );
198	twoaday	211	memset (name, 0, pos+1);
199			strncpy (name, line, pos);
200	werner	36	}
201	twoaday	211	g = new_group (&opt->grp, name);
202	werner	36	buf2 = buf;
203	twoaday	211	while ((p = strsep (&buf2, " ")) && *p) {
204	twoaday	271	m = new conf_member_s;
205	twoaday	211	if (!m)
206			BUG (0);
207			memset (m, 0, sizeof *m);
208	werner	36	m->used = 1;
209	twoaday	211	m->name = m_strdup (p);
210			if (!g->list)
211	werner	36	g->list = m;
212			else {
213	twoaday	211	for (t=g->list; t->next; t = t->next)
214	werner	36	;
215			t->next = m;
216			}
217			}
218	twoaday	211	free_if_alloc (buf);
219			if (!m)
220	werner	36	return NULL;
221			return g->name;
222	twoaday	211	}
223	werner	36
224	twoaday	211
225	werner	36	void
226	twoaday	271	conf_release_group (conf_group_t grp)
227	werner	36	{
228	twoaday	271	conf_member_t m, m2;
229	werner	36
230			m = grp->list;
231	twoaday	211	while (m) {
232	werner	36	m2 = m->next;
233	twoaday	211	free_if_alloc (m->name);
234			free_if_alloc (m);
235	werner	36	m = m2;
236			}
237	twoaday	211	}
238	werner	36
239
240	twoaday	271	static void
241			release_option (conf_option_t opt)
242	werner	36	{
243			if (!opt)
244			return;
245	twoaday	211	free_if_alloc (opt->name);
246			free_if_alloc (opt->val);
247	twoaday	212	free_if_alloc (opt);
248	werner	36	}
249
250
251			void
252	twoaday	270	release_config (config_file_t opt)
253	werner	36	{
254	twoaday	271	conf_option_t e, e2;
255			conf_group_t g, g2;
256	werner	36
257	twoaday	270	if (!opt)
258			return;
259	werner	36	e = opt->list;
260	twoaday	211	while (e) {
261	werner	36	e2 = e->next;
262			release_option (e);
263			e = e2;
264			}
265			g = opt->grp;
266	twoaday	211	while (g) {
267	werner	36	g2 = g->next;
268	twoaday	271	conf_release_group (g);
269	werner	36	g = g2;
270			}
271	twoaday	211	free_if_alloc (opt);
272			}
273	werner	36
274
275			int
276	twoaday	270	commit_config (const char *file, config_file_t opt)
277	werner	36	{
278			FILE *inp;
279	twoaday	271	conf_option_t e;
280			conf_group_t g;
281			conf_member_t m;
282	werner	36
283			inp = fopen (file, "w+b");
284	twoaday	211	if (!inp)
285			return WPTERR_FILE_OPEN;
286			for (e = opt->list; e; e = e->next) {
287			if (!e->used)
288	werner	36	continue;
289	twoaday	211	switch (e->type) {
290	werner	36	case ENTRY_OPAQUE:
291	twoaday	211	fprintf (inp, "%s", e->name);
292	werner	36	break;
293
294			case ENTRY_MULTI:
295	twoaday	211	fprintf (inp, "%s %s\r\n", e->name, e->val);
296	werner	36	break;
297
298			case ENTRY_SINGLE:
299	twoaday	211	fprintf (inp, "%s\r\n", e->name);
300	werner	36	break;
301
302			case ENTRY_GROUP:
303	twoaday	271	g = conf_find_group (opt, e->name);
304	twoaday	211	if (g && g->used) {
305			fprintf (inp, "group %s=", g->name);
306			for (m = g->list; m; m = m->next) {
307			if (m->used)
308			fprintf (inp, "%s ", m->name);
309	werner	36	}
310	twoaday	211	fprintf (inp, "\r\n");
311	werner	36	}
312			break;
313			}
314			}
315			fclose (inp);
316			return 0;
317	twoaday	211	}
318	werner	36
319
320	twoaday	270	void
321			new_config (config_file_t *r_opt)
322			{
323			config_file_t opt;
324
325	twoaday	271	opt = new conf_file_s;
326	twoaday	270	if (!opt)
327			BUG (NULL);
328			memset (opt, 0, sizeof *opt);
329			*r_opt = opt;
330			}
331
332
333	werner	36	int
334	twoaday	270	parse_config (const char file, config_file_t r_opt)
335	werner	36	{
336			FILE *inp;
337			char buf[1024], *p;
338	twoaday	270	config_file_t opt = NULL;
339	werner	36
340	twoaday	270	if (!r_opt)
341			return -1;
342
343	twoaday	211	inp = fopen( file, "rb");
344	twoaday	270	if (!inp) {
345			inp = fopen (file, "wb");
346			if (inp == NULL)
347	werner	36	return -1;
348			}
349	twoaday	271	opt = new conf_file_s;
350	twoaday	270	if (!opt)
351			BUG (NULL);
352			memset (opt, 0, sizeof *opt);
353			while (!feof (inp)) {
354	twoaday	271	p = fgets (buf, DIM (buf) -1, inp);
355	twoaday	270	if (!p)
356	werner	36	break;
357	twoaday	270	if (p == '#' \|\| p == '\r' \|\| p == '\n' \|\| p == '\t') {
358			add_opaque_option (opt, p, 1);
359	werner	36	continue;
360			}
361	twoaday	270	if( strstr (p, "\r\n" ))
362			p[strlen (p) - 2] = '\0';
363			else if (strstr (p, "\n"))
364			p[strlen (p) - 1] = '\0';
365			if (!strchr( p, ' ' ))
366			add_single_option (opt, p, 1);
367			else if (!strncmp (p, "group", 5)) {
368	twoaday	211	const char *s = group_from_cfgfile (opt, p);
369			if (s)
370			add_group_option (opt, s, 1);
371	werner	36	}
372			else
373	twoaday	211	add_multi_option (opt, p, 1);
374	werner	36	}
375	twoaday	211	fclose (inp);
376	twoaday	270	*r_opt = opt;
377	werner	36	return 0;
378	twoaday	211	}
379	werner	36
380
381	twoaday	271	/* Search for an option with the name @str and
382			return this option if it exists.
383			Return value: NULL if not found. */
384			conf_option_t
385			conf_find_option (config_file_t opt, const char *str)
386	werner	36	{
387	twoaday	271	conf_option_t e;
388	werner	36
389			for (e = opt->list; e; e = e->next) {
390			if (e->type == ENTRY_OPAQUE)
391			continue;
392			if (!stricmp (e->name, str))
393			break;
394			}
395
396			return e;
397	twoaday	211	}
398	werner	36
399
400	twoaday	271	conf_group_t
401			conf_find_group (config_file_t opt, const char *str)
402	werner	36	{
403	twoaday	271	conf_group_t g;
404	werner	36
405	twoaday	211	for (g = opt->grp; g; g = g->next) {
406			if (!stricmp( g->name, str))
407	werner	36	break;
408			}
409
410			return g;
411	twoaday	211	}
412	werner	36
413
414	twoaday	271	conf_member_t
415			conf_find_member (config_file_t opt, const char grp, const char str)
416	werner	36	{
417	twoaday	271	conf_member_t m;
418			conf_group_t g = conf_find_group (opt, grp);
419	twoaday	211
420			if (!g)
421			return NULL;
422
423			for (m = g->list; m; m = m->next) {
424			if (!stricmp (m->name, str))
425			return m;
426	werner	36	}
427	twoaday	211	return NULL;
428			}
429	werner	36
430
431			int
432	twoaday	271	conf_delete_group (config_file_t opt, const char *str)
433	werner	36	{
434	twoaday	271	conf_group_t g = conf_find_group (opt, str);
435	twoaday	211
436			if (g)
437	werner	36	g->used = 0;
438	twoaday	211	return g? 0 : -1;
439			}
440	werner	36
441
442			int
443	twoaday	271	conf_delete_member (config_file_t opt, const char grp, const char str)
444	werner	36	{
445	twoaday	271	conf_member_t m = conf_find_member (opt, grp, str);
446	werner	36
447	twoaday	211	if (m)
448			m->used = 0;
449			return m? 0 : -1;
450			}
451	werner	36
452
453			int
454	twoaday	271	conf_delete_option (config_file_t opt, const char * str)
455	werner	36	{
456	twoaday	271	conf_option_t e = conf_find_option (opt, str);
457	twoaday	211
458			if (e)
459	werner	36	e->used = 0;
460	twoaday	211	return e? 0 : -1;
461			}
462	werner	36
463
464			int
465	twoaday	271	conf_add_entry_int (config_file_t opt, int type, const char *name, int val)
466	werner	36	{
467	twoaday	270	char buf[64];
468
469			_snprintf (buf, DIM (buf)-1, "%d", val);
470	twoaday	271	conf_add_entry (opt, type, name, buf);
471	twoaday	270	return 0;
472			}
473
474			int
475	twoaday	271	conf_add_entry (config_file_t opt, int type, const char name, const char val)
476	twoaday	270	{
477	twoaday	271	conf_option_t e;
478	werner	36
479	twoaday	211	e = new_option ();
480	werner	36	e->used = 1;
481			e->type = type;
482	twoaday	211	e->name = m_strdup (name);
483			e->val = val? m_strdup (val) : NULL;
484			add_option (&opt->list, e);
485	werner	36	return 0;
486	twoaday	211	}
487	werner	36
488
489	twoaday	271	/* Modify the value of the entry with the name @name.
490			If the entry were not found, add it to the option list. */
491	werner	36	int
492	twoaday	271	conf_modify_entry (config_file_t opt, int type, const char name, const char val)
493	werner	36	{
494	twoaday	271	conf_option_t e;
495	werner	36	int rc = 0;
496
497	twoaday	271	e = conf_find_option (opt, name);
498	twoaday	211	if (!e)
499	twoaday	271	rc = conf_add_entry (opt, type, name, val);
500			else if (type != ENTRY_SINGLE && val != NULL) {
501	twoaday	211	free_if_alloc (e->val);
502			e->val = m_strdup (val);
503	twoaday	270	rc = 0;
504	werner	36	}
505
506			return rc;
507	twoaday	211	}
508	werner	36
509
510			int
511	twoaday	271	conf_add_member (config_file_t opt, const char grp, const char str)
512	werner	36	{
513	twoaday	271	conf_group_t g = conf_find_group (opt, grp);
514			conf_member_t m, t;
515	werner	36
516	twoaday	211	if (!g)
517			return -1;
518
519	twoaday	271	m = new conf_member_s;
520	twoaday	211	if (!m)
521			BUG (NULL);
522			memset (m, 0, sizeof *m);
523			m->used = 1;
524			m->name = m_strdup (str);
525			if( !g->list )
526			g->list = m;
527			else {
528			for( t = g->list; t->next; t = t->next )
529			;
530			t->next = m;
531			}
532			return 0;
533			}
534	werner	36
535	twoaday	211
536	werner	36	int
537	twoaday	271	conf_add_group (config_file_t opt, const char *str)
538	werner	36	{
539	twoaday	271	conf_group_t g, t;
540	werner	36
541	twoaday	271	g = new conf_group_s;
542	twoaday	211	if (!g)
543			BUG (NULL);
544			memset (g, 0, sizeof *g);
545	werner	36	g->used = 1;
546	twoaday	211	g->name = m_strdup (str);
547	werner	36
548	twoaday	211	if (!opt->grp)
549	werner	36	opt->grp = g;
550			else {
551	twoaday	211	for (t = opt->grp; t->next; t = t->next)
552	werner	36	;
553			t->next = g;
554			}
555	twoaday	271	conf_add_entry (opt, ENTRY_GROUP, str, NULL);
556	werner	36	return 0;
557	twoaday	211	}