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