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