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