trunk/Src/wptGPGParser.cpp

/* wptGPGParser.cpp - GPG config file parser
 *      Copyright (C) 2002, 2003, 2004 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 <stdio.h>
#include <string.h>
#include <windows.h>

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

static void
add_opaque_option (gpg_optfile_t opt, const char * line, int used)
{
    gpg_option_t e, t;

    e = new gpg_option_s;
    if (!e)
        BUG (0);
    memset (e, 0, sizeof *e);
    e->used = used > 0? 1 : 0;
    e->name = m_strdup (line);
    e->type = ENTRY_OPAQUE;
    if (!opt->list)
        opt->list = e;
    else {      
        for (t = opt->list; t->next; t = t->next)
            ;
        t->next = e;
    }
} /* add_opaque_option */


static void
add_single_option (gpg_optfile_t opt, const char * name, int used)
{
    gpg_option_t e, t;

    e = new gpg_option_s;
    if (!e)
        BUG (0);
    memset (e, 0, sizeof *e);
    e->used = used > 0? 1 : 0;
    e->name = m_strdup (name);
    e->type = ENTRY_SINGLE;
    if (!opt->list)
        opt->list = e;
    else {
        for (t = opt->list; t->next; t = t->next)
            ;
        t->next = e;
    }
} /* add_single_option */


static int
add_group_option( gpg_optfile_t opt, const char *name, int used )
{
    gpg_option_t e, t;

    e = new gpg_option_s;    
    if( !e )
        BUG( NULL );
    memset( e, 0, sizeof *e );
    e->used = used > 0? 1 : 0;
    e->name = m_strdup( name );
    e->type = ENTRY_GROUP;    
    if( !opt->list )
        opt->list = e;
    else {
        for( t = opt->list; t->next; t = t->next )
            ;
        t->next = e;
    }
    return 0;
} /* add_group_option */


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

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

    return ncount;
} /* count_whitespaces */


static int
add_multi_option( gpg_optfile_t opt, char *line, int used )
{
    gpg_option_t e ,t;
    char *p;
    int state = 0;

    e = new gpg_option_s;    
    if( !e )
        BUG( NULL );
    memset( e, 0, sizeof *e );
    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, ' ' );
        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;
    if( !opt->list )
        opt->list = e;
    else {
        for( t=opt->list; t->next; t = t->next )
            ;
        t->next = e;
    }
    return 0;
} /* add_multi_option */


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;
} /* new_group */


static const char*
_add_group( 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 == NULL || strncmp( line, "group ", 6 ) )
        return NULL;
    buf = m_strdup( line + (p - line + 1) );
    if( !buf )
        BUG( NULL );    
    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( NULL );
        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;
} /* _add_group */

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;
    }
} /* release_group */


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 );
} /* release_gpg_options */


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 -1;
    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;
} /* commit_gpg_options */


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 = _add_group( 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;
} /* parse_gpg_options */


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;
} /* find_option */


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;
} /* find_group */


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 = NULL;
    if( g ) {
        for( m = g->list; m; m = m->next ) {
            if( !stricmp( m->name, str ) )
                break;
        }
    }

    return m;
} /* find_member */


int
delete_group( gpg_optfile_t opt, const char *str )
{
    gpg_group_t g = find_group( opt, str );
    if( g ) {
        g->used = 0;
        return 0;
    }

    return -1;
} /* delete_group */


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 0;
    }

    return -1;
} /* delete_member */

    
int
delete_option (gpg_optfile_t opt, const char * str)
{
    gpg_option_t e = find_option (opt, str);
    if (e) {
        e->used = 0;
        return 0;
    }

    return -1;
} /* delete_option */


int
add_entry( gpg_optfile_t opt, int type, const char *name, const char *val )
{
    gpg_option_t e, t;

    e = new gpg_option_s;    
    if( !e )
        BUG( NULL );
    memset( e, 0, sizeof *e );
    e->used = 1;
    e->type = type;
    e->name = m_strdup( name );
    e->val = val? m_strdup( val ) : NULL;
    if( !opt->list )
        opt->list = e;
    else {
        for( t = opt->list; t->next; t = t->next )
            ;
        t->next = e;
    }
    return 0;
} /* add_entry */


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;
} /* modify_entry */

    
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 ) {
        m = new gpg_member_s;        
        if( !m )
            BUG( NULL );
        memset( m, 0, sizeof *m );
        m->used = 1;
        m->name = m_strdup( str );
        if( !m->name )
            BUG( NULL );
        if( !g->list )
            g->list = m;
        else {
            for( t = g->list; t->next; t = t->next )
                ;
            t->next = m;
        }
        return 0;
    }
    return -1;
} /* add_member */


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;
} /* add_group */
 

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