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