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