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