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"

static void
add_option (gpg_option_t *list, gpg_option_t n)
{
    gpg_option_t t;

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

static gpg_option_t
new_option (void)
{
    gpg_option_t e;

    e = new gpg_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)
{
    gpg_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)
{
    gpg_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)
{
    gpg_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)
{
    gpg_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 gpg_group_t
new_group (gpg_group_t *grp, const char *name)
{
    gpg_group_t g, t;

    g = new gpg_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;
    gpg_group_t g;
    gpg_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 gpg_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
release_group (gpg_group_t grp)
{
    gpg_member_t m, m2;
    
    m = grp->list;
    while (m) {
        m2 = m->next;
        free_if_alloc (m->name);
        free_if_alloc (m);
        m = m2;
    }
}


void
release_option (gpg_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)
{
    gpg_option_t e, e2;
    gpg_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;
        release_group (g);
        g = g2;
    }
    free_if_alloc (opt);
}


int
commit_config (const char *file, config_file_t opt)
{
    FILE *inp;
    gpg_option_t e;
    gpg_group_t g;
    gpg_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 = 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 gpg_optfile_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 gpg_optfile_s;
    if (!opt)
        BUG (NULL);
    memset (opt, 0, sizeof *opt);
    while (!feof (inp))  {
        p = fgets (buf, sizeof (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;
}


gpg_option_t
find_option (config_file_t opt, const char *str)
{
    gpg_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;
}


gpg_group_t
find_group (config_file_t opt, const char *str)
{
    gpg_group_t g;

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

    return g;
}


gpg_member_t
find_member (config_file_t opt, const char *grp, const char *str)
{
    gpg_member_t m;
    gpg_group_t g = 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
delete_group (config_file_t opt, const char *str)
{
    gpg_group_t g = find_group (opt, str);

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


int
delete_member (config_file_t opt, const char *grp, const char *str)
{
    gpg_member_t m = find_member (opt, grp, str);

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

    
int
delete_option (config_file_t opt, const char * str)
{
    gpg_option_t e = find_option (opt, str);

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


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

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

int
add_entry (config_file_t opt, int type, const char *name, const char *val)
{
    gpg_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;
}


int
modify_entry (config_file_t opt, int type, const char *name, const char *val)
{
    gpg_option_t e;
    int rc = 0;

    e = find_option (opt, name);
    if (!e)
        rc = add_entry (opt, type, name, val);
    else if (type != ENTRY_SINGLE) {
        free_if_alloc (e->val);
        e->val = m_strdup (val);
        rc = 0;
    }

    return rc;
}

    
int
add_member (config_file_t opt, const char *grp, const char *str)
{
    gpg_group_t g = find_group (opt, grp);
    gpg_member_t m, t;

    if (!g)
        return -1;
    
    m = new gpg_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
add_group (config_file_t opt, const char *str)
{
    gpg_group_t g, t;

    g = new gpg_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;
    }
    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	werner	36	static void
35	twoaday	211	add_option (gpg_option_t *list, gpg_option_t n)
36	werner	36	{
37	twoaday	211	gpg_option_t t;
38	werner	36
39	twoaday	211	if (!*list)
40			*list = n;
41			else {
42			for (t = *list; t->next; t = t->next)
43			;
44			t->next = n;
45			}
46			}
47
48			static gpg_option_t
49			new_option (void)
50			{
51			gpg_option_t e;
52
53	werner	36	e = new gpg_option_s;
54			if (!e)
55	twoaday	211	BUG (0);
56	twoaday	212	memset (e, 0, sizeof *e);
57	twoaday	211	return e;
58			}
59
60
61			static void
62	twoaday	270	add_opaque_option (config_file_t opt, const char *line, int used)
63	twoaday	211	{
64			gpg_option_t e;
65
66			e = new_option ();
67	werner	36	e->used = used > 0? 1 : 0;
68			e->name = m_strdup (line);
69			e->type = ENTRY_OPAQUE;
70	twoaday	211	add_option (&opt->list, e);
71			}
72	werner	36
73
74			static void
75	twoaday	270	add_single_option (config_file_t opt, const char *name, int used)
76	werner	36	{
77	twoaday	211	gpg_option_t e;
78	werner	36
79	twoaday	211	e = new_option ();
80	werner	36	e->used = used > 0? 1 : 0;
81			e->name = m_strdup (name);
82			e->type = ENTRY_SINGLE;
83	twoaday	211	add_option (&opt->list, e);
84			}
85	werner	36
86
87			static int
88	twoaday	270	add_group_option (config_file_t opt, const char *name, int used)
89	werner	36	{
90	twoaday	211	gpg_option_t e;
91	werner	36
92	twoaday	211	e = new_option ();
93	werner	36	e->used = used > 0? 1 : 0;
94	twoaday	211	e->name = m_strdup (name);
95			e->type = ENTRY_GROUP;
96			add_option (&opt->list, e);
97	werner	36	return 0;
98	twoaday	211	}
99	werner	36
100
101			static size_t
102	twoaday	211	count_whitespaces (char *line)
103	werner	36	{
104	twoaday	211	size_t i;
105			size_t ncount = 0;
106	werner	36
107	twoaday	211	if (!strchr (line, ' '))
108	werner	36	return 0;
109	twoaday	211	for( i = 0; i < strlen (line); i++) {
110			if (line[i] == ' ')
111	werner	36	ncount++;
112			}
113			return ncount;
114	twoaday	211	}
115	werner	36
116
117			static int
118	twoaday	270	add_multi_option (config_file_t opt, char *line, int used)
119	werner	36	{
120	twoaday	211	gpg_option_t e;
121	werner	36	char *p;
122			int state = 0;
123
124	twoaday	211	e = new_option ();
125			if (count_whitespaces (line) == 1) {
126			while ((p = strsep (&line, " ")) && state != 2) {
127			switch (state) {
128			case 0: e->name = m_strdup (p); break;
129			case 1: e->val = m_strdup (p); break;
130	werner	36	}
131			state++;
132			}
133			}
134			else {
135	twoaday	211	p = strchr (line, ' ');
136			if (!p)
137			return -1;
138	werner	36	state = p - line;
139			e->name = new char[state + 1];
140	twoaday	211	if (!e->name)
141			BUG (NULL);
142			memcpy (e->name, line, state);
143	werner	36	e->name[state] = '\0';
144	twoaday	211	strncpy (e->name, line, state);
145			e->val = m_strdup (line + state + 1);
146	werner	36	}
147			e->used = used;
148			e->type = ENTRY_MULTI;
149	twoaday	211	add_option (&opt->list, e);
150
151	werner	36	return 0;
152	twoaday	211	}
153	werner	36
154
155			static gpg_group_t
156	twoaday	211	new_group (gpg_group_t grp, const char name)
157	werner	36	{
158			gpg_group_t g, t;
159
160			g = new gpg_group_s;
161	twoaday	211	if (!g)
162			BUG (NULL);
163			memset (g, 0, sizeof *g);
164	werner	36	g->used = 1;
165	twoaday	211	g->name = m_strdup (name);
166			if (!*grp)
167	werner	36	*grp = g;
168			else {
169	twoaday	211	for (t = *grp; t->next; t = t->next)
170	werner	36	;
171			t->next = g;
172			}
173			return g;
174	twoaday	211	}
175	werner	36
176
177			static const char*
178	twoaday	270	group_from_cfgfile (config_file_t opt, const char *line)
179	werner	36	{
180			char p, buf, buf2, name = NULL;
181			gpg_group_t g;
182			gpg_member_t m = NULL, t;
183
184	twoaday	211	p = strchr (line, '=');
185			if (!p \|\| strncmp (line, "group ", 6))
186	werner	36	return NULL;
187	twoaday	211	buf = m_strdup (line + (p - line + 1));
188	werner	36	line += 6;
189	twoaday	211	p = strchr (line, '=');
190			if (p) {
191	werner	36	size_t pos = p - line;
192			name = new char[pos + 1];
193	twoaday	211	if (!name)
194	werner	36	BUG( NULL );
195	twoaday	211	memset (name, 0, pos+1);
196			strncpy (name, line, pos);
197	werner	36	}
198	twoaday	211	g = new_group (&opt->grp, name);
199	werner	36	buf2 = buf;
200	twoaday	211	while ((p = strsep (&buf2, " ")) && *p) {
201			m = new gpg_member_s;
202			if (!m)
203			BUG (0);
204			memset (m, 0, sizeof *m);
205	werner	36	m->used = 1;
206	twoaday	211	m->name = m_strdup (p);
207			if (!g->list)
208	werner	36	g->list = m;
209			else {
210	twoaday	211	for (t=g->list; t->next; t = t->next)
211	werner	36	;
212			t->next = m;
213			}
214			}
215	twoaday	211	free_if_alloc (buf);
216			if (!m)
217	werner	36	return NULL;
218			return g->name;
219	twoaday	211	}
220	werner	36
221	twoaday	211
222	werner	36	void
223	twoaday	211	release_group (gpg_group_t grp)
224	werner	36	{
225			gpg_member_t m, m2;
226
227			m = grp->list;
228	twoaday	211	while (m) {
229	werner	36	m2 = m->next;
230	twoaday	211	free_if_alloc (m->name);
231			free_if_alloc (m);
232	werner	36	m = m2;
233			}
234	twoaday	211	}
235	werner	36
236
237			void
238			release_option (gpg_option_t opt)
239			{
240			if (!opt)
241			return;
242	twoaday	211	free_if_alloc (opt->name);
243			free_if_alloc (opt->val);
244	twoaday	212	free_if_alloc (opt);
245	werner	36	}
246
247
248			void
249	twoaday	270	release_config (config_file_t opt)
250	werner	36	{
251			gpg_option_t e, e2;
252			gpg_group_t g, g2;
253
254	twoaday	270	if (!opt)
255			return;
256	werner	36	e = opt->list;
257	twoaday	211	while (e) {
258	werner	36	e2 = e->next;
259			release_option (e);
260			e = e2;
261			}
262			g = opt->grp;
263	twoaday	211	while (g) {
264	werner	36	g2 = g->next;
265	twoaday	211	release_group (g);
266	werner	36	g = g2;
267			}
268	twoaday	211	free_if_alloc (opt);
269			}
270	werner	36
271
272			int
273	twoaday	270	commit_config (const char *file, config_file_t opt)
274	werner	36	{
275			FILE *inp;
276			gpg_option_t e;
277			gpg_group_t g;
278			gpg_member_t m;
279
280			inp = fopen (file, "w+b");
281	twoaday	211	if (!inp)
282			return WPTERR_FILE_OPEN;
283			for (e = opt->list; e; e = e->next) {
284			if (!e->used)
285	werner	36	continue;
286	twoaday	211	switch (e->type) {
287	werner	36	case ENTRY_OPAQUE:
288	twoaday	211	fprintf (inp, "%s", e->name);
289	werner	36	break;
290
291			case ENTRY_MULTI:
292	twoaday	211	fprintf (inp, "%s %s\r\n", e->name, e->val);
293	werner	36	break;
294
295			case ENTRY_SINGLE:
296	twoaday	211	fprintf (inp, "%s\r\n", e->name);
297	werner	36	break;
298
299			case ENTRY_GROUP:
300	twoaday	211	g = find_group (opt, e->name);
301			if (g && g->used) {
302			fprintf (inp, "group %s=", g->name);
303			for (m = g->list; m; m = m->next) {
304			if (m->used)
305			fprintf (inp, "%s ", m->name);
306	werner	36	}
307	twoaday	211	fprintf (inp, "\r\n");
308	werner	36	}
309			break;
310			}
311			}
312			fclose (inp);
313			return 0;
314	twoaday	211	}
315	werner	36
316
317	twoaday	270	void
318			new_config (config_file_t *r_opt)
319			{
320			config_file_t opt;
321
322			opt = new gpg_optfile_s;
323			if (!opt)
324			BUG (NULL);
325			memset (opt, 0, sizeof *opt);
326			*r_opt = opt;
327			}
328
329
330	werner	36	int
331	twoaday	270	parse_config (const char file, config_file_t r_opt)
332	werner	36	{
333			FILE *inp;
334			char buf[1024], *p;
335	twoaday	270	config_file_t opt = NULL;
336	werner	36
337	twoaday	270	if (!r_opt)
338			return -1;
339
340	twoaday	211	inp = fopen( file, "rb");
341	twoaday	270	if (!inp) {
342			inp = fopen (file, "wb");
343			if (inp == NULL)
344	werner	36	return -1;
345			}
346			opt = new gpg_optfile_s;
347	twoaday	270	if (!opt)
348			BUG (NULL);
349			memset (opt, 0, sizeof *opt);
350			while (!feof (inp)) {
351			p = fgets (buf, sizeof (buf) -1, inp);
352			if (!p)
353	werner	36	break;
354	twoaday	270	if (p == '#' \|\| p == '\r' \|\| p == '\n' \|\| p == '\t') {
355			add_opaque_option (opt, p, 1);
356	werner	36	continue;
357			}
358	twoaday	270	if( strstr (p, "\r\n" ))
359			p[strlen (p) - 2] = '\0';
360			else if (strstr (p, "\n"))
361			p[strlen (p) - 1] = '\0';
362			if (!strchr( p, ' ' ))
363			add_single_option (opt, p, 1);
364			else if (!strncmp (p, "group", 5)) {
365	twoaday	211	const char *s = group_from_cfgfile (opt, p);
366			if (s)
367			add_group_option (opt, s, 1);
368	werner	36	}
369			else
370	twoaday	211	add_multi_option (opt, p, 1);
371	werner	36	}
372	twoaday	211	fclose (inp);
373	twoaday	270	*r_opt = opt;
374	werner	36	return 0;
375	twoaday	211	}
376	werner	36
377
378			gpg_option_t
379	twoaday	270	find_option (config_file_t opt, const char *str)
380	werner	36	{
381			gpg_option_t e;
382
383			for (e = opt->list; e; e = e->next) {
384			if (e->type == ENTRY_OPAQUE)
385			continue;
386			if (!stricmp (e->name, str))
387			break;
388			}
389
390			return e;
391	twoaday	211	}
392	werner	36
393
394			gpg_group_t
395	twoaday	270	find_group (config_file_t opt, const char *str)
396	werner	36	{
397			gpg_group_t g;
398
399	twoaday	211	for (g = opt->grp; g; g = g->next) {
400			if (!stricmp( g->name, str))
401	werner	36	break;
402			}
403
404			return g;
405	twoaday	211	}
406	werner	36
407
408			gpg_member_t
409	twoaday	270	find_member (config_file_t opt, const char grp, const char str)
410	werner	36	{
411	twoaday	270	gpg_member_t m;
412	twoaday	211	gpg_group_t g = find_group (opt, grp);
413
414			if (!g)
415			return NULL;
416
417			for (m = g->list; m; m = m->next) {
418			if (!stricmp (m->name, str))
419			return m;
420	werner	36	}
421	twoaday	211	return NULL;
422			}
423	werner	36
424
425			int
426	twoaday	270	delete_group (config_file_t opt, const char *str)
427	werner	36	{
428	twoaday	211	gpg_group_t g = find_group (opt, str);
429
430			if (g)
431	werner	36	g->used = 0;
432	twoaday	211	return g? 0 : -1;
433			}
434	werner	36
435
436			int
437	twoaday	270	delete_member (config_file_t opt, const char grp, const char str)
438	werner	36	{
439	twoaday	211	gpg_member_t m = find_member (opt, grp, str);
440	werner	36
441	twoaday	211	if (m)
442			m->used = 0;
443			return m? 0 : -1;
444			}
445	werner	36
446
447			int
448	twoaday	270	delete_option (config_file_t opt, const char * str)
449	werner	36	{
450			gpg_option_t e = find_option (opt, str);
451	twoaday	211
452			if (e)
453	werner	36	e->used = 0;
454	twoaday	211	return e? 0 : -1;
455			}
456	werner	36
457
458			int
459	twoaday	270	add_entry_int (config_file_t opt, int type, const char *name, int val)
460	werner	36	{
461	twoaday	270	char buf[64];
462
463			_snprintf (buf, DIM (buf)-1, "%d", val);
464			add_entry (opt, type, name, buf);
465			return 0;
466			}
467
468			int
469			add_entry (config_file_t opt, int type, const char name, const char val)
470			{
471	twoaday	211	gpg_option_t e;
472	werner	36
473	twoaday	211	e = new_option ();
474	werner	36	e->used = 1;
475			e->type = type;
476	twoaday	211	e->name = m_strdup (name);
477			e->val = val? m_strdup (val) : NULL;
478			add_option (&opt->list, e);
479	werner	36	return 0;
480	twoaday	211	}
481	werner	36
482
483			int
484	twoaday	270	modify_entry (config_file_t opt, int type, const char name, const char val)
485	werner	36	{
486			gpg_option_t e;
487			int rc = 0;
488
489	twoaday	211	e = find_option (opt, name);
490			if (!e)
491			rc = add_entry (opt, type, name, val);
492			else if (type != ENTRY_SINGLE) {
493			free_if_alloc (e->val);
494			e->val = m_strdup (val);
495	twoaday	270	rc = 0;
496	werner	36	}
497
498			return rc;
499	twoaday	211	}
500	werner	36
501
502			int
503	twoaday	270	add_member (config_file_t opt, const char grp, const char str)
504	werner	36	{
505	twoaday	211	gpg_group_t g = find_group (opt, grp);
506	werner	36	gpg_member_t m, t;
507
508	twoaday	211	if (!g)
509			return -1;
510
511			m = new gpg_member_s;
512			if (!m)
513			BUG (NULL);
514			memset (m, 0, sizeof *m);
515			m->used = 1;
516			m->name = m_strdup (str);
517			if( !g->list )
518			g->list = m;
519			else {
520			for( t = g->list; t->next; t = t->next )
521			;
522			t->next = m;
523			}
524			return 0;
525			}
526	werner	36
527	twoaday	211
528	werner	36	int
529	twoaday	270	add_group (config_file_t opt, const char *str)
530	werner	36	{
531			gpg_group_t g, t;
532
533	twoaday	270	g = new gpg_group_s;
534	twoaday	211	if (!g)
535			BUG (NULL);
536			memset (g, 0, sizeof *g);
537	werner	36	g->used = 1;
538	twoaday	211	g->name = m_strdup (str);
539	werner	36
540	twoaday	211	if (!opt->grp)
541	werner	36	opt->grp = g;
542			else {
543	twoaday	211	for (t = opt->grp; t->next; t = t->next)
544	werner	36	;
545			t->next = g;
546			}
547	twoaday	211	add_entry (opt, ENTRY_GROUP, str, NULL);
548	werner	36	return 0;
549	twoaday	211	}