doc/
[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 USE_SIMPLE_GETTEXT
1031   if (domain)
1032     {
1033       static int switched_codeset;
1034       char *text;
1035       
1036       if (!switched_codeset)
1037         {
1038           switched_codeset = 1;
1039           gettext_select_utf8 (1);
1040         }
1041
1042       if (!strcmp (domain, "gnupg"))
1043         domain = PACKAGE_GT;
1044
1045       /* FIXME: we have no dgettext, thus we can't switch.  */
1046
1047       text = gettext (msgid);
1048       return text ? text : msgid;
1049     }
1050 #elif defined(ENABLE_NLS)
1051   if (domain)
1052     {
1053       static int switched_codeset;
1054       char *text;
1055       
1056       if (!switched_codeset)
1057         {
1058           switched_codeset = 1;
1059           bind_textdomain_codeset (PACKAGE_GT, "utf-8");
1060
1061           bindtextdomain ("dirmngr", LOCALEDIR);
1062           bind_textdomain_codeset ("dirmngr", "utf-8");
1063    
1064         }
1065
1066       /* Note: This is a hack to actually use the gnupg2 domain as
1067          long we are in a transition phase where gnupg 1.x and 1.9 may
1068          coexist. */
1069       if (!strcmp (domain, "gnupg"))
1070         domain = PACKAGE_GT;
1071
1072       text = dgettext (domain, msgid);
1073       return text ? text : msgid;
1074     }
1075   else
1076 #endif
1077     return msgid;
1078 }
1079
1080
1081 /* Percent-Escape special characters.  The string is valid until the
1082    next invocation of the function.  */
1083 static char *
1084 my_percent_escape (const char *src)
1085 {
1086   static char *esc_str;
1087   static int esc_str_len;
1088   int new_len = 3 * strlen (src) + 1;
1089   char *dst;
1090
1091   if (esc_str_len < new_len)
1092     {
1093       char *new_esc_str = realloc (esc_str, new_len);
1094       if (!new_esc_str)
1095         gc_error (1, errno, "can not escape string");
1096       esc_str = new_esc_str;
1097       esc_str_len = new_len;
1098     }
1099
1100   dst = esc_str;
1101   while (*src)
1102     {
1103       if (*src == '%')
1104         {
1105           *(dst++) = '%';
1106           *(dst++) = '2';
1107           *(dst++) = '5';
1108         }         
1109       else if (*src == ':')
1110         {
1111           /* The colon is used as field separator.  */
1112           *(dst++) = '%';
1113           *(dst++) = '3';
1114           *(dst++) = 'a';
1115         }
1116       else if (*src == ',')
1117         {
1118           /* The comma is used as list separator.  */
1119           *(dst++) = '%';
1120           *(dst++) = '2';
1121           *(dst++) = 'c';
1122         }
1123       else
1124         *(dst++) = *(src);
1125       src++;
1126     }
1127   *dst = '\0';
1128   return esc_str;
1129 }
1130
1131
1132
1133 /* Percent-Deescape special characters.  The string is valid until the
1134    next invocation of the function.  */
1135 static char *
1136 percent_deescape (const char *src)
1137 {
1138   static char *str;
1139   static int str_len;
1140   int new_len = 3 * strlen (src) + 1;
1141   char *dst;
1142
1143   if (str_len < new_len)
1144     {
1145       char *new_str = realloc (str, new_len);
1146       if (!new_str)
1147         gc_error (1, errno, "can not deescape string");
1148       str = new_str;
1149       str_len = new_len;
1150     }
1151
1152   dst = str;
1153   while (*src)
1154     {
1155       if (*src == '%')
1156         {
1157           int val = hextobyte (src + 1);
1158
1159           if (val < 0)
1160             gc_error (1, 0, "malformed end of string %s", src);
1161
1162           *(dst++) = (char) val;
1163           src += 3;
1164         }         
1165       else
1166         *(dst++) = *(src++);
1167     }
1168   *dst = '\0';
1169   return str;
1170 }
1171
1172 \f
1173 /* List all components that are available.  */
1174 void
1175 gc_component_list_components (FILE *out)
1176 {
1177   gc_component_t component;
1178   gc_option_t *option;
1179   gc_backend_t backend;
1180   int backend_seen[GC_BACKEND_NR];
1181   const char *desc;
1182   const char *pgmname;
1183
1184   for (component = 0; component < GC_COMPONENT_NR; component++)
1185     {
1186       option = gc_component[component].options;
1187       if (option)
1188         {
1189           for (backend = 0; backend < GC_BACKEND_NR; backend++)
1190             backend_seen[backend] = 0;
1191
1192           pgmname = "";
1193           for (; option && option->name; option++)
1194             {
1195               if ((option->flags & GC_OPT_FLAG_GROUP))
1196                 continue;
1197               backend = option->backend;
1198               if (backend_seen[backend])
1199                 continue;
1200               backend_seen[backend] = 1;
1201               assert (backend != GC_BACKEND_ANY);
1202               if (gc_backend[backend].program
1203                   && !gc_backend[backend].module_name)
1204                 continue;
1205               pgmname = gnupg_module_name (gc_backend[backend].module_name);
1206               break;
1207             }
1208
1209           desc = gc_component[component].desc;
1210           desc = my_dgettext (gc_component[component].desc_domain, desc);
1211           fprintf (out, "%s:%s:",
1212                    gc_component[component].name,  my_percent_escape (desc));
1213           fprintf (out, "%s\n",  my_percent_escape (pgmname));
1214         }
1215     }
1216 }
1217
1218
1219 \f
1220 static int
1221 all_digits_p (const char *p, size_t len)
1222 {
1223   if (!len)
1224     return 0; /* No. */
1225   for (; len; len--, p++)
1226     if (!isascii (*p) || !isdigit (*p))
1227       return 0; /* No.  */
1228   return 1; /* Yes.  */
1229 }
1230
1231
1232 /* Collect all error lines from file descriptor FD. Only lines
1233    prefixed with TAG are considered.  Close that file descriptor
1234    then.  Returns a list of error line items (which may be empty).
1235    There is no error return.  */
1236 static error_line_t
1237 collect_error_output (int fd, const char *tag)
1238 {
1239   FILE *fp;
1240   char buffer[1024];
1241   char *p, *p2, *p3;
1242   int c, cont_line;
1243   unsigned int pos;
1244   error_line_t eitem, errlines, *errlines_tail;
1245   size_t taglen = strlen (tag);
1246
1247   fp = fdopen (fd, "r");
1248   if (!fp)
1249     gc_error (1, errno, "can't fdopen pipe for reading");
1250
1251   errlines = NULL;
1252   errlines_tail = &errlines;
1253   pos = 0;
1254   cont_line = 0;
1255   while ((c=getc (fp)) != EOF)
1256     {
1257       buffer[pos++] = c;
1258       if (pos >= sizeof buffer - 5 || c == '\n')
1259         {
1260           buffer[pos - (c == '\n')] = 0;
1261           if (cont_line)
1262             ; /*Ignore continuations of previous line. */
1263           else if (!strncmp (buffer, tag, taglen) && buffer[taglen] == ':') 
1264             {
1265               /* "gpgsm: foo:4: bla" */
1266               /* Yep, we are interested in this line.  */
1267               p = buffer + taglen + 1;
1268               while (*p == ' ' || *p == '\t')
1269                 p++;
1270               if (!*p)
1271                 ; /* Empty lines are ignored.  */
1272               else if ( (p2 = strchr (p, ':')) && (p3 = strchr (p2+1, ':'))
1273                         && all_digits_p (p2+1, p3 - (p2+1)))
1274                 {
1275                   /* Line in standard compiler format.  */
1276                   p3++;
1277                   while (*p3 == ' ' || *p3 == '\t')
1278                     p3++;
1279                   eitem = xmalloc (sizeof *eitem + strlen (p));
1280                   eitem->next = NULL;
1281                   strcpy (eitem->buffer, p);
1282                   eitem->fname = eitem->buffer;
1283                   eitem->buffer[p2-p] = 0;
1284                   eitem->errtext = eitem->buffer + (p3 - p);
1285                   /* (we already checked that there are only ascii
1286                      digits followed by a colon) */
1287                   eitem->lineno = 0;
1288                   for (p2++; isdigit (*p2); p2++)
1289                     eitem->lineno = eitem->lineno*10 + (*p2 - '0');
1290                   *errlines_tail = eitem;
1291                   errlines_tail = &eitem->next;
1292                 }
1293               else
1294                 {
1295                   /* Other error output.  */
1296                   eitem = xmalloc (sizeof *eitem + strlen (p));
1297                   eitem->next = NULL;
1298                   strcpy (eitem->buffer, p);
1299                   eitem->fname = NULL;
1300                   eitem->errtext = eitem->buffer;
1301                   eitem->lineno = 0;
1302                   *errlines_tail = eitem;
1303                   errlines_tail = &eitem->next;
1304                 }
1305             }
1306           pos = 0;
1307           /* If this was not a complete line mark that we are in a
1308              continuation.  */
1309           cont_line = (c != '\n');
1310         }
1311     }
1312   
1313   /* We ignore error lines not terminated by a LF.  */
1314
1315   fclose (fp);
1316   return errlines;
1317 }
1318
1319
1320 /* Check the options of a single component.  Returns 0 if everything
1321    is OK.  */
1322 int
1323 gc_component_check_options (int component, FILE *out, const char *conf_file)
1324 {
1325   gpg_error_t err;
1326   unsigned int result;
1327   int backend_seen[GC_BACKEND_NR];
1328   gc_backend_t backend;
1329   gc_option_t *option;
1330   const char *pgmname;
1331   const char *argv[4];
1332   int i;
1333   pid_t pid;
1334   int exitcode;
1335   int filedes[2];
1336   error_line_t errlines;
1337
1338   /* We use a temporary file to collect the error output.  It would be
1339      better to use a pipe here but as of now we have no suitable
1340      fucntion to create a portable pipe outside of exechelp.  Thus it
1341      is easier to use the tempfile approach.  */
1342
1343   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1344     backend_seen[backend] = 0;
1345
1346   option = gc_component[component].options;
1347   for (; option && option->name; option++)
1348     {
1349       if ((option->flags & GC_OPT_FLAG_GROUP))
1350         continue;
1351       backend = option->backend;
1352       if (backend_seen[backend])
1353         continue;
1354       backend_seen[backend] = 1;
1355       assert (backend != GC_BACKEND_ANY);
1356       if (!gc_backend[backend].program)
1357         continue;
1358       if (!gc_backend[backend].module_name)
1359         continue;
1360
1361       break;
1362     }
1363   if (! option || ! option->name)
1364     return 0;
1365
1366   pgmname = gnupg_module_name (gc_backend[backend].module_name);
1367   i = 0;
1368   if (conf_file)
1369     {
1370       argv[i++] = "--options";
1371       argv[i++] = conf_file;
1372     }
1373   argv[i++] = "--gpgconf-test";
1374   argv[i++] = NULL;
1375   
1376   err = gnupg_create_inbound_pipe (filedes);
1377   if (err)
1378     gc_error (1, 0, _("error creating a pipe: %s\n"), 
1379               gpg_strerror (err));
1380   
1381   result = 0;
1382   errlines = NULL;
1383   if (gnupg_spawn_process_fd (pgmname, argv, -1, -1, filedes[1], &pid))
1384     {
1385       close (filedes[0]);
1386       close (filedes[1]);
1387       result |= 1; /* Program could not be run.  */
1388     }
1389   else 
1390     {
1391       close (filedes[1]);
1392       errlines = collect_error_output (filedes[0], 
1393                                        gc_component[component].name);
1394       if (gnupg_wait_process (pgmname, pid, &exitcode))
1395         {
1396           if (exitcode == -1)
1397             result |= 1; /* Program could not be run or it
1398                             terminated abnormally.  */
1399           result |= 2; /* Program returned an error.  */
1400         }
1401     }
1402   
1403   /* If the program could not be run, we can't tell whether
1404      the config file is good.  */
1405   if (result & 1)
1406     result |= 2;  
1407   
1408   if (out)
1409     {
1410       const char *desc;
1411       error_line_t errptr;
1412
1413       desc = gc_component[component].desc;
1414       desc = my_dgettext (gc_component[component].desc_domain, desc);
1415       fprintf (out, "%s:%s:",
1416                gc_component[component].name, my_percent_escape (desc));
1417       fputs (my_percent_escape (pgmname), out);
1418       fprintf (out, ":%d:%d:", !(result & 1), !(result & 2));
1419       for (errptr = errlines; errptr; errptr = errptr->next)
1420         {
1421           if (errptr != errlines)
1422             fputs ("\n:::::", out); /* Continuation line.  */
1423           if (errptr->fname)
1424             fputs (my_percent_escape (errptr->fname), out);
1425           putc (':', out);
1426           if (errptr->fname)
1427             fprintf (out, "%u", errptr->lineno);
1428           putc (':', out);
1429           fputs (my_percent_escape (errptr->errtext), out);
1430           putc (':', out);
1431         }
1432       putc ('\n', out);
1433     }
1434
1435   while (errlines)
1436     {
1437       error_line_t tmp = errlines->next;
1438       xfree (errlines);
1439       errlines = tmp;
1440     }
1441
1442   return result;
1443 }
1444
1445
1446 /* Check all components that are available.  */
1447 void
1448 gc_check_programs (FILE *out)
1449 {
1450   gc_component_t component;
1451
1452   for (component = 0; component < GC_COMPONENT_NR; component++)
1453     gc_component_check_options (component, out, NULL);
1454 }
1455
1456
1457 \f
1458 /* Find the component with the name NAME.  Returns -1 if not
1459    found.  */
1460 int
1461 gc_component_find (const char *name)
1462 {
1463   gc_component_t idx;
1464
1465   for (idx = 0; idx < GC_COMPONENT_NR; idx++)
1466     {
1467       if (gc_component[idx].options
1468           && !strcmp (name, gc_component[idx].name))
1469         return idx;
1470     }
1471   return -1;
1472 }
1473
1474 \f
1475 /* List the option OPTION.  */
1476 static void
1477 list_one_option (const gc_option_t *option, FILE *out)
1478 {
1479   const char *desc = NULL;
1480   char *arg_name = NULL;
1481
1482   if (option->desc)
1483     {
1484       desc = my_dgettext (option->desc_domain, option->desc);
1485
1486       if (*desc == '|')
1487         {
1488           const char *arg_tail = strchr (&desc[1], '|');
1489
1490           if (arg_tail)
1491             {
1492               int arg_len = arg_tail - &desc[1];
1493               arg_name = xmalloc (arg_len + 1);
1494               memcpy (arg_name, &desc[1], arg_len);
1495               arg_name[arg_len] = '\0';
1496               desc = arg_tail + 1;
1497             }
1498         }
1499     }
1500
1501
1502   /* YOU MUST NOT REORDER THE FIELDS IN THIS OUTPUT, AS THEIR ORDER IS
1503      PART OF THE EXTERNAL INTERFACE.  YOU MUST NOT REMOVE ANY
1504      FIELDS.  */
1505
1506   /* The name field.  */
1507   fprintf (out, "%s", option->name);
1508
1509   /* The flags field.  */
1510   fprintf (out, ":%lu", option->flags);
1511   if (opt.verbose)
1512     {
1513       putc (' ', out);
1514           
1515       if (!option->flags)
1516         fprintf (out, "none");
1517       else
1518         {
1519           unsigned long flags = option->flags;
1520           unsigned long flag = 0;
1521           unsigned long first = 1;
1522
1523           while (flags)
1524             {
1525               if (flags & 1)
1526                 {
1527                   if (first)
1528                     first = 0;
1529                   else
1530                     putc (',', out);
1531                   fprintf (out, "%s", gc_flag[flag].name);
1532                 }
1533               flags >>= 1;
1534               flag++;
1535             }
1536         }
1537     }
1538
1539   /* The level field.  */
1540   fprintf (out, ":%u", option->level);
1541   if (opt.verbose)
1542     fprintf (out, " %s", gc_level[option->level].name);
1543
1544   /* The description field.  */
1545   fprintf (out, ":%s", desc ? my_percent_escape (desc) : "");
1546   
1547   /* The type field.  */
1548   fprintf (out, ":%u", option->arg_type);
1549   if (opt.verbose)
1550     fprintf (out, " %s", gc_arg_type[option->arg_type].name);
1551
1552   /* The alternate type field.  */
1553   fprintf (out, ":%u", gc_arg_type[option->arg_type].fallback);
1554   if (opt.verbose)
1555     fprintf (out, " %s",
1556              gc_arg_type[gc_arg_type[option->arg_type].fallback].name);
1557
1558   /* The argument name field.  */
1559   fprintf (out, ":%s", arg_name ? my_percent_escape (arg_name) : "");
1560   if (arg_name)
1561     xfree (arg_name);
1562
1563   /* The default value field.  */
1564   fprintf (out, ":%s", option->default_value ? option->default_value : "");
1565
1566   /* The default argument field.  */
1567   fprintf (out, ":%s", option->default_arg ? option->default_arg : "");
1568
1569   /* The value field.  */
1570   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
1571       && (option->flags & GC_OPT_FLAG_LIST)
1572       && option->value)
1573     /* The special format "1,1,1,1,...,1" is converted to a number
1574        here.  */
1575     fprintf (out, ":%u", (unsigned int)((strlen (option->value) + 1) / 2));
1576   else
1577     fprintf (out, ":%s", option->value ? option->value : "");
1578
1579   /* ADD NEW FIELDS HERE.  */
1580
1581   putc ('\n', out);
1582 }
1583
1584
1585 /* List all options of the component COMPONENT.  */
1586 void
1587 gc_component_list_options (int component, FILE *out)
1588 {  
1589   const gc_option_t *option = gc_component[component].options;
1590
1591   while (option && option->name)
1592     {
1593       /* Do not output unknown or internal options.  */
1594       if (!(option->flags & GC_OPT_FLAG_GROUP)
1595           && (!option->active || option->level == GC_LEVEL_INTERNAL))
1596         {
1597           option++;
1598           continue;
1599         }
1600
1601       if (option->flags & GC_OPT_FLAG_GROUP)
1602         {
1603           const gc_option_t *group_option = option + 1;
1604           gc_expert_level_t level = GC_LEVEL_NR;
1605
1606           /* The manual states that the group level is always the
1607              minimum of the levels of all contained options.  Due to
1608              different active options, and because it is hard to
1609              maintain manually, we calculate it here.  The value in
1610              the global static table is ignored.  */
1611           
1612           while (group_option->name)
1613             {
1614               if (group_option->flags & GC_OPT_FLAG_GROUP)
1615                 break;
1616               if (group_option->level < level)
1617                 level = group_option->level;
1618               group_option++;
1619             }
1620
1621           /* Check if group is empty.  */
1622           if (level != GC_LEVEL_NR)
1623             {
1624               gc_option_t opt_copy;
1625
1626               /* Fix up the group level.  */
1627               memcpy (&opt_copy, option, sizeof (opt_copy));
1628               opt_copy.level = level;
1629               list_one_option (&opt_copy, out);
1630             }
1631         }
1632       else
1633         list_one_option (option, out);
1634
1635       option++;
1636     }
1637 }
1638
1639
1640 /* Find the option NAME in component COMPONENT, for the backend
1641    BACKEND.  If BACKEND is GC_BACKEND_ANY, any backend will match.  */
1642 static gc_option_t *
1643 find_option (gc_component_t component, const char *name,
1644              gc_backend_t backend)
1645 {
1646   gc_option_t *option = gc_component[component].options;
1647   while (option->name)
1648     {
1649       if (!(option->flags & GC_OPT_FLAG_GROUP)
1650           && !strcmp (option->name, name)
1651           && (backend == GC_BACKEND_ANY || option->backend == backend))
1652         break;
1653       option++;
1654     }
1655   return option->name ? option : NULL;
1656 }
1657
1658 \f
1659 /* Determine the configuration pathname for the component COMPONENT
1660    and backend BACKEND.  */
1661 static char *
1662 get_config_pathname (gc_component_t component, gc_backend_t backend)
1663 {
1664   char *pathname = NULL;
1665   gc_option_t *option = find_option
1666     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
1667   assert (option);
1668   assert (option->arg_type == GC_ARG_TYPE_PATHNAME);
1669   assert (!(option->flags & GC_OPT_FLAG_LIST));
1670
1671   if (!option->active || !option->default_value)
1672     gc_error (1, 0, "Option %s, needed by backend %s, was not initialized",
1673               gc_backend[backend].option_config_filename,
1674               gc_backend[backend].name);
1675
1676   if (option->value && *option->value)
1677     pathname = percent_deescape (&option->value[1]);
1678   else if (option->default_value && *option->default_value)
1679     pathname = percent_deescape (&option->default_value[1]);
1680   else
1681     pathname = "";
1682
1683 #ifdef HAVE_DOSISH_SYSTEM
1684   if (!(pathname[0] 
1685         && pathname[1] == ':'
1686         && (pathname[2] == '/' || pathname[2] == '\\')))
1687 #else
1688   if (pathname[0] != '/')
1689 #endif
1690     gc_error (1, 0, "Option %s, needed by backend %s, is not absolute",
1691               gc_backend[backend].option_config_filename,
1692               gc_backend[backend].name);
1693
1694   return pathname;
1695 }
1696
1697 \f
1698 /* Retrieve the options for the component COMPONENT from backend
1699    BACKEND, which we already know is a program-type backend.  */
1700 static void
1701 retrieve_options_from_program (gc_component_t component, gc_backend_t backend)
1702 {
1703   gpg_error_t err;
1704   int filedes[2];
1705   const char *pgmname;
1706   const char *argv[2];
1707   int exitcode;
1708   pid_t pid;
1709   char *line = NULL;
1710   size_t line_len = 0;
1711   ssize_t length;
1712   FILE *config;
1713   char *config_pathname;
1714
1715   err = gnupg_create_inbound_pipe (filedes);
1716   if (err)
1717     gc_error (1, 0, _("error creating a pipe: %s\n"), gpg_strerror (err));
1718
1719   pgmname = (gc_backend[backend].module_name 
1720              ? gnupg_module_name (gc_backend[backend].module_name) 
1721              : gc_backend[backend].program );
1722   argv[0] = "--gpgconf-list";
1723   argv[1] = NULL;
1724
1725   err = gnupg_spawn_process_fd (pgmname, argv, -1, filedes[1], -1, &pid);
1726   if (err)
1727     {
1728       close (filedes[0]);
1729       close (filedes[1]);
1730       gc_error (1, 0, "could not gather active options from `%s': %s",
1731                 pgmname, gpg_strerror (err));
1732     }
1733   close (filedes[1]);
1734   config = fdopen (filedes[0], "r");
1735   if (!config)
1736     gc_error (1, errno, "can't fdopen pipe for reading");
1737
1738   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1739     {
1740       gc_option_t *option;
1741       char *linep;
1742       unsigned long flags = 0;
1743       char *default_value = NULL;
1744       
1745       /* Strip newline and carriage return, if present.  */
1746       while (length > 0
1747              && (line[length - 1] == '\n' || line[length - 1] == '\r'))
1748         line[--length] = '\0';
1749
1750       linep = strchr (line, ':');
1751       if (linep)
1752         *(linep++) = '\0';
1753       
1754       /* Extract additional flags.  Default to none.  */
1755       if (linep)
1756         {
1757           char *end;
1758           char *tail;
1759
1760           end = strchr (linep, ':');
1761           if (end)
1762             *(end++) = '\0';
1763
1764           errno = 0;
1765           flags = strtoul (linep, &tail, 0);
1766           if (errno)
1767             gc_error (1, errno, "malformed flags in option %s from %s",
1768                       line, pgmname);
1769           if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
1770             gc_error (1, 0, "garbage after flags in option %s from %s",
1771                       line, pgmname);
1772
1773           linep = end;
1774         }
1775
1776       /* Extract default value, if present.  Default to empty if
1777          not.  */
1778       if (linep)
1779         {
1780           char *end;
1781
1782           end = strchr (linep, ':');
1783           if (end)
1784             *(end++) = '\0';
1785
1786           if (flags & GC_OPT_FLAG_DEFAULT)
1787             default_value = linep;
1788
1789           linep = end;
1790         }
1791
1792       /* Look up the option in the component and install the
1793          configuration data.  */
1794       option = find_option (component, line, backend);
1795       if (option)
1796         {
1797           if (option->active)
1798             gc_error (1, errno, "option %s returned twice from %s",
1799                       line, pgmname);
1800           option->active = 1;
1801
1802           option->flags |= flags;
1803           if (default_value && *default_value)
1804             option->default_value = xstrdup (default_value);
1805         }
1806     }
1807   if (length < 0 || ferror (config))
1808     gc_error (1, errno, "error reading from %s",pgmname);
1809   if (fclose (config) && ferror (config))
1810     gc_error (1, errno, "error closing %s", pgmname);
1811
1812   err = gnupg_wait_process (pgmname, pid, &exitcode);
1813   if (err)
1814     gc_error (1, 0, "running %s failed (exitcode=%d): %s",
1815               pgmname, exitcode, gpg_strerror (err));
1816
1817
1818   /* At this point, we can parse the configuration file.  */
1819   config_pathname = get_config_pathname (component, backend);
1820
1821   config = fopen (config_pathname, "r");
1822   if (!config)
1823     gc_error (0, errno, "warning: can not open config file %s",
1824               config_pathname);
1825   else
1826     {
1827       while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1828         {
1829           char *name;
1830           char *value;
1831           gc_option_t *option;
1832           
1833           name = line;
1834           while (*name == ' ' || *name == '\t')
1835             name++;
1836           if (!*name || *name == '#' || *name == '\r' || *name == '\n')
1837             continue;
1838
1839           value = name;
1840           while (*value && *value != ' ' && *value != '\t'
1841                  && *value != '#' && *value != '\r' && *value != '\n')
1842             value++;
1843           if (*value == ' ' || *value == '\t')
1844             {
1845               char *end;
1846
1847               *(value++) = '\0';
1848               while (*value == ' ' || *value == '\t')
1849                 value++;
1850
1851               end = value;
1852               while (*end && *end != '#' && *end != '\r' && *end != '\n')
1853                 end++;
1854               while (end > value && (end[-1] == ' ' || end[-1] == '\t'))
1855                 end--;
1856               *end = '\0';
1857             }
1858           else
1859             *value = '\0';
1860
1861           /* Look up the option in the component and install the
1862              configuration data.  */
1863           option = find_option (component, line, backend);
1864           if (option)
1865             {
1866               char *opt_value;
1867
1868               if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
1869                 {
1870                   if (*value)
1871                     gc_error (0, 0,
1872                               "warning: ignoring argument %s for option %s",
1873                               value, name);
1874                   opt_value = xstrdup ("1");
1875                 }
1876               else if (gc_arg_type[option->arg_type].fallback
1877                        == GC_ARG_TYPE_STRING)
1878                 opt_value = xasprintf ("\"%s", my_percent_escape (value));
1879               else
1880                 {
1881                   /* FIXME: Verify that the number is sane.  */
1882                   opt_value = xstrdup (value);
1883                 }
1884
1885               /* Now enter the option into the table.  */
1886               if (!(option->flags & GC_OPT_FLAG_LIST))
1887                 {
1888                   if (option->value)
1889                     free (option->value);
1890                   option->value = opt_value;
1891                 }
1892               else
1893                 {
1894                   if (!option->value)
1895                     option->value = opt_value;
1896                   else
1897                     {
1898                       char *opt_val = opt_value;
1899
1900                       option->value = xasprintf ("%s,%s", option->value,
1901                                                  opt_val);
1902                       xfree (opt_value);
1903                     }
1904                 }
1905             }
1906         }
1907
1908       if (length < 0 || ferror (config))
1909         gc_error (1, errno, "error reading from %s", config_pathname);
1910       if (fclose (config) && ferror (config))
1911         gc_error (1, errno, "error closing %s", config_pathname);
1912     }
1913
1914   xfree (line);
1915 }
1916
1917
1918 /* Retrieve the options for the component COMPONENT from backend
1919    BACKEND, which we already know is of type file list.  */ 
1920 static void
1921 retrieve_options_from_file (gc_component_t component, gc_backend_t backend)
1922 {
1923   gc_option_t *list_option;
1924   char *list_pathname;
1925   FILE *list_file;
1926   char *line = NULL;
1927   size_t line_len = 0;
1928   ssize_t length;
1929   char *list = NULL;
1930
1931   list_option = find_option (component,
1932                              gc_backend[backend].option_name, GC_BACKEND_ANY);
1933   assert (list_option);
1934   assert (!list_option->active);
1935
1936   list_pathname = get_config_pathname (component, backend);
1937   list_file = fopen (list_pathname, "r");
1938   if (!list_file)
1939     gc_error (0, errno, "warning: can not open list file %s", list_pathname);
1940   else
1941     {
1942
1943       while ((length = read_line (list_file, &line, &line_len, NULL)) > 0)
1944         {
1945           char *start;
1946           char *end;
1947           char *new_list;
1948
1949           start = line;
1950           while (*start == ' ' || *start == '\t')
1951             start++;
1952           if (!*start || *start == '#' || *start == '\r' || *start == '\n')
1953             continue;
1954
1955           end = start;
1956           while (*end && *end != '#' && *end != '\r' && *end != '\n')
1957             end++;
1958           /* Walk back to skip trailing white spaces.  Looks evil, but
1959              works because of the conditions on START and END imposed
1960              at this point (END is at least START + 1, and START is
1961              not a whitespace character).  */
1962           while (*(end - 1) == ' ' || *(end - 1) == '\t')
1963             end--;
1964           *end = '\0';
1965           /* FIXME: Oh, no!  This is so lame!  Should use realloc and
1966              really append.  */
1967           if (list)
1968             {
1969               new_list = xasprintf ("%s,\"%s", list, my_percent_escape (start));
1970               xfree (list);
1971               list = new_list;
1972             }
1973           else
1974             list = xasprintf ("\"%s", my_percent_escape (start));
1975         }
1976       if (length < 0 || ferror (list_file))
1977         gc_error (1, errno, "can not read list file %s", list_pathname);
1978     }
1979
1980   list_option->active = 1;
1981   list_option->value = list;
1982
1983   if (list_file && fclose (list_file) && ferror (list_file))
1984     gc_error (1, errno, "error closing %s", list_pathname);
1985   xfree (line);
1986 }
1987
1988
1989 /* Retrieve the currently active options and their defaults from all
1990    involved backends for this component.  Using -1 for component will
1991    retrieve all options from all components. */
1992 void
1993 gc_component_retrieve_options (int component)
1994 {
1995   int process_all = 0;
1996   int backend_seen[GC_BACKEND_NR];
1997   gc_backend_t backend;
1998   gc_option_t *option;
1999
2000   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2001     backend_seen[backend] = 0;
2002
2003   if (component == -1)
2004     {
2005       process_all = 1;
2006       component = 0;
2007       assert (component < GC_COMPONENT_NR);
2008     }
2009       
2010   do
2011     {
2012       option = gc_component[component].options;
2013
2014       while (option && option->name)
2015         {
2016           if (!(option->flags & GC_OPT_FLAG_GROUP))
2017             {
2018               backend = option->backend;
2019               
2020               if (backend_seen[backend])
2021                 {
2022                   option++;
2023                   continue;
2024                 }
2025               backend_seen[backend] = 1;
2026               
2027               assert (backend != GC_BACKEND_ANY);
2028               
2029               if (gc_backend[backend].program)
2030                 retrieve_options_from_program (component, backend);
2031               else
2032                 retrieve_options_from_file (component, backend);
2033             }
2034           option++;
2035         }
2036     }
2037   while (process_all && ++component < GC_COMPONENT_NR);
2038
2039 }
2040
2041
2042 \f
2043 /* Perform a simple validity check based on the type.  Return in
2044    NEW_VALUE_NR the value of the number in NEW_VALUE if OPTION is of
2045    type GC_ARG_TYPE_NONE.  */
2046 static void
2047 option_check_validity (gc_option_t *option, unsigned long flags,
2048                        char *new_value, unsigned long *new_value_nr)
2049 {
2050   char *arg;
2051
2052   if (!option->active)
2053     gc_error (1, 0, "option %s not supported by backend %s",
2054               option->name, gc_backend[option->backend].name);
2055       
2056   if (option->new_flags || option->new_value)
2057     gc_error (1, 0, "option %s already changed", option->name);
2058
2059   if (flags & GC_OPT_FLAG_DEFAULT)
2060     {
2061       if (*new_value)
2062         gc_error (1, 0, "argument %s provided for deleted option %s",
2063                   new_value, option->name);
2064
2065       return;
2066     }
2067
2068   /* GC_ARG_TYPE_NONE options have special list treatment.  */
2069   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
2070     {
2071       char *tail;
2072
2073       errno = 0;
2074       *new_value_nr = strtoul (new_value, &tail, 0);
2075
2076       if (errno)
2077         gc_error (1, errno, "invalid argument for option %s",
2078                   option->name);
2079       if (*tail)
2080         gc_error (1, 0, "garbage after argument for option %s",
2081                       option->name);
2082
2083       if (!(option->flags & GC_OPT_FLAG_LIST))
2084         {
2085           if (*new_value_nr != 1)
2086             gc_error (1, 0, "argument for non-list option %s of type 0 "
2087                       "(none) must be 1", option->name);
2088         }
2089       else
2090         {
2091           if (*new_value_nr == 0)
2092             gc_error (1, 0, "argument for option %s of type 0 (none) "
2093                       "must be positive", option->name);
2094         }
2095
2096       return;
2097     }
2098
2099   arg = new_value;
2100   do
2101     {
2102       if (*arg == '\0' || *arg == ',')
2103         {
2104           if (!(option->flags & GC_OPT_FLAG_ARG_OPT))
2105             gc_error (1, 0, "argument required for option %s", option->name);
2106
2107           if (*arg == ',' && !(option->flags & GC_OPT_FLAG_LIST))
2108             gc_error (1, 0, "list found for non-list option %s", option->name);
2109         }
2110       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_STRING)
2111         {
2112           if (*arg != '"')
2113             gc_error (1, 0, "string argument for option %s must begin "
2114                       "with a quote (\") character", option->name);
2115
2116           /* FIXME: We do not allow empty string arguments for now, as
2117              we do not quote arguments in configuration files, and
2118              thus no argument is indistinguishable from the empty
2119              string.  */
2120           if (arg[1] == '\0' || arg[1] == ',')
2121             gc_error (1, 0, "empty string argument for option %s is "
2122                       "currently not allowed.  Please report this!",
2123                       option->name);
2124         }
2125       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2126         {
2127           errno = 0;
2128           (void) strtol (arg, &arg, 0);
2129
2130           if (errno)
2131             gc_error (1, errno, "invalid argument for option %s",
2132                       option->name);
2133
2134           if (*arg != '\0' && *arg != ',')
2135             gc_error (1, 0, "garbage after argument for option %s",
2136                       option->name);
2137         }
2138       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2139         {
2140           errno = 0;
2141           (void) strtoul (arg, &arg, 0);
2142
2143           if (errno)
2144             gc_error (1, errno, "invalid argument for option %s",
2145                       option->name);
2146
2147           if (*arg != '\0' && *arg != ',')
2148             gc_error (1, 0, "garbage after argument for option %s",
2149                       option->name);
2150         }
2151       arg = strchr (arg, ',');
2152       if (arg)
2153         arg++;
2154     }
2155   while (arg && *arg);
2156 }
2157
2158 #ifdef HAVE_W32_SYSTEM
2159 int
2160 copy_file (const char *src_name, const char *dst_name)
2161 {
2162 #define BUF_LEN 4096
2163   char buffer[BUF_LEN];
2164   int len;
2165   FILE *src;
2166   FILE *dst;
2167
2168   src = fopen (src_name, "r");
2169   if (src == NULL)
2170     return -1;
2171
2172   dst = fopen (dst_name, "w");
2173   if (dst == NULL)
2174     {
2175       int saved_err = errno;
2176       fclose (src);
2177       errno = saved_err;
2178       return -1;
2179     }
2180
2181   do
2182     {
2183       int written;
2184
2185       len = fread (buffer, 1, BUF_LEN, src);
2186       if (len == 0)
2187         break;
2188       written = fwrite (buffer, 1, len, dst);
2189       if (written != len)
2190         break;
2191     }
2192   while (!feof (src) && !ferror (src) && !ferror (dst));
2193
2194   if (ferror (src) || ferror (dst) || !feof (src))
2195     {
2196       int saved_errno = errno;
2197       fclose (src);
2198       fclose (dst);
2199       unlink (dst_name);
2200       errno = saved_errno;
2201       return -1;
2202     }
2203
2204   if (fclose (dst) && ferror (dst))
2205     gc_error (1, errno, "error closing %s", dst_name);
2206   if (fclose (src) && ferror (src))
2207     gc_error (1, errno, "error closing %s", src_name);
2208
2209   return 0;
2210 }
2211 #endif /* HAVE_W32_SYSTEM */
2212
2213
2214 /* Create and verify the new configuration file for the specified
2215    backend and component.  Returns 0 on success and -1 on error.  */
2216 static int
2217 change_options_file (gc_component_t component, gc_backend_t backend,
2218                      char **src_filenamep, char **dest_filenamep,
2219                      char **orig_filenamep)
2220 {
2221   static const char marker[] = "###+++--- GPGConf ---+++###";
2222   /* True if we are within the marker in the config file.  */
2223   int in_marker = 0;
2224   gc_option_t *option;
2225   char *line = NULL;
2226   size_t line_len;
2227   ssize_t length;
2228   int res;
2229   int fd;
2230   FILE *src_file = NULL;
2231   FILE *dest_file = NULL;
2232   char *src_filename;
2233   char *dest_filename;
2234   char *orig_filename;
2235   char *arg;
2236   char *cur_arg = NULL;
2237
2238   option = find_option (component,
2239                         gc_backend[backend].option_name, GC_BACKEND_ANY);
2240   assert (option);
2241   assert (option->active);
2242   assert (gc_arg_type[option->arg_type].fallback != GC_ARG_TYPE_NONE);
2243
2244   /* FIXME.  Throughout the function, do better error reporting.  */
2245   /* Note that get_config_pathname() calls percent_deescape(), so we
2246      call this before processing the arguments.  */
2247   dest_filename = xstrdup (get_config_pathname (component, backend));
2248   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, getpid ());
2249   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename, getpid ());
2250
2251   arg = option->new_value;
2252   if (arg && arg[0] == '\0')
2253     arg = NULL;
2254   else if (arg)
2255     {
2256       char *end;
2257
2258       arg++;
2259       end = strchr (arg, ',');
2260       if (end)
2261         *end = '\0';
2262
2263       cur_arg = percent_deescape (arg);
2264       if (end)
2265         {
2266           *end = ',';
2267           arg = end + 1;
2268         }
2269       else
2270         arg = NULL;
2271     }
2272
2273 #ifdef HAVE_W32_SYSTEM
2274   res = copy_file (dest_filename, orig_filename);
2275 #else
2276   res = link (dest_filename, orig_filename);
2277 #endif
2278   if (res < 0 && errno != ENOENT)
2279     return -1;
2280   if (res < 0)
2281     {
2282       xfree (orig_filename);
2283       orig_filename = NULL;
2284     }
2285
2286   /* We now initialize the return strings, so the caller can do the
2287      cleanup for us.  */
2288   *src_filenamep = src_filename;
2289   *dest_filenamep = dest_filename;
2290   *orig_filenamep = orig_filename;
2291
2292   /* Use open() so that we can use O_EXCL.  */
2293   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2294   if (fd < 0)
2295     return -1;
2296   src_file = fdopen (fd, "w");
2297   res = errno;
2298   if (!src_file)
2299     {
2300       errno = res;
2301       return -1;
2302     }
2303
2304   /* Only if ORIG_FILENAME is not NULL did the configuration file
2305      exist already.  In this case, we will copy its content into the
2306      new configuration file, changing it to our liking in the
2307      process.  */
2308   if (orig_filename)
2309     {
2310       dest_file = fopen (dest_filename, "r");
2311       if (!dest_file)
2312         goto change_file_one_err;
2313
2314       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2315         {
2316           int disable = 0;
2317           char *start;
2318
2319           if (!strncmp (marker, line, sizeof (marker) - 1))
2320             {
2321               if (!in_marker)
2322                 in_marker = 1;
2323               else
2324                 break;
2325             }
2326
2327           start = line;
2328           while (*start == ' ' || *start == '\t')
2329             start++;
2330           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2331             {
2332               char *end;
2333               char *endp;
2334               char saved_end;
2335
2336               endp = start;
2337               end = endp;
2338
2339               /* Search for the end of the line.  */
2340               while (*endp && *endp != '#' && *endp != '\r' && *endp != '\n')
2341                 {
2342                   endp++;
2343                   if (*endp && *endp != ' ' && *endp != '\t'
2344                       && *endp != '\r' && *endp != '\n' && *endp != '#')
2345                     end = endp + 1;
2346                 }
2347               saved_end = *end;
2348               *end = '\0';
2349
2350               if ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2351                   || !cur_arg || strcmp (start, cur_arg))
2352                 disable = 1;
2353               else
2354                 {
2355                   /* Find next argument.  */
2356                   if (arg)
2357                     {
2358                       char *arg_end;
2359
2360                       arg++;
2361                       arg_end = strchr (arg, ',');
2362                       if (arg_end)
2363                         *arg_end = '\0';
2364
2365                       cur_arg = percent_deescape (arg);
2366                       if (arg_end)
2367                         {
2368                           *arg_end = ',';
2369                           arg = arg_end + 1;
2370                         }
2371                       else
2372                         arg = NULL;
2373                     }
2374                   else
2375                     cur_arg = NULL;
2376                 }
2377
2378               *end = saved_end;
2379             }
2380
2381           if (disable)
2382             {
2383               if (!in_marker)
2384                 {
2385                   fprintf (src_file,
2386                            "# GPGConf disabled this option here at %s\n",
2387                            asctimestamp (gnupg_get_time ()));
2388                   if (ferror (src_file))
2389                     goto change_file_one_err;
2390                   fprintf (src_file, "# %s", line);
2391                   if (ferror (src_file))
2392                     goto change_file_one_err;
2393                 }
2394             }
2395           else
2396             {
2397               fprintf (src_file, "%s", line);
2398               if (ferror (src_file))
2399                 goto change_file_one_err;
2400             }
2401         }
2402       if (length < 0 || ferror (dest_file))
2403         goto change_file_one_err;
2404     }
2405
2406   if (!in_marker)
2407     {
2408       /* There was no marker.  This is the first time we edit the
2409          file.  We add our own marker at the end of the file and
2410          proceed.  Note that we first write a newline, this guards us
2411          against files which lack the newline at the end of the last
2412          line, while it doesn't hurt us in all other cases.  */
2413       fprintf (src_file, "\n%s\n", marker);
2414       if (ferror (src_file))
2415         goto change_file_one_err;
2416     }
2417
2418   /* At this point, we have copied everything up to the end marker
2419      into the new file, except for the arguments we are going to add.
2420      Now, dump the new arguments and write the end marker, possibly
2421      followed by the rest of the original file.  */
2422   while (cur_arg)
2423     {
2424       fprintf (src_file, "%s\n", cur_arg);
2425
2426       /* Find next argument.  */
2427       if (arg)
2428         {
2429           char *end;
2430
2431           arg++;
2432           end = strchr (arg, ',');
2433           if (end)
2434             *end = '\0';
2435
2436           cur_arg = percent_deescape (arg);
2437           if (end)
2438             {
2439               *end = ',';
2440               arg = end + 1;
2441             }
2442           else
2443             arg = NULL;
2444         }
2445       else
2446         cur_arg = NULL;
2447     }
2448
2449   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2450   if (ferror (src_file))
2451     goto change_file_one_err;
2452
2453   if (!in_marker)
2454     {
2455       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2456       if (ferror (src_file))
2457         goto change_file_one_err;
2458       fprintf (src_file, "# It will disable options before this marked "
2459                "block, but it will\n");
2460       if (ferror (src_file))
2461         goto change_file_one_err;
2462       fprintf (src_file, "# never change anything below these lines.\n");
2463       if (ferror (src_file))
2464         goto change_file_one_err;
2465     }
2466   if (dest_file)
2467     {
2468       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2469         {
2470           fprintf (src_file, "%s", line);
2471           if (ferror (src_file))
2472             goto change_file_one_err;
2473         }
2474       if (length < 0 || ferror (dest_file))
2475         goto change_file_one_err;
2476     }
2477   xfree (line);
2478   line = NULL;
2479
2480   res = fclose (src_file);
2481   if (res)
2482     {
2483       res = errno;
2484       close (fd);
2485       if (dest_file)
2486         fclose (dest_file);
2487       errno = res;
2488       return -1;
2489     }
2490   close (fd);
2491   if (dest_file)
2492     {
2493       res = fclose (dest_file);
2494       if (res)
2495         return -1;
2496     }
2497   return 0;
2498
2499  change_file_one_err:
2500   xfree (line);
2501   res = errno;
2502   if (src_file)
2503     {
2504       fclose (src_file);
2505       close (fd);
2506     }
2507   if (dest_file)
2508     fclose (dest_file);
2509   errno = res;
2510   return -1;
2511 }
2512
2513
2514 /* Create and verify the new configuration file for the specified
2515    backend and component.  Returns 0 on success and -1 on error.  */
2516 static int
2517 change_options_program (gc_component_t component, gc_backend_t backend,
2518                         char **src_filenamep, char **dest_filenamep,
2519                         char **orig_filenamep)
2520 {
2521   static const char marker[] = "###+++--- GPGConf ---+++###";
2522   /* True if we are within the marker in the config file.  */
2523   int in_marker = 0;
2524   gc_option_t *option;
2525   char *line = NULL;
2526   size_t line_len;
2527   ssize_t length;
2528   int res;
2529   int fd;
2530   FILE *src_file = NULL;
2531   FILE *dest_file = NULL;
2532   char *src_filename;
2533   char *dest_filename;
2534   char *orig_filename;
2535   /* Special hack for gpg, see below.  */
2536   int utf8strings_seen = 0;
2537
2538   /* FIXME.  Throughout the function, do better error reporting.  */
2539   dest_filename = xstrdup (get_config_pathname (component, backend));
2540   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, getpid ());
2541   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename, getpid ());
2542
2543 #ifdef HAVE_W32_SYSTEM
2544   res = copy_file (dest_filename, orig_filename);
2545 #else
2546   res = link (dest_filename, orig_filename);
2547 #endif
2548   if (res < 0 && errno != ENOENT)
2549     return -1;
2550   if (res < 0)
2551     {
2552       xfree (orig_filename);
2553       orig_filename = NULL;
2554     }
2555
2556   /* We now initialize the return strings, so the caller can do the
2557      cleanup for us.  */
2558   *src_filenamep = src_filename;
2559   *dest_filenamep = dest_filename;
2560   *orig_filenamep = orig_filename;
2561
2562   /* Use open() so that we can use O_EXCL.  */
2563   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2564   if (fd < 0)
2565     return -1;
2566   src_file = fdopen (fd, "w");
2567   res = errno;
2568   if (!src_file)
2569     {
2570       errno = res;
2571       return -1;
2572     }
2573
2574   /* Only if ORIG_FILENAME is not NULL did the configuration file
2575      exist already.  In this case, we will copy its content into the
2576      new configuration file, changing it to our liking in the
2577      process.  */
2578   if (orig_filename)
2579     {
2580       dest_file = fopen (dest_filename, "r");
2581       if (!dest_file)
2582         goto change_one_err;
2583
2584       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2585         {
2586           int disable = 0;
2587           char *start;
2588
2589           if (!strncmp (marker, line, sizeof (marker) - 1))
2590             {
2591               if (!in_marker)
2592                 in_marker = 1;
2593               else
2594                 break;
2595             }
2596           else if (backend == GC_BACKEND_GPG && in_marker
2597                    && ! strcmp ("utf8-strings\n", line))
2598             {
2599               /* Strip duplicated entries.  */
2600               if (utf8strings_seen)
2601                 disable = 1;
2602               else
2603                 utf8strings_seen = 1;
2604             }
2605
2606           start = line;
2607           while (*start == ' ' || *start == '\t')
2608             start++;
2609           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2610             {
2611               char *end;
2612               char saved_end;
2613
2614               end = start;
2615               while (*end && *end != ' ' && *end != '\t'
2616                      && *end != '\r' && *end != '\n' && *end != '#')
2617                 end++;
2618               saved_end = *end;
2619               *end = '\0';
2620
2621               option = find_option (component, start, backend);
2622               *end = saved_end;
2623               if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2624                              || option->new_value))
2625                 disable = 1;
2626             }
2627           if (disable)
2628             {
2629               if (!in_marker)
2630                 {
2631                   fprintf (src_file,
2632                            "# GPGConf disabled this option here at %s\n",
2633                            asctimestamp (gnupg_get_time ()));
2634                   if (ferror (src_file))
2635                     goto change_one_err;
2636                   fprintf (src_file, "# %s", line);
2637                   if (ferror (src_file))
2638                     goto change_one_err;
2639                 }
2640             }
2641           else
2642             {
2643               fprintf (src_file, "%s", line);
2644               if (ferror (src_file))
2645                 goto change_one_err;
2646             }
2647         }
2648       if (length < 0 || ferror (dest_file))
2649         goto change_one_err;
2650     }
2651
2652   if (!in_marker)
2653     {
2654       /* There was no marker.  This is the first time we edit the
2655          file.  We add our own marker at the end of the file and
2656          proceed.  Note that we first write a newline, this guards us
2657          against files which lack the newline at the end of the last
2658          line, while it doesn't hurt us in all other cases.  */
2659       fprintf (src_file, "\n%s\n", marker);
2660       if (ferror (src_file))
2661         goto change_one_err;
2662     }
2663   /* At this point, we have copied everything up to the end marker
2664      into the new file, except for the options we are going to change.
2665      Now, dump the changed options (except for those we are going to
2666      revert to their default), and write the end marker, possibly
2667      followed by the rest of the original file.  */
2668
2669   /* We have to turn on UTF8 strings for GnuPG.  */
2670   if (backend == GC_BACKEND_GPG && ! utf8strings_seen)
2671     fprintf (src_file, "utf8-strings\n");
2672
2673   option = gc_component[component].options;
2674   while (option->name)
2675     {
2676       if (!(option->flags & GC_OPT_FLAG_GROUP)
2677           && option->backend == backend
2678           && option->new_value)
2679         {
2680           char *arg = option->new_value;
2681
2682           do
2683             {
2684               if (*arg == '\0' || *arg == ',')
2685                 {
2686                   fprintf (src_file, "%s\n", option->name);
2687                   if (ferror (src_file))
2688                     goto change_one_err;
2689                 }
2690               else if (gc_arg_type[option->arg_type].fallback
2691                        == GC_ARG_TYPE_NONE)
2692                 {
2693                   assert (*arg == '1');
2694                   fprintf (src_file, "%s\n", option->name);
2695                   if (ferror (src_file))
2696                     goto change_one_err;
2697
2698                   arg++;
2699                 }
2700               else if (gc_arg_type[option->arg_type].fallback
2701                        == GC_ARG_TYPE_STRING)
2702                 {
2703                   char *end;
2704                   
2705                   assert (*arg == '"');
2706                   arg++;
2707                   
2708                   end = strchr (arg, ',');
2709                   if (end)
2710                     *end = '\0';
2711
2712                   fprintf (src_file, "%s %s\n", option->name,
2713                            percent_deescape (arg));
2714                   if (ferror (src_file))
2715                     goto change_one_err;
2716
2717                   if (end)
2718                     *end = ',';
2719                   arg = end;
2720                 }
2721               else
2722                 {
2723                   char *end;
2724
2725                   end = strchr (arg, ',');
2726                   if (end)
2727                     *end = '\0';
2728
2729                   fprintf (src_file, "%s %s\n", option->name, arg);
2730                   if (ferror (src_file))
2731                     goto change_one_err;
2732
2733                   if (end)
2734                     *end = ',';
2735                   arg = end;
2736                 }
2737
2738               assert (arg == NULL || *arg == '\0' || *arg == ',');
2739               if (arg && *arg == ',')
2740                 arg++;
2741             }
2742           while (arg && *arg);
2743         }
2744       option++;
2745     }
2746
2747   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2748   if (ferror (src_file))
2749     goto change_one_err;
2750
2751   if (!in_marker)
2752     {
2753       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2754       if (ferror (src_file))
2755         goto change_one_err;
2756       fprintf (src_file, "# It will disable options before this marked "
2757                "block, but it will\n");
2758       if (ferror (src_file))
2759         goto change_one_err;
2760       fprintf (src_file, "# never change anything below these lines.\n");
2761       if (ferror (src_file))
2762         goto change_one_err;
2763     }
2764   if (dest_file)
2765     {
2766       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2767         {
2768           fprintf (src_file, "%s", line);
2769           if (ferror (src_file))
2770             goto change_one_err;
2771         }
2772       if (length < 0 || ferror (dest_file))
2773         goto change_one_err;
2774     }
2775   xfree (line);
2776   line = NULL;
2777
2778   res = fclose (src_file);
2779   if (res)
2780     {
2781       res = errno;
2782       close (fd);
2783       if (dest_file)
2784         fclose (dest_file);
2785       errno = res;
2786       return -1;
2787     }
2788   close (fd);
2789   if (dest_file)
2790     {
2791       res = fclose (dest_file);
2792       if (res)
2793         return -1;
2794     }
2795   return 0;
2796
2797  change_one_err:
2798   xfree (line);
2799   res = errno;
2800   if (src_file)
2801     {
2802       fclose (src_file);
2803       close (fd);
2804     }
2805   if (dest_file)
2806     fclose (dest_file);
2807   errno = res;
2808   return -1;
2809 }
2810
2811
2812 /* Common code for gc_component_change_options and
2813    gc_process_gpgconf_conf.  */
2814 static void
2815 change_one_value (gc_option_t *option, int *runtime,
2816                   unsigned long flags, char *new_value)
2817 {
2818   unsigned long new_value_nr = 0;
2819
2820   option_check_validity (option, flags, new_value, &new_value_nr);
2821
2822   if (option->flags & GC_OPT_FLAG_RUNTIME)
2823     runtime[option->backend] = 1;
2824
2825   option->new_flags = flags;
2826   if (!(flags & GC_OPT_FLAG_DEFAULT))
2827     {
2828       if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
2829           && (option->flags & GC_OPT_FLAG_LIST))
2830         {
2831           char *str;
2832
2833           /* We convert the number to a list of 1's for convenient
2834              list handling.  */
2835           assert (new_value_nr > 0);
2836           option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
2837           str = option->new_value;
2838           *(str++) = '1';
2839           while (--new_value_nr > 0)
2840             {
2841               *(str++) = ',';
2842               *(str++) = '1';
2843             }
2844           *(str++) = '\0';
2845         }
2846       else
2847         option->new_value = xstrdup (new_value);
2848     }
2849 }
2850
2851
2852 /* Read the modifications from IN and apply them.  If IN is NULL the
2853    modifications are expected to already have been set to the global
2854    table. */
2855 void
2856 gc_component_change_options (int component, FILE *in, FILE *out)
2857 {
2858   int err = 0;
2859   int runtime[GC_BACKEND_NR];
2860   char *src_pathname[GC_BACKEND_NR];
2861   char *dest_pathname[GC_BACKEND_NR];
2862   char *orig_pathname[GC_BACKEND_NR];
2863   gc_backend_t backend;
2864   gc_option_t *option;
2865   char *line = NULL;
2866   size_t line_len = 0;
2867   ssize_t length;
2868
2869   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2870     {
2871       runtime[backend] = 0;
2872       src_pathname[backend] = NULL;
2873       dest_pathname[backend] = NULL;
2874       orig_pathname[backend] = NULL;
2875     }
2876
2877   if (in)
2878     {
2879       /* Read options from the file IN.  */
2880       while ((length = read_line (in, &line, &line_len, NULL)) > 0)
2881         {
2882           char *linep;
2883           unsigned long flags = 0;
2884           char *new_value = "";
2885           
2886           /* Strip newline and carriage return, if present.  */
2887           while (length > 0
2888                  && (line[length - 1] == '\n' || line[length - 1] == '\r'))
2889             line[--length] = '\0';
2890           
2891           linep = strchr (line, ':');
2892           if (linep)
2893             *(linep++) = '\0';
2894           
2895           /* Extract additional flags.  Default to none.  */
2896           if (linep)
2897             {
2898               char *end;
2899               char *tail;
2900
2901               end = strchr (linep, ':');
2902               if (end)
2903                 *(end++) = '\0';
2904               
2905               errno = 0;
2906               flags = strtoul (linep, &tail, 0);
2907               if (errno)
2908                 gc_error (1, errno, "malformed flags in option %s", line);
2909               if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
2910                 gc_error (1, 0, "garbage after flags in option %s", line);
2911               
2912               linep = end;
2913             }
2914
2915           /* Don't allow setting of the no change flag.  */
2916           flags &= ~GC_OPT_FLAG_NO_CHANGE;
2917           
2918           /* Extract default value, if present.  Default to empty if not.  */
2919           if (linep)
2920             {
2921               char *end;
2922               end = strchr (linep, ':');
2923               if (end)
2924                 *(end++) = '\0';
2925               new_value = linep;
2926               linep = end;
2927             }
2928           
2929           option = find_option (component, line, GC_BACKEND_ANY);
2930           if (!option)
2931             gc_error (1, 0, "unknown option %s", line);
2932           
2933           if ((option->flags & GC_OPT_FLAG_NO_CHANGE))
2934             {
2935               gc_error (0, 0, "ignoring new value for option %s",
2936                         option->name);
2937               continue;
2938             }
2939           
2940           change_one_value (option, runtime, flags, new_value);
2941         }
2942     }
2943
2944   /* Now that we have collected and locally verified the changes,
2945      write them out to new configuration files, verify them
2946      externally, and then commit them.  */
2947   option = gc_component[component].options;
2948   while (option && option->name)
2949     {
2950       /* Go on if we have already seen this backend, or if there is
2951          nothing to do.  */
2952       if (src_pathname[option->backend]
2953           || !(option->new_flags || option->new_value))
2954         {
2955           option++;
2956           continue;
2957         }
2958
2959       if (gc_backend[option->backend].program)
2960         {
2961           err = change_options_program (component, option->backend,
2962                                         &src_pathname[option->backend],
2963                                         &dest_pathname[option->backend],
2964                                         &orig_pathname[option->backend]);
2965           if (! err)
2966             {
2967               /* External verification.  */
2968               err = gc_component_check_options (component, out,
2969                                                 src_pathname[option->backend]);
2970               if (err)
2971                 {
2972                   gc_error (0, 0,
2973                             _("External verification of component %s failed"),
2974                             gc_component[component].name);
2975                   errno = EINVAL;
2976                 }
2977             }
2978
2979         }
2980       else
2981         err = change_options_file (component, option->backend,
2982                                    &src_pathname[option->backend],
2983                                    &dest_pathname[option->backend],
2984                                    &orig_pathname[option->backend]);
2985         
2986       if (err)
2987         break;
2988           
2989       option++;
2990     }
2991
2992   if (! err && ! opt.dry_run)
2993     {
2994       int i;
2995
2996       for (i = 0; i < GC_BACKEND_NR; i++)
2997         {
2998           if (src_pathname[i])
2999             {
3000               /* FIXME: Make a verification here.  */
3001
3002               assert (dest_pathname[i]);
3003
3004               if (orig_pathname[i])
3005                 {
3006 #ifdef HAVE_W32_SYSTEM
3007                   /* There is no atomic update on W32.  */
3008                   err = unlink (dest_pathname[i]);
3009 #endif /* HAVE_W32_SYSTEM */
3010                   if (!err)
3011                     err = rename (src_pathname[i], dest_pathname[i]);
3012                 }
3013               else
3014                 {
3015 #ifdef HAVE_W32_SYSTEM
3016                   /* We skip the unlink if we expect the file not to
3017                      be there.  */
3018                   err = rename (src_pathname[i], dest_pathname[i]);
3019 #else /* HAVE_W32_SYSTEM */
3020                   /* This is a bit safer than rename() because we
3021                      expect DEST_PATHNAME not to be there.  If it
3022                      happens to be there, this will fail.  */
3023                   err = link (src_pathname[i], dest_pathname[i]);
3024                   if (!err)
3025                     err = unlink (src_pathname[i]);
3026 #endif /* !HAVE_W32_SYSTEM */
3027                 }
3028               if (err)
3029                 break;
3030               src_pathname[i] = NULL;
3031             }
3032         }
3033     }
3034
3035   if (err || opt.dry_run)
3036     {
3037       int i;
3038       int saved_errno = errno;
3039
3040       /* An error occured or a dry-run is requested.  */
3041       for (i = 0; i < GC_BACKEND_NR; i++)
3042         {
3043           if (src_pathname[i])
3044             {
3045               /* The change was not yet committed.  */
3046               unlink (src_pathname[i]);
3047               if (orig_pathname[i])
3048                 unlink (orig_pathname[i]);
3049             }
3050           else
3051             {
3052               /* The changes were already committed.  FIXME: This is a
3053                  tad dangerous, as we don't know if we don't overwrite
3054                  a version of the file that is even newer than the one
3055                  we just installed.  */
3056               if (orig_pathname[i])
3057                 {
3058 #ifdef HAVE_W32_SYSTEM
3059                   /* There is no atomic update on W32.  */
3060                   unlink (dest_pathname[i]);
3061 #endif /* HAVE_W32_SYSTEM */
3062                   rename (orig_pathname[i], dest_pathname[i]);
3063                 }
3064               else
3065                 unlink (dest_pathname[i]);
3066             }
3067         }
3068       if (err)
3069         gc_error (1, saved_errno, "could not commit changes");
3070
3071       /* Fall-through for dry run.  */
3072       goto leave;
3073     }
3074
3075   /* If it all worked, notify the daemons of the changes.  */
3076   if (opt.runtime)
3077     for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3078       {
3079         if (runtime[backend] && gc_backend[backend].runtime_change)
3080           (*gc_backend[backend].runtime_change) ();
3081       }
3082
3083   /* Move the per-process backup file into its place.  */
3084   for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3085     if (orig_pathname[backend])
3086       {
3087         char *backup_pathname;
3088
3089         assert (dest_pathname[backend]);
3090
3091         backup_pathname = xasprintf ("%s.gpgconf.bak", dest_pathname[backend]);
3092
3093 #ifdef HAVE_W32_SYSTEM
3094         /* There is no atomic update on W32.  */
3095         unlink (backup_pathname);
3096 #endif /* HAVE_W32_SYSTEM */
3097         rename (orig_pathname[backend], backup_pathname);
3098       }
3099
3100  leave:
3101   xfree (line);
3102 }
3103
3104
3105 /* Check whether USER matches the current user of one of its group.
3106    This function may change USER.  Returns true is there is a
3107    match.  */
3108 static int
3109 key_matches_user_or_group (char *user)
3110 {
3111   char *group;
3112
3113   if (*user == '*' && user[1] == 0)
3114     return 1; /* A single asterisk matches all users.  */
3115
3116   group = strchr (user, ':');
3117   if (group)
3118     *group++ = 0;
3119
3120 #ifdef HAVE_W32_SYSTEM
3121   /* Under Windows we don't support groups. */   
3122   if (group && *group)
3123     gc_error (0, 0, _("Note that group specifications are ignored\n"));
3124   if (*user)
3125     {
3126       static char *my_name;
3127
3128       if (!my_name)
3129         {
3130           char tmp[1];
3131           DWORD size = 1;
3132
3133           GetUserNameA (tmp, &size);
3134           my_name = xmalloc (size);
3135           if (!GetUserNameA (my_name, &size))
3136             gc_error (1,0, "error getting current user name: %s",
3137                       w32_strerror (-1));
3138         }
3139
3140       if (!strcmp (user, my_name))
3141         return 1; /* Found.  */
3142     }
3143 #else /*!HAVE_W32_SYSTEM*/
3144   /* First check whether the user matches.  */
3145   if (*user)
3146     {
3147       static char *my_name;
3148
3149       if (!my_name)
3150         {
3151           struct passwd *pw = getpwuid ( getuid () );
3152           if (!pw)
3153             gc_error (1, errno, "getpwuid failed for current user");
3154           my_name = xstrdup (pw->pw_name);
3155         }
3156       if (!strcmp (user, my_name))
3157         return 1; /* Found.  */
3158     }
3159
3160   /* If that failed, check whether a group matches.  */
3161   if (group && *group)
3162     {
3163       static char *my_group;
3164       static char **my_supgroups;
3165       int n;
3166
3167       if (!my_group)
3168         {
3169           struct group *gr = getgrgid ( getgid () );
3170           if (!gr)
3171             gc_error (1, errno, "getgrgid failed for current user");
3172           my_group = xstrdup (gr->gr_name);
3173         }
3174       if (!strcmp (group, my_group))
3175         return 1; /* Found.  */
3176
3177       if (!my_supgroups)
3178         {
3179           int ngids;
3180           gid_t *gids;
3181
3182           ngids = getgroups (0, NULL);
3183           gids  = xcalloc (ngids+1, sizeof *gids);
3184           ngids = getgroups (ngids, gids);
3185           if (ngids < 0)
3186             gc_error (1, errno, "getgroups failed for current user");
3187           my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
3188           for (n=0; n < ngids; n++)
3189             {
3190               struct group *gr = getgrgid ( gids[n] );
3191               if (!gr)
3192                 gc_error (1, errno, "getgrgid failed for supplementary group");
3193               my_supgroups[n] = xstrdup (gr->gr_name);
3194             }
3195           xfree (gids);
3196         }
3197
3198       for (n=0; my_supgroups[n]; n++)
3199         if (!strcmp (group, my_supgroups[n]))
3200           return 1; /* Found.  */
3201     }
3202 #endif /*!HAVE_W32_SYSTEM*/
3203   return 0; /* No match.  */
3204 }
3205
3206
3207
3208 /* Read and process the global configuration file for gpgconf.  This
3209    optional file is used to update our internal tables at runtime and
3210    may also be used to set new default values.  If FNAME is NULL the
3211    default name will be used.  With UPDATE set to true the internal
3212    tables are actually updated; if not set, only a syntax check is
3213    done.  If DEFAULTS is true the global options are written to the
3214    configuration files.  If LISTFP is set, no changes are done but the
3215    configuration file is printed to LISTFP in a colon separated format.
3216
3217    Returns 0 on success or if the config file is not present; -1 is
3218    returned on error. */
3219 int
3220 gc_process_gpgconf_conf (const char *fname_arg, int update, int defaults,
3221                          FILE *listfp)
3222 {
3223   int result = 0;
3224   char *line = NULL;
3225   size_t line_len = 0;
3226   ssize_t length;
3227   FILE *config;
3228   int lineno = 0;
3229   int in_rule = 0;
3230   int got_match = 0;
3231   int runtime[GC_BACKEND_NR];
3232   int used_components[GC_COMPONENT_NR];
3233   int backend_id, component_id;
3234   char *fname;
3235
3236   if (fname_arg)
3237     fname = xstrdup (fname_arg);
3238   else
3239     fname = make_filename (gnupg_sysconfdir (), "gpgconf.conf", NULL);
3240
3241   for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3242     runtime[backend_id] = 0;
3243   for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3244     used_components[component_id] = 0;
3245
3246   config = fopen (fname, "r");
3247   if (!config)
3248     {
3249       /* Do not print an error if the file is not available, except
3250          when running in syntax check mode.  */
3251       if (errno != ENOENT || !update)
3252         {
3253           gc_error (0, errno, "can not open global config file `%s'", fname);
3254           result = -1;
3255         }
3256       xfree (fname);
3257       return result;
3258     }
3259
3260   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
3261     {
3262       char *key, *component, *option, *flags, *value;
3263       char *empty;
3264       gc_option_t *option_info = NULL;
3265       char *p;
3266       int is_continuation;
3267       
3268       lineno++;
3269       key = line;
3270       while (*key == ' ' || *key == '\t')
3271         key++;
3272       if (!*key || *key == '#' || *key == '\r' || *key == '\n')
3273         continue;
3274
3275       is_continuation = (key != line);
3276
3277       /* Parse the key field.  */
3278       if (!is_continuation && got_match)
3279         break;  /* Finish after the first match.  */
3280       else if (!is_continuation)
3281         {
3282           in_rule = 0;
3283           for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
3284             ;
3285           if (!*p)
3286             {
3287               gc_error (0, 0, "missing rule at `%s', line %d", fname, lineno);
3288               result = -1;
3289               continue;
3290             }
3291           *p++ = 0;
3292           component = p;
3293         }
3294       else if (!in_rule)
3295         {
3296           gc_error (0, 0, "continuation but no rule at `%s', line %d",
3297                     fname, lineno);
3298           result = -1;
3299           continue;
3300         }
3301       else
3302         {
3303           component = key;
3304           key = NULL;
3305         }
3306
3307       in_rule = 1;
3308
3309       /* Parse the component.  */
3310       while (*component == ' ' || *component == '\t')
3311         component++;
3312       for (p=component; *p && !strchr (" \t\r\n", *p); p++)
3313         ;
3314       if (p == component)
3315         {
3316           gc_error (0, 0, "missing component at `%s', line %d",
3317                     fname, lineno);
3318           result = -1;
3319           continue;
3320         }
3321       empty = p;
3322       *p++ = 0;
3323       option = p;
3324       component_id = gc_component_find (component);
3325       if (component_id < 0)
3326         {
3327           gc_error (0, 0, "unknown component at `%s', line %d",
3328                     fname, lineno);
3329           result = -1;
3330         }
3331
3332       /* Parse the option name.  */
3333       while (*option == ' ' || *option == '\t')
3334         option++;
3335       for (p=option; *p && !strchr (" \t\r\n", *p); p++)
3336         ;
3337       if (p == option)
3338         {
3339           gc_error (0, 0, "missing option at `%s', line %d",
3340                     fname, lineno);
3341           result = -1;
3342           continue;
3343         }
3344       *p++ = 0;
3345       flags = p;
3346       if ( component_id != -1)
3347         {
3348           option_info = find_option (component_id, option, GC_BACKEND_ANY);
3349           if (!option_info)
3350             {
3351               gc_error (0, 0, "unknown option at `%s', line %d",
3352                         fname, lineno);
3353               result = -1;
3354             }
3355         }
3356
3357
3358       /* Parse the optional flags.  */
3359       while (*flags == ' ' || *flags == '\t')
3360         flags++;
3361       if (*flags == '[')
3362         {
3363           flags++;
3364           p = strchr (flags, ']');
3365           if (!p)
3366             {
3367               gc_error (0, 0, "syntax error in rule at `%s', line %d",
3368                         fname, lineno);
3369               result = -1;
3370               continue;
3371             }
3372           *p++ = 0;
3373           value = p;
3374         }
3375       else  /* No flags given.  */
3376         {
3377           value = flags;
3378           flags = NULL;
3379         }
3380
3381       /* Parse the optional value.  */
3382       while (*value == ' ' || *value == '\t')
3383        value++;
3384       for (p=value; *p && !strchr ("\r\n", *p); p++)
3385         ;
3386       if (p == value)
3387         value = empty; /* No value given; let it point to an empty string.  */
3388       else
3389         {
3390           /* Strip trailing white space.  */
3391           *p = 0;
3392           for (p--; p > value && (*p == ' ' || *p == '\t'); p--)
3393             *p = 0;
3394         }
3395
3396       /* Check flag combinations.  */
3397       if (!flags)
3398         ;
3399       else if (!strcmp (flags, "default"))
3400         {
3401           if (*value)
3402             {
3403               gc_error (0, 0, "flag \"default\" may not be combined "
3404                         "with a value at `%s', line %d",
3405                         fname, lineno);
3406               result = -1;
3407             }
3408         }
3409       else if (!strcmp (flags, "change"))
3410         ;
3411       else if (!strcmp (flags, "no-change"))
3412         ;
3413       else
3414         {
3415           gc_error (0, 0, "unknown flag at `%s', line %d",
3416                     fname, lineno);
3417           result = -1;
3418         }
3419
3420       /* In list mode we print out all records.  */
3421       if (listfp && !result)
3422         {
3423           /* If this is a new ruleset, print a key record.  */
3424           if (!is_continuation)
3425             {
3426               char *group = strchr (key, ':');
3427               if (group)
3428                 {
3429                   *group++ = 0;
3430                   if ((p = strchr (group, ':')))
3431                     *p = 0; /* We better strip any extra stuff. */
3432                 }                    
3433               
3434               fprintf (listfp, "k:%s:", my_percent_escape (key));
3435               fprintf (listfp, "%s\n", group? my_percent_escape (group):"");
3436             }
3437
3438           /* All other lines are rule records.  */
3439           fprintf (listfp, "r:::%s:%s:%s:",
3440                    gc_component[component_id].name,                     
3441                    option_info->name? option_info->name : "",
3442                    flags? flags : "");
3443           if (value != empty)
3444             fprintf (listfp, "\"%s", my_percent_escape (value));
3445           
3446           putc ('\n', listfp);
3447         }
3448
3449       /* Check whether the key matches but do this only if we are not
3450          running in syntax check mode. */
3451       if ( update 
3452            && !result && !listfp
3453            && (got_match || (key && key_matches_user_or_group (key))) )
3454         {
3455           int newflags = 0;
3456
3457           got_match = 1;
3458
3459           /* Apply the flags from gpgconf.conf.  */
3460           if (!flags)
3461             ;
3462           else if (!strcmp (flags, "default"))
3463             newflags |= GC_OPT_FLAG_DEFAULT;
3464           else if (!strcmp (flags, "no-change"))
3465             option_info->flags |= GC_OPT_FLAG_NO_CHANGE;
3466           else if (!strcmp (flags, "change"))
3467             option_info->flags &= ~GC_OPT_FLAG_NO_CHANGE;
3468
3469           if (defaults)
3470             {
3471               assert (component_id >= 0 && component_id < GC_COMPONENT_NR);
3472               used_components[component_id] = 1;
3473
3474               /* Here we explicitly allow to update the value again.  */
3475               if (newflags)
3476                 {
3477                   option_info->new_flags = 0;
3478                 }
3479               if (*value)
3480                 {
3481                   xfree (option_info->new_value);
3482                   option_info->new_value = NULL;
3483                 }
3484               change_one_value (option_info, runtime, newflags, value);
3485             }
3486         }
3487     }
3488
3489   if (length < 0 || ferror (config))
3490     {
3491       gc_error (0, errno, "error reading from `%s'", fname);
3492       result = -1;
3493     }
3494   if (fclose (config) && ferror (config))
3495     gc_error (0, errno, "error closing `%s'", fname);
3496
3497   xfree (line);
3498
3499   /* If it all worked, process the options. */
3500   if (!result && update && defaults && !listfp)
3501     {
3502       /* We need to switch off the runtime update, so that we can do
3503          it later all at once. */
3504       int save_opt_runtime = opt.runtime;
3505       opt.runtime = 0;
3506
3507       for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3508         {
3509           gc_component_change_options (component_id, NULL, NULL);
3510         }
3511       opt.runtime = save_opt_runtime;
3512
3513       if (opt.runtime)
3514         {
3515           for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)  
3516             if (runtime[backend_id] && gc_backend[backend_id].runtime_change)
3517               (*gc_backend[backend_id].runtime_change) ();
3518         }
3519     }
3520
3521   xfree (fname);
3522   return result;
3523 }