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