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