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