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