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 
 */

#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;
    int rc = 0;

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