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