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