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