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