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