trunk/Src/wptGPGParser.cpp

/* wptGPGParser.cpp - GPG 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 (gpg_optfile_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 (gpg_optfile_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 (gpg_optfile_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 (gpg_optfile_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 (gpg_optfile_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_gpg_options (gpg_optfile_t opt)
{
    gpg_option_t e, e2;
    gpg_group_t g, g2;

    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_gpg_options (const char *file, gpg_optfile_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;
}


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

    inp = fopen( file, "rb");
    if( inp == NULL ) {
        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);
    if (r_opt)
        *r_opt = opt;
    return 0;
}


gpg_option_t
find_option (gpg_optfile_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 (gpg_optfile_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 (gpg_optfile_t opt, const char *grp, const char *str)
{
    gpg_group_t g = find_group (opt, grp);
    gpg_member_t m;

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


int
delete_group (gpg_optfile_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 (gpg_optfile_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 (gpg_optfile_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 (gpg_optfile_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 (gpg_optfile_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);
    }

    return rc;
}

    
int
add_member (gpg_optfile_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 (gpg_optfile_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;
}
 

#if 0
void
walk_group( const char *name, gpg_member_t mbr )
{
    gpg_member_t m;

    printf( "name=%s\n", name );
    for( m = mbr; m; m = m->next )
        printf( "%s\n", m->name );
}


int
main( int argc, char **argv )
{
    int rc;
    gpg_optfile_t opt;
    gpg_group_t g;
    gpg_option_t e;

    rc = parse_gpg_options( "c:\\gnupg\\gpg.conf", &opt );
    if( rc )
        printf( "parse_option: error\n" );
    else {
#if 0
        /*delete_option( opt, "encrypt-to" );*/
        delete_member( opt, "bar", "richard" );
        add_member( opt, "bar", "leo" );
        add_group( opt, "foobar" );
        delete_group( opt, "foobar" );
        add_entry( opt, ENTRY_SINGLE, "use-agent", NULL );        
#endif
        for( e = opt->list; e; e = e->next ) {
            if( e->type != 1 )
                printf( "%d: %s %s\n", e->used, e->name, e->val );
        }       
        /*commit_gpg_options( "c:\\gnupg\\gpg2.conf", opt );*/  
        for( g = opt->grp; g; g = g->next )
            walk_group( g->name, g->list );        
        release_option( opt );
    }
    
    return 0;
}
#endif
1	werner	36	/* wptGPGParser.cpp - GPG 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			memset (e, 0, sizeof (e));
57			return e;
58			}
59
60
61			static void
62			add_opaque_option (gpg_optfile_t opt, const char *line, int used)
63			{
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	211	add_single_option (gpg_optfile_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	211	add_group_option (gpg_optfile_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	211	add_multi_option (gpg_optfile_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	211	group_from_cfgfile (gpg_optfile_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			free_if_alloc (opt );
245	werner	36	}
246
247
248			void
249	twoaday	211	release_gpg_options (gpg_optfile_t opt)
250	werner	36	{
251			gpg_option_t e, e2;
252			gpg_group_t g, g2;
253
254			e = opt->list;
255	twoaday	211	while (e) {
256	werner	36	e2 = e->next;
257			release_option (e);
258			e = e2;
259			}
260			g = opt->grp;
261	twoaday	211	while (g) {
262	werner	36	g2 = g->next;
263	twoaday	211	release_group (g);
264	werner	36	g = g2;
265			}
266	twoaday	211	free_if_alloc (opt);
267			}
268	werner	36
269
270			int
271	twoaday	211	commit_gpg_options (const char *file, gpg_optfile_t opt)
272	werner	36	{
273			FILE *inp;
274			gpg_option_t e;
275			gpg_group_t g;
276			gpg_member_t m;
277
278			inp = fopen (file, "w+b");
279	twoaday	211	if (!inp)
280			return WPTERR_FILE_OPEN;
281			for (e = opt->list; e; e = e->next) {
282			if (!e->used)
283	werner	36	continue;
284	twoaday	211	switch (e->type) {
285	werner	36	case ENTRY_OPAQUE:
286	twoaday	211	fprintf (inp, "%s", e->name);
287	werner	36	break;
288
289			case ENTRY_MULTI:
290	twoaday	211	fprintf (inp, "%s %s\r\n", e->name, e->val);
291	werner	36	break;
292
293			case ENTRY_SINGLE:
294	twoaday	211	fprintf (inp, "%s\r\n", e->name);
295	werner	36	break;
296
297			case ENTRY_GROUP:
298	twoaday	211	g = find_group (opt, e->name);
299			if (g && g->used) {
300			fprintf (inp, "group %s=", g->name);
301			for (m = g->list; m; m = m->next) {
302			if (m->used)
303			fprintf (inp, "%s ", m->name);
304	werner	36	}
305	twoaday	211	fprintf (inp, "\r\n");
306	werner	36	}
307			break;
308			}
309			}
310			fclose (inp);
311			return 0;
312	twoaday	211	}
313	werner	36
314
315			int
316	twoaday	211	parse_gpg_options (const char file, gpg_optfile_t r_opt )
317	werner	36	{
318			FILE *inp;
319			char buf[1024], *p;
320			gpg_optfile_t opt = NULL;
321
322	twoaday	211	inp = fopen( file, "rb");
323	werner	36	if( inp == NULL ) {
324			inp = fopen( file, "wb" );
325			if( inp == NULL )
326			return -1;
327			}
328			opt = new gpg_optfile_s;
329			if( !opt )
330			BUG( NULL );
331			memset( opt, 0, sizeof *opt );
332			while( !feof( inp ) ) {
333			p = fgets( buf, sizeof buf -1, inp );
334			if( !p )
335			break;
336			if( p == '#' \|\| p == '\r' \|\| p == '\n' \|\| p == '\t' ) {
337			add_opaque_option( opt, p, 1 );
338			continue;
339			}
340			if( strstr( p, "\r\n" ) )
341			p[strlen( p ) - 2] = '\0';
342			else if( strstr( p, "\n" ) )
343			p[strlen( p ) - 1] = '\0';
344			if( !strchr( p, ' ' ) )
345			add_single_option( opt, p, 1 );
346			else if( !strncmp( p, "group", 5 ) ) {
347	twoaday	211	const char *s = group_from_cfgfile (opt, p);
348			if (s)
349			add_group_option (opt, s, 1);
350	werner	36	}
351			else
352	twoaday	211	add_multi_option (opt, p, 1);
353	werner	36	}
354	twoaday	211	fclose (inp);
355			if (r_opt)
356	werner	36	*r_opt = opt;
357			return 0;
358	twoaday	211	}
359	werner	36
360
361			gpg_option_t
362	twoaday	211	find_option (gpg_optfile_t opt, const char *str)
363	werner	36	{
364			gpg_option_t e;
365
366			for (e = opt->list; e; e = e->next) {
367			if (e->type == ENTRY_OPAQUE)
368			continue;
369			if (!stricmp (e->name, str))
370			break;
371			}
372
373			return e;
374	twoaday	211	}
375	werner	36
376
377			gpg_group_t
378	twoaday	211	find_group (gpg_optfile_t opt, const char *str)
379	werner	36	{
380			gpg_group_t g;
381
382	twoaday	211	for (g = opt->grp; g; g = g->next) {
383			if (!stricmp( g->name, str))
384	werner	36	break;
385			}
386
387			return g;
388	twoaday	211	}
389	werner	36
390
391			gpg_member_t
392	twoaday	211	find_member (gpg_optfile_t opt, const char grp, const char str)
393	werner	36	{
394	twoaday	211	gpg_group_t g = find_group (opt, grp);
395			gpg_member_t m;
396
397			if (!g)
398			return NULL;
399
400			for (m = g->list; m; m = m->next) {
401			if (!stricmp (m->name, str))
402			return m;
403	werner	36	}
404	twoaday	211	return NULL;
405			}
406	werner	36
407
408			int
409	twoaday	211	delete_group (gpg_optfile_t opt, const char *str)
410	werner	36	{
411	twoaday	211	gpg_group_t g = find_group (opt, str);
412
413			if (g)
414	werner	36	g->used = 0;
415	twoaday	211	return g? 0 : -1;
416			}
417	werner	36
418
419			int
420	twoaday	211	delete_member (gpg_optfile_t opt, const char grp, const char str)
421	werner	36	{
422	twoaday	211	gpg_member_t m = find_member (opt, grp, str);
423	werner	36
424	twoaday	211	if (m)
425			m->used = 0;
426			return m? 0 : -1;
427			}
428	werner	36
429
430			int
431			delete_option (gpg_optfile_t opt, const char * str)
432			{
433			gpg_option_t e = find_option (opt, str);
434	twoaday	211
435			if (e)
436	werner	36	e->used = 0;
437	twoaday	211	return e? 0 : -1;
438			}
439	werner	36
440
441			int
442	twoaday	211	add_entry (gpg_optfile_t opt, int type, const char name, const char val)
443	werner	36	{
444	twoaday	211	gpg_option_t e;
445	werner	36
446	twoaday	211	e = new_option ();
447	werner	36	e->used = 1;
448			e->type = type;
449	twoaday	211	e->name = m_strdup (name);
450			e->val = val? m_strdup (val) : NULL;
451			add_option (&opt->list, e);
452	werner	36	return 0;
453	twoaday	211	}
454	werner	36
455
456			int
457	twoaday	211	modify_entry (gpg_optfile_t opt, int type, const char name, const char val)
458	werner	36	{
459			gpg_option_t e;
460			int rc = 0;
461
462	twoaday	211	e = find_option (opt, name);
463			if (!e)
464			rc = add_entry (opt, type, name, val);
465			else if (type != ENTRY_SINGLE) {
466			free_if_alloc (e->val);
467			e->val = m_strdup (val);
468	werner	36	}
469
470			return rc;
471	twoaday	211	}
472	werner	36
473
474			int
475	twoaday	211	add_member (gpg_optfile_t opt, const char grp, const char str)
476	werner	36	{
477	twoaday	211	gpg_group_t g = find_group (opt, grp);
478	werner	36	gpg_member_t m, t;
479
480	twoaday	211	if (!g)
481			return -1;
482
483			m = new gpg_member_s;
484			if (!m)
485			BUG (NULL);
486			memset (m, 0, sizeof *m);
487			m->used = 1;
488			m->name = m_strdup (str);
489			if( !g->list )
490			g->list = m;
491			else {
492			for( t = g->list; t->next; t = t->next )
493			;
494			t->next = m;
495			}
496			return 0;
497			}
498	werner	36
499	twoaday	211
500	werner	36	int
501	twoaday	211	add_group (gpg_optfile_t opt, const char *str)
502	werner	36	{
503			gpg_group_t g, t;
504
505			g = new gpg_group_s;
506	twoaday	211	if (!g)
507			BUG (NULL);
508			memset (g, 0, sizeof *g);
509	werner	36	g->used = 1;
510	twoaday	211	g->name = m_strdup (str);
511	werner	36
512	twoaday	211	if (!opt->grp)
513	werner	36	opt->grp = g;
514			else {
515	twoaday	211	for (t = opt->grp; t->next; t = t->next)
516	werner	36	;
517			t->next = g;
518			}
519	twoaday	211	add_entry (opt, ENTRY_GROUP, str, NULL);
520	werner	36	return 0;
521	twoaday	211	}
522	werner	36
523
524			#if 0
525			void
526			walk_group( const char *name, gpg_member_t mbr )
527			{
528			gpg_member_t m;
529
530			printf( "name=%s\n", name );
531			for( m = mbr; m; m = m->next )
532			printf( "%s\n", m->name );
533			}
534
535
536			int
537			main( int argc, char **argv )
538			{
539			int rc;
540			gpg_optfile_t opt;
541			gpg_group_t g;
542			gpg_option_t e;
543
544			rc = parse_gpg_options( "c:\\gnupg\\gpg.conf", &opt );
545			if( rc )
546			printf( "parse_option: error\n" );
547			else {
548			#if 0
549			/delete_option( opt, "encrypt-to" );/
550			delete_member( opt, "bar", "richard" );
551			add_member( opt, "bar", "leo" );
552			add_group( opt, "foobar" );
553			delete_group( opt, "foobar" );
554			add_entry( opt, ENTRY_SINGLE, "use-agent", NULL );
555			#endif
556			for( e = opt->list; e; e = e->next ) {
557			if( e->type != 1 )
558			printf( "%d: %s %s\n", e->used, e->name, e->val );
559			}
560			/commit_gpg_options( "c:\\gnupg\\gpg2.conf", opt );/
561			for( g = opt->grp; g; g = g->next )
562			walk_group( g->name, g->list );
563			release_option( opt );
564			}
565
566			return 0;
567			}
568			#endif