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