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