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