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