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