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