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