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