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