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