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