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