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