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