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