gpg: Cleanup compiler warnings due to some configure options.
[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     return msgid;
1234 #else
1235   (void)domain;
1236   return msgid;
1237 #endif
1238 }
1239
1240
1241 /* Percent-Escape special characters.  The string is valid until the
1242    next invocation of the function.  */
1243 char *
1244 gc_percent_escape (const char *src)
1245 {
1246   static char *esc_str;
1247   static int esc_str_len;
1248   int new_len = 3 * strlen (src) + 1;
1249   char *dst;
1250
1251   if (esc_str_len < new_len)
1252     {
1253       char *new_esc_str = realloc (esc_str, new_len);
1254       if (!new_esc_str)
1255         gc_error (1, errno, "can not escape string");
1256       esc_str = new_esc_str;
1257       esc_str_len = new_len;
1258     }
1259
1260   dst = esc_str;
1261   while (*src)
1262     {
1263       if (*src == '%')
1264         {
1265           *(dst++) = '%';
1266           *(dst++) = '2';
1267           *(dst++) = '5';
1268         }
1269       else if (*src == ':')
1270         {
1271           /* The colon is used as field separator.  */
1272           *(dst++) = '%';
1273           *(dst++) = '3';
1274           *(dst++) = 'a';
1275         }
1276       else if (*src == ',')
1277         {
1278           /* The comma is used as list separator.  */
1279           *(dst++) = '%';
1280           *(dst++) = '2';
1281           *(dst++) = 'c';
1282         }
1283       else
1284         *(dst++) = *(src);
1285       src++;
1286     }
1287   *dst = '\0';
1288   return esc_str;
1289 }
1290
1291
1292
1293 /* Percent-Deescape special characters.  The string is valid until the
1294    next invocation of the function.  */
1295 static char *
1296 percent_deescape (const char *src)
1297 {
1298   static char *str;
1299   static int str_len;
1300   int new_len = 3 * strlen (src) + 1;
1301   char *dst;
1302
1303   if (str_len < new_len)
1304     {
1305       char *new_str = realloc (str, new_len);
1306       if (!new_str)
1307         gc_error (1, errno, "can not deescape string");
1308       str = new_str;
1309       str_len = new_len;
1310     }
1311
1312   dst = str;
1313   while (*src)
1314     {
1315       if (*src == '%')
1316         {
1317           int val = hextobyte (src + 1);
1318
1319           if (val < 0)
1320             gc_error (1, 0, "malformed end of string %s", src);
1321
1322           *(dst++) = (char) val;
1323           src += 3;
1324         }
1325       else
1326         *(dst++) = *(src++);
1327     }
1328   *dst = '\0';
1329   return str;
1330 }
1331
1332 \f
1333 /* List all components that are available.  */
1334 void
1335 gc_component_list_components (estream_t out)
1336 {
1337   gc_component_t component;
1338   gc_option_t *option;
1339   gc_backend_t backend;
1340   int backend_seen[GC_BACKEND_NR];
1341   const char *desc;
1342   const char *pgmname;
1343
1344   for (component = 0; component < GC_COMPONENT_NR; component++)
1345     {
1346       option = gc_component[component].options;
1347       if (option)
1348         {
1349           for (backend = 0; backend < GC_BACKEND_NR; backend++)
1350             backend_seen[backend] = 0;
1351
1352           pgmname = "";
1353           for (; option && option->name; option++)
1354             {
1355               if ((option->flags & GC_OPT_FLAG_GROUP))
1356                 continue;
1357               backend = option->backend;
1358               if (backend_seen[backend])
1359                 continue;
1360               backend_seen[backend] = 1;
1361               assert (backend != GC_BACKEND_ANY);
1362               if (gc_backend[backend].program
1363                   && !gc_backend[backend].module_name)
1364                 continue;
1365               pgmname = gnupg_module_name (gc_backend[backend].module_name);
1366               break;
1367             }
1368
1369           desc = gc_component[component].desc;
1370           desc = my_dgettext (gc_component[component].desc_domain, desc);
1371           es_fprintf (out, "%s:%s:",
1372                       gc_component[component].name,  gc_percent_escape (desc));
1373           es_fprintf (out, "%s\n",  gc_percent_escape (pgmname));
1374         }
1375     }
1376 }
1377
1378
1379 \f
1380 static int
1381 all_digits_p (const char *p, size_t len)
1382 {
1383   if (!len)
1384     return 0; /* No. */
1385   for (; len; len--, p++)
1386     if (!isascii (*p) || !isdigit (*p))
1387       return 0; /* No.  */
1388   return 1; /* Yes.  */
1389 }
1390
1391
1392 /* Collect all error lines from stream FP. Only lines prefixed with
1393    TAG are considered.  Returns a list of error line items (which may
1394    be empty).  There is no error return.  */
1395 static error_line_t
1396 collect_error_output (estream_t fp, const char *tag)
1397 {
1398   char buffer[1024];
1399   char *p, *p2, *p3;
1400   int c, cont_line;
1401   unsigned int pos;
1402   error_line_t eitem, errlines, *errlines_tail;
1403   size_t taglen = strlen (tag);
1404
1405   errlines = NULL;
1406   errlines_tail = &errlines;
1407   pos = 0;
1408   cont_line = 0;
1409   while ((c=es_getc (fp)) != EOF)
1410     {
1411       buffer[pos++] = c;
1412       if (pos >= sizeof buffer - 5 || c == '\n')
1413         {
1414           buffer[pos - (c == '\n')] = 0;
1415           if (cont_line)
1416             ; /*Ignore continuations of previous line. */
1417           else if (!strncmp (buffer, tag, taglen) && buffer[taglen] == ':')
1418             {
1419               /* "gpgsm: foo:4: bla" */
1420               /* Yep, we are interested in this line.  */
1421               p = buffer + taglen + 1;
1422               while (*p == ' ' || *p == '\t')
1423                 p++;
1424               trim_trailing_spaces (p); /* Get rid of extra CRs.  */
1425               if (!*p)
1426                 ; /* Empty lines are ignored.  */
1427               else if ( (p2 = strchr (p, ':')) && (p3 = strchr (p2+1, ':'))
1428                         && all_digits_p (p2+1, p3 - (p2+1)))
1429                 {
1430                   /* Line in standard compiler format.  */
1431                   p3++;
1432                   while (*p3 == ' ' || *p3 == '\t')
1433                     p3++;
1434                   eitem = xmalloc (sizeof *eitem + strlen (p));
1435                   eitem->next = NULL;
1436                   strcpy (eitem->buffer, p);
1437                   eitem->fname = eitem->buffer;
1438                   eitem->buffer[p2-p] = 0;
1439                   eitem->errtext = eitem->buffer + (p3 - p);
1440                   /* (we already checked that there are only ascii
1441                      digits followed by a colon) */
1442                   eitem->lineno = 0;
1443                   for (p2++; isdigit (*p2); p2++)
1444                     eitem->lineno = eitem->lineno*10 + (*p2 - '0');
1445                   *errlines_tail = eitem;
1446                   errlines_tail = &eitem->next;
1447                 }
1448               else
1449                 {
1450                   /* Other error output.  */
1451                   eitem = xmalloc (sizeof *eitem + strlen (p));
1452                   eitem->next = NULL;
1453                   strcpy (eitem->buffer, p);
1454                   eitem->fname = NULL;
1455                   eitem->errtext = eitem->buffer;
1456                   eitem->lineno = 0;
1457                   *errlines_tail = eitem;
1458                   errlines_tail = &eitem->next;
1459                 }
1460             }
1461           pos = 0;
1462           /* If this was not a complete line mark that we are in a
1463              continuation.  */
1464           cont_line = (c != '\n');
1465         }
1466     }
1467
1468   /* We ignore error lines not terminated by a LF.  */
1469   return errlines;
1470 }
1471
1472
1473 /* Check the options of a single component.  Returns 0 if everything
1474    is OK.  */
1475 int
1476 gc_component_check_options (int component, estream_t out, const char *conf_file)
1477 {
1478   gpg_error_t err;
1479   unsigned int result;
1480   int backend_seen[GC_BACKEND_NR];
1481   gc_backend_t backend;
1482   gc_option_t *option;
1483   const char *pgmname;
1484   const char *argv[4];
1485   int i;
1486   pid_t pid;
1487   int exitcode;
1488   estream_t errfp;
1489   error_line_t errlines;
1490
1491   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1492     backend_seen[backend] = 0;
1493
1494   option = gc_component[component].options;
1495   for (; option && option->name; option++)
1496     {
1497       if ((option->flags & GC_OPT_FLAG_GROUP))
1498         continue;
1499       backend = option->backend;
1500       if (backend_seen[backend])
1501         continue;
1502       backend_seen[backend] = 1;
1503       assert (backend != GC_BACKEND_ANY);
1504       if (!gc_backend[backend].program)
1505         continue;
1506       if (!gc_backend[backend].module_name)
1507         continue;
1508
1509       break;
1510     }
1511   if (! option || ! option->name)
1512     return 0;
1513
1514   pgmname = gnupg_module_name (gc_backend[backend].module_name);
1515   i = 0;
1516   if (conf_file)
1517     {
1518       argv[i++] = "--options";
1519       argv[i++] = conf_file;
1520     }
1521   if (component == GC_COMPONENT_PINENTRY)
1522     argv[i++] = "--version";
1523   else
1524     argv[i++] = "--gpgconf-test";
1525   argv[i++] = NULL;
1526
1527   result = 0;
1528   errlines = NULL;
1529   err = gnupg_spawn_process (pgmname, argv, GPG_ERR_SOURCE_DEFAULT, NULL, 0,
1530                              NULL, NULL, &errfp, &pid);
1531   if (err)
1532     result |= 1; /* Program could not be run.  */
1533   else
1534     {
1535       errlines = collect_error_output (errfp,
1536                                        gc_component[component].name);
1537       if (gnupg_wait_process (pgmname, pid, 1, &exitcode))
1538         {
1539           if (exitcode == -1)
1540             result |= 1; /* Program could not be run or it
1541                             terminated abnormally.  */
1542           result |= 2; /* Program returned an error.  */
1543         }
1544       gnupg_release_process (pid);
1545       es_fclose (errfp);
1546     }
1547
1548   /* If the program could not be run, we can't tell whether
1549      the config file is good.  */
1550   if (result & 1)
1551     result |= 2;
1552
1553   if (out)
1554     {
1555       const char *desc;
1556       error_line_t errptr;
1557
1558       desc = gc_component[component].desc;
1559       desc = my_dgettext (gc_component[component].desc_domain, desc);
1560       es_fprintf (out, "%s:%s:",
1561                   gc_component[component].name, gc_percent_escape (desc));
1562       es_fputs (gc_percent_escape (pgmname), out);
1563       es_fprintf (out, ":%d:%d:", !(result & 1), !(result & 2));
1564       for (errptr = errlines; errptr; errptr = errptr->next)
1565         {
1566           if (errptr != errlines)
1567             es_fputs ("\n:::::", out); /* Continuation line.  */
1568           if (errptr->fname)
1569             es_fputs (gc_percent_escape (errptr->fname), out);
1570           es_putc (':', out);
1571           if (errptr->fname)
1572             es_fprintf (out, "%u", errptr->lineno);
1573           es_putc (':', out);
1574           es_fputs (gc_percent_escape (errptr->errtext), out);
1575           es_putc (':', out);
1576         }
1577       es_putc ('\n', out);
1578     }
1579
1580   while (errlines)
1581     {
1582       error_line_t tmp = errlines->next;
1583       xfree (errlines);
1584       errlines = tmp;
1585     }
1586
1587   return result;
1588 }
1589
1590
1591
1592 /* Check all components that are available.  */
1593 void
1594 gc_check_programs (estream_t out)
1595 {
1596   gc_component_t component;
1597
1598   for (component = 0; component < GC_COMPONENT_NR; component++)
1599     gc_component_check_options (component, out, NULL);
1600 }
1601
1602
1603 \f
1604 /* Find the component with the name NAME.  Returns -1 if not
1605    found.  */
1606 int
1607 gc_component_find (const char *name)
1608 {
1609   gc_component_t idx;
1610
1611   for (idx = 0; idx < GC_COMPONENT_NR; idx++)
1612     {
1613       if (gc_component[idx].options
1614           && !strcmp (name, gc_component[idx].name))
1615         return idx;
1616     }
1617   return -1;
1618 }
1619
1620 \f
1621 /* List the option OPTION.  */
1622 static void
1623 list_one_option (const gc_option_t *option, estream_t out)
1624 {
1625   const char *desc = NULL;
1626   char *arg_name = NULL;
1627
1628   if (option->desc)
1629     {
1630       desc = my_dgettext (option->desc_domain, option->desc);
1631
1632       if (*desc == '|')
1633         {
1634           const char *arg_tail = strchr (&desc[1], '|');
1635
1636           if (arg_tail)
1637             {
1638               int arg_len = arg_tail - &desc[1];
1639               arg_name = xmalloc (arg_len + 1);
1640               memcpy (arg_name, &desc[1], arg_len);
1641               arg_name[arg_len] = '\0';
1642               desc = arg_tail + 1;
1643             }
1644         }
1645     }
1646
1647
1648   /* YOU MUST NOT REORDER THE FIELDS IN THIS OUTPUT, AS THEIR ORDER IS
1649      PART OF THE EXTERNAL INTERFACE.  YOU MUST NOT REMOVE ANY
1650      FIELDS.  */
1651
1652   /* The name field.  */
1653   es_fprintf (out, "%s", option->name);
1654
1655   /* The flags field.  */
1656   es_fprintf (out, ":%lu", option->flags);
1657   if (opt.verbose)
1658     {
1659       es_putc (' ', out);
1660
1661       if (!option->flags)
1662         es_fprintf (out, "none");
1663       else
1664         {
1665           unsigned long flags = option->flags;
1666           unsigned long flag = 0;
1667           unsigned long first = 1;
1668
1669           while (flags)
1670             {
1671               if (flags & 1)
1672                 {
1673                   if (first)
1674                     first = 0;
1675                   else
1676                     es_putc (',', out);
1677                   es_fprintf (out, "%s", gc_flag[flag].name);
1678                 }
1679               flags >>= 1;
1680               flag++;
1681             }
1682         }
1683     }
1684
1685   /* The level field.  */
1686   es_fprintf (out, ":%u", option->level);
1687   if (opt.verbose)
1688     es_fprintf (out, " %s", gc_level[option->level].name);
1689
1690   /* The description field.  */
1691   es_fprintf (out, ":%s", desc ? gc_percent_escape (desc) : "");
1692
1693   /* The type field.  */
1694   es_fprintf (out, ":%u", option->arg_type);
1695   if (opt.verbose)
1696     es_fprintf (out, " %s", gc_arg_type[option->arg_type].name);
1697
1698   /* The alternate type field.  */
1699   es_fprintf (out, ":%u", gc_arg_type[option->arg_type].fallback);
1700   if (opt.verbose)
1701     es_fprintf (out, " %s",
1702                 gc_arg_type[gc_arg_type[option->arg_type].fallback].name);
1703
1704   /* The argument name field.  */
1705   es_fprintf (out, ":%s", arg_name ? gc_percent_escape (arg_name) : "");
1706   xfree (arg_name);
1707
1708   /* The default value field.  */
1709   es_fprintf (out, ":%s", option->default_value ? option->default_value : "");
1710
1711   /* The default argument field.  */
1712   es_fprintf (out, ":%s", option->default_arg ? option->default_arg : "");
1713
1714   /* The value field.  */
1715   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
1716       && (option->flags & GC_OPT_FLAG_LIST)
1717       && option->value)
1718     /* The special format "1,1,1,1,...,1" is converted to a number
1719        here.  */
1720     es_fprintf (out, ":%u", (unsigned int)((strlen (option->value) + 1) / 2));
1721   else
1722     es_fprintf (out, ":%s", option->value ? option->value : "");
1723
1724   /* ADD NEW FIELDS HERE.  */
1725
1726   es_putc ('\n', out);
1727 }
1728
1729
1730 /* List all options of the component COMPONENT.  */
1731 void
1732 gc_component_list_options (int component, estream_t out)
1733 {
1734   const gc_option_t *option = gc_component[component].options;
1735
1736   while (option && option->name)
1737     {
1738       /* Do not output unknown or internal options.  */
1739       if (!(option->flags & GC_OPT_FLAG_GROUP)
1740           && (!option->active || option->level == GC_LEVEL_INTERNAL))
1741         {
1742           option++;
1743           continue;
1744         }
1745
1746       if (option->flags & GC_OPT_FLAG_GROUP)
1747         {
1748           const gc_option_t *group_option = option + 1;
1749           gc_expert_level_t level = GC_LEVEL_NR;
1750
1751           /* The manual states that the group level is always the
1752              minimum of the levels of all contained options.  Due to
1753              different active options, and because it is hard to
1754              maintain manually, we calculate it here.  The value in
1755              the global static table is ignored.  */
1756
1757           while (group_option->name)
1758             {
1759               if (group_option->flags & GC_OPT_FLAG_GROUP)
1760                 break;
1761               if (group_option->level < level)
1762                 level = group_option->level;
1763               group_option++;
1764             }
1765
1766           /* Check if group is empty.  */
1767           if (level != GC_LEVEL_NR)
1768             {
1769               gc_option_t opt_copy;
1770
1771               /* Fix up the group level.  */
1772               memcpy (&opt_copy, option, sizeof (opt_copy));
1773               opt_copy.level = level;
1774               list_one_option (&opt_copy, out);
1775             }
1776         }
1777       else
1778         list_one_option (option, out);
1779
1780       option++;
1781     }
1782 }
1783
1784
1785 /* Find the option NAME in component COMPONENT, for the backend
1786    BACKEND.  If BACKEND is GC_BACKEND_ANY, any backend will match.  */
1787 static gc_option_t *
1788 find_option (gc_component_t component, const char *name,
1789              gc_backend_t backend)
1790 {
1791   gc_option_t *option = gc_component[component].options;
1792   while (option->name)
1793     {
1794       if (!(option->flags & GC_OPT_FLAG_GROUP)
1795           && !strcmp (option->name, name)
1796           && (backend == GC_BACKEND_ANY || option->backend == backend))
1797         break;
1798       option++;
1799     }
1800   return option->name ? option : NULL;
1801 }
1802
1803 \f
1804 /* Determine the configuration filename for the component COMPONENT
1805    and backend BACKEND.  */
1806 static char *
1807 get_config_filename (gc_component_t component, gc_backend_t backend)
1808 {
1809   char *filename = NULL;
1810   gc_option_t *option = find_option
1811     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
1812   assert (option);
1813   assert (option->arg_type == GC_ARG_TYPE_FILENAME);
1814   assert (!(option->flags & GC_OPT_FLAG_LIST));
1815
1816   if (!option->active || !option->default_value)
1817     gc_error (1, 0, "Option %s, needed by backend %s, was not initialized",
1818               gc_backend[backend].option_config_filename,
1819               gc_backend[backend].name);
1820
1821   if (option->value && *option->value)
1822     filename = percent_deescape (&option->value[1]);
1823   else if (option->default_value && *option->default_value)
1824     filename = percent_deescape (&option->default_value[1]);
1825   else
1826     filename = "";
1827
1828 #if HAVE_W32CE_SYSTEM
1829   if (!(filename[0] == '/' || filename[0] == '\\'))
1830 #elif defined(HAVE_DOSISH_SYSTEM)
1831   if (!(filename[0]
1832         && filename[1] == ':'
1833         && (filename[2] == '/' || filename[2] == '\\')))
1834 #else
1835   if (filename[0] != '/')
1836 #endif
1837     gc_error (1, 0, "Option %s, needed by backend %s, is not absolute",
1838               gc_backend[backend].option_config_filename,
1839               gc_backend[backend].name);
1840
1841   return filename;
1842 }
1843
1844 \f
1845 /* Retrieve the options for the component COMPONENT from backend
1846    BACKEND, which we already know is a program-type backend.  */
1847 static void
1848 retrieve_options_from_program (gc_component_t component, gc_backend_t backend)
1849 {
1850   gpg_error_t err;
1851   const char *pgmname;
1852   const char *argv[2];
1853   estream_t outfp;
1854   int exitcode;
1855   pid_t pid;
1856   char *line = NULL;
1857   size_t line_len = 0;
1858   ssize_t length;
1859   estream_t config;
1860   char *config_filename;
1861
1862   pgmname = (gc_backend[backend].module_name
1863              ? gnupg_module_name (gc_backend[backend].module_name)
1864              : gc_backend[backend].program );
1865   argv[0] = "--gpgconf-list";
1866   argv[1] = NULL;
1867
1868   err = gnupg_spawn_process (pgmname, argv, GPG_ERR_SOURCE_DEFAULT, NULL, 0,
1869                              NULL, &outfp, NULL, &pid);
1870   if (err)
1871     {
1872       gc_error (1, 0, "could not gather active options from '%s': %s",
1873                 pgmname, gpg_strerror (err));
1874     }
1875
1876   while ((length = es_read_line (outfp, &line, &line_len, NULL)) > 0)
1877     {
1878       gc_option_t *option;
1879       char *linep;
1880       unsigned long flags = 0;
1881       char *default_value = NULL;
1882
1883       /* Strip newline and carriage return, if present.  */
1884       while (length > 0
1885              && (line[length - 1] == '\n' || line[length - 1] == '\r'))
1886         line[--length] = '\0';
1887
1888       linep = strchr (line, ':');
1889       if (linep)
1890         *(linep++) = '\0';
1891
1892       /* Extract additional flags.  Default to none.  */
1893       if (linep)
1894         {
1895           char *end;
1896           char *tail;
1897
1898           end = strchr (linep, ':');
1899           if (end)
1900             *(end++) = '\0';
1901
1902           gpg_err_set_errno (0);
1903           flags = strtoul (linep, &tail, 0);
1904           if (errno)
1905             gc_error (1, errno, "malformed flags in option %s from %s",
1906                       line, pgmname);
1907           if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
1908             gc_error (1, 0, "garbage after flags in option %s from %s",
1909                       line, pgmname);
1910
1911           linep = end;
1912         }
1913
1914       /* Extract default value, if present.  Default to empty if
1915          not.  */
1916       if (linep)
1917         {
1918           char *end;
1919
1920           end = strchr (linep, ':');
1921           if (end)
1922             *(end++) = '\0';
1923
1924           if (flags & GC_OPT_FLAG_DEFAULT)
1925             default_value = linep;
1926
1927           linep = end;
1928         }
1929
1930       /* Look up the option in the component and install the
1931          configuration data.  */
1932       option = find_option (component, line, backend);
1933       if (option)
1934         {
1935           if (option->active)
1936             gc_error (1, errno, "option %s returned twice from %s",
1937                       line, pgmname);
1938           option->active = 1;
1939
1940           option->flags |= flags;
1941           if (default_value && *default_value)
1942             option->default_value = xstrdup (default_value);
1943         }
1944     }
1945   if (length < 0 || es_ferror (outfp))
1946     gc_error (1, errno, "error reading from %s", pgmname);
1947   if (es_fclose (outfp))
1948     gc_error (1, errno, "error closing %s", pgmname);
1949
1950   err = gnupg_wait_process (pgmname, pid, 1, &exitcode);
1951   if (err)
1952     gc_error (1, 0, "running %s failed (exitcode=%d): %s",
1953               pgmname, exitcode, gpg_strerror (err));
1954   gnupg_release_process (pid);
1955
1956
1957   /* At this point, we can parse the configuration file.  */
1958   config_filename = get_config_filename (component, backend);
1959
1960   config = es_fopen (config_filename, "r");
1961   if (!config)
1962     gc_error (0, errno, "warning: can not open config file %s",
1963               config_filename);
1964   else
1965     {
1966       while ((length = es_read_line (config, &line, &line_len, NULL)) > 0)
1967         {
1968           char *name;
1969           char *value;
1970           gc_option_t *option;
1971
1972           name = line;
1973           while (*name == ' ' || *name == '\t')
1974             name++;
1975           if (!*name || *name == '#' || *name == '\r' || *name == '\n')
1976             continue;
1977
1978           value = name;
1979           while (*value && *value != ' ' && *value != '\t'
1980                  && *value != '#' && *value != '\r' && *value != '\n')
1981             value++;
1982           if (*value == ' ' || *value == '\t')
1983             {
1984               char *end;
1985
1986               *(value++) = '\0';
1987               while (*value == ' ' || *value == '\t')
1988                 value++;
1989
1990               end = value;
1991               while (*end && *end != '#' && *end != '\r' && *end != '\n')
1992                 end++;
1993               while (end > value && (end[-1] == ' ' || end[-1] == '\t'))
1994                 end--;
1995               *end = '\0';
1996             }
1997           else
1998             *value = '\0';
1999
2000           /* Look up the option in the component and install the
2001              configuration data.  */
2002           option = find_option (component, line, backend);
2003           if (option)
2004             {
2005               char *opt_value;
2006
2007               if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
2008                 {
2009                   if (*value)
2010                     gc_error (0, 0,
2011                               "warning: ignoring argument %s for option %s",
2012                               value, name);
2013                   opt_value = xstrdup ("1");
2014                 }
2015               else if (gc_arg_type[option->arg_type].fallback
2016                        == GC_ARG_TYPE_STRING)
2017                 opt_value = xasprintf ("\"%s", gc_percent_escape (value));
2018               else
2019                 {
2020                   /* FIXME: Verify that the number is sane.  */
2021                   opt_value = xstrdup (value);
2022                 }
2023
2024               /* Now enter the option into the table.  */
2025               if (!(option->flags & GC_OPT_FLAG_LIST))
2026                 {
2027                   if (option->value)
2028                     free (option->value);
2029                   option->value = opt_value;
2030                 }
2031               else
2032                 {
2033                   if (!option->value)
2034                     option->value = opt_value;
2035                   else
2036                     {
2037                       char *opt_val = opt_value;
2038
2039                       option->value = xasprintf ("%s,%s", option->value,
2040                                                  opt_val);
2041                       xfree (opt_value);
2042                     }
2043                 }
2044             }
2045         }
2046
2047       if (length < 0 || es_ferror (config))
2048         gc_error (1, errno, "error reading from %s", config_filename);
2049       if (es_fclose (config))
2050         gc_error (1, errno, "error closing %s", config_filename);
2051     }
2052
2053   xfree (line);
2054 }
2055
2056
2057 /* Retrieve the options for the component COMPONENT from backend
2058    BACKEND, which we already know is of type file list.  */
2059 static void
2060 retrieve_options_from_file (gc_component_t component, gc_backend_t backend)
2061 {
2062   gc_option_t *list_option;
2063   gc_option_t *config_option;
2064   char *list_filename;
2065   FILE *list_file;
2066   char *line = NULL;
2067   size_t line_len = 0;
2068   ssize_t length;
2069   char *list = NULL;
2070
2071   list_option = find_option (component,
2072                              gc_backend[backend].option_name, GC_BACKEND_ANY);
2073   assert (list_option);
2074   assert (!list_option->active);
2075
2076   list_filename = get_config_filename (component, backend);
2077   list_file = fopen (list_filename, "r");
2078   if (!list_file)
2079     gc_error (0, errno, "warning: can not open list file %s", list_filename);
2080   else
2081     {
2082
2083       while ((length = read_line (list_file, &line, &line_len, NULL)) > 0)
2084         {
2085           char *start;
2086           char *end;
2087           char *new_list;
2088
2089           start = line;
2090           while (*start == ' ' || *start == '\t')
2091             start++;
2092           if (!*start || *start == '#' || *start == '\r' || *start == '\n')
2093             continue;
2094
2095           end = start;
2096           while (*end && *end != '#' && *end != '\r' && *end != '\n')
2097             end++;
2098           /* Walk back to skip trailing white spaces.  Looks evil, but
2099              works because of the conditions on START and END imposed
2100              at this point (END is at least START + 1, and START is
2101              not a whitespace character).  */
2102           while (*(end - 1) == ' ' || *(end - 1) == '\t')
2103             end--;
2104           *end = '\0';
2105           /* FIXME: Oh, no!  This is so lame!  Should use realloc and
2106              really append.  */
2107           if (list)
2108             {
2109               new_list = xasprintf ("%s,\"%s", list, gc_percent_escape (start));
2110               xfree (list);
2111               list = new_list;
2112             }
2113           else
2114             list = xasprintf ("\"%s", gc_percent_escape (start));
2115         }
2116       if (length < 0 || ferror (list_file))
2117         gc_error (1, errno, "can not read list file %s", list_filename);
2118     }
2119
2120   list_option->active = 1;
2121   list_option->value = list;
2122
2123   /* Fix up the read-only flag.  */
2124   config_option = find_option
2125     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
2126   if (config_option->flags & GC_OPT_FLAG_NO_CHANGE)
2127     list_option->flags |= GC_OPT_FLAG_NO_CHANGE;
2128
2129   if (list_file && fclose (list_file))
2130     gc_error (1, errno, "error closing %s", list_filename);
2131   xfree (line);
2132 }
2133
2134
2135 /* Retrieve the currently active options and their defaults from all
2136    involved backends for this component.  Using -1 for component will
2137    retrieve all options from all components. */
2138 void
2139 gc_component_retrieve_options (int component)
2140 {
2141   int process_all = 0;
2142   int backend_seen[GC_BACKEND_NR];
2143   gc_backend_t backend;
2144   gc_option_t *option;
2145
2146   if (component == GC_COMPONENT_PINENTRY)
2147     return; /* Dummy module for now.  */
2148
2149   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2150     backend_seen[backend] = 0;
2151
2152   if (component == -1)
2153     {
2154       process_all = 1;
2155       component = 0;
2156       assert (component < GC_COMPONENT_NR);
2157     }
2158
2159   do
2160     {
2161       option = gc_component[component].options;
2162
2163       while (option && option->name)
2164         {
2165           if (!(option->flags & GC_OPT_FLAG_GROUP))
2166             {
2167               backend = option->backend;
2168
2169               if (backend_seen[backend])
2170                 {
2171                   option++;
2172                   continue;
2173                 }
2174               backend_seen[backend] = 1;
2175
2176               assert (backend != GC_BACKEND_ANY);
2177
2178               if (gc_backend[backend].program)
2179                 retrieve_options_from_program (component, backend);
2180               else
2181                 retrieve_options_from_file (component, backend);
2182             }
2183           option++;
2184         }
2185     }
2186   while (process_all && ++component < GC_COMPONENT_NR);
2187
2188 }
2189
2190
2191 \f
2192 /* Perform a simple validity check based on the type.  Return in
2193    NEW_VALUE_NR the value of the number in NEW_VALUE if OPTION is of
2194    type GC_ARG_TYPE_NONE.  */
2195 static void
2196 option_check_validity (gc_option_t *option, unsigned long flags,
2197                        char *new_value, unsigned long *new_value_nr)
2198 {
2199   char *arg;
2200
2201   if (!option->active)
2202     gc_error (1, 0, "option %s not supported by backend %s",
2203               option->name, gc_backend[option->backend].name);
2204
2205   if (option->new_flags || option->new_value)
2206     gc_error (1, 0, "option %s already changed", option->name);
2207
2208   if (flags & GC_OPT_FLAG_DEFAULT)
2209     {
2210       if (*new_value)
2211         gc_error (1, 0, "argument %s provided for deleted option %s",
2212                   new_value, option->name);
2213
2214       return;
2215     }
2216
2217   /* GC_ARG_TYPE_NONE options have special list treatment.  */
2218   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
2219     {
2220       char *tail;
2221
2222       gpg_err_set_errno (0);
2223       *new_value_nr = strtoul (new_value, &tail, 0);
2224
2225       if (errno)
2226         gc_error (1, errno, "invalid argument for option %s",
2227                   option->name);
2228       if (*tail)
2229         gc_error (1, 0, "garbage after argument for option %s",
2230                       option->name);
2231
2232       if (!(option->flags & GC_OPT_FLAG_LIST))
2233         {
2234           if (*new_value_nr != 1)
2235             gc_error (1, 0, "argument for non-list option %s of type 0 "
2236                       "(none) must be 1", option->name);
2237         }
2238       else
2239         {
2240           if (*new_value_nr == 0)
2241             gc_error (1, 0, "argument for option %s of type 0 (none) "
2242                       "must be positive", option->name);
2243         }
2244
2245       return;
2246     }
2247
2248   arg = new_value;
2249   do
2250     {
2251       if (*arg == '\0' || *arg == ',')
2252         {
2253           if (!(option->flags & GC_OPT_FLAG_ARG_OPT))
2254             gc_error (1, 0, "argument required for option %s", option->name);
2255
2256           if (*arg == ',' && !(option->flags & GC_OPT_FLAG_LIST))
2257             gc_error (1, 0, "list found for non-list option %s", option->name);
2258         }
2259       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_STRING)
2260         {
2261           if (*arg != '"')
2262             gc_error (1, 0, "string argument for option %s must begin "
2263                       "with a quote (\") character", option->name);
2264
2265           /* FIXME: We do not allow empty string arguments for now, as
2266              we do not quote arguments in configuration files, and
2267              thus no argument is indistinguishable from the empty
2268              string.  */
2269           if (arg[1] == '\0' || arg[1] == ',')
2270             gc_error (1, 0, "empty string argument for option %s is "
2271                       "currently not allowed.  Please report this!",
2272                       option->name);
2273         }
2274       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2275         {
2276           long res;
2277
2278           gpg_err_set_errno (0);
2279           res = strtol (arg, &arg, 0);
2280           (void) res;
2281
2282           if (errno)
2283             gc_error (1, errno, "invalid argument for option %s",
2284                       option->name);
2285
2286           if (*arg != '\0' && *arg != ',')
2287             gc_error (1, 0, "garbage after argument for option %s",
2288                       option->name);
2289         }
2290       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2291         {
2292           unsigned long res;
2293
2294           gpg_err_set_errno (0);
2295           res = strtoul (arg, &arg, 0);
2296           (void) res;
2297
2298           if (errno)
2299             gc_error (1, errno, "invalid argument for option %s",
2300                       option->name);
2301
2302           if (*arg != '\0' && *arg != ',')
2303             gc_error (1, 0, "garbage after argument for option %s",
2304                       option->name);
2305         }
2306       arg = strchr (arg, ',');
2307       if (arg)
2308         arg++;
2309     }
2310   while (arg && *arg);
2311 }
2312
2313 #ifdef HAVE_W32_SYSTEM
2314 int
2315 copy_file (const char *src_name, const char *dst_name)
2316 {
2317 #define BUF_LEN 4096
2318   char buffer[BUF_LEN];
2319   int len;
2320   FILE *src;
2321   FILE *dst;
2322
2323   src = fopen (src_name, "r");
2324   if (src == NULL)
2325     return -1;
2326
2327   dst = fopen (dst_name, "w");
2328   if (dst == NULL)
2329     {
2330       int saved_err = errno;
2331       fclose (src);
2332       gpg_err_set_errno (saved_err);
2333       return -1;
2334     }
2335
2336   do
2337     {
2338       int written;
2339
2340       len = fread (buffer, 1, BUF_LEN, src);
2341       if (len == 0)
2342         break;
2343       written = fwrite (buffer, 1, len, dst);
2344       if (written != len)
2345         break;
2346     }
2347   while (!feof (src) && !ferror (src) && !ferror (dst));
2348
2349   if (ferror (src) || ferror (dst) || !feof (src))
2350     {
2351       int saved_errno = errno;
2352       fclose (src);
2353       fclose (dst);
2354       unlink (dst_name);
2355       gpg_err_set_errno (saved_errno);
2356       return -1;
2357     }
2358
2359   if (fclose (dst))
2360     gc_error (1, errno, "error closing %s", dst_name);
2361   if (fclose (src))
2362     gc_error (1, errno, "error closing %s", src_name);
2363
2364   return 0;
2365 }
2366 #endif /* HAVE_W32_SYSTEM */
2367
2368
2369 /* Create and verify the new configuration file for the specified
2370    backend and component.  Returns 0 on success and -1 on error.  */
2371 static int
2372 change_options_file (gc_component_t component, gc_backend_t backend,
2373                      char **src_filenamep, char **dest_filenamep,
2374                      char **orig_filenamep)
2375 {
2376   static const char marker[] = "###+++--- GPGConf ---+++###";
2377   /* True if we are within the marker in the config file.  */
2378   int in_marker = 0;
2379   gc_option_t *option;
2380   char *line = NULL;
2381   size_t line_len;
2382   ssize_t length;
2383   int res;
2384   int fd;
2385   FILE *src_file = NULL;
2386   FILE *dest_file = NULL;
2387   char *src_filename;
2388   char *dest_filename;
2389   char *orig_filename;
2390   char *arg;
2391   char *cur_arg = NULL;
2392
2393   option = find_option (component,
2394                         gc_backend[backend].option_name, GC_BACKEND_ANY);
2395   assert (option);
2396   assert (option->active);
2397   assert (gc_arg_type[option->arg_type].fallback != GC_ARG_TYPE_NONE);
2398
2399   /* FIXME.  Throughout the function, do better error reporting.  */
2400   /* Note that get_config_filename() calls percent_deescape(), so we
2401      call this before processing the arguments.  */
2402   dest_filename = xstrdup (get_config_filename (component, backend));
2403   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, (int)getpid ());
2404   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename,(int)getpid ());
2405
2406   arg = option->new_value;
2407   if (arg && arg[0] == '\0')
2408     arg = NULL;
2409   else if (arg)
2410     {
2411       char *end;
2412
2413       arg++;
2414       end = strchr (arg, ',');
2415       if (end)
2416         *end = '\0';
2417
2418       cur_arg = percent_deescape (arg);
2419       if (end)
2420         {
2421           *end = ',';
2422           arg = end + 1;
2423         }
2424       else
2425         arg = NULL;
2426     }
2427
2428 #ifdef HAVE_W32_SYSTEM
2429   res = copy_file (dest_filename, orig_filename);
2430 #else
2431   res = link (dest_filename, orig_filename);
2432 #endif
2433   if (res < 0 && errno != ENOENT)
2434     return -1;
2435   if (res < 0)
2436     {
2437       xfree (orig_filename);
2438       orig_filename = NULL;
2439     }
2440
2441   /* We now initialize the return strings, so the caller can do the
2442      cleanup for us.  */
2443   *src_filenamep = src_filename;
2444   *dest_filenamep = dest_filename;
2445   *orig_filenamep = orig_filename;
2446
2447   /* Use open() so that we can use O_EXCL.  */
2448   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2449   if (fd < 0)
2450     return -1;
2451   src_file = fdopen (fd, "w");
2452   res = errno;
2453   if (!src_file)
2454     {
2455       gpg_err_set_errno (res);
2456       return -1;
2457     }
2458
2459   /* Only if ORIG_FILENAME is not NULL did the configuration file
2460      exist already.  In this case, we will copy its content into the
2461      new configuration file, changing it to our liking in the
2462      process.  */
2463   if (orig_filename)
2464     {
2465       dest_file = fopen (dest_filename, "r");
2466       if (!dest_file)
2467         goto change_file_one_err;
2468
2469       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2470         {
2471           int disable = 0;
2472           char *start;
2473
2474           if (!strncmp (marker, line, sizeof (marker) - 1))
2475             {
2476               if (!in_marker)
2477                 in_marker = 1;
2478               else
2479                 break;
2480             }
2481
2482           start = line;
2483           while (*start == ' ' || *start == '\t')
2484             start++;
2485           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2486             {
2487               char *end;
2488               char *endp;
2489               char saved_end;
2490
2491               endp = start;
2492               end = endp;
2493
2494               /* Search for the end of the line.  */
2495               while (*endp && *endp != '#' && *endp != '\r' && *endp != '\n')
2496                 {
2497                   endp++;
2498                   if (*endp && *endp != ' ' && *endp != '\t'
2499                       && *endp != '\r' && *endp != '\n' && *endp != '#')
2500                     end = endp + 1;
2501                 }
2502               saved_end = *end;
2503               *end = '\0';
2504
2505               if ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2506                   || !cur_arg || strcmp (start, cur_arg))
2507                 disable = 1;
2508               else
2509                 {
2510                   /* Find next argument.  */
2511                   if (arg)
2512                     {
2513                       char *arg_end;
2514
2515                       arg++;
2516                       arg_end = strchr (arg, ',');
2517                       if (arg_end)
2518                         *arg_end = '\0';
2519
2520                       cur_arg = percent_deescape (arg);
2521                       if (arg_end)
2522                         {
2523                           *arg_end = ',';
2524                           arg = arg_end + 1;
2525                         }
2526                       else
2527                         arg = NULL;
2528                     }
2529                   else
2530                     cur_arg = NULL;
2531                 }
2532
2533               *end = saved_end;
2534             }
2535
2536           if (disable)
2537             {
2538               if (!in_marker)
2539                 {
2540                   fprintf (src_file,
2541                            "# GPGConf disabled this option here at %s\n",
2542                            asctimestamp (gnupg_get_time ()));
2543                   if (ferror (src_file))
2544                     goto change_file_one_err;
2545                   fprintf (src_file, "# %s", line);
2546                   if (ferror (src_file))
2547                     goto change_file_one_err;
2548                 }
2549             }
2550           else
2551             {
2552               fprintf (src_file, "%s", line);
2553               if (ferror (src_file))
2554                 goto change_file_one_err;
2555             }
2556         }
2557       if (length < 0 || ferror (dest_file))
2558         goto change_file_one_err;
2559     }
2560
2561   if (!in_marker)
2562     {
2563       /* There was no marker.  This is the first time we edit the
2564          file.  We add our own marker at the end of the file and
2565          proceed.  Note that we first write a newline, this guards us
2566          against files which lack the newline at the end of the last
2567          line, while it doesn't hurt us in all other cases.  */
2568       fprintf (src_file, "\n%s\n", marker);
2569       if (ferror (src_file))
2570         goto change_file_one_err;
2571     }
2572
2573   /* At this point, we have copied everything up to the end marker
2574      into the new file, except for the arguments we are going to add.
2575      Now, dump the new arguments and write the end marker, possibly
2576      followed by the rest of the original file.  */
2577   while (cur_arg)
2578     {
2579       fprintf (src_file, "%s\n", cur_arg);
2580
2581       /* Find next argument.  */
2582       if (arg)
2583         {
2584           char *end;
2585
2586           arg++;
2587           end = strchr (arg, ',');
2588           if (end)
2589             *end = '\0';
2590
2591           cur_arg = percent_deescape (arg);
2592           if (end)
2593             {
2594               *end = ',';
2595               arg = end + 1;
2596             }
2597           else
2598             arg = NULL;
2599         }
2600       else
2601         cur_arg = NULL;
2602     }
2603
2604   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2605   if (ferror (src_file))
2606     goto change_file_one_err;
2607
2608   if (!in_marker)
2609     {
2610       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2611       if (ferror (src_file))
2612         goto change_file_one_err;
2613       fprintf (src_file, "# It will disable options before this marked "
2614                "block, but it will\n");
2615       if (ferror (src_file))
2616         goto change_file_one_err;
2617       fprintf (src_file, "# never change anything below these lines.\n");
2618       if (ferror (src_file))
2619         goto change_file_one_err;
2620     }
2621   if (dest_file)
2622     {
2623       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2624         {
2625           fprintf (src_file, "%s", line);
2626           if (ferror (src_file))
2627             goto change_file_one_err;
2628         }
2629       if (length < 0 || ferror (dest_file))
2630         goto change_file_one_err;
2631     }
2632   xfree (line);
2633   line = NULL;
2634
2635   res = fclose (src_file);
2636   if (res)
2637     {
2638       res = errno;
2639       close (fd);
2640       if (dest_file)
2641         fclose (dest_file);
2642       gpg_err_set_errno (res);
2643       return -1;
2644     }
2645   close (fd);
2646   if (dest_file)
2647     {
2648       res = fclose (dest_file);
2649       if (res)
2650         return -1;
2651     }
2652   return 0;
2653
2654  change_file_one_err:
2655   xfree (line);
2656   res = errno;
2657   if (src_file)
2658     {
2659       fclose (src_file);
2660       close (fd);
2661     }
2662   if (dest_file)
2663     fclose (dest_file);
2664   gpg_err_set_errno (res);
2665   return -1;
2666 }
2667
2668
2669 /* Create and verify the new configuration file for the specified
2670    backend and component.  Returns 0 on success and -1 on error.  */
2671 static int
2672 change_options_program (gc_component_t component, gc_backend_t backend,
2673                         char **src_filenamep, char **dest_filenamep,
2674                         char **orig_filenamep)
2675 {
2676   static const char marker[] = "###+++--- GPGConf ---+++###";
2677   /* True if we are within the marker in the config file.  */
2678   int in_marker = 0;
2679   gc_option_t *option;
2680   char *line = NULL;
2681   size_t line_len;
2682   ssize_t length;
2683   int res;
2684   int fd;
2685   FILE *src_file = NULL;
2686   FILE *dest_file = NULL;
2687   char *src_filename;
2688   char *dest_filename;
2689   char *orig_filename;
2690   /* Special hack for gpg, see below.  */
2691   int utf8strings_seen = 0;
2692
2693   /* FIXME.  Throughout the function, do better error reporting.  */
2694   dest_filename = xstrdup (get_config_filename (component, backend));
2695   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, (int)getpid ());
2696   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename,(int)getpid ());
2697
2698 #ifdef HAVE_W32_SYSTEM
2699   res = copy_file (dest_filename, orig_filename);
2700 #else
2701   res = link (dest_filename, orig_filename);
2702 #endif
2703   if (res < 0 && errno != ENOENT)
2704     return -1;
2705   if (res < 0)
2706     {
2707       xfree (orig_filename);
2708       orig_filename = NULL;
2709     }
2710
2711   /* We now initialize the return strings, so the caller can do the
2712      cleanup for us.  */
2713   *src_filenamep = src_filename;
2714   *dest_filenamep = dest_filename;
2715   *orig_filenamep = orig_filename;
2716
2717   /* Use open() so that we can use O_EXCL.  */
2718   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2719   if (fd < 0)
2720     return -1;
2721   src_file = fdopen (fd, "w");
2722   res = errno;
2723   if (!src_file)
2724     {
2725       gpg_err_set_errno (res);
2726       return -1;
2727     }
2728
2729   /* Only if ORIG_FILENAME is not NULL did the configuration file
2730      exist already.  In this case, we will copy its content into the
2731      new configuration file, changing it to our liking in the
2732      process.  */
2733   if (orig_filename)
2734     {
2735       dest_file = fopen (dest_filename, "r");
2736       if (!dest_file)
2737         goto change_one_err;
2738
2739       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2740         {
2741           int disable = 0;
2742           char *start;
2743
2744           if (!strncmp (marker, line, sizeof (marker) - 1))
2745             {
2746               if (!in_marker)
2747                 in_marker = 1;
2748               else
2749                 break;
2750             }
2751           else if (backend == GC_BACKEND_GPG && in_marker
2752                    && ! strcmp ("utf8-strings\n", line))
2753             {
2754               /* Strip duplicated entries.  */
2755               if (utf8strings_seen)
2756                 disable = 1;
2757               else
2758                 utf8strings_seen = 1;
2759             }
2760
2761           start = line;
2762           while (*start == ' ' || *start == '\t')
2763             start++;
2764           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2765             {
2766               char *end;
2767               char saved_end;
2768
2769               end = start;
2770               while (*end && *end != ' ' && *end != '\t'
2771                      && *end != '\r' && *end != '\n' && *end != '#')
2772                 end++;
2773               saved_end = *end;
2774               *end = '\0';
2775
2776               option = find_option (component, start, backend);
2777               *end = saved_end;
2778               if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2779                              || option->new_value))
2780                 disable = 1;
2781             }
2782           if (disable)
2783             {
2784               if (!in_marker)
2785                 {
2786                   fprintf (src_file,
2787                            "# GPGConf disabled this option here at %s\n",
2788                            asctimestamp (gnupg_get_time ()));
2789                   if (ferror (src_file))
2790                     goto change_one_err;
2791                   fprintf (src_file, "# %s", line);
2792                   if (ferror (src_file))
2793                     goto change_one_err;
2794                 }
2795             }
2796           else
2797             {
2798               fprintf (src_file, "%s", line);
2799               if (ferror (src_file))
2800                 goto change_one_err;
2801             }
2802         }
2803       if (length < 0 || ferror (dest_file))
2804         goto change_one_err;
2805     }
2806
2807   if (!in_marker)
2808     {
2809       /* There was no marker.  This is the first time we edit the
2810          file.  We add our own marker at the end of the file and
2811          proceed.  Note that we first write a newline, this guards us
2812          against files which lack the newline at the end of the last
2813          line, while it doesn't hurt us in all other cases.  */
2814       fprintf (src_file, "\n%s\n", marker);
2815       if (ferror (src_file))
2816         goto change_one_err;
2817     }
2818   /* At this point, we have copied everything up to the end marker
2819      into the new file, except for the options we are going to change.
2820      Now, dump the changed options (except for those we are going to
2821      revert to their default), and write the end marker, possibly
2822      followed by the rest of the original file.  */
2823
2824   /* We have to turn on UTF8 strings for GnuPG.  */
2825   if (backend == GC_BACKEND_GPG && ! utf8strings_seen)
2826     fprintf (src_file, "utf8-strings\n");
2827
2828   option = gc_component[component].options;
2829   while (option->name)
2830     {
2831       if (!(option->flags & GC_OPT_FLAG_GROUP)
2832           && option->backend == backend
2833           && option->new_value)
2834         {
2835           char *arg = option->new_value;
2836
2837           do
2838             {
2839               if (*arg == '\0' || *arg == ',')
2840                 {
2841                   fprintf (src_file, "%s\n", option->name);
2842                   if (ferror (src_file))
2843                     goto change_one_err;
2844                 }
2845               else if (gc_arg_type[option->arg_type].fallback
2846                        == GC_ARG_TYPE_NONE)
2847                 {
2848                   assert (*arg == '1');
2849                   fprintf (src_file, "%s\n", option->name);
2850                   if (ferror (src_file))
2851                     goto change_one_err;
2852
2853                   arg++;
2854                 }
2855               else if (gc_arg_type[option->arg_type].fallback
2856                        == GC_ARG_TYPE_STRING)
2857                 {
2858                   char *end;
2859
2860                   assert (*arg == '"');
2861                   arg++;
2862
2863                   end = strchr (arg, ',');
2864                   if (end)
2865                     *end = '\0';
2866
2867                   fprintf (src_file, "%s %s\n", option->name,
2868                            percent_deescape (arg));
2869                   if (ferror (src_file))
2870                     goto change_one_err;
2871
2872                   if (end)
2873                     *end = ',';
2874                   arg = end;
2875                 }
2876               else
2877                 {
2878                   char *end;
2879
2880                   end = strchr (arg, ',');
2881                   if (end)
2882                     *end = '\0';
2883
2884                   fprintf (src_file, "%s %s\n", option->name, arg);
2885                   if (ferror (src_file))
2886                     goto change_one_err;
2887
2888                   if (end)
2889                     *end = ',';
2890                   arg = end;
2891                 }
2892
2893               assert (arg == NULL || *arg == '\0' || *arg == ',');
2894               if (arg && *arg == ',')
2895                 arg++;
2896             }
2897           while (arg && *arg);
2898         }
2899       option++;
2900     }
2901
2902   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2903   if (ferror (src_file))
2904     goto change_one_err;
2905
2906   if (!in_marker)
2907     {
2908       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2909       if (ferror (src_file))
2910         goto change_one_err;
2911       fprintf (src_file, "# It will disable options before this marked "
2912                "block, but it will\n");
2913       if (ferror (src_file))
2914         goto change_one_err;
2915       fprintf (src_file, "# never change anything below these lines.\n");
2916       if (ferror (src_file))
2917         goto change_one_err;
2918     }
2919   if (dest_file)
2920     {
2921       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2922         {
2923           fprintf (src_file, "%s", line);
2924           if (ferror (src_file))
2925             goto change_one_err;
2926         }
2927       if (length < 0 || ferror (dest_file))
2928         goto change_one_err;
2929     }
2930   xfree (line);
2931   line = NULL;
2932
2933   res = fclose (src_file);
2934   if (res)
2935     {
2936       res = errno;
2937       close (fd);
2938       if (dest_file)
2939         fclose (dest_file);
2940       gpg_err_set_errno (res);
2941       return -1;
2942     }
2943   close (fd);
2944   if (dest_file)
2945     {
2946       res = fclose (dest_file);
2947       if (res)
2948         return -1;
2949     }
2950   return 0;
2951
2952  change_one_err:
2953   xfree (line);
2954   res = errno;
2955   if (src_file)
2956     {
2957       fclose (src_file);
2958       close (fd);
2959     }
2960   if (dest_file)
2961     fclose (dest_file);
2962   gpg_err_set_errno (res);
2963   return -1;
2964 }
2965
2966
2967 /* Common code for gc_component_change_options and
2968    gc_process_gpgconf_conf.  */
2969 static void
2970 change_one_value (gc_option_t *option, int *runtime,
2971                   unsigned long flags, char *new_value)
2972 {
2973   unsigned long new_value_nr = 0;
2974
2975   option_check_validity (option, flags, new_value, &new_value_nr);
2976
2977   if (option->flags & GC_OPT_FLAG_RUNTIME)
2978     runtime[option->backend] = 1;
2979
2980   option->new_flags = flags;
2981   if (!(flags & GC_OPT_FLAG_DEFAULT))
2982     {
2983       if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
2984           && (option->flags & GC_OPT_FLAG_LIST))
2985         {
2986           char *str;
2987
2988           /* We convert the number to a list of 1's for convenient
2989              list handling.  */
2990           assert (new_value_nr > 0);
2991           option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
2992           str = option->new_value;
2993           *(str++) = '1';
2994           while (--new_value_nr > 0)
2995             {
2996               *(str++) = ',';
2997               *(str++) = '1';
2998             }
2999           *(str++) = '\0';
3000         }
3001       else
3002         option->new_value = xstrdup (new_value);
3003     }
3004 }
3005
3006
3007 /* Read the modifications from IN and apply them.  If IN is NULL the
3008    modifications are expected to already have been set to the global
3009    table. */
3010 void
3011 gc_component_change_options (int component, estream_t in, estream_t out)
3012 {
3013   int err = 0;
3014   int runtime[GC_BACKEND_NR];
3015   char *src_filename[GC_BACKEND_NR];
3016   char *dest_filename[GC_BACKEND_NR];
3017   char *orig_filename[GC_BACKEND_NR];
3018   gc_backend_t backend;
3019   gc_option_t *option;
3020   char *line = NULL;
3021   size_t line_len = 0;
3022   ssize_t length;
3023
3024   if (component == GC_COMPONENT_PINENTRY)
3025     return; /* Dummy component for now.  */
3026
3027   for (backend = 0; backend < GC_BACKEND_NR; backend++)
3028     {
3029       runtime[backend] = 0;
3030       src_filename[backend] = NULL;
3031       dest_filename[backend] = NULL;
3032       orig_filename[backend] = NULL;
3033     }
3034
3035   if (in)
3036     {
3037       /* Read options from the file IN.  */
3038       while ((length = es_read_line (in, &line, &line_len, NULL)) > 0)
3039         {
3040           char *linep;
3041           unsigned long flags = 0;
3042           char *new_value = "";
3043
3044           /* Strip newline and carriage return, if present.  */
3045           while (length > 0
3046                  && (line[length - 1] == '\n' || line[length - 1] == '\r'))
3047             line[--length] = '\0';
3048
3049           linep = strchr (line, ':');
3050           if (linep)
3051             *(linep++) = '\0';
3052
3053           /* Extract additional flags.  Default to none.  */
3054           if (linep)
3055             {
3056               char *end;
3057               char *tail;
3058
3059               end = strchr (linep, ':');
3060               if (end)
3061                 *(end++) = '\0';
3062
3063               gpg_err_set_errno (0);
3064               flags = strtoul (linep, &tail, 0);
3065               if (errno)
3066                 gc_error (1, errno, "malformed flags in option %s", line);
3067               if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
3068                 gc_error (1, 0, "garbage after flags in option %s", line);
3069
3070               linep = end;
3071             }
3072
3073           /* Don't allow setting of the no change flag.  */
3074           flags &= ~GC_OPT_FLAG_NO_CHANGE;
3075
3076           /* Extract default value, if present.  Default to empty if not.  */
3077           if (linep)
3078             {
3079               char *end;
3080               end = strchr (linep, ':');
3081               if (end)
3082                 *(end++) = '\0';
3083               new_value = linep;
3084               linep = end;
3085             }
3086
3087           option = find_option (component, line, GC_BACKEND_ANY);
3088           if (!option)
3089             gc_error (1, 0, "unknown option %s", line);
3090
3091           if ((option->flags & GC_OPT_FLAG_NO_CHANGE))
3092             {
3093               gc_error (0, 0, "ignoring new value for option %s",
3094                         option->name);
3095               continue;
3096             }
3097
3098           change_one_value (option, runtime, flags, new_value);
3099         }
3100     }
3101
3102   /* Now that we have collected and locally verified the changes,
3103      write them out to new configuration files, verify them
3104      externally, and then commit them.  */
3105   option = gc_component[component].options;
3106   while (option && option->name)
3107     {
3108       /* Go on if we have already seen this backend, or if there is
3109          nothing to do.  */
3110       if (src_filename[option->backend]
3111           || !(option->new_flags || option->new_value))
3112         {
3113           option++;
3114           continue;
3115         }
3116
3117       if (gc_backend[option->backend].program)
3118         {
3119           err = change_options_program (component, option->backend,
3120                                         &src_filename[option->backend],
3121                                         &dest_filename[option->backend],
3122                                         &orig_filename[option->backend]);
3123           if (! err)
3124             {
3125               /* External verification.  */
3126               err = gc_component_check_options (component, out,
3127                                                 src_filename[option->backend]);
3128               if (err)
3129                 {
3130                   gc_error (0, 0,
3131                             _("External verification of component %s failed"),
3132                             gc_component[component].name);
3133                   gpg_err_set_errno (EINVAL);
3134                 }
3135             }
3136
3137         }
3138       else
3139         err = change_options_file (component, option->backend,
3140                                    &src_filename[option->backend],
3141                                    &dest_filename[option->backend],
3142                                    &orig_filename[option->backend]);
3143
3144       if (err)
3145         break;
3146
3147       option++;
3148     }
3149
3150   if (! err && ! opt.dry_run)
3151     {
3152       int i;
3153
3154       for (i = 0; i < GC_BACKEND_NR; i++)
3155         {
3156           if (src_filename[i])
3157             {
3158               /* FIXME: Make a verification here.  */
3159
3160               assert (dest_filename[i]);
3161
3162               if (orig_filename[i])
3163                 {
3164 #ifdef HAVE_W32_SYSTEM
3165                   /* There is no atomic update on W32.  */
3166                   err = unlink (dest_filename[i]);
3167 #endif /* HAVE_W32_SYSTEM */
3168                   if (!err)
3169                     err = rename (src_filename[i], dest_filename[i]);
3170                 }
3171               else
3172                 {
3173 #ifdef HAVE_W32_SYSTEM
3174                   /* We skip the unlink if we expect the file not to
3175                      be there.  */
3176                   err = rename (src_filename[i], dest_filename[i]);
3177 #else /* HAVE_W32_SYSTEM */
3178                   /* This is a bit safer than rename() because we
3179                      expect DEST_FILENAME not to be there.  If it
3180                      happens to be there, this will fail.  */
3181                   err = link (src_filename[i], dest_filename[i]);
3182                   if (!err)
3183                     err = unlink (src_filename[i]);
3184 #endif /* !HAVE_W32_SYSTEM */
3185                 }
3186               if (err)
3187                 break;
3188               src_filename[i] = NULL;
3189             }
3190         }
3191     }
3192
3193   if (err || opt.dry_run)
3194     {
3195       int i;
3196       int saved_errno = errno;
3197
3198       /* An error occured or a dry-run is requested.  */
3199       for (i = 0; i < GC_BACKEND_NR; i++)
3200         {
3201           if (src_filename[i])
3202             {
3203               /* The change was not yet committed.  */
3204               unlink (src_filename[i]);
3205               if (orig_filename[i])
3206                 unlink (orig_filename[i]);
3207             }
3208           else
3209             {
3210               /* The changes were already committed.  FIXME: This is a
3211                  tad dangerous, as we don't know if we don't overwrite
3212                  a version of the file that is even newer than the one
3213                  we just installed.  */
3214               if (orig_filename[i])
3215                 {
3216 #ifdef HAVE_W32_SYSTEM
3217                   /* There is no atomic update on W32.  */
3218                   unlink (dest_filename[i]);
3219 #endif /* HAVE_W32_SYSTEM */
3220                   rename (orig_filename[i], dest_filename[i]);
3221                 }
3222               else
3223                 unlink (dest_filename[i]);
3224             }
3225         }
3226       if (err)
3227         gc_error (1, saved_errno, "could not commit changes");
3228
3229       /* Fall-through for dry run.  */
3230       goto leave;
3231     }
3232
3233   /* If it all worked, notify the daemons of the changes.  */
3234   if (opt.runtime)
3235     for (backend = 0; backend < GC_BACKEND_NR; backend++)
3236       {
3237         if (runtime[backend] && gc_backend[backend].runtime_change)
3238           (*gc_backend[backend].runtime_change) (0);
3239       }
3240
3241   /* Move the per-process backup file into its place.  */
3242   for (backend = 0; backend < GC_BACKEND_NR; backend++)
3243     if (orig_filename[backend])
3244       {
3245         char *backup_filename;
3246
3247         assert (dest_filename[backend]);
3248
3249         backup_filename = xasprintf ("%s.gpgconf.bak", dest_filename[backend]);
3250
3251 #ifdef HAVE_W32_SYSTEM
3252         /* There is no atomic update on W32.  */
3253         unlink (backup_filename);
3254 #endif /* HAVE_W32_SYSTEM */
3255         rename (orig_filename[backend], backup_filename);
3256       }
3257
3258  leave:
3259   xfree (line);
3260 }
3261
3262
3263 /* Check whether USER matches the current user of one of its group.
3264    This function may change USER.  Returns true is there is a
3265    match.  */
3266 static int
3267 key_matches_user_or_group (char *user)
3268 {
3269   char *group;
3270
3271   if (*user == '*' && user[1] == 0)
3272     return 1; /* A single asterisk matches all users.  */
3273
3274   group = strchr (user, ':');
3275   if (group)
3276     *group++ = 0;
3277
3278 #ifdef HAVE_W32_SYSTEM
3279   /* Under Windows we don't support groups. */
3280   if (group && *group)
3281     gc_error (0, 0, _("Note that group specifications are ignored\n"));
3282 #ifndef HAVE_W32CE_SYSTEM
3283   if (*user)
3284     {
3285       static char *my_name;
3286
3287       if (!my_name)
3288         {
3289           char tmp[1];
3290           DWORD size = 1;
3291
3292           GetUserNameA (tmp, &size);
3293           my_name = xmalloc (size);
3294           if (!GetUserNameA (my_name, &size))
3295             gc_error (1,0, "error getting current user name: %s",
3296                       w32_strerror (-1));
3297         }
3298
3299       if (!strcmp (user, my_name))
3300         return 1; /* Found.  */
3301     }
3302 #endif /*HAVE_W32CE_SYSTEM*/
3303 #else /*!HAVE_W32_SYSTEM*/
3304   /* First check whether the user matches.  */
3305   if (*user)
3306     {
3307       static char *my_name;
3308
3309       if (!my_name)
3310         {
3311           struct passwd *pw = getpwuid ( getuid () );
3312           if (!pw)
3313             gc_error (1, errno, "getpwuid failed for current user");
3314           my_name = xstrdup (pw->pw_name);
3315         }
3316       if (!strcmp (user, my_name))
3317         return 1; /* Found.  */
3318     }
3319
3320   /* If that failed, check whether a group matches.  */
3321   if (group && *group)
3322     {
3323       static char *my_group;
3324       static char **my_supgroups;
3325       int n;
3326
3327       if (!my_group)
3328         {
3329           struct group *gr = getgrgid ( getgid () );
3330           if (!gr)
3331             gc_error (1, errno, "getgrgid failed for current user");
3332           my_group = xstrdup (gr->gr_name);
3333         }
3334       if (!strcmp (group, my_group))
3335         return 1; /* Found.  */
3336
3337       if (!my_supgroups)
3338         {
3339           int ngids;
3340           gid_t *gids;
3341
3342           ngids = getgroups (0, NULL);
3343           gids  = xcalloc (ngids+1, sizeof *gids);
3344           ngids = getgroups (ngids, gids);
3345           if (ngids < 0)
3346             gc_error (1, errno, "getgroups failed for current user");
3347           my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
3348           for (n=0; n < ngids; n++)
3349             {
3350               struct group *gr = getgrgid ( gids[n] );
3351               if (!gr)
3352                 gc_error (1, errno, "getgrgid failed for supplementary group");
3353               my_supgroups[n] = xstrdup (gr->gr_name);
3354             }
3355           xfree (gids);
3356         }
3357
3358       for (n=0; my_supgroups[n]; n++)
3359         if (!strcmp (group, my_supgroups[n]))
3360           return 1; /* Found.  */
3361     }
3362 #endif /*!HAVE_W32_SYSTEM*/
3363   return 0; /* No match.  */
3364 }
3365
3366
3367
3368 /* Read and process the global configuration file for gpgconf.  This
3369    optional file is used to update our internal tables at runtime and
3370    may also be used to set new default values.  If FNAME is NULL the
3371    default name will be used.  With UPDATE set to true the internal
3372    tables are actually updated; if not set, only a syntax check is
3373    done.  If DEFAULTS is true the global options are written to the
3374    configuration files.  If LISTFP is set, no changes are done but the
3375    configuration file is printed to LISTFP in a colon separated format.
3376
3377    Returns 0 on success or if the config file is not present; -1 is
3378    returned on error. */
3379 int
3380 gc_process_gpgconf_conf (const char *fname_arg, int update, int defaults,
3381                          estream_t listfp)
3382 {
3383   int result = 0;
3384   char *line = NULL;
3385   size_t line_len = 0;
3386   ssize_t length;
3387   FILE *config;
3388   int lineno = 0;
3389   int in_rule = 0;
3390   int got_match = 0;
3391   int runtime[GC_BACKEND_NR];
3392   int backend_id, component_id;
3393   char *fname;
3394
3395   if (fname_arg)
3396     fname = xstrdup (fname_arg);
3397   else
3398     fname = make_filename (gnupg_sysconfdir (), "gpgconf.conf", NULL);
3399
3400   for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3401     runtime[backend_id] = 0;
3402
3403   config = fopen (fname, "r");
3404   if (!config)
3405     {
3406       /* Do not print an error if the file is not available, except
3407          when running in syntax check mode.  */
3408       if (errno != ENOENT || !update)
3409         {
3410           gc_error (0, errno, "can not open global config file '%s'", fname);
3411           result = -1;
3412         }
3413       xfree (fname);
3414       return result;
3415     }
3416
3417   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
3418     {
3419       char *key, *component, *option, *flags, *value;
3420       char *empty;
3421       gc_option_t *option_info = NULL;
3422       char *p;
3423       int is_continuation;
3424
3425       lineno++;
3426       key = line;
3427       while (*key == ' ' || *key == '\t')
3428         key++;
3429       if (!*key || *key == '#' || *key == '\r' || *key == '\n')
3430         continue;
3431
3432       is_continuation = (key != line);
3433
3434       /* Parse the key field.  */
3435       if (!is_continuation && got_match)
3436         break;  /* Finish after the first match.  */
3437       else if (!is_continuation)
3438         {
3439           in_rule = 0;
3440           for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
3441             ;
3442           if (!*p)
3443             {
3444               gc_error (0, 0, "missing rule at '%s', line %d", fname, lineno);
3445               result = -1;
3446               continue;
3447             }
3448           *p++ = 0;
3449           component = p;
3450         }
3451       else if (!in_rule)
3452         {
3453           gc_error (0, 0, "continuation but no rule at '%s', line %d",
3454                     fname, lineno);
3455           result = -1;
3456           continue;
3457         }
3458       else
3459         {
3460           component = key;
3461           key = NULL;
3462         }
3463
3464       in_rule = 1;
3465
3466       /* Parse the component.  */
3467       while (*component == ' ' || *component == '\t')
3468         component++;
3469       for (p=component; *p && !strchr (" \t\r\n", *p); p++)
3470         ;
3471       if (p == component)
3472         {
3473           gc_error (0, 0, "missing component at '%s', line %d",
3474                     fname, lineno);
3475           result = -1;
3476           continue;
3477         }
3478       empty = p;
3479       *p++ = 0;
3480       option = p;
3481       component_id = gc_component_find (component);
3482       if (component_id < 0)
3483         {
3484           gc_error (0, 0, "unknown component at '%s', line %d",
3485                     fname, lineno);
3486           result = -1;
3487         }
3488
3489       /* Parse the option name.  */
3490       while (*option == ' ' || *option == '\t')
3491         option++;
3492       for (p=option; *p && !strchr (" \t\r\n", *p); p++)
3493         ;
3494       if (p == option)
3495         {
3496           gc_error (0, 0, "missing option at '%s', line %d",
3497                     fname, lineno);
3498           result = -1;
3499           continue;
3500         }
3501       *p++ = 0;
3502       flags = p;
3503       if ( component_id != -1)
3504         {
3505           option_info = find_option (component_id, option, GC_BACKEND_ANY);
3506           if (!option_info)
3507             {
3508               gc_error (0, 0, "unknown option at '%s', line %d",
3509                         fname, lineno);
3510               result = -1;
3511             }
3512         }
3513
3514
3515       /* Parse the optional flags.  */
3516       while (*flags == ' ' || *flags == '\t')
3517         flags++;
3518       if (*flags == '[')
3519         {
3520           flags++;
3521           p = strchr (flags, ']');
3522           if (!p)
3523             {
3524               gc_error (0, 0, "syntax error in rule at '%s', line %d",
3525                         fname, lineno);
3526               result = -1;
3527               continue;
3528             }
3529           *p++ = 0;
3530           value = p;
3531         }
3532       else  /* No flags given.  */
3533         {
3534           value = flags;
3535           flags = NULL;
3536         }
3537
3538       /* Parse the optional value.  */
3539       while (*value == ' ' || *value == '\t')
3540        value++;
3541       for (p=value; *p && !strchr ("\r\n", *p); p++)
3542         ;
3543       if (p == value)
3544         value = empty; /* No value given; let it point to an empty string.  */
3545       else
3546         {
3547           /* Strip trailing white space.  */
3548           *p = 0;
3549           for (p--; p > value && (*p == ' ' || *p == '\t'); p--)
3550             *p = 0;
3551         }
3552
3553       /* Check flag combinations.  */
3554       if (!flags)
3555         ;
3556       else if (!strcmp (flags, "default"))
3557         {
3558           if (*value)
3559             {
3560               gc_error (0, 0, "flag \"default\" may not be combined "
3561                         "with a value at '%s', line %d",
3562                         fname, lineno);
3563               result = -1;
3564             }
3565         }
3566       else if (!strcmp (flags, "change"))
3567         ;
3568       else if (!strcmp (flags, "no-change"))
3569         ;
3570       else
3571         {
3572           gc_error (0, 0, "unknown flag at '%s', line %d",
3573                     fname, lineno);
3574           result = -1;
3575         }
3576
3577       /* In list mode we print out all records.  */
3578       if (listfp && !result)
3579         {
3580           /* If this is a new ruleset, print a key record.  */
3581           if (!is_continuation)
3582             {
3583               char *group = strchr (key, ':');
3584               if (group)
3585                 {
3586                   *group++ = 0;
3587                   if ((p = strchr (group, ':')))
3588                     *p = 0; /* We better strip any extra stuff. */
3589                 }
3590
3591               es_fprintf (listfp, "k:%s:", gc_percent_escape (key));
3592               es_fprintf (listfp, "%s\n", group? gc_percent_escape (group):"");
3593             }
3594
3595           /* All other lines are rule records.  */
3596           es_fprintf (listfp, "r:::%s:%s:%s:",
3597                       gc_component[component_id].name,
3598                       option_info->name? option_info->name : "",
3599                       flags? flags : "");
3600           if (value != empty)
3601             es_fprintf (listfp, "\"%s", gc_percent_escape (value));
3602
3603           es_putc ('\n', listfp);
3604         }
3605
3606       /* Check whether the key matches but do this only if we are not
3607          running in syntax check mode. */
3608       if ( update
3609            && !result && !listfp
3610            && (got_match || (key && key_matches_user_or_group (key))) )
3611         {
3612           int newflags = 0;
3613
3614           got_match = 1;
3615
3616           /* Apply the flags from gpgconf.conf.  */
3617           if (!flags)
3618             ;
3619           else if (!strcmp (flags, "default"))
3620             newflags |= GC_OPT_FLAG_DEFAULT;
3621           else if (!strcmp (flags, "no-change"))
3622             option_info->flags |= GC_OPT_FLAG_NO_CHANGE;
3623           else if (!strcmp (flags, "change"))
3624             option_info->flags &= ~GC_OPT_FLAG_NO_CHANGE;
3625
3626           if (defaults)
3627             {
3628               /* Here we explicitly allow to update the value again.  */
3629               if (newflags)
3630                 {
3631                   option_info->new_flags = 0;
3632                 }
3633               if (*value)
3634                 {
3635                   xfree (option_info->new_value);
3636                   option_info->new_value = NULL;
3637                 }
3638               change_one_value (option_info, runtime, newflags, value);
3639             }
3640         }
3641     }
3642
3643   if (length < 0 || ferror (config))
3644     {
3645       gc_error (0, errno, "error reading from '%s'", fname);
3646       result = -1;
3647     }
3648   if (fclose (config))
3649     gc_error (0, errno, "error closing '%s'", fname);
3650
3651   xfree (line);
3652
3653   /* If it all worked, process the options. */
3654   if (!result && update && defaults && !listfp)
3655     {
3656       /* We need to switch off the runtime update, so that we can do
3657          it later all at once. */
3658       int save_opt_runtime = opt.runtime;
3659       opt.runtime = 0;
3660
3661       for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3662         {
3663           gc_component_change_options (component_id, NULL, NULL);
3664         }
3665       opt.runtime = save_opt_runtime;
3666
3667       if (opt.runtime)
3668         {
3669           for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3670             if (runtime[backend_id] && gc_backend[backend_id].runtime_change)
3671               (*gc_backend[backend_id].runtime_change) (0);
3672         }
3673     }
3674
3675   xfree (fname);
3676   return result;
3677 }