/[winpt]/trunk/Src/wptGPGParser.cpp
ViewVC logotype

Diff of /trunk/Src/wptGPGParser.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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