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