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