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