Enhanced --auto-key-locate.
[gnupg.git] / tools / gpgconf-comp.c
1 /* gpgconf-comp.c - Configuration utility for GnuPG.
2  * Copyright (C) 2004, 2007, 2008 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful, but
12  * 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 GnuPG; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #if HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <fcntl.h>
27 #include <unistd.h>
28 #include <sys/types.h>
29 #include <assert.h>
30 #include <errno.h>
31 #include <time.h>
32 #include <stdarg.h>
33 #include <signal.h>
34 #include <ctype.h>
35 #ifdef HAVE_W32_SYSTEM
36 # define WIN32_LEAN_AND_MEAN 1
37 # include <windows.h>
38 #else
39 # include <pwd.h>
40 # include <grp.h>
41 #endif
42
43 /* For log_logv(), asctimestamp(), gnupg_get_time ().  */
44 #define JNLIB_NEED_LOG_LOGV
45 #include "util.h"
46 #include "i18n.h"
47 #include "exechelp.h"
48
49 #include "gc-opt-flags.h"
50 #include "gpgconf.h"
51
52
53 /* There is a problem with gpg 1.4 under Windows: --gpgconf-list
54    returns a plain filename without escaping.  As long as we have not
55    fixed that we need to use gpg2 - it might actually be better to use
56    gpg2 in any case.  */
57 #ifdef HAVE_W32_SYSTEM
58 #define GPGNAME "gpg2"
59 #else
60 #define GPGNAME "gpg"
61 #endif
62
63 \f
64 /* TODO:
65    Components: Add more components and their options.
66    Robustness: Do more validation.  Call programs to do validation for us.
67    Add options to change backend binary path.
68    Extract binary path for some backends from gpgsm/gpg config.
69 */
70
71 \f
72 #if (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
73 void gc_error (int status, int errnum, const char *fmt, ...) \
74   __attribute__ ((format (printf, 3, 4)));
75 #endif
76
77 /* Output a diagnostic message.  If ERRNUM is not 0, then the output
78    is followed by a colon, a white space, and the error string for the
79    error number ERRNUM.  In any case the output is finished by a
80    newline.  The message is prepended by the program name, a colon,
81    and a whitespace.  The output may be further formatted or
82    redirected by the jnlib logging facility.  */
83 void
84 gc_error (int status, int errnum, const char *fmt, ...)
85 {
86   va_list arg_ptr;
87
88   va_start (arg_ptr, fmt);
89   log_logv (JNLIB_LOG_ERROR, fmt, arg_ptr);
90   va_end (arg_ptr);
91
92   if (errnum)
93     log_printf (": %s\n", strerror (errnum));
94   else
95     log_printf ("\n");
96
97   if (status)
98     {
99       log_printf (NULL);
100       log_printf ("fatal error (exit status %i)\n", status);
101       exit (status);
102     }
103 }
104
105 \f
106 /* Forward declaration.  */
107 void gpg_agent_runtime_change (void);
108
109 /* Backend configuration.  Backends are used to decide how the default
110    and current value of an option can be determined, and how the
111    option can be changed.  To every option in every component belongs
112    exactly one backend that controls and determines the option.  Some
113    backends are programs from the GPG system.  Others might be
114    implemented by GPGConf itself.  If you change this enum, don't
115    forget to update GC_BACKEND below.  */
116 typedef enum
117   {
118     /* Any backend, used for find_option ().  */
119     GC_BACKEND_ANY,
120
121     /* The Gnu Privacy Guard.  */
122     GC_BACKEND_GPG,
123
124     /* The Gnu Privacy Guard for S/MIME.  */
125     GC_BACKEND_GPGSM,
126
127     /* The GPG Agent.  */
128     GC_BACKEND_GPG_AGENT,
129
130     /* The GnuPG SCDaemon.  */
131     GC_BACKEND_SCDAEMON,
132
133     /* The Aegypten directory manager.  */
134     GC_BACKEND_DIRMNGR,
135
136     /* The LDAP server list file for the Aegypten director manager.  */
137     GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST,
138
139     /* The number of the above entries.  */
140     GC_BACKEND_NR
141   } gc_backend_t;
142
143
144 /* To be able to implement generic algorithms for the various
145    backends, we collect all information about them in this struct.  */
146 static struct
147 {
148   /* The name of the backend.  */
149   const char *name;
150
151   /* The name of the program that acts as the backend.  Some backends
152      don't have an associated program, but are implemented directly by
153      GPGConf.  In this case, PROGRAM is NULL.  */
154   char *program;
155
156   /* The module name (GNUPG_MODULE_NAME_foo) as defined by
157      ../common/util.h.  This value is used to get the actual installed
158      path of the program.  0 is used if no backedn program is
159      available. */
160   char module_name;
161
162   /* The runtime change callback.  */
163   void (*runtime_change) (void);
164
165   /* The option name for the configuration filename of this backend.
166      This must be an absolute pathname.  It can be an option from a
167      different backend (but then ordering of the options might
168      matter).  */
169   const char *option_config_filename;
170
171   /* If this is a file backend rather than a program backend, then
172      this is the name of the option associated with the file.  */
173   const char *option_name;
174 } gc_backend[GC_BACKEND_NR] =
175   {
176     { NULL },           /* GC_BACKEND_ANY dummy entry.  */
177     { "GnuPG", GPGNAME, GNUPG_MODULE_NAME_GPG,
178       NULL, "gpgconf-gpg.conf" },
179     { "GPGSM", "gpgsm", GNUPG_MODULE_NAME_GPGSM,
180       NULL, "gpgconf-gpgsm.conf" },
181     { "GPG Agent", "gpg-agent", GNUPG_MODULE_NAME_AGENT, 
182       gpg_agent_runtime_change, "gpgconf-gpg-agent.conf" },
183     { "SCDaemon", "scdaemon", GNUPG_MODULE_NAME_SCDAEMON,
184       NULL, "gpgconf-scdaemon.conf" },
185     { "DirMngr", "dirmngr", GNUPG_MODULE_NAME_DIRMNGR,
186       NULL, "gpgconf-dirmngr.conf" },
187     { "DirMngr LDAP Server List", NULL, 0, 
188       NULL, "ldapserverlist-file", "LDAP Server" },
189   };
190
191 \f
192 /* Option configuration.  */
193
194 /* An option might take an argument, or not.  Argument types can be
195    basic or complex.  Basic types are generic and easy to validate.
196    Complex types provide more specific information about the intended
197    use, but can be difficult to validate.  If you add to this enum,
198    don't forget to update GC_ARG_TYPE below.  YOU MUST NOT CHANGE THE
199    NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE EXTERNAL
200    INTERFACE.  */
201 typedef enum
202   {
203     /* Basic argument types.  */
204
205     /* No argument.  */
206     GC_ARG_TYPE_NONE = 0,
207
208     /* A String argument.  */
209     GC_ARG_TYPE_STRING = 1,
210
211     /* A signed integer argument.  */
212     GC_ARG_TYPE_INT32 = 2,
213
214     /* An unsigned integer argument.  */
215     GC_ARG_TYPE_UINT32 = 3,
216
217     /* ADD NEW BASIC TYPE ENTRIES HERE.  */
218
219     /* Complex argument types.  */
220
221     /* A complete pathname.  */
222     GC_ARG_TYPE_PATHNAME = 32,
223
224     /* An LDAP server in the format
225        HOSTNAME:PORT:USERNAME:PASSWORD:BASE_DN.  */
226     GC_ARG_TYPE_LDAP_SERVER = 33,
227
228     /* A 40 character fingerprint.  */
229     GC_ARG_TYPE_KEY_FPR = 34,
230
231     /* A user ID or key ID or fingerprint for a certificate.  */
232     GC_ARG_TYPE_PUB_KEY = 35,
233
234     /* A user ID or key ID or fingerprint for a certificate with a key.  */
235     GC_ARG_TYPE_SEC_KEY = 36,
236
237     /* ADD NEW COMPLEX TYPE ENTRIES HERE.  */
238
239     /* The number of the above entries.  */
240     GC_ARG_TYPE_NR
241   } gc_arg_type_t;
242
243
244 /* For every argument, we record some information about it in the
245    following struct.  */
246 static struct
247 {
248   /* For every argument type exists a basic argument type that can be
249      used as a fallback for input and validation purposes.  */
250   gc_arg_type_t fallback;
251
252   /* Human-readable name of the type.  */
253   const char *name;
254 } gc_arg_type[GC_ARG_TYPE_NR] =
255   {
256     /* The basic argument types have their own types as fallback.  */
257     { GC_ARG_TYPE_NONE, "none" },
258     { GC_ARG_TYPE_STRING, "string" },
259     { GC_ARG_TYPE_INT32, "int32" },
260     { GC_ARG_TYPE_UINT32, "uint32" },
261
262     /* Reserved basic type entries for future extension.  */
263     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
264     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
265     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
266     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
267     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
268     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
269     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
270     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
271     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
272     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
273     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
274     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
275     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
276     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
277
278     /* The complex argument types have a basic type as fallback.  */
279     { GC_ARG_TYPE_STRING, "pathname" },
280     { GC_ARG_TYPE_STRING, "ldap server" },
281     { GC_ARG_TYPE_STRING, "key fpr" },
282     { GC_ARG_TYPE_STRING, "pub key" },
283     { GC_ARG_TYPE_STRING, "sec key" },
284   };
285
286
287 /* Every option has an associated expert level, than can be used to
288    hide advanced and expert options from beginners.  If you add to
289    this list, don't forget to update GC_LEVEL below.  YOU MUST NOT
290    CHANGE THE NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE
291    EXTERNAL INTERFACE.  */
292 typedef enum
293   {
294     /* The basic options should always be displayed.  */
295     GC_LEVEL_BASIC,
296
297     /* The advanced options may be hidden from beginners.  */
298     GC_LEVEL_ADVANCED,
299
300     /* The expert options should only be displayed to experts.  */
301     GC_LEVEL_EXPERT,
302
303     /* The invisible options should normally never be displayed.  */
304     GC_LEVEL_INVISIBLE,
305
306     /* The internal options are never exported, they mark options that
307        are recorded for internal use only.  */
308     GC_LEVEL_INTERNAL,
309
310     /* ADD NEW ENTRIES HERE.  */
311
312     /* The number of the above entries.  */
313     GC_LEVEL_NR
314   } gc_expert_level_t;
315
316 /* A description for each expert level.  */
317 static struct
318 {
319   const char *name;
320 } gc_level[] =
321   {
322     { "basic" },
323     { "advanced" },
324     { "expert" },
325     { "invisible" },
326     { "internal" }
327   };
328
329
330 /* Option flags.  The flags which are used by the backends are defined
331    by gc-opt-flags.h, included above.
332
333    YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING FLAGS, AS THEY ARE
334    PART OF THE EXTERNAL INTERFACE.  */
335
336 /* Some entries in the option list are not options, but mark the
337    beginning of a new group of options.  These entries have the GROUP
338    flag set.  */
339 #define GC_OPT_FLAG_GROUP       (1UL << 0)
340 /* The ARG_OPT flag for an option indicates that the argument is
341    optional.  This is never set for GC_ARG_TYPE_NONE options.  */
342 #define GC_OPT_FLAG_ARG_OPT     (1UL << 1)
343 /* The LIST flag for an option indicates that the option can occur
344    several times.  A comma separated list of arguments is used as the
345    argument value.  */
346 #define GC_OPT_FLAG_LIST        (1UL << 2)
347 /* The NO_CHANGE flag for an option indicates that the user should not
348    be allowed to change this option using the standard gpgconf method.
349    Frontends using gpgconf should grey out such options, so that only
350    the current value is displayed.  */
351 #define GC_OPT_FLAG_NO_CHANGE   (1UL <<7)
352
353
354 /* A human-readable description for each flag.  */
355 static struct
356 {
357   const char *name;
358 } gc_flag[] =
359   {
360     { "group" },
361     { "optional arg" },
362     { "list" },
363     { "runtime" },
364     { "default" },
365     { "default desc" },
366     { "no arg desc" },
367     { "no change" }
368   };
369
370
371 /* To each option, or group marker, the information in the GC_OPTION
372    struct is provided.  If you change this, don't forget to update the
373    option list of each component.  */
374 struct gc_option
375 {
376   /* If this is NULL, then this is a terminator in an array of unknown
377      length.  Otherwise, if this entry is a group marker (see FLAGS),
378      then this is the name of the group described by this entry.
379      Otherwise it is the name of the option described by this
380      entry.  The name must not contain a colon.  */
381   const char *name;
382
383   /* The option flags.  If the GROUP flag is set, then this entry is a
384      group marker, not an option, and only the fields LEVEL,
385      DESC_DOMAIN and DESC are valid.  In all other cases, this entry
386      describes a new option and all fields are valid.  */
387   unsigned long flags;
388
389   /* The expert level.  This field is valid for options and groups.  A
390      group has the expert level of the lowest-level option in the
391      group.  */
392   gc_expert_level_t level;
393
394   /* A gettext domain in which the following description can be found.
395      If this is NULL, then DESC is not translated.  Valid for groups
396      and options.
397      
398      Note that we try to keep the description of groups within the
399      gnupg domain. 
400      
401      IMPORTANT: If you add a new domain please make sure to add a code
402      set switching call to the function my_dgettext further below.  */
403   const char *desc_domain;
404
405   /* A gettext description for this group or option.  If it starts
406      with a '|', then the string up to the next '|' describes the
407      argument, and the description follows the second '|'. 
408
409      In general enclosing these description in N_() is not required
410      because the description should be identical to the one in the
411      help menu of the respective program. */
412   const char *desc;
413
414   /* The following fields are only valid for options.  */
415
416   /* The type of the option argument.  */
417   gc_arg_type_t arg_type;
418
419   /* The backend that implements this option.  */
420   gc_backend_t backend;
421
422   /* The following fields are set to NULL at startup (because all
423      option's are declared as static variables).  They are at the end
424      of the list so that they can be omitted from the option
425      declarations.  */
426
427   /* This is true if the option is supported by this version of the
428      backend.  */
429   int active;
430
431   /* The default value for this option.  This is NULL if the option is
432      not present in the backend, the empty string if no default is
433      available, and otherwise a quoted string.  */
434   char *default_value;
435
436   /* The default argument is only valid if the "optional arg" flag is
437      set, and specifies the default argument (value) that is used if
438      the argument is omitted.  */
439   char *default_arg;
440
441   /* The current value of this option.  */
442   char *value;
443
444   /* The new flags for this option.  The only defined flag is actually
445      GC_OPT_FLAG_DEFAULT, and it means that the option should be
446      deleted.  In this case, NEW_VALUE is NULL.  */
447   unsigned long new_flags;
448
449   /* The new value of this option.  */
450   char *new_value;
451 };
452 typedef struct gc_option gc_option_t;
453
454 /* Use this macro to terminate an option list.  */
455 #define GC_OPTION_NULL { NULL }
456
457 \f
458 /* The options of the GC_COMPONENT_GPG_AGENT component.  */
459 static gc_option_t gc_options_gpg_agent[] =
460  {
461    /* The configuration file to which we write the changes.  */
462    { "gpgconf-gpg-agent.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
463      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG_AGENT },
464
465    { "Monitor",
466      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
467      "gnupg", N_("Options controlling the diagnostic output") },
468    { "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
469      "gnupg", "verbose",
470      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
471    { "quiet", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
472      "gnupg", "be somewhat more quiet",
473      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
474    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
475      NULL, NULL,
476      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
477
478    { "Configuration",
479      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
480      "gnupg", N_("Options controlling the configuration") },
481    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
482      "gnupg", "|FILE|read options from FILE",
483      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG_AGENT },
484    { "disable-scdaemon", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
485      "gnupg", "do not use the SCdaemon",
486      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
487
488    { "Debug",
489      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
490      "gnupg", N_("Options useful for debugging") },
491    { "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
492      "gnupg", "|LEVEL|set the debugging level to LEVEL",
493      GC_ARG_TYPE_STRING, GC_BACKEND_GPG_AGENT },
494    { "log-file", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
495      "gnupg", N_("|FILE|write server mode logs to FILE"),
496      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG_AGENT },
497    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
498      NULL, NULL,
499      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
500
501    { "Security",
502      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
503      "gnupg", N_("Options controlling the security") },
504    { "default-cache-ttl", GC_OPT_FLAG_RUNTIME,
505      GC_LEVEL_BASIC, "gnupg", 
506      "|N|expire cached PINs after N seconds",
507      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
508    { "default-cache-ttl-ssh", GC_OPT_FLAG_RUNTIME,
509      GC_LEVEL_ADVANCED, "gnupg",
510      N_("|N|expire SSH keys after N seconds"),
511      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
512    { "max-cache-ttl", GC_OPT_FLAG_RUNTIME,
513      GC_LEVEL_EXPERT, "gnupg",
514      N_("|N|set maximum PIN cache lifetime to N seconds"),
515      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
516    { "max-cache-ttl-ssh", GC_OPT_FLAG_RUNTIME,
517      GC_LEVEL_EXPERT, "gnupg", 
518      N_("|N|set maximum SSH key lifetime to N seconds"),
519      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
520    { "ignore-cache-for-signing", GC_OPT_FLAG_RUNTIME,
521      GC_LEVEL_BASIC, "gnupg", "do not use the PIN cache when signing",
522      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
523    { "allow-mark-trusted", GC_OPT_FLAG_RUNTIME,
524      GC_LEVEL_ADVANCED, "gnupg", "allow clients to mark keys as \"trusted\"",
525      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
526    { "no-grab", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT,
527      "gnupg", "do not grab keyboard and mouse",
528      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
529
530    { "Passphrase policy",
531      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
532      "gnupg", N_("Options enforcing a passphrase policy") },
533    { "enforce-passphrase-constraints", GC_OPT_FLAG_RUNTIME, 
534      GC_LEVEL_EXPERT, "gnupg", 
535      N_("do not allow to bypass the passphrase policy"),
536      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
537    { "min-passphrase-len", GC_OPT_FLAG_RUNTIME,
538      GC_LEVEL_ADVANCED, "gnupg", 
539      N_("|N|set minimal required length for new passphrases to N"),
540      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
541    { "min-passphrase-nonalpha", GC_OPT_FLAG_RUNTIME,
542      GC_LEVEL_EXPERT, "gnupg", 
543      N_("|N|require at least N non-alpha characters for a new passphrase"),
544      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
545    { "check-passphrase-pattern", GC_OPT_FLAG_RUNTIME,
546      GC_LEVEL_EXPERT,
547      "gnupg", N_("|FILE|check new passphrases against pattern in FILE"),
548      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG_AGENT },
549    { "max-passphrase-days", GC_OPT_FLAG_RUNTIME,
550      GC_LEVEL_EXPERT, "gnupg", 
551      N_("|N|expire the passphrase after N days"),
552      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
553    { "enable-passphrase-history", GC_OPT_FLAG_RUNTIME, 
554      GC_LEVEL_EXPERT, "gnupg", 
555      N_("do not allow the reuse of old passphrases"),
556      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
557
558    GC_OPTION_NULL
559  };
560
561
562 /* The options of the GC_COMPONENT_SCDAEMON component.  */
563 static gc_option_t gc_options_scdaemon[] =
564  {
565    /* The configuration file to which we write the changes.  */
566    { "gpgconf-scdaemon.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
567      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_SCDAEMON },
568
569    { "Monitor",
570      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
571      "gnupg", N_("Options controlling the diagnostic output") },
572    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
573      "gnupg", "verbose",
574      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
575    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
576      "gnupg", "be somewhat more quiet",
577      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
578    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
579      NULL, NULL,
580      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
581
582    { "Configuration",
583      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
584      "gnupg", N_("Options controlling the configuration") },
585    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
586      "gnupg", "|FILE|read options from FILE",
587      GC_ARG_TYPE_PATHNAME, GC_BACKEND_SCDAEMON },
588    { "reader-port", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
589      "gnupg", "|N|connect to reader at port N",
590      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
591    { "ctapi-driver", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
592      "gnupg", "|NAME|use NAME as ct-API driver",
593      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
594    { "pcsc-driver", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
595      "gnupg", "|NAME|use NAME as PC/SC driver",
596      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
597    { "disable-opensc", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
598      "gnupg", "do not use the OpenSC layer",
599      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
600    { "disable-ccid", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
601      "gnupg", "do not use the internal CCID driver",
602      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
603    { "disable-keypad", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
604      "gnupg", "do not use a reader's keypad",
605      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
606
607    { "Debug",
608      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
609      "gnupg", N_("Options useful for debugging") },
610    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
611      "gnupg", "|LEVEL|set the debugging level to LEVEL",
612      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
613    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
614      "gnupg", N_("|FILE|write server mode logs to FILE"),
615      GC_ARG_TYPE_PATHNAME, GC_BACKEND_SCDAEMON },
616
617    { "Security",
618      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
619      "gnupg", N_("Options controlling the security") },
620    { "allow-admin", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
621      "gnupg", "allow the use of admin card commands",
622      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
623
624
625    GC_OPTION_NULL
626  };
627
628
629 /* The options of the GC_COMPONENT_GPG component.  */
630 static gc_option_t gc_options_gpg[] =
631  {
632    /* The configuration file to which we write the changes.  */
633    { "gpgconf-gpg.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
634      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG },
635
636    { "Monitor",
637      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
638      "gnupg", N_("Options controlling the diagnostic output") },
639    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
640      "gnupg", "verbose",
641      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
642    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
643      "gnupg", "be somewhat more quiet",
644      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
645    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
646      NULL, NULL,
647      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
648
649    { "Configuration",
650      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
651      "gnupg", N_("Options controlling the configuration") },
652    { "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
653      "gnupg", N_("|NAME|use NAME as default secret key"),
654      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
655    { "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
656      "gnupg", N_("|NAME|encrypt to user ID NAME as well"),
657      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
658    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
659      "gnupg", "|FILE|read options from FILE",
660      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG },
661
662    { "Debug",
663      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
664      "gnupg", N_("Options useful for debugging") },
665    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
666      "gnupg", "|LEVEL|set the debugging level to LEVEL",
667      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
668    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
669      "gnupg", N_("|FILE|write server mode logs to FILE"),
670      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG },
671 /*    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE, */
672 /*      NULL, NULL, */
673 /*      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG }, */
674
675    { "Keyserver",
676      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
677      "gnupg", N_("Configuration for Keyservers") },
678    { "keyserver", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
679      "gnupg", N_("|URL|use keyserver at URL"),
680      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
681    { "allow-pka-lookup", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
682      "gnupg", N_("allow PKA lookups (DNS requests)"),
683      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
684    { "auto-key-locate", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
685      "gnupg", N_("|MECHANISMS|use MECHANISMS to locate keys by mail address"),
686      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
687
688
689    GC_OPTION_NULL
690  };
691
692
693
694 /* The options of the GC_COMPONENT_GPGSM component.  */
695 static gc_option_t gc_options_gpgsm[] =
696  {
697    /* The configuration file to which we write the changes.  */
698    { "gpgconf-gpgsm.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
699      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPGSM },
700
701    { "Monitor",
702      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
703      "gnupg", N_("Options controlling the diagnostic output") },
704    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
705      "gnupg", "verbose",
706      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
707    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
708      "gnupg", "be somewhat more quiet",
709      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
710    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
711      NULL, NULL,
712      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
713
714    { "Configuration",
715      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
716      "gnupg", N_("Options controlling the configuration") },
717    { "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
718      "gnupg", N_("|NAME|use NAME as default secret key"),
719      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
720    { "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
721      "gnupg", N_("|NAME|encrypt to user ID NAME as well"),
722      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
723    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
724      "gnupg", "|FILE|read options from FILE",
725      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPGSM },
726    { "prefer-system-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
727      "gnupg", "use system's dirmngr if available",
728      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
729    { "disable-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
730      "gnupg", N_("disable all access to the dirmngr"),
731      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
732    { "p12-charset", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
733      "gnupg", N_("|NAME|use encoding NAME for PKCS#12 passphrases"),
734      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
735
736    { "Debug",
737      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
738      "gnupg", N_("Options useful for debugging") },
739    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
740      "gnupg", "|LEVEL|set the debugging level to LEVEL",
741      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
742    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
743      "gnupg", N_("|FILE|write server mode logs to FILE"),
744      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPGSM },
745    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
746      NULL, NULL,
747      GC_ARG_TYPE_UINT32, GC_BACKEND_GPGSM },
748
749    { "Security",
750      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
751      "gnupg", N_("Options controlling the security") },
752    { "disable-crl-checks", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
753      "gnupg", "never consult a CRL",
754      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
755    { "disable-trusted-cert-crl-check", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
756      "gnupg", N_("do not check CRLs for root certificates"),
757      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
758    { "enable-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
759      "gnupg", "check validity using OCSP",
760      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
761    { "include-certs", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
762      "gnupg", "|N|number of certificates to include",
763      GC_ARG_TYPE_INT32, GC_BACKEND_GPGSM },
764    { "disable-policy-checks", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
765      "gnupg", "do not check certificate policies",
766      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
767    { "auto-issuer-key-retrieve", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
768      "gnupg", "fetch missing issuer certificates",
769      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
770    { "cipher-algo", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
771      "gnupg", "|NAME|use cipher algorithm NAME",
772      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
773
774    GC_OPTION_NULL
775  };
776
777
778 /* The options of the GC_COMPONENT_DIRMNGR component.  */
779 static gc_option_t gc_options_dirmngr[] =
780  {
781    /* The configuration file to which we write the changes.  */
782    { "gpgconf-dirmngr.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
783      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_DIRMNGR },
784
785    { "Monitor",
786      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
787      "gnupg", N_("Options controlling the diagnostic output") },
788    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
789      "dirmngr", "verbose",
790      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
791    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
792      "dirmngr", "be somewhat more quiet",
793      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
794    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
795      NULL, NULL,
796      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
797
798    { "Format",
799      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
800      "gnupg", N_("Options controlling the format of the output") },
801    { "sh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
802      "dirmngr", "sh-style command output",
803      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
804    { "csh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
805      "dirmngr", "csh-style command output",
806      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
807    
808    { "Configuration",
809      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
810      "gnupg", N_("Options controlling the configuration") },
811    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
812      "dirmngr", "|FILE|read options from FILE",
813      GC_ARG_TYPE_PATHNAME, GC_BACKEND_DIRMNGR },
814
815    { "Debug",
816      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
817      "gnupg", N_("Options useful for debugging") },
818    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
819      "dirmngr", "|LEVEL|set the debugging level to LEVEL",
820      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
821    { "no-detach", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
822      "dirmngr", "do not detach from the console",
823      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
824    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
825      "dirmngr", N_("|FILE|write server mode logs to FILE"),
826      GC_ARG_TYPE_PATHNAME, GC_BACKEND_DIRMNGR },
827    { "debug-wait", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
828      NULL, NULL,
829      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
830    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
831      NULL, NULL,
832      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
833
834    { "Enforcement",
835      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
836      "gnupg", N_("Options controlling the interactivity and enforcement") },
837    { "batch", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
838      "dirmngr", "run without asking a user",
839      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
840    { "force", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
841      "dirmngr", "force loading of outdated CRLs",
842      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
843
844    { "HTTP",
845      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
846      "gnupg", N_("Configuration for HTTP servers") },
847    { "disable-http", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
848      "dirmngr", "inhibit the use of HTTP",
849       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
850    { "ignore-http-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
851      "dirmngr", "ignore HTTP CRL distribution points",
852       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
853    { "http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
854      "dirmngr", "|URL|redirect all HTTP requests to URL",
855      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
856    { "honor-http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
857      "gnupg", N_("use system's HTTP proxy setting"),
858      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
859
860    { "LDAP",
861      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
862      "gnupg", N_("Configuration of LDAP servers to use") },
863    { "disable-ldap", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
864      "dirmngr", "inhibit the use of LDAP",
865       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
866    { "ignore-ldap-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
867      "dirmngr", "ignore LDAP CRL distribution points",
868       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
869    { "ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
870      "dirmngr", "|HOST|use HOST for LDAP queries",
871      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
872    { "only-ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
873      "dirmngr", "do not use fallback hosts with --ldap-proxy",
874       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
875    { "add-servers", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
876      "dirmngr", "add new servers discovered in CRL distribution points"
877      " to serverlist", GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
878    { "ldaptimeout", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
879      "dirmngr", "|N|set LDAP timeout to N seconds",
880      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
881    /* The following entry must not be removed, as it is required for
882       the GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST.  */
883    { "ldapserverlist-file",
884      GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
885      "dirmngr", "|FILE|read LDAP server list from FILE",
886      GC_ARG_TYPE_PATHNAME, GC_BACKEND_DIRMNGR },
887    /* This entry must come after at least one entry for
888       GC_BACKEND_DIRMNGR in this component, so that the entry for
889       "ldapserverlist-file will be initialized before this one.  */
890    { "LDAP Server", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
891      "gnupg", N_("LDAP server list"),
892      GC_ARG_TYPE_LDAP_SERVER, GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST },
893    { "max-replies", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
894      "dirmngr", "|N|do not return more than N items in one query",
895      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
896
897    { "OCSP",
898      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
899      "gnupg", N_("Configuration for OCSP") },
900    { "allow-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
901      "dirmngr", "allow sending OCSP requests",
902      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
903    { "ignore-ocsp-service-url", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
904      "dirmngr", "ignore certificate contained OCSP service URLs",
905       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
906    { "ocsp-responder", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
907      "dirmngr", "|URL|use OCSP responder at URL",
908      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
909    { "ocsp-signer", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
910      "dirmngr", "|FPR|OCSP response signed by FPR",
911      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
912
913
914    GC_OPTION_NULL
915  };
916
917 \f
918 /* Component system.  Each component is a set of options that can be
919    configured at the same time.  If you change this, don't forget to
920    update GC_COMPONENT below.  */
921 typedef enum
922   {
923     /* The classic GPG for OpenPGP.  */
924     GC_COMPONENT_GPG,
925
926     /* The GPG Agent.  */
927     GC_COMPONENT_GPG_AGENT,
928
929     /* The Smardcard Daemon.  */
930     GC_COMPONENT_SCDAEMON,
931
932     /* GPG for S/MIME.  */
933     GC_COMPONENT_GPGSM,
934
935     /* The LDAP Directory Manager for CRLs.  */
936     GC_COMPONENT_DIRMNGR,
937
938     /* The number of components.  */
939     GC_COMPONENT_NR
940   } gc_component_t;
941
942
943 /* The information associated with each component.  */
944 static struct
945 {
946   /* The name of this component.  Must not contain a colon (':')
947      character.  */
948   const char *name;
949
950   /* The gettext domain for the description DESC.  If this is NULL,
951      then the description is not translated.  */
952   const char *desc_domain;
953
954   /* The description for this domain.  */
955   const char *desc;
956
957   /* The list of options for this component, terminated by
958      GC_OPTION_NULL.  */
959   gc_option_t *options;
960 } gc_component[] =
961   {
962     { "gpg", NULL,   "GPG for OpenPGP", gc_options_gpg },
963     { "gpg-agent", NULL, "GPG Agent", gc_options_gpg_agent },
964     { "scdaemon", NULL, "Smartcard Daemon", gc_options_scdaemon },
965     { "gpgsm", NULL, "GPG for S/MIME", gc_options_gpgsm },
966     { "dirmngr", NULL, "Directory Manager", gc_options_dirmngr }
967   };
968
969
970
971 /* Structure used to collect error output of the backend programs.  */
972 struct error_line_s;
973 typedef struct error_line_s *error_line_t;
974 struct error_line_s
975 {
976   error_line_t next;   /* Link to next item.  */
977   const char *fname;   /* Name of the config file (points into BUFFER).  */
978   unsigned int lineno; /* Line number of the config file.  */
979   const char *errtext; /* Text of the error message (points into BUFFER).  */
980   char buffer[1];  /* Helper buffer.  */
981 };
982
983
984 \f
985 /* Engine specific support.  */
986 void
987 gpg_agent_runtime_change (void)
988 {
989 #ifndef HAVE_W32_SYSTEM
990   char *agent = getenv ("GPG_AGENT_INFO");
991   char *pid_str;
992   unsigned long pid_long;
993   char *tail;
994   pid_t pid;
995
996   if (!agent)
997     return;
998
999   pid_str = strchr (agent, ':');
1000   if (!pid_str)
1001     return;
1002
1003   pid_str++;
1004   errno = 0;
1005   pid_long = strtoul (pid_str, &tail, 0);
1006   if (errno || (*tail != ':' && *tail != '\0'))
1007     return;
1008
1009   pid = (pid_t) pid_long;
1010
1011   /* Check for overflow.  */
1012   if (pid_long != (unsigned long) pid)
1013     return;
1014
1015   /* Ignore any errors here.  */
1016   kill (pid, SIGHUP);
1017 #endif /*!HAVE_W32_SYSTEM*/
1018 }
1019
1020 \f
1021 /* More or less Robust version of dgettext.  It has the side effect of
1022    switching the codeset to utf-8 because this is what we want to
1023    output.  In theory it is posible to keep the orginal code set and
1024    switch back for regular disgnostic output (redefine "_(" for that)
1025    but given the natur of this tool, being something invoked from
1026    other pograms, it does not make much sense.  */
1027 static const char *
1028 my_dgettext (const char *domain, const char *msgid)
1029 {
1030 #ifdef ENABLE_NLS
1031   if (domain)
1032     {
1033       static int switched_codeset;
1034       char *text;
1035       
1036       if (!switched_codeset)
1037         {
1038           switched_codeset = 1;
1039           bind_textdomain_codeset (PACKAGE_GT, "utf-8");
1040
1041           bindtextdomain ("dirmngr", LOCALEDIR);
1042           bind_textdomain_codeset ("dirmngr", "utf-8");
1043    
1044         }
1045
1046       /* Note: This is a hack to actually use the gnupg2 domain as
1047          long we are in a transition phase where gnupg 1.x and 1.9 may
1048          coexist. */
1049       if (!strcmp (domain, "gnupg"))
1050         domain = PACKAGE_GT;
1051
1052       text = dgettext (domain, msgid);
1053       return text ? text : msgid;
1054     }
1055   else
1056 #endif
1057     return msgid;
1058 }
1059
1060
1061 /* Percent-Escape special characters.  The string is valid until the
1062    next invocation of the function.  */
1063 static char *
1064 my_percent_escape (const char *src)
1065 {
1066   static char *esc_str;
1067   static int esc_str_len;
1068   int new_len = 3 * strlen (src) + 1;
1069   char *dst;
1070
1071   if (esc_str_len < new_len)
1072     {
1073       char *new_esc_str = realloc (esc_str, new_len);
1074       if (!new_esc_str)
1075         gc_error (1, errno, "can not escape string");
1076       esc_str = new_esc_str;
1077       esc_str_len = new_len;
1078     }
1079
1080   dst = esc_str;
1081   while (*src)
1082     {
1083       if (*src == '%')
1084         {
1085           *(dst++) = '%';
1086           *(dst++) = '2';
1087           *(dst++) = '5';
1088         }         
1089       else if (*src == ':')
1090         {
1091           /* The colon is used as field separator.  */
1092           *(dst++) = '%';
1093           *(dst++) = '3';
1094           *(dst++) = 'a';
1095         }
1096       else if (*src == ',')
1097         {
1098           /* The comma is used as list separator.  */
1099           *(dst++) = '%';
1100           *(dst++) = '2';
1101           *(dst++) = 'c';
1102         }
1103       else
1104         *(dst++) = *(src);
1105       src++;
1106     }
1107   *dst = '\0';
1108   return esc_str;
1109 }
1110
1111
1112
1113 /* Percent-Deescape special characters.  The string is valid until the
1114    next invocation of the function.  */
1115 static char *
1116 percent_deescape (const char *src)
1117 {
1118   static char *str;
1119   static int str_len;
1120   int new_len = 3 * strlen (src) + 1;
1121   char *dst;
1122
1123   if (str_len < new_len)
1124     {
1125       char *new_str = realloc (str, new_len);
1126       if (!new_str)
1127         gc_error (1, errno, "can not deescape string");
1128       str = new_str;
1129       str_len = new_len;
1130     }
1131
1132   dst = str;
1133   while (*src)
1134     {
1135       if (*src == '%')
1136         {
1137           int val = hextobyte (src + 1);
1138
1139           if (val < 0)
1140             gc_error (1, 0, "malformed end of string %s", src);
1141
1142           *(dst++) = (char) val;
1143           src += 3;
1144         }         
1145       else
1146         *(dst++) = *(src++);
1147     }
1148   *dst = '\0';
1149   return str;
1150 }
1151
1152 \f
1153 /* List all components that are available.  */
1154 void
1155 gc_component_list_components (FILE *out)
1156 {
1157   gc_component_t component;
1158   gc_option_t *option;
1159   gc_backend_t backend;
1160   int backend_seen[GC_BACKEND_NR];
1161   const char *desc;
1162   const char *pgmname;
1163
1164   for (component = 0; component < GC_COMPONENT_NR; component++)
1165     {
1166       option = gc_component[component].options;
1167       if (option)
1168         {
1169           for (backend = 0; backend < GC_BACKEND_NR; backend++)
1170             backend_seen[backend] = 0;
1171
1172           pgmname = "";
1173           for (; option && option->name; option++)
1174             {
1175               if ((option->flags & GC_OPT_FLAG_GROUP))
1176                 continue;
1177               backend = option->backend;
1178               if (backend_seen[backend])
1179                 continue;
1180               backend_seen[backend] = 1;
1181               assert (backend != GC_BACKEND_ANY);
1182               if (gc_backend[backend].program
1183                   && !gc_backend[backend].module_name)
1184                 continue;
1185               pgmname = gnupg_module_name (gc_backend[backend].module_name);
1186               break;
1187             }
1188
1189           desc = gc_component[component].desc;
1190           desc = my_dgettext (gc_component[component].desc_domain, desc);
1191           fprintf (out, "%s:%s:",
1192                    gc_component[component].name,  my_percent_escape (desc));
1193           fprintf (out, "%s\n",  my_percent_escape (pgmname));
1194         }
1195     }
1196 }
1197
1198
1199 \f
1200 static int
1201 all_digits_p (const char *p, size_t len)
1202 {
1203   if (!len)
1204     return 0; /* No. */
1205   for (; len; len--, p++)
1206     if (!isascii (*p) || !isdigit (*p))
1207       return 0; /* No.  */
1208   return 1; /* Yes.  */
1209 }
1210
1211
1212 /* Collect all error lines from file descriptor FD. Only lines
1213    prefixed with TAG are considered.  Close that file descriptor
1214    then.  Returns a list of error line items (which may be empty).
1215    There is no error return.  */
1216 static error_line_t
1217 collect_error_output (int fd, const char *tag)
1218 {
1219   FILE *fp;
1220   char buffer[1024];
1221   char *p, *p2, *p3;
1222   int c, cont_line;
1223   unsigned int pos;
1224   error_line_t eitem, errlines, *errlines_tail;
1225   size_t taglen = strlen (tag);
1226
1227   fp = fdopen (fd, "r");
1228   if (!fp)
1229     gc_error (1, errno, "can't fdopen pipe for reading");
1230
1231   errlines = NULL;
1232   errlines_tail = &errlines;
1233   pos = 0;
1234   cont_line = 0;
1235   while ((c=getc (fp)) != EOF)
1236     {
1237       buffer[pos++] = c;
1238       if (pos >= sizeof buffer - 5 || c == '\n')
1239         {
1240           buffer[pos - (c == '\n')] = 0;
1241           if (cont_line)
1242             ; /*Ignore continuations of previous line. */
1243           else if (!strncmp (buffer, tag, taglen) && buffer[taglen] == ':') 
1244             {
1245               /* "gpgsm: foo:4: bla" */
1246               /* Yep, we are interested in this line.  */
1247               p = buffer + taglen + 1;
1248               while (*p == ' ' || *p == '\t')
1249                 p++;
1250               if (!*p)
1251                 ; /* Empty lines are ignored.  */
1252               else if ( (p2 = strchr (p, ':')) && (p3 = strchr (p2+1, ':'))
1253                         && all_digits_p (p2+1, p3 - (p2+1)))
1254                 {
1255                   /* Line in standard compiler format.  */
1256                   p3++;
1257                   while (*p3 == ' ' || *p3 == '\t')
1258                     p3++;
1259                   eitem = xmalloc (sizeof *eitem + strlen (p));
1260                   eitem->next = NULL;
1261                   strcpy (eitem->buffer, p);
1262                   eitem->fname = eitem->buffer;
1263                   eitem->buffer[p2-p] = 0;
1264                   eitem->errtext = eitem->buffer + (p3 - p);
1265                   /* (we already checked that there are only ascii
1266                      digits followed by a colon) */
1267                   eitem->lineno = 0;
1268                   for (p2++; isdigit (*p2); p2++)
1269                     eitem->lineno = eitem->lineno*10 + (*p2 - '0');
1270                   *errlines_tail = eitem;
1271                   errlines_tail = &eitem->next;
1272                 }
1273               else
1274                 {
1275                   /* Other error output.  */
1276                   eitem = xmalloc (sizeof *eitem + strlen (p));
1277                   eitem->next = NULL;
1278                   strcpy (eitem->buffer, p);
1279                   eitem->fname = NULL;
1280                   eitem->errtext = eitem->buffer;
1281                   eitem->lineno = 0;
1282                   *errlines_tail = eitem;
1283                   errlines_tail = &eitem->next;
1284                 }
1285             }
1286           pos = 0;
1287           /* If this was not a complete line mark that we are in a
1288              continuation.  */
1289           cont_line = (c != '\n');
1290         }
1291     }
1292   
1293   /* We ignore error lines not terminated by a LF.  */
1294
1295   fclose (fp);
1296   return errlines;
1297 }
1298
1299
1300
1301 /* Check all components that are available.  */
1302 void
1303 gc_component_check_programs (FILE *out)
1304 {
1305   gpg_error_t err;
1306   gc_component_t component;
1307   unsigned int result;
1308   int backend_seen[GC_BACKEND_NR];
1309   gc_backend_t backend;
1310   gc_option_t *option;
1311   const char *desc;
1312   const char *pgmname;
1313   const char *argv[2];
1314   pid_t pid;
1315   int exitcode;
1316   int filedes[2];
1317   error_line_t errlines, errptr;
1318
1319   /* We use a temporary file to collect the error output.  It would be
1320      better to use a pipe here but as of now we have no suitable
1321      fucntion to create a portable pipe outside of exechelp.  Thus it
1322      is easier to use the tempfile approach.  */
1323   for (component = 0; component < GC_COMPONENT_NR; component++)
1324     {
1325       if (!gc_component[component].options)
1326         continue;
1327
1328       for (backend = 0; backend < GC_BACKEND_NR; backend++)
1329         backend_seen[backend] = 0;
1330
1331       option = gc_component[component].options;
1332       for (; option && option->name; option++)
1333         {
1334           if ((option->flags & GC_OPT_FLAG_GROUP))
1335             continue;
1336           backend = option->backend;
1337           if (backend_seen[backend])
1338             continue;
1339           backend_seen[backend] = 1;
1340           assert (backend != GC_BACKEND_ANY);
1341           if (!gc_backend[backend].program)
1342             continue;
1343           if (!gc_backend[backend].module_name)
1344             continue;
1345
1346           pgmname = gnupg_module_name (gc_backend[backend].module_name);
1347           argv[0] = "--gpgconf-test";
1348           argv[1] = NULL;
1349
1350           err = gnupg_create_inbound_pipe (filedes);
1351           if (err)
1352             gc_error (1, 0, _("error creating a pipe: %s\n"), 
1353                       gpg_strerror (err));
1354
1355           result = 0;
1356           errlines = NULL;
1357           if (gnupg_spawn_process_fd (pgmname, argv, -1, -1, filedes[1], &pid))
1358             {
1359               close (filedes[0]);
1360               close (filedes[1]);
1361               result |= 1; /* Program could not be run.  */
1362             }
1363           else 
1364             {
1365               close (filedes[1]);
1366               errlines = collect_error_output (filedes[0], 
1367                                                gc_component[component].name);
1368               if (gnupg_wait_process (pgmname, pid, &exitcode))
1369                 {
1370                   if (exitcode == -1)
1371                     result |= 1; /* Program could not be run or it
1372                                     terminated abnormally.  */
1373                   result |= 2; /* Program returned an error.  */
1374                 }
1375             }
1376           
1377           /* If the program could not be run, we can't tell whether
1378              the config file is good.  */
1379           if ((result&1))
1380             result |= 2;  
1381           
1382           desc = gc_component[component].desc;
1383           desc = my_dgettext (gc_component[component].desc_domain, desc);
1384           fprintf (out, "%s:%s:",
1385                    gc_component[component].name, my_percent_escape (desc));
1386           fputs (my_percent_escape (pgmname), out);
1387           fprintf (out, ":%d:%d:", !(result & 1), !(result & 2));
1388           for (errptr = errlines; errptr; errptr = errptr->next)
1389             {
1390               if (errptr != errlines)
1391                 fputs ("\n:::::", out); /* Continuation line.  */
1392               if (errptr->fname)
1393                 fputs (my_percent_escape (errptr->fname), out);
1394               putc (':', out);
1395               if (errptr->fname)
1396                 fprintf (out, "%u", errptr->lineno);
1397               putc (':', out);
1398               fputs (my_percent_escape (errptr->errtext), out);
1399               putc (':', out);
1400             }
1401           putc ('\n', out);
1402           
1403           while (errlines)
1404             {
1405               error_line_t tmp = errlines->next;
1406               xfree (errlines);
1407               errlines = tmp;
1408             }
1409           break; /* Loop over options of this component  */
1410         }
1411     } 
1412 }
1413
1414
1415 \f
1416 /* Find the component with the name NAME.  Returns -1 if not
1417    found.  */
1418 int
1419 gc_component_find (const char *name)
1420 {
1421   gc_component_t idx;
1422
1423   for (idx = 0; idx < GC_COMPONENT_NR; idx++)
1424     {
1425       if (gc_component[idx].options
1426           && !strcmp (name, gc_component[idx].name))
1427         return idx;
1428     }
1429   return -1;
1430 }
1431
1432 \f
1433 /* List the option OPTION.  */
1434 static void
1435 list_one_option (const gc_option_t *option, FILE *out)
1436 {
1437   const char *desc = NULL;
1438   char *arg_name = NULL;
1439
1440   if (option->desc)
1441     {
1442       desc = my_dgettext (option->desc_domain, option->desc);
1443
1444       if (*desc == '|')
1445         {
1446           const char *arg_tail = strchr (&desc[1], '|');
1447
1448           if (arg_tail)
1449             {
1450               int arg_len = arg_tail - &desc[1];
1451               arg_name = xmalloc (arg_len + 1);
1452               memcpy (arg_name, &desc[1], arg_len);
1453               arg_name[arg_len] = '\0';
1454               desc = arg_tail + 1;
1455             }
1456         }
1457     }
1458
1459
1460   /* YOU MUST NOT REORDER THE FIELDS IN THIS OUTPUT, AS THEIR ORDER IS
1461      PART OF THE EXTERNAL INTERFACE.  YOU MUST NOT REMOVE ANY
1462      FIELDS.  */
1463
1464   /* The name field.  */
1465   fprintf (out, "%s", option->name);
1466
1467   /* The flags field.  */
1468   fprintf (out, ":%lu", option->flags);
1469   if (opt.verbose)
1470     {
1471       putc (' ', out);
1472           
1473       if (!option->flags)
1474         fprintf (out, "none");
1475       else
1476         {
1477           unsigned long flags = option->flags;
1478           unsigned long flag = 0;
1479           unsigned long first = 1;
1480
1481           while (flags)
1482             {
1483               if (flags & 1)
1484                 {
1485                   if (first)
1486                     first = 0;
1487                   else
1488                     putc (',', out);
1489                   fprintf (out, "%s", gc_flag[flag].name);
1490                 }
1491               flags >>= 1;
1492               flag++;
1493             }
1494         }
1495     }
1496
1497   /* The level field.  */
1498   fprintf (out, ":%u", option->level);
1499   if (opt.verbose)
1500     fprintf (out, " %s", gc_level[option->level].name);
1501
1502   /* The description field.  */
1503   fprintf (out, ":%s", desc ? my_percent_escape (desc) : "");
1504   
1505   /* The type field.  */
1506   fprintf (out, ":%u", option->arg_type);
1507   if (opt.verbose)
1508     fprintf (out, " %s", gc_arg_type[option->arg_type].name);
1509
1510   /* The alternate type field.  */
1511   fprintf (out, ":%u", gc_arg_type[option->arg_type].fallback);
1512   if (opt.verbose)
1513     fprintf (out, " %s",
1514              gc_arg_type[gc_arg_type[option->arg_type].fallback].name);
1515
1516   /* The argument name field.  */
1517   fprintf (out, ":%s", arg_name ? my_percent_escape (arg_name) : "");
1518   if (arg_name)
1519     xfree (arg_name);
1520
1521   /* The default value field.  */
1522   fprintf (out, ":%s", option->default_value ? option->default_value : "");
1523
1524   /* The default argument field.  */
1525   fprintf (out, ":%s", option->default_arg ? option->default_arg : "");
1526
1527   /* The value field.  */
1528   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
1529       && (option->flags & GC_OPT_FLAG_LIST)
1530       && option->value)
1531     /* The special format "1,1,1,1,...,1" is converted to a number
1532        here.  */
1533     fprintf (out, ":%u", (unsigned int)((strlen (option->value) + 1) / 2));
1534   else
1535     fprintf (out, ":%s", option->value ? option->value : "");
1536
1537   /* ADD NEW FIELDS HERE.  */
1538
1539   putc ('\n', out);
1540 }
1541
1542
1543 /* List all options of the component COMPONENT.  */
1544 void
1545 gc_component_list_options (int component, FILE *out)
1546 {  
1547   const gc_option_t *option = gc_component[component].options;
1548
1549   while (option && option->name)
1550     {
1551       /* Do not output unknown or internal options.  */
1552       if (!(option->flags & GC_OPT_FLAG_GROUP)
1553           && (!option->active || option->level == GC_LEVEL_INTERNAL))
1554         {
1555           option++;
1556           continue;
1557         }
1558
1559       if (option->flags & GC_OPT_FLAG_GROUP)
1560         {
1561           const gc_option_t *group_option = option + 1;
1562           gc_expert_level_t level = GC_LEVEL_NR;
1563
1564           /* The manual states that the group level is always the
1565              minimum of the levels of all contained options.  Due to
1566              different active options, and because it is hard to
1567              maintain manually, we calculate it here.  The value in
1568              the global static table is ignored.  */
1569           
1570           while (group_option->name)
1571             {
1572               if (group_option->flags & GC_OPT_FLAG_GROUP)
1573                 break;
1574               if (group_option->level < level)
1575                 level = group_option->level;
1576               group_option++;
1577             }
1578
1579           /* Check if group is empty.  */
1580           if (level != GC_LEVEL_NR)
1581             {
1582               gc_option_t opt_copy;
1583
1584               /* Fix up the group level.  */
1585               memcpy (&opt_copy, option, sizeof (opt_copy));
1586               opt_copy.level = level;
1587               list_one_option (&opt_copy, out);
1588             }
1589         }
1590       else
1591         list_one_option (option, out);
1592
1593       option++;
1594     }
1595 }
1596
1597
1598 /* Find the option NAME in component COMPONENT, for the backend
1599    BACKEND.  If BACKEND is GC_BACKEND_ANY, any backend will match.  */
1600 static gc_option_t *
1601 find_option (gc_component_t component, const char *name,
1602              gc_backend_t backend)
1603 {
1604   gc_option_t *option = gc_component[component].options;
1605   while (option->name)
1606     {
1607       if (!(option->flags & GC_OPT_FLAG_GROUP)
1608           && !strcmp (option->name, name)
1609           && (backend == GC_BACKEND_ANY || option->backend == backend))
1610         break;
1611       option++;
1612     }
1613   return option->name ? option : NULL;
1614 }
1615
1616 \f
1617 /* Determine the configuration pathname for the component COMPONENT
1618    and backend BACKEND.  */
1619 static char *
1620 get_config_pathname (gc_component_t component, gc_backend_t backend)
1621 {
1622   char *pathname = NULL;
1623   gc_option_t *option = find_option
1624     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
1625   assert (option);
1626   assert (option->arg_type == GC_ARG_TYPE_PATHNAME);
1627   assert (!(option->flags & GC_OPT_FLAG_LIST));
1628
1629   if (!option->active || !option->default_value)
1630     gc_error (1, 0, "Option %s, needed by backend %s, was not initialized",
1631               gc_backend[backend].option_config_filename,
1632               gc_backend[backend].name);
1633
1634   if (option->value && *option->value)
1635     pathname = percent_deescape (&option->value[1]);
1636   else if (option->default_value && *option->default_value)
1637     pathname = percent_deescape (&option->default_value[1]);
1638   else
1639     pathname = "";
1640
1641 #ifdef HAVE_DOSISH_SYSTEM
1642   if (!(pathname[0] 
1643         && pathname[1] == ':'
1644         && (pathname[2] == '/' || pathname[2] == '\\')))
1645 #else
1646   if (pathname[0] != '/')
1647 #endif
1648     gc_error (1, 0, "Option %s, needed by backend %s, is not absolute",
1649               gc_backend[backend].option_config_filename,
1650               gc_backend[backend].name);
1651
1652   return pathname;
1653 }
1654
1655 \f
1656 /* Retrieve the options for the component COMPONENT from backend
1657    BACKEND, which we already know is a program-type backend.  */
1658 static void
1659 retrieve_options_from_program (gc_component_t component, gc_backend_t backend)
1660 {
1661   gpg_error_t err;
1662   int filedes[2];
1663   const char *pgmname;
1664   const char *argv[2];
1665   int exitcode;
1666   pid_t pid;
1667   char *line = NULL;
1668   size_t line_len = 0;
1669   ssize_t length;
1670   FILE *config;
1671   char *config_pathname;
1672
1673   err = gnupg_create_inbound_pipe (filedes);
1674   if (err)
1675     gc_error (1, 0, _("error creating a pipe: %s\n"), gpg_strerror (err));
1676
1677   pgmname = (gc_backend[backend].module_name 
1678              ? gnupg_module_name (gc_backend[backend].module_name) 
1679              : gc_backend[backend].program );
1680   argv[0] = "--gpgconf-list";
1681   argv[1] = NULL;
1682
1683   err = gnupg_spawn_process_fd (pgmname, argv, -1, filedes[1], -1, &pid);
1684   if (err)
1685     {
1686       close (filedes[0]);
1687       close (filedes[1]);
1688       gc_error (1, 0, "could not gather active options from `%s': %s",
1689                 pgmname, gpg_strerror (err));
1690     }
1691   close (filedes[1]);
1692   config = fdopen (filedes[0], "r");
1693   if (!config)
1694     gc_error (1, errno, "can't fdopen pipe for reading");
1695
1696   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1697     {
1698       gc_option_t *option;
1699       char *linep;
1700       unsigned long flags = 0;
1701       char *default_value = NULL;
1702       
1703       /* Strip newline and carriage return, if present.  */
1704       while (length > 0
1705              && (line[length - 1] == '\n' || line[length - 1] == '\r'))
1706         line[--length] = '\0';
1707
1708       linep = strchr (line, ':');
1709       if (linep)
1710         *(linep++) = '\0';
1711       
1712       /* Extract additional flags.  Default to none.  */
1713       if (linep)
1714         {
1715           char *end;
1716           char *tail;
1717
1718           end = strchr (linep, ':');
1719           if (end)
1720             *(end++) = '\0';
1721
1722           errno = 0;
1723           flags = strtoul (linep, &tail, 0);
1724           if (errno)
1725             gc_error (1, errno, "malformed flags in option %s from %s",
1726                       line, pgmname);
1727           if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
1728             gc_error (1, 0, "garbage after flags in option %s from %s",
1729                       line, pgmname);
1730
1731           linep = end;
1732         }
1733
1734       /* Extract default value, if present.  Default to empty if
1735          not.  */
1736       if (linep)
1737         {
1738           char *end;
1739
1740           end = strchr (linep, ':');
1741           if (end)
1742             *(end++) = '\0';
1743
1744           if (flags & GC_OPT_FLAG_DEFAULT)
1745             default_value = linep;
1746
1747           linep = end;
1748         }
1749
1750       /* Look up the option in the component and install the
1751          configuration data.  */
1752       option = find_option (component, line, backend);
1753       if (option)
1754         {
1755           if (option->active)
1756             gc_error (1, errno, "option %s returned twice from %s",
1757                       line, pgmname);
1758           option->active = 1;
1759
1760           option->flags |= flags;
1761           if (default_value && *default_value)
1762             option->default_value = xstrdup (default_value);
1763         }
1764     }
1765   if (length < 0 || ferror (config))
1766     gc_error (1, errno, "error reading from %s",pgmname);
1767   if (fclose (config) && ferror (config))
1768     gc_error (1, errno, "error closing %s", pgmname);
1769
1770   err = gnupg_wait_process (pgmname, pid, &exitcode);
1771   if (err)
1772     gc_error (1, 0, "running %s failed (exitcode=%d): %s",
1773               pgmname, exitcode, gpg_strerror (err));
1774
1775
1776   /* At this point, we can parse the configuration file.  */
1777   config_pathname = get_config_pathname (component, backend);
1778
1779   config = fopen (config_pathname, "r");
1780   if (!config)
1781     gc_error (0, errno, "warning: can not open config file %s",
1782               config_pathname);
1783   else
1784     {
1785       while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1786         {
1787           char *name;
1788           char *value;
1789           gc_option_t *option;
1790           
1791           name = line;
1792           while (*name == ' ' || *name == '\t')
1793             name++;
1794           if (!*name || *name == '#' || *name == '\r' || *name == '\n')
1795             continue;
1796
1797           value = name;
1798           while (*value && *value != ' ' && *value != '\t'
1799                  && *value != '#' && *value != '\r' && *value != '\n')
1800             value++;
1801           if (*value == ' ' || *value == '\t')
1802             {
1803               char *end;
1804
1805               *(value++) = '\0';
1806               while (*value == ' ' || *value == '\t')
1807                 value++;
1808
1809               end = value;
1810               while (*end && *end != '#' && *end != '\r' && *end != '\n')
1811                 end++;
1812               while (end > value && (end[-1] == ' ' || end[-1] == '\t'))
1813                 end--;
1814               *end = '\0';
1815             }
1816           else
1817             *value = '\0';
1818
1819           /* Look up the option in the component and install the
1820              configuration data.  */
1821           option = find_option (component, line, backend);
1822           if (option)
1823             {
1824               char *opt_value;
1825
1826               if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
1827                 {
1828                   if (*value)
1829                     gc_error (0, 0,
1830                               "warning: ignoring argument %s for option %s",
1831                               value, name);
1832                   opt_value = xstrdup ("1");
1833                 }
1834               else if (gc_arg_type[option->arg_type].fallback
1835                        == GC_ARG_TYPE_STRING)
1836                 opt_value = xasprintf ("\"%s", my_percent_escape (value));
1837               else
1838                 {
1839                   /* FIXME: Verify that the number is sane.  */
1840                   opt_value = xstrdup (value);
1841                 }
1842
1843               /* Now enter the option into the table.  */
1844               if (!(option->flags & GC_OPT_FLAG_LIST))
1845                 {
1846                   if (option->value)
1847                     free (option->value);
1848                   option->value = opt_value;
1849                 }
1850               else
1851                 {
1852                   if (!option->value)
1853                     option->value = opt_value;
1854                   else
1855                     {
1856                       char *opt_val = opt_value;
1857
1858                       option->value = xasprintf ("%s,%s", option->value,
1859                                                  opt_val);
1860                       xfree (opt_value);
1861                     }
1862                 }
1863             }
1864         }
1865
1866       if (length < 0 || ferror (config))
1867         gc_error (1, errno, "error reading from %s", config_pathname);
1868       if (fclose (config) && ferror (config))
1869         gc_error (1, errno, "error closing %s", config_pathname);
1870     }
1871
1872   xfree (line);
1873 }
1874
1875
1876 /* Retrieve the options for the component COMPONENT from backend
1877    BACKEND, which we already know is of type file list.  */ 
1878 static void
1879 retrieve_options_from_file (gc_component_t component, gc_backend_t backend)
1880 {
1881   gc_option_t *list_option;
1882   char *list_pathname;
1883   FILE *list_file;
1884   char *line = NULL;
1885   size_t line_len = 0;
1886   ssize_t length;
1887   char *list = NULL;
1888
1889   list_option = find_option (component,
1890                              gc_backend[backend].option_name, GC_BACKEND_ANY);
1891   assert (list_option);
1892   assert (!list_option->active);
1893
1894   list_pathname = get_config_pathname (component, backend);
1895   list_file = fopen (list_pathname, "r");
1896   if (!list_file)
1897     gc_error (0, errno, "warning: can not open list file %s", list_pathname);
1898   else
1899     {
1900
1901       while ((length = read_line (list_file, &line, &line_len, NULL)) > 0)
1902         {
1903           char *start;
1904           char *end;
1905           char *new_list;
1906
1907           start = line;
1908           while (*start == ' ' || *start == '\t')
1909             start++;
1910           if (!*start || *start == '#' || *start == '\r' || *start == '\n')
1911             continue;
1912
1913           end = start;
1914           while (*end && *end != '#' && *end != '\r' && *end != '\n')
1915             end++;
1916           /* Walk back to skip trailing white spaces.  Looks evil, but
1917              works because of the conditions on START and END imposed
1918              at this point (END is at least START + 1, and START is
1919              not a whitespace character).  */
1920           while (*(end - 1) == ' ' || *(end - 1) == '\t')
1921             end--;
1922           *end = '\0';
1923           /* FIXME: Oh, no!  This is so lame!  Should use realloc and
1924              really append.  */
1925           if (list)
1926             {
1927               new_list = xasprintf ("%s,\"%s", list, my_percent_escape (start));
1928               xfree (list);
1929               list = new_list;
1930             }
1931           else
1932             list = xasprintf ("\"%s", my_percent_escape (start));
1933         }
1934       if (length < 0 || ferror (list_file))
1935         gc_error (1, errno, "can not read list file %s", list_pathname);
1936     }
1937
1938   list_option->active = 1;
1939   list_option->value = list;
1940
1941   if (list_file && fclose (list_file) && ferror (list_file))
1942     gc_error (1, errno, "error closing %s", list_pathname);
1943   xfree (line);
1944 }
1945
1946
1947 /* Retrieve the currently active options and their defaults from all
1948    involved backends for this component.  Using -1 for component will
1949    retrieve all options from all components. */
1950 void
1951 gc_component_retrieve_options (int component)
1952 {
1953   int process_all = 0;
1954   int backend_seen[GC_BACKEND_NR];
1955   gc_backend_t backend;
1956   gc_option_t *option;
1957
1958   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1959     backend_seen[backend] = 0;
1960
1961   if (component == -1)
1962     {
1963       process_all = 1;
1964       component = 0;
1965       assert (component < GC_COMPONENT_NR);
1966     }
1967       
1968   do
1969     {
1970       option = gc_component[component].options;
1971
1972       while (option && option->name)
1973         {
1974           if (!(option->flags & GC_OPT_FLAG_GROUP))
1975             {
1976               backend = option->backend;
1977               
1978               if (backend_seen[backend])
1979                 {
1980                   option++;
1981                   continue;
1982                 }
1983               backend_seen[backend] = 1;
1984               
1985               assert (backend != GC_BACKEND_ANY);
1986               
1987               if (gc_backend[backend].program)
1988                 retrieve_options_from_program (component, backend);
1989               else
1990                 retrieve_options_from_file (component, backend);
1991             }
1992           option++;
1993         }
1994     }
1995   while (process_all && ++component < GC_COMPONENT_NR);
1996
1997 }
1998
1999
2000 \f
2001 /* Perform a simple validity check based on the type.  Return in
2002    NEW_VALUE_NR the value of the number in NEW_VALUE if OPTION is of
2003    type GC_ARG_TYPE_NONE.  */
2004 static void
2005 option_check_validity (gc_option_t *option, unsigned long flags,
2006                        char *new_value, unsigned long *new_value_nr)
2007 {
2008   char *arg;
2009
2010   if (!option->active)
2011     gc_error (1, 0, "option %s not supported by backend %s",
2012               option->name, gc_backend[option->backend].name);
2013       
2014   if (option->new_flags || option->new_value)
2015     gc_error (1, 0, "option %s already changed", option->name);
2016
2017   if (flags & GC_OPT_FLAG_DEFAULT)
2018     {
2019       if (*new_value)
2020         gc_error (1, 0, "argument %s provided for deleted option %s",
2021                   new_value, option->name);
2022
2023       return;
2024     }
2025
2026   /* GC_ARG_TYPE_NONE options have special list treatment.  */
2027   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
2028     {
2029       char *tail;
2030
2031       errno = 0;
2032       *new_value_nr = strtoul (new_value, &tail, 0);
2033
2034       if (errno)
2035         gc_error (1, errno, "invalid argument for option %s",
2036                   option->name);
2037       if (*tail)
2038         gc_error (1, 0, "garbage after argument for option %s",
2039                       option->name);
2040
2041       if (!(option->flags & GC_OPT_FLAG_LIST))
2042         {
2043           if (*new_value_nr != 1)
2044             gc_error (1, 0, "argument for non-list option %s of type 0 "
2045                       "(none) must be 1", option->name);
2046         }
2047       else
2048         {
2049           if (*new_value_nr == 0)
2050             gc_error (1, 0, "argument for option %s of type 0 (none) "
2051                       "must be positive", option->name);
2052         }
2053
2054       return;
2055     }
2056
2057   arg = new_value;
2058   do
2059     {
2060       if (*arg == '\0' || *arg == ',')
2061         {
2062           if (!(option->flags & GC_OPT_FLAG_ARG_OPT))
2063             gc_error (1, 0, "argument required for option %s", option->name);
2064
2065           if (*arg == ',' && !(option->flags & GC_OPT_FLAG_LIST))
2066             gc_error (1, 0, "list found for non-list option %s", option->name);
2067         }
2068       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_STRING)
2069         {
2070           if (*arg != '"')
2071             gc_error (1, 0, "string argument for option %s must begin "
2072                       "with a quote (\") character", option->name);
2073
2074           /* FIXME: We do not allow empty string arguments for now, as
2075              we do not quote arguments in configuration files, and
2076              thus no argument is indistinguishable from the empty
2077              string.  */
2078           if (arg[1] == '\0' || arg[1] == ',')
2079             gc_error (1, 0, "empty string argument for option %s is "
2080                       "currently not allowed.  Please report this!",
2081                       option->name);
2082         }
2083       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2084         {
2085           errno = 0;
2086           (void) strtol (arg, &arg, 0);
2087
2088           if (errno)
2089             gc_error (1, errno, "invalid argument for option %s",
2090                       option->name);
2091
2092           if (*arg != '\0' && *arg != ',')
2093             gc_error (1, 0, "garbage after argument for option %s",
2094                       option->name);
2095         }
2096       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2097         {
2098           errno = 0;
2099           (void) strtoul (arg, &arg, 0);
2100
2101           if (errno)
2102             gc_error (1, errno, "invalid argument for option %s",
2103                       option->name);
2104
2105           if (*arg != '\0' && *arg != ',')
2106             gc_error (1, 0, "garbage after argument for option %s",
2107                       option->name);
2108         }
2109       arg = strchr (arg, ',');
2110       if (arg)
2111         arg++;
2112     }
2113   while (arg && *arg);
2114 }
2115
2116 #ifdef HAVE_W32_SYSTEM
2117 int
2118 copy_file (const char *src_name, const char *dst_name)
2119 {
2120 #define BUF_LEN 4096
2121   char buffer[BUF_LEN];
2122   int len;
2123   FILE *src;
2124   FILE *dst;
2125
2126   src = fopen (src_name, "r");
2127   if (src == NULL)
2128     return -1;
2129
2130   dst = fopen (dst_name, "w");
2131   if (dst == NULL)
2132     {
2133       int saved_err = errno;
2134       fclose (src);
2135       errno = saved_err;
2136       return -1;
2137     }
2138
2139   do
2140     {
2141       int written;
2142
2143       len = fread (buffer, 1, BUF_LEN, src);
2144       if (len == 0)
2145         break;
2146       written = fwrite (buffer, 1, len, dst);
2147       if (written != len)
2148         break;
2149     }
2150   while (!feof (src) && !ferror (src) && !ferror (dst));
2151
2152   if (ferror (src) || ferror (dst) || !feof (src))
2153     {
2154       int saved_errno = errno;
2155       fclose (src);
2156       fclose (dst);
2157       unlink (dst_name);
2158       errno = saved_errno;
2159       return -1;
2160     }
2161
2162   if (fclose (dst) && ferror (dst))
2163     gc_error (1, errno, "error closing %s", dst_name);
2164   if (fclose (src) && ferror (src))
2165     gc_error (1, errno, "error closing %s", src_name);
2166
2167   return 0;
2168 }
2169 #endif /* HAVE_W32_SYSTEM */
2170
2171
2172 /* Create and verify the new configuration file for the specified
2173    backend and component.  Returns 0 on success and -1 on error.  */
2174 static int
2175 change_options_file (gc_component_t component, gc_backend_t backend,
2176                      char **src_filenamep, char **dest_filenamep,
2177                      char **orig_filenamep)
2178 {
2179   static const char marker[] = "###+++--- GPGConf ---+++###";
2180   /* True if we are within the marker in the config file.  */
2181   int in_marker = 0;
2182   gc_option_t *option;
2183   char *line = NULL;
2184   size_t line_len;
2185   ssize_t length;
2186   int res;
2187   int fd;
2188   FILE *src_file = NULL;
2189   FILE *dest_file = NULL;
2190   char *src_filename;
2191   char *dest_filename;
2192   char *orig_filename;
2193   char *arg;
2194   char *cur_arg = NULL;
2195
2196   option = find_option (component,
2197                         gc_backend[backend].option_name, GC_BACKEND_ANY);
2198   assert (option);
2199   assert (option->active);
2200   assert (gc_arg_type[option->arg_type].fallback != GC_ARG_TYPE_NONE);
2201
2202   /* FIXME.  Throughout the function, do better error reporting.  */
2203   /* Note that get_config_pathname() calls percent_deescape(), so we
2204      call this before processing the arguments.  */
2205   dest_filename = xstrdup (get_config_pathname (component, backend));
2206   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, getpid ());
2207   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename, getpid ());
2208
2209   arg = option->new_value;
2210   if (arg && arg[0] == '\0')
2211     arg = NULL;
2212   else if (arg)
2213     {
2214       char *end;
2215
2216       arg++;
2217       end = strchr (arg, ',');
2218       if (end)
2219         *end = '\0';
2220
2221       cur_arg = percent_deescape (arg);
2222       if (end)
2223         {
2224           *end = ',';
2225           arg = end + 1;
2226         }
2227       else
2228         arg = NULL;
2229     }
2230
2231 #ifdef HAVE_W32_SYSTEM
2232   res = copy_file (dest_filename, orig_filename);
2233 #else
2234   res = link (dest_filename, orig_filename);
2235 #endif
2236   if (res < 0 && errno != ENOENT)
2237     return -1;
2238   if (res < 0)
2239     {
2240       xfree (orig_filename);
2241       orig_filename = NULL;
2242     }
2243
2244   /* We now initialize the return strings, so the caller can do the
2245      cleanup for us.  */
2246   *src_filenamep = src_filename;
2247   *dest_filenamep = dest_filename;
2248   *orig_filenamep = orig_filename;
2249
2250   /* Use open() so that we can use O_EXCL.  */
2251   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2252   if (fd < 0)
2253     return -1;
2254   src_file = fdopen (fd, "w");
2255   res = errno;
2256   if (!src_file)
2257     {
2258       errno = res;
2259       return -1;
2260     }
2261
2262   /* Only if ORIG_FILENAME is not NULL did the configuration file
2263      exist already.  In this case, we will copy its content into the
2264      new configuration file, changing it to our liking in the
2265      process.  */
2266   if (orig_filename)
2267     {
2268       dest_file = fopen (dest_filename, "r");
2269       if (!dest_file)
2270         goto change_file_one_err;
2271
2272       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2273         {
2274           int disable = 0;
2275           char *start;
2276
2277           if (!strncmp (marker, line, sizeof (marker) - 1))
2278             {
2279               if (!in_marker)
2280                 in_marker = 1;
2281               else
2282                 break;
2283             }
2284
2285           start = line;
2286           while (*start == ' ' || *start == '\t')
2287             start++;
2288           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2289             {
2290               char *end;
2291               char *endp;
2292               char saved_end;
2293
2294               endp = start;
2295               end = endp;
2296
2297               /* Search for the end of the line.  */
2298               while (*endp && *endp != '#' && *endp != '\r' && *endp != '\n')
2299                 {
2300                   endp++;
2301                   if (*endp && *endp != ' ' && *endp != '\t'
2302                       && *endp != '\r' && *endp != '\n' && *endp != '#')
2303                     end = endp + 1;
2304                 }
2305               saved_end = *end;
2306               *end = '\0';
2307
2308               if ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2309                   || !cur_arg || strcmp (start, cur_arg))
2310                 disable = 1;
2311               else
2312                 {
2313                   /* Find next argument.  */
2314                   if (arg)
2315                     {
2316                       char *arg_end;
2317
2318                       arg++;
2319                       arg_end = strchr (arg, ',');
2320                       if (arg_end)
2321                         *arg_end = '\0';
2322
2323                       cur_arg = percent_deescape (arg);
2324                       if (arg_end)
2325                         {
2326                           *arg_end = ',';
2327                           arg = arg_end + 1;
2328                         }
2329                       else
2330                         arg = NULL;
2331                     }
2332                   else
2333                     cur_arg = NULL;
2334                 }
2335
2336               *end = saved_end;
2337             }
2338
2339           if (disable)
2340             {
2341               if (!in_marker)
2342                 {
2343                   fprintf (src_file,
2344                            "# GPGConf disabled this option here at %s\n",
2345                            asctimestamp (gnupg_get_time ()));
2346                   if (ferror (src_file))
2347                     goto change_file_one_err;
2348                   fprintf (src_file, "# %s", line);
2349                   if (ferror (src_file))
2350                     goto change_file_one_err;
2351                 }
2352             }
2353           else
2354             {
2355               fprintf (src_file, "%s", line);
2356               if (ferror (src_file))
2357                 goto change_file_one_err;
2358             }
2359         }
2360       if (length < 0 || ferror (dest_file))
2361         goto change_file_one_err;
2362     }
2363
2364   if (!in_marker)
2365     {
2366       /* There was no marker.  This is the first time we edit the
2367          file.  We add our own marker at the end of the file and
2368          proceed.  Note that we first write a newline, this guards us
2369          against files which lack the newline at the end of the last
2370          line, while it doesn't hurt us in all other cases.  */
2371       fprintf (src_file, "\n%s\n", marker);
2372       if (ferror (src_file))
2373         goto change_file_one_err;
2374     }
2375
2376   /* At this point, we have copied everything up to the end marker
2377      into the new file, except for the arguments we are going to add.
2378      Now, dump the new arguments and write the end marker, possibly
2379      followed by the rest of the original file.  */
2380   while (cur_arg)
2381     {
2382       fprintf (src_file, "%s\n", cur_arg);
2383
2384       /* Find next argument.  */
2385       if (arg)
2386         {
2387           char *end;
2388
2389           arg++;
2390           end = strchr (arg, ',');
2391           if (end)
2392             *end = '\0';
2393
2394           cur_arg = percent_deescape (arg);
2395           if (end)
2396             {
2397               *end = ',';
2398               arg = end + 1;
2399             }
2400           else
2401             arg = NULL;
2402         }
2403       else
2404         cur_arg = NULL;
2405     }
2406
2407   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2408   if (ferror (src_file))
2409     goto change_file_one_err;
2410
2411   if (!in_marker)
2412     {
2413       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2414       if (ferror (src_file))
2415         goto change_file_one_err;
2416       fprintf (src_file, "# It will disable options before this marked "
2417                "block, but it will\n");
2418       if (ferror (src_file))
2419         goto change_file_one_err;
2420       fprintf (src_file, "# never change anything below these lines.\n");
2421       if (ferror (src_file))
2422         goto change_file_one_err;
2423     }
2424   if (dest_file)
2425     {
2426       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2427         {
2428           fprintf (src_file, "%s", line);
2429           if (ferror (src_file))
2430             goto change_file_one_err;
2431         }
2432       if (length < 0 || ferror (dest_file))
2433         goto change_file_one_err;
2434     }
2435   xfree (line);
2436   line = NULL;
2437
2438   res = fclose (src_file);
2439   if (res)
2440     {
2441       res = errno;
2442       close (fd);
2443       if (dest_file)
2444         fclose (dest_file);
2445       errno = res;
2446       return -1;
2447     }
2448   close (fd);
2449   if (dest_file)
2450     {
2451       res = fclose (dest_file);
2452       if (res)
2453         return -1;
2454     }
2455   return 0;
2456
2457  change_file_one_err:
2458   xfree (line);
2459   res = errno;
2460   if (src_file)
2461     {
2462       fclose (src_file);
2463       close (fd);
2464     }
2465   if (dest_file)
2466     fclose (dest_file);
2467   errno = res;
2468   return -1;
2469 }
2470
2471
2472 /* Create and verify the new configuration file for the specified
2473    backend and component.  Returns 0 on success and -1 on error.  */
2474 static int
2475 change_options_program (gc_component_t component, gc_backend_t backend,
2476                         char **src_filenamep, char **dest_filenamep,
2477                         char **orig_filenamep)
2478 {
2479   static const char marker[] = "###+++--- GPGConf ---+++###";
2480   /* True if we are within the marker in the config file.  */
2481   int in_marker = 0;
2482   gc_option_t *option;
2483   char *line = NULL;
2484   size_t line_len;
2485   ssize_t length;
2486   int res;
2487   int fd;
2488   FILE *src_file = NULL;
2489   FILE *dest_file = NULL;
2490   char *src_filename;
2491   char *dest_filename;
2492   char *orig_filename;
2493   /* Special hack for gpg, see below.  */
2494   int utf8strings_seen = 0;
2495
2496   /* FIXME.  Throughout the function, do better error reporting.  */
2497   dest_filename = xstrdup (get_config_pathname (component, backend));
2498   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, getpid ());
2499   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename, getpid ());
2500
2501 #ifdef HAVE_W32_SYSTEM
2502   res = copy_file (dest_filename, orig_filename);
2503 #else
2504   res = link (dest_filename, orig_filename);
2505 #endif
2506   if (res < 0 && errno != ENOENT)
2507     return -1;
2508   if (res < 0)
2509     {
2510       xfree (orig_filename);
2511       orig_filename = NULL;
2512     }
2513
2514   /* We now initialize the return strings, so the caller can do the
2515      cleanup for us.  */
2516   *src_filenamep = src_filename;
2517   *dest_filenamep = dest_filename;
2518   *orig_filenamep = orig_filename;
2519
2520   /* Use open() so that we can use O_EXCL.  */
2521   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2522   if (fd < 0)
2523     return -1;
2524   src_file = fdopen (fd, "w");
2525   res = errno;
2526   if (!src_file)
2527     {
2528       errno = res;
2529       return -1;
2530     }
2531
2532   /* Only if ORIG_FILENAME is not NULL did the configuration file
2533      exist already.  In this case, we will copy its content into the
2534      new configuration file, changing it to our liking in the
2535      process.  */
2536   if (orig_filename)
2537     {
2538       dest_file = fopen (dest_filename, "r");
2539       if (!dest_file)
2540         goto change_one_err;
2541
2542       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2543         {
2544           int disable = 0;
2545           char *start;
2546
2547           if (!strncmp (marker, line, sizeof (marker) - 1))
2548             {
2549               if (!in_marker)
2550                 in_marker = 1;
2551               else
2552                 break;
2553             }
2554           else if (backend == GC_BACKEND_GPG && in_marker
2555                    && ! strcmp ("utf8-strings\n", line))
2556             {
2557               /* Strip duplicated entries.  */
2558               if (utf8strings_seen)
2559                 disable = 1;
2560               else
2561                 utf8strings_seen = 1;
2562             }
2563
2564           start = line;
2565           while (*start == ' ' || *start == '\t')
2566             start++;
2567           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2568             {
2569               char *end;
2570               char saved_end;
2571
2572               end = start;
2573               while (*end && *end != ' ' && *end != '\t'
2574                      && *end != '\r' && *end != '\n' && *end != '#')
2575                 end++;
2576               saved_end = *end;
2577               *end = '\0';
2578
2579               option = find_option (component, start, backend);
2580               *end = saved_end;
2581               if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2582                              || option->new_value))
2583                 disable = 1;
2584             }
2585           if (disable)
2586             {
2587               if (!in_marker)
2588                 {
2589                   fprintf (src_file,
2590                            "# GPGConf disabled this option here at %s\n",
2591                            asctimestamp (gnupg_get_time ()));
2592                   if (ferror (src_file))
2593                     goto change_one_err;
2594                   fprintf (src_file, "# %s", line);
2595                   if (ferror (src_file))
2596                     goto change_one_err;
2597                 }
2598             }
2599           else
2600             {
2601               fprintf (src_file, "%s", line);
2602               if (ferror (src_file))
2603                 goto change_one_err;
2604             }
2605         }
2606       if (length < 0 || ferror (dest_file))
2607         goto change_one_err;
2608     }
2609
2610   if (!in_marker)
2611     {
2612       /* There was no marker.  This is the first time we edit the
2613          file.  We add our own marker at the end of the file and
2614          proceed.  Note that we first write a newline, this guards us
2615          against files which lack the newline at the end of the last
2616          line, while it doesn't hurt us in all other cases.  */
2617       fprintf (src_file, "\n%s\n", marker);
2618       if (ferror (src_file))
2619         goto change_one_err;
2620     }
2621   /* At this point, we have copied everything up to the end marker
2622      into the new file, except for the options we are going to change.
2623      Now, dump the changed options (except for those we are going to
2624      revert to their default), and write the end marker, possibly
2625      followed by the rest of the original file.  */
2626
2627   /* We have to turn on UTF8 strings for GnuPG.  */
2628   if (backend == GC_BACKEND_GPG && ! utf8strings_seen)
2629     fprintf (src_file, "utf8-strings\n");
2630
2631   option = gc_component[component].options;
2632   while (option->name)
2633     {
2634       if (!(option->flags & GC_OPT_FLAG_GROUP)
2635           && option->backend == backend
2636           && option->new_value)
2637         {
2638           char *arg = option->new_value;
2639
2640           do
2641             {
2642               if (*arg == '\0' || *arg == ',')
2643                 {
2644                   fprintf (src_file, "%s\n", option->name);
2645                   if (ferror (src_file))
2646                     goto change_one_err;
2647                 }
2648               else if (gc_arg_type[option->arg_type].fallback
2649                        == GC_ARG_TYPE_NONE)
2650                 {
2651                   assert (*arg == '1');
2652                   fprintf (src_file, "%s\n", option->name);
2653                   if (ferror (src_file))
2654                     goto change_one_err;
2655
2656                   arg++;
2657                 }
2658               else if (gc_arg_type[option->arg_type].fallback
2659                        == GC_ARG_TYPE_STRING)
2660                 {
2661                   char *end;
2662                   
2663                   assert (*arg == '"');
2664                   arg++;
2665                   
2666                   end = strchr (arg, ',');
2667                   if (end)
2668                     *end = '\0';
2669
2670                   fprintf (src_file, "%s %s\n", option->name,
2671                            percent_deescape (arg));
2672                   if (ferror (src_file))
2673                     goto change_one_err;
2674
2675                   if (end)
2676                     *end = ',';
2677                   arg = end;
2678                 }
2679               else
2680                 {
2681                   char *end;
2682
2683                   end = strchr (arg, ',');
2684                   if (end)
2685                     *end = '\0';
2686
2687                   fprintf (src_file, "%s %s\n", option->name, arg);
2688                   if (ferror (src_file))
2689                     goto change_one_err;
2690
2691                   if (end)
2692                     *end = ',';
2693                   arg = end;
2694                 }
2695
2696               assert (arg == NULL || *arg == '\0' || *arg == ',');
2697               if (arg && *arg == ',')
2698                 arg++;
2699             }
2700           while (arg && *arg);
2701         }
2702       option++;
2703     }
2704
2705   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2706   if (ferror (src_file))
2707     goto change_one_err;
2708
2709   if (!in_marker)
2710     {
2711       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2712       if (ferror (src_file))
2713         goto change_one_err;
2714       fprintf (src_file, "# It will disable options before this marked "
2715                "block, but it will\n");
2716       if (ferror (src_file))
2717         goto change_one_err;
2718       fprintf (src_file, "# never change anything below these lines.\n");
2719       if (ferror (src_file))
2720         goto change_one_err;
2721     }
2722   if (dest_file)
2723     {
2724       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2725         {
2726           fprintf (src_file, "%s", line);
2727           if (ferror (src_file))
2728             goto change_one_err;
2729         }
2730       if (length < 0 || ferror (dest_file))
2731         goto change_one_err;
2732     }
2733   xfree (line);
2734   line = NULL;
2735
2736   res = fclose (src_file);
2737   if (res)
2738     {
2739       res = errno;
2740       close (fd);
2741       if (dest_file)
2742         fclose (dest_file);
2743       errno = res;
2744       return -1;
2745     }
2746   close (fd);
2747   if (dest_file)
2748     {
2749       res = fclose (dest_file);
2750       if (res)
2751         return -1;
2752     }
2753   return 0;
2754
2755  change_one_err:
2756   xfree (line);
2757   res = errno;
2758   if (src_file)
2759     {
2760       fclose (src_file);
2761       close (fd);
2762     }
2763   if (dest_file)
2764     fclose (dest_file);
2765   errno = res;
2766   return -1;
2767 }
2768
2769
2770 /* Common code for gc_component_change_options and
2771    gc_process_gpgconf_conf.  */
2772 static void
2773 change_one_value (gc_option_t *option, int *runtime,
2774                   unsigned long flags, char *new_value)
2775 {
2776   unsigned long new_value_nr = 0;
2777
2778   option_check_validity (option, flags, new_value, &new_value_nr);
2779
2780   if (option->flags & GC_OPT_FLAG_RUNTIME)
2781     runtime[option->backend] = 1;
2782
2783   option->new_flags = flags;
2784   if (!(flags & GC_OPT_FLAG_DEFAULT))
2785     {
2786       if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
2787           && (option->flags & GC_OPT_FLAG_LIST))
2788         {
2789           char *str;
2790
2791           /* We convert the number to a list of 1's for convenient
2792              list handling.  */
2793           assert (new_value_nr > 0);
2794           option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
2795           str = option->new_value;
2796           *(str++) = '1';
2797           while (--new_value_nr > 0)
2798             {
2799               *(str++) = ',';
2800               *(str++) = '1';
2801             }
2802           *(str++) = '\0';
2803         }
2804       else
2805         option->new_value = xstrdup (new_value);
2806     }
2807 }
2808
2809
2810 /* Read the modifications from IN and apply them.  If IN is NULL the
2811    modifications are expected to already have been set to the global
2812    table. */
2813 void
2814 gc_component_change_options (int component, FILE *in)
2815 {
2816   int err = 0;
2817   int runtime[GC_BACKEND_NR];
2818   char *src_pathname[GC_BACKEND_NR];
2819   char *dest_pathname[GC_BACKEND_NR];
2820   char *orig_pathname[GC_BACKEND_NR];
2821   gc_backend_t backend;
2822   gc_option_t *option;
2823   char *line = NULL;
2824   size_t line_len = 0;
2825   ssize_t length;
2826
2827   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2828     {
2829       runtime[backend] = 0;
2830       src_pathname[backend] = NULL;
2831       dest_pathname[backend] = NULL;
2832       orig_pathname[backend] = NULL;
2833     }
2834
2835   if (in)
2836     {
2837       /* Read options from the file IN.  */
2838       while ((length = read_line (in, &line, &line_len, NULL)) > 0)
2839         {
2840           char *linep;
2841           unsigned long flags = 0;
2842           char *new_value = "";
2843           
2844           /* Strip newline and carriage return, if present.  */
2845           while (length > 0
2846                  && (line[length - 1] == '\n' || line[length - 1] == '\r'))
2847             line[--length] = '\0';
2848           
2849           linep = strchr (line, ':');
2850           if (linep)
2851             *(linep++) = '\0';
2852           
2853           /* Extract additional flags.  Default to none.  */
2854           if (linep)
2855             {
2856               char *end;
2857               char *tail;
2858
2859               end = strchr (linep, ':');
2860               if (end)
2861                 *(end++) = '\0';
2862               
2863               errno = 0;
2864               flags = strtoul (linep, &tail, 0);
2865               if (errno)
2866                 gc_error (1, errno, "malformed flags in option %s", line);
2867               if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
2868                 gc_error (1, 0, "garbage after flags in option %s", line);
2869               
2870               linep = end;
2871             }
2872
2873           /* Don't allow setting of the no change flag.  */
2874           flags &= ~GC_OPT_FLAG_NO_CHANGE;
2875           
2876           /* Extract default value, if present.  Default to empty if not.  */
2877           if (linep)
2878             {
2879               char *end;
2880               end = strchr (linep, ':');
2881               if (end)
2882                 *(end++) = '\0';
2883               new_value = linep;
2884               linep = end;
2885             }
2886           
2887           option = find_option (component, line, GC_BACKEND_ANY);
2888           if (!option)
2889             gc_error (1, 0, "unknown option %s", line);
2890           
2891           if ((option->flags & GC_OPT_FLAG_NO_CHANGE))
2892             {
2893               gc_error (0, 0, "ignoring new value for option %s",
2894                         option->name);
2895               continue;
2896             }
2897           
2898           change_one_value (option, runtime, flags, new_value);
2899         }
2900     }
2901
2902   /* Now that we have collected and locally verified the changes,
2903      write them out to new configuration files, verify them
2904      externally, and then commit them.  */
2905   option = gc_component[component].options;
2906   while (option && option->name)
2907     {
2908       /* Go on if we have already seen this backend, or if there is
2909          nothing to do.  */
2910       if (src_pathname[option->backend]
2911           || !(option->new_flags || option->new_value))
2912         {
2913           option++;
2914           continue;
2915         }
2916
2917       if (gc_backend[option->backend].program)
2918         err = change_options_program (component, option->backend,
2919                                       &src_pathname[option->backend],
2920                                       &dest_pathname[option->backend],
2921                                       &orig_pathname[option->backend]);
2922       else
2923         err = change_options_file (component, option->backend,
2924                                    &src_pathname[option->backend],
2925                                    &dest_pathname[option->backend],
2926                                    &orig_pathname[option->backend]);
2927         
2928       if (err)
2929         break;
2930           
2931       option++;
2932     }
2933
2934   if (!err)
2935     {
2936       int i;
2937
2938       for (i = 0; i < GC_BACKEND_NR; i++)
2939         {
2940           if (src_pathname[i])
2941             {
2942               /* FIXME: Make a verification here.  */
2943
2944               assert (dest_pathname[i]);
2945
2946               if (orig_pathname[i])
2947                 {
2948 #ifdef HAVE_W32_SYSTEM
2949                   /* There is no atomic update on W32.  */
2950                   err = unlink (dest_pathname[i]);
2951 #endif /* HAVE_W32_SYSTEM */
2952                   if (!err)
2953                     err = rename (src_pathname[i], dest_pathname[i]);
2954                 }
2955               else
2956                 {
2957 #ifdef HAVE_W32_SYSTEM
2958                   /* We skip the unlink if we expect the file not to
2959                      be there.  */
2960                   err = rename (src_pathname[i], dest_pathname[i]);
2961 #else /* HAVE_W32_SYSTEM */
2962                   /* This is a bit safer than rename() because we
2963                      expect DEST_PATHNAME not to be there.  If it
2964                      happens to be there, this will fail.  */
2965                   err = link (src_pathname[i], dest_pathname[i]);
2966                   if (!err)
2967                     err = unlink (src_pathname[i]);
2968 #endif /* !HAVE_W32_SYSTEM */
2969                 }
2970               if (err)
2971                 break;
2972               src_pathname[i] = NULL;
2973             }
2974         }
2975     }
2976
2977   if (err)
2978     {
2979       int i;
2980       int saved_errno = errno;
2981
2982       /* An error occured.  */
2983       for (i = 0; i < GC_BACKEND_NR; i++)
2984         {
2985           if (src_pathname[i])
2986             {
2987               /* The change was not yet committed.  */
2988               unlink (src_pathname[i]);
2989               if (orig_pathname[i])
2990                 unlink (orig_pathname[i]);
2991             }
2992           else
2993             {
2994               /* The changes were already committed.  FIXME: This is a
2995                  tad dangerous, as we don't know if we don't overwrite
2996                  a version of the file that is even newer than the one
2997                  we just installed.  */
2998               if (orig_pathname[i])
2999                 {
3000 #ifdef HAVE_W32_SYSTEM
3001                   /* There is no atomic update on W32.  */
3002                   unlink (dest_pathname[i]);
3003 #endif /* HAVE_W32_SYSTEM */
3004                   rename (orig_pathname[i], dest_pathname[i]);
3005                 }
3006               else
3007                 unlink (dest_pathname[i]);
3008             }
3009         }
3010       gc_error (1, saved_errno, "could not commit changes");
3011     }
3012
3013   /* If it all worked, notify the daemons of the changes.  */
3014   if (opt.runtime)
3015     for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3016       {
3017         if (runtime[backend] && gc_backend[backend].runtime_change)
3018           (*gc_backend[backend].runtime_change) ();
3019       }
3020
3021   /* Move the per-process backup file into its place.  */
3022   for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3023     if (orig_pathname[backend])
3024       {
3025         char *backup_pathname;
3026
3027         assert (dest_pathname[backend]);
3028
3029         backup_pathname = xasprintf ("%s.gpgconf.bak", dest_pathname[backend]);
3030
3031 #ifdef HAVE_W32_SYSTEM
3032         /* There is no atomic update on W32.  */
3033         unlink (backup_pathname);
3034 #endif /* HAVE_W32_SYSTEM */
3035         rename (orig_pathname[backend], backup_pathname);
3036       }
3037
3038   xfree (line);
3039 }
3040
3041
3042 /* Check whether USER matches the current user of one of its group.
3043    This function may change USER.  Returns true is there is a
3044    match.  */
3045 static int
3046 key_matches_user_or_group (char *user)
3047 {
3048   char *group;
3049
3050   if (*user == '*' && user[1] == 0)
3051     return 1; /* A single asterisk matches all users.  */
3052
3053   group = strchr (user, ':');
3054   if (group)
3055     *group++ = 0;
3056
3057 #ifdef HAVE_W32_SYSTEM
3058   /* Under Windows we don't support groups. */   
3059   if (group && *group)
3060     gc_error (0, 0, _("Note that group specifications are ignored\n"));
3061   if (*user)
3062     {
3063       static char *my_name;
3064
3065       if (!my_name)
3066         {
3067           char tmp[1];
3068           DWORD size = 1;
3069
3070           GetUserNameA (tmp, &size);
3071           my_name = xmalloc (size);
3072           if (!GetUserNameA (my_name, &size))
3073             gc_error (1,0, "error getting current user name: %s",
3074                       w32_strerror (-1));
3075         }
3076
3077       if (!strcmp (user, my_name))
3078         return 1; /* Found.  */
3079     }
3080 #else /*!HAVE_W32_SYSTEM*/
3081   /* First check whether the user matches.  */
3082   if (*user)
3083     {
3084       static char *my_name;
3085
3086       if (!my_name)
3087         {
3088           struct passwd *pw = getpwuid ( getuid () );
3089           if (!pw)
3090             gc_error (1, errno, "getpwuid failed for current user");
3091           my_name = xstrdup (pw->pw_name);
3092         }
3093       if (!strcmp (user, my_name))
3094         return 1; /* Found.  */
3095     }
3096
3097   /* If that failed, check whether a group matches.  */
3098   if (group && *group)
3099     {
3100       static char *my_group;
3101       static char **my_supgroups;
3102       int n;
3103
3104       if (!my_group)
3105         {
3106           struct group *gr = getgrgid ( getgid () );
3107           if (!gr)
3108             gc_error (1, errno, "getgrgid failed for current user");
3109           my_group = xstrdup (gr->gr_name);
3110         }
3111       if (!strcmp (group, my_group))
3112         return 1; /* Found.  */
3113
3114       if (!my_supgroups)
3115         {
3116           int ngids;
3117           gid_t *gids;
3118
3119           ngids = getgroups (0, NULL);
3120           gids  = xcalloc (ngids+1, sizeof *gids);
3121           ngids = getgroups (ngids, gids);
3122           if (ngids < 0)
3123             gc_error (1, errno, "getgroups failed for current user");
3124           my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
3125           for (n=0; n < ngids; n++)
3126             {
3127               struct group *gr = getgrgid ( gids[n] );
3128               if (!gr)
3129                 gc_error (1, errno, "getgrgid failed for supplementary group");
3130               my_supgroups[n] = xstrdup (gr->gr_name);
3131             }
3132           xfree (gids);
3133         }
3134
3135       for (n=0; my_supgroups[n]; n++)
3136         if (!strcmp (group, my_supgroups[n]))
3137           return 1; /* Found.  */
3138     }
3139 #endif /*!HAVE_W32_SYSTEM*/
3140   return 0; /* No match.  */
3141 }
3142
3143
3144
3145 /* Read and process the global configuration file for gpgconf.  This
3146    optional file is used to update our internal tables at runtime and
3147    may also be used to set new default values.  If FNAME is NULL the
3148    default name will be used.  With UPDATE set to true the internal
3149    tables are actually updated; if not set, only a syntax check is
3150    done.  If DEFAULTS is true the global options are written to the
3151    configuration files.  If LISTFP is set, no changes are done but the
3152    configuration file is printed to LISTFP in a colon separated format.
3153
3154    Returns 0 on success or if the config file is not present; -1 is
3155    returned on error. */
3156 int
3157 gc_process_gpgconf_conf (const char *fname_arg, int update, int defaults,
3158                          FILE *listfp)
3159 {
3160   int result = 0;
3161   char *line = NULL;
3162   size_t line_len = 0;
3163   ssize_t length;
3164   FILE *config;
3165   int lineno = 0;
3166   int in_rule = 0;
3167   int got_match = 0;
3168   int runtime[GC_BACKEND_NR];
3169   int used_components[GC_COMPONENT_NR];
3170   int backend_id, component_id;
3171   char *fname;
3172
3173   if (fname_arg)
3174     fname = xstrdup (fname_arg);
3175   else
3176     fname = make_filename (gnupg_sysconfdir (), "gpgconf.conf", NULL);
3177
3178   for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3179     runtime[backend_id] = 0;
3180   for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3181     used_components[component_id] = 0;
3182
3183   config = fopen (fname, "r");
3184   if (!config)
3185     {
3186       /* Do not print an error if the file is not available, except
3187          when running in syntax check mode.  */
3188       if (errno != ENOENT || !update)
3189         {
3190           gc_error (0, errno, "can not open global config file `%s'", fname);
3191           result = -1;
3192         }
3193       xfree (fname);
3194       return result;
3195     }
3196
3197   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
3198     {
3199       char *key, *component, *option, *flags, *value;
3200       char *empty;
3201       gc_option_t *option_info = NULL;
3202       char *p;
3203       int is_continuation;
3204       
3205       lineno++;
3206       key = line;
3207       while (*key == ' ' || *key == '\t')
3208         key++;
3209       if (!*key || *key == '#' || *key == '\r' || *key == '\n')
3210         continue;
3211
3212       is_continuation = (key != line);
3213
3214       /* Parse the key field.  */
3215       if (!is_continuation && got_match)
3216         break;  /* Finish after the first match.  */
3217       else if (!is_continuation)
3218         {
3219           in_rule = 0;
3220           for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
3221             ;
3222           if (!*p)
3223             {
3224               gc_error (0, 0, "missing rule at `%s', line %d", fname, lineno);
3225               result = -1;
3226               continue;
3227             }
3228           *p++ = 0;
3229           component = p;
3230         }
3231       else if (!in_rule)
3232         {
3233           gc_error (0, 0, "continuation but no rule at `%s', line %d",
3234                     fname, lineno);
3235           result = -1;
3236           continue;
3237         }
3238       else
3239         {
3240           component = key;
3241           key = NULL;
3242         }
3243
3244       in_rule = 1;
3245
3246       /* Parse the component.  */
3247       while (*component == ' ' || *component == '\t')
3248         component++;
3249       for (p=component; *p && !strchr (" \t\r\n", *p); p++)
3250         ;
3251       if (p == component)
3252         {
3253           gc_error (0, 0, "missing component at `%s', line %d",
3254                     fname, lineno);
3255           result = -1;
3256           continue;
3257         }
3258       empty = p;
3259       *p++ = 0;
3260       option = p;
3261       component_id = gc_component_find (component);
3262       if (component_id < 0)
3263         {
3264           gc_error (0, 0, "unknown component at `%s', line %d",
3265                     fname, lineno);
3266           result = -1;
3267         }
3268
3269       /* Parse the option name.  */
3270       while (*option == ' ' || *option == '\t')
3271         option++;
3272       for (p=option; *p && !strchr (" \t\r\n", *p); p++)
3273         ;
3274       if (p == option)
3275         {
3276           gc_error (0, 0, "missing option at `%s', line %d",
3277                     fname, lineno);
3278           result = -1;
3279           continue;
3280         }
3281       *p++ = 0;
3282       flags = p;
3283       if ( component_id != -1)
3284         {
3285           option_info = find_option (component_id, option, GC_BACKEND_ANY);
3286           if (!option_info)
3287             {
3288               gc_error (0, 0, "unknown option at `%s', line %d",
3289                         fname, lineno);
3290               result = -1;
3291             }
3292         }
3293
3294
3295       /* Parse the optional flags.  */
3296       while (*flags == ' ' || *flags == '\t')
3297         flags++;
3298       if (*flags == '[')
3299         {
3300           flags++;
3301           p = strchr (flags, ']');
3302           if (!p)
3303             {
3304               gc_error (0, 0, "syntax error in rule at `%s', line %d",
3305                         fname, lineno);
3306               result = -1;
3307               continue;
3308             }
3309           *p++ = 0;
3310           value = p;
3311         }
3312       else  /* No flags given.  */
3313         {
3314           value = flags;
3315           flags = NULL;
3316         }
3317
3318       /* Parse the optional value.  */
3319       while (*value == ' ' || *value == '\t')
3320        value++;
3321       for (p=value; *p && !strchr ("\r\n", *p); p++)
3322         ;
3323       if (p == value)
3324         value = empty; /* No value given; let it point to an empty string.  */
3325       else
3326         {
3327           /* Strip trailing white space.  */
3328           *p = 0;
3329           for (p--; p > value && (*p == ' ' || *p == '\t'); p--)
3330             *p = 0;
3331         }
3332
3333       /* Check flag combinations.  */
3334       if (!flags)
3335         ;
3336       else if (!strcmp (flags, "default"))
3337         {
3338           if (*value)
3339             {
3340               gc_error (0, 0, "flag \"default\" may not be combined "
3341                         "with a value at `%s', line %d",
3342                         fname, lineno);
3343               result = -1;
3344             }
3345         }
3346       else if (!strcmp (flags, "change"))
3347         ;
3348       else if (!strcmp (flags, "no-change"))
3349         ;
3350       else
3351         {
3352           gc_error (0, 0, "unknown flag at `%s', line %d",
3353                     fname, lineno);
3354           result = -1;
3355         }
3356
3357       /* In list mode we print out all records.  */
3358       if (listfp && !result)
3359         {
3360           /* If this is a new ruleset, print a key record.  */
3361           if (!is_continuation)
3362             {
3363               char *group = strchr (key, ':');
3364               if (group)
3365                 {
3366                   *group++ = 0;
3367                   if ((p = strchr (group, ':')))
3368                     *p = 0; /* We better strip any extra stuff. */
3369                 }                    
3370               
3371               fprintf (listfp, "k:%s:", my_percent_escape (key));
3372               fprintf (listfp, "%s\n", group? my_percent_escape (group):"");
3373             }
3374
3375           /* All other lines are rule records.  */
3376           fprintf (listfp, "r:::%s:%s:%s:",
3377                    gc_component[component_id].name,                     
3378                    option_info->name? option_info->name : "",
3379                    flags? flags : "");
3380           if (value != empty)
3381             fprintf (listfp, "\"%s", my_percent_escape (value));
3382           
3383           putc ('\n', listfp);
3384         }
3385
3386       /* Check whether the key matches but do this only if we are not
3387          running in syntax check mode. */
3388       if ( update 
3389            && !result && !listfp
3390            && (got_match || (key && key_matches_user_or_group (key))) )
3391         {
3392           int newflags = 0;
3393
3394           got_match = 1;
3395
3396           /* Apply the flags from gpgconf.conf.  */
3397           if (!flags)
3398             ;
3399           else if (!strcmp (flags, "default"))
3400             newflags |= GC_OPT_FLAG_DEFAULT;
3401           else if (!strcmp (flags, "no-change"))
3402             option_info->flags |= GC_OPT_FLAG_NO_CHANGE;
3403           else if (!strcmp (flags, "change"))
3404             option_info->flags &= ~GC_OPT_FLAG_NO_CHANGE;
3405
3406           if (defaults)
3407             {
3408               assert (component_id >= 0 && component_id < GC_COMPONENT_NR);
3409               used_components[component_id] = 1;
3410
3411               /* Here we explicitly allow to update the value again.  */
3412               if (newflags)
3413                 {
3414                   option_info->new_flags = 0;
3415                 }
3416               if (*value)
3417                 {
3418                   xfree (option_info->new_value);
3419                   option_info->new_value = NULL;
3420                 }
3421               change_one_value (option_info, runtime, newflags, value);
3422             }
3423         }
3424     }
3425
3426   if (length < 0 || ferror (config))
3427     {
3428       gc_error (0, errno, "error reading from `%s'", fname);
3429       result = -1;
3430     }
3431   if (fclose (config) && ferror (config))
3432     gc_error (0, errno, "error closing `%s'", fname);
3433
3434   xfree (line);
3435
3436   /* If it all worked, process the options. */
3437   if (!result && update && defaults && !listfp)
3438     {
3439       /* We need to switch off the runtime update, so that we can do
3440          it later all at once. */
3441       int save_opt_runtime = opt.runtime;
3442       opt.runtime = 0;
3443
3444       for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3445         {
3446           gc_component_change_options (component_id, NULL);
3447         }
3448       opt.runtime = save_opt_runtime;
3449
3450       if (opt.runtime)
3451         {
3452           for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)  
3453             if (runtime[backend_id] && gc_backend[backend_id].runtime_change)
3454               (*gc_backend[backend_id].runtime_change) ();
3455         }
3456     }
3457
3458   xfree (fname);
3459   return result;
3460 }