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