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