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