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