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