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