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