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