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