Merged Dirmngr with GnuPG.
[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 Aegypten directory manager.  */
137     GC_BACKEND_DIRMNGR,
138
139     /* The LDAP server list file for the Aegypten director manager.  */
140     GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST,
141
142     /* The number of the above entries.  */
143     GC_BACKEND_NR
144   } gc_backend_t;
145
146
147 /* To be able to implement generic algorithms for the various
148    backends, we collect all information about them in this struct.  */
149 static struct
150 {
151   /* The name of the backend.  */
152   const char *name;
153
154   /* The name of the program that acts as the backend.  Some backends
155      don't have an associated program, but are implemented directly by
156      GPGConf.  In this case, PROGRAM is NULL.  */
157   char *program;
158
159   /* The module name (GNUPG_MODULE_NAME_foo) as defined by
160      ../common/util.h.  This value is used to get the actual installed
161      path of the program.  0 is used if no backedn program is
162      available. */
163   char module_name;
164
165   /* The runtime change callback.  */
166   void (*runtime_change) (void);
167
168   /* The option name for the configuration filename of this backend.
169      This must be an absolute filename.  It can be an option from a
170      different backend (but then ordering of the options might
171      matter).  Note: This must be unique among all components.  */
172   const char *option_config_filename;
173
174   /* If this is a file backend rather than a program backend, then
175      this is the name of the option associated with the file.  */
176   const char *option_name;
177 } gc_backend[GC_BACKEND_NR] =
178   {
179     { NULL },           /* GC_BACKEND_ANY dummy entry.  */
180     { "GnuPG", GPGNAME, GNUPG_MODULE_NAME_GPG,
181       NULL, "gpgconf-gpg.conf" },
182     { "GPGSM", "gpgsm", GNUPG_MODULE_NAME_GPGSM,
183       NULL, "gpgconf-gpgsm.conf" },
184     { "GPG Agent", "gpg-agent", GNUPG_MODULE_NAME_AGENT, 
185       gpg_agent_runtime_change, "gpgconf-gpg-agent.conf" },
186     { "SCDaemon", "scdaemon", GNUPG_MODULE_NAME_SCDAEMON,
187       scdaemon_runtime_change, "gpgconf-scdaemon.conf" },
188     { "DirMngr", "dirmngr", GNUPG_MODULE_NAME_DIRMNGR,
189       NULL, "gpgconf-dirmngr.conf" },
190     { "DirMngr LDAP Server List", NULL, 0, 
191       NULL, "ldapserverlist-file", "LDAP Server" },
192   };
193
194 \f
195 /* Option configuration.  */
196
197 /* An option might take an argument, or not.  Argument types can be
198    basic or complex.  Basic types are generic and easy to validate.
199    Complex types provide more specific information about the intended
200    use, but can be difficult to validate.  If you add to this enum,
201    don't forget to update GC_ARG_TYPE below.  YOU MUST NOT CHANGE THE
202    NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE EXTERNAL
203    INTERFACE.  */
204 typedef enum
205   {
206     /* Basic argument types.  */
207
208     /* No argument.  */
209     GC_ARG_TYPE_NONE = 0,
210
211     /* A String argument.  */
212     GC_ARG_TYPE_STRING = 1,
213
214     /* A signed integer argument.  */
215     GC_ARG_TYPE_INT32 = 2,
216
217     /* An unsigned integer argument.  */
218     GC_ARG_TYPE_UINT32 = 3,
219
220     /* ADD NEW BASIC TYPE ENTRIES HERE.  */
221
222     /* Complex argument types.  */
223
224     /* A complete filename.  */
225     GC_ARG_TYPE_FILENAME = 32,
226
227     /* An LDAP server in the format
228        HOSTNAME:PORT:USERNAME:PASSWORD:BASE_DN.  */
229     GC_ARG_TYPE_LDAP_SERVER = 33,
230
231     /* A 40 character fingerprint.  */
232     GC_ARG_TYPE_KEY_FPR = 34,
233
234     /* A user ID or key ID or fingerprint for a certificate.  */
235     GC_ARG_TYPE_PUB_KEY = 35,
236
237     /* A user ID or key ID or fingerprint for a certificate with a key.  */
238     GC_ARG_TYPE_SEC_KEY = 36,
239
240     /* A alias list made up of a key, an equal sign and a space
241        separated list of values.  */
242     GC_ARG_TYPE_ALIAS_LIST = 37,
243
244     /* ADD NEW COMPLEX TYPE ENTRIES HERE.  */
245
246     /* The number of the above entries.  */
247     GC_ARG_TYPE_NR
248   } gc_arg_type_t;
249
250
251 /* For every argument, we record some information about it in the
252    following struct.  */
253 static struct
254 {
255   /* For every argument type exists a basic argument type that can be
256      used as a fallback for input and validation purposes.  */
257   gc_arg_type_t fallback;
258
259   /* Human-readable name of the type.  */
260   const char *name;
261 } gc_arg_type[GC_ARG_TYPE_NR] =
262   {
263     /* The basic argument types have their own types as fallback.  */
264     { GC_ARG_TYPE_NONE, "none" },
265     { GC_ARG_TYPE_STRING, "string" },
266     { GC_ARG_TYPE_INT32, "int32" },
267     { GC_ARG_TYPE_UINT32, "uint32" },
268
269     /* Reserved basic type entries for future extension.  */
270     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
271     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
272     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
273     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
274     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
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
285     /* The complex argument types have a basic type as fallback.  */
286     { GC_ARG_TYPE_STRING, "filename" },
287     { GC_ARG_TYPE_STRING, "ldap server" },
288     { GC_ARG_TYPE_STRING, "key fpr" },
289     { GC_ARG_TYPE_STRING, "pub key" },
290     { GC_ARG_TYPE_STRING, "sec key" },
291     { GC_ARG_TYPE_STRING, "alias list" },
292   };
293
294
295 /* Every option has an associated expert level, than can be used to
296    hide advanced and expert options from beginners.  If you add to
297    this list, don't forget to update GC_LEVEL below.  YOU MUST NOT
298    CHANGE THE NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE
299    EXTERNAL INTERFACE.  */
300 typedef enum
301   {
302     /* The basic options should always be displayed.  */
303     GC_LEVEL_BASIC,
304
305     /* The advanced options may be hidden from beginners.  */
306     GC_LEVEL_ADVANCED,
307
308     /* The expert options should only be displayed to experts.  */
309     GC_LEVEL_EXPERT,
310
311     /* The invisible options should normally never be displayed.  */
312     GC_LEVEL_INVISIBLE,
313
314     /* The internal options are never exported, they mark options that
315        are recorded for internal use only.  */
316     GC_LEVEL_INTERNAL,
317
318     /* ADD NEW ENTRIES HERE.  */
319
320     /* The number of the above entries.  */
321     GC_LEVEL_NR
322   } gc_expert_level_t;
323
324 /* A description for each expert level.  */
325 static struct
326 {
327   const char *name;
328 } gc_level[] =
329   {
330     { "basic" },
331     { "advanced" },
332     { "expert" },
333     { "invisible" },
334     { "internal" }
335   };
336
337
338 /* Option flags.  The flags which are used by the backends are defined
339    by gc-opt-flags.h, included above.
340
341    YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING FLAGS, AS THEY ARE
342    PART OF THE EXTERNAL INTERFACE.  */
343
344 /* Some entries in the option list are not options, but mark the
345    beginning of a new group of options.  These entries have the GROUP
346    flag set.  */
347 #define GC_OPT_FLAG_GROUP       (1UL << 0)
348 /* The ARG_OPT flag for an option indicates that the argument is
349    optional.  This is never set for GC_ARG_TYPE_NONE options.  */
350 #define GC_OPT_FLAG_ARG_OPT     (1UL << 1)
351 /* The LIST flag for an option indicates that the option can occur
352    several times.  A comma separated list of arguments is used as the
353    argument value.  */
354 #define GC_OPT_FLAG_LIST        (1UL << 2)
355 /* The NO_CHANGE flag for an option indicates that the user should not
356    be allowed to change this option using the standard gpgconf method.
357    Frontends using gpgconf should grey out such options, so that only
358    the current value is displayed.  */
359 #define GC_OPT_FLAG_NO_CHANGE   (1UL <<7)
360
361
362 /* A human-readable description for each flag.  */
363 static struct
364 {
365   const char *name;
366 } gc_flag[] =
367   {
368     { "group" },
369     { "optional arg" },
370     { "list" },
371     { "runtime" },
372     { "default" },
373     { "default desc" },
374     { "no arg desc" },
375     { "no change" }
376   };
377
378
379 /* To each option, or group marker, the information in the GC_OPTION
380    struct is provided.  If you change this, don't forget to update the
381    option list of each component.  */
382 struct gc_option
383 {
384   /* If this is NULL, then this is a terminator in an array of unknown
385      length.  Otherwise, if this entry is a group marker (see FLAGS),
386      then this is the name of the group described by this entry.
387      Otherwise it is the name of the option described by this
388      entry.  The name must not contain a colon.  */
389   const char *name;
390
391   /* The option flags.  If the GROUP flag is set, then this entry is a
392      group marker, not an option, and only the fields LEVEL,
393      DESC_DOMAIN and DESC are valid.  In all other cases, this entry
394      describes a new option and all fields are valid.  */
395   unsigned long flags;
396
397   /* The expert level.  This field is valid for options and groups.  A
398      group has the expert level of the lowest-level option in the
399      group.  */
400   gc_expert_level_t level;
401
402   /* A gettext domain in which the following description can be found.
403      If this is NULL, then DESC is not translated.  Valid for groups
404      and options.
405      
406      Note that we try to keep the description of groups within the
407      gnupg domain. 
408      
409      IMPORTANT: If you add a new domain please make sure to add a code
410      set switching call to the function my_dgettext further below.  */
411   const char *desc_domain;
412
413   /* A gettext description for this group or option.  If it starts
414      with a '|', then the string up to the next '|' describes the
415      argument, and the description follows the second '|'. 
416
417      In general enclosing these description in N_() is not required
418      because the description should be identical to the one in the
419      help menu of the respective program. */
420   const char *desc;
421
422   /* The following fields are only valid for options.  */
423
424   /* The type of the option argument.  */
425   gc_arg_type_t arg_type;
426
427   /* The backend that implements this option.  */
428   gc_backend_t backend;
429
430   /* The following fields are set to NULL at startup (because all
431      option's are declared as static variables).  They are at the end
432      of the list so that they can be omitted from the option
433      declarations.  */
434
435   /* This is true if the option is supported by this version of the
436      backend.  */
437   int active;
438
439   /* The default value for this option.  This is NULL if the option is
440      not present in the backend, the empty string if no default is
441      available, and otherwise a quoted string.  */
442   char *default_value;
443
444   /* The default argument is only valid if the "optional arg" flag is
445      set, and specifies the default argument (value) that is used if
446      the argument is omitted.  */
447   char *default_arg;
448
449   /* The current value of this option.  */
450   char *value;
451
452   /* The new flags for this option.  The only defined flag is actually
453      GC_OPT_FLAG_DEFAULT, and it means that the option should be
454      deleted.  In this case, NEW_VALUE is NULL.  */
455   unsigned long new_flags;
456
457   /* The new value of this option.  */
458   char *new_value;
459 };
460 typedef struct gc_option gc_option_t;
461
462 /* Use this macro to terminate an option list.  */
463 #define GC_OPTION_NULL { NULL }
464
465 \f
466 /* The options of the GC_COMPONENT_GPG_AGENT component.  */
467 static gc_option_t gc_options_gpg_agent[] =
468  {
469    /* The configuration file to which we write the changes.  */
470    { "gpgconf-gpg-agent.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
471      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG_AGENT },
472
473    { "Monitor",
474      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
475      "gnupg", N_("Options controlling the diagnostic output") },
476    { "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
477      "gnupg", "verbose",
478      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
479    { "quiet", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
480      "gnupg", "be somewhat more quiet",
481      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
482    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
483      NULL, NULL,
484      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
485
486    { "Configuration",
487      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
488      "gnupg", N_("Options controlling the configuration") },
489    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
490      "gnupg", "|FILE|read options from FILE",
491      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG_AGENT },
492    { "disable-scdaemon", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
493      "gnupg", "do not use the SCdaemon",
494      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
495
496    { "Debug",
497      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
498      "gnupg", N_("Options useful for debugging") },
499    { "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
500      "gnupg", "|LEVEL|set the debugging level to LEVEL",
501      GC_ARG_TYPE_STRING, GC_BACKEND_GPG_AGENT },
502    { "log-file", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
503      "gnupg", N_("|FILE|write server mode logs to FILE"),
504      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG_AGENT },
505    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
506      NULL, NULL,
507      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
508
509    { "Security",
510      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
511      "gnupg", N_("Options controlling the security") },
512    { "default-cache-ttl", GC_OPT_FLAG_RUNTIME,
513      GC_LEVEL_BASIC, "gnupg", 
514      "|N|expire cached PINs after N seconds",
515      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
516    { "default-cache-ttl-ssh", GC_OPT_FLAG_RUNTIME,
517      GC_LEVEL_ADVANCED, "gnupg",
518      N_("|N|expire SSH keys after N seconds"),
519      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
520    { "max-cache-ttl", GC_OPT_FLAG_RUNTIME,
521      GC_LEVEL_EXPERT, "gnupg",
522      N_("|N|set maximum PIN cache lifetime to N seconds"),
523      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
524    { "max-cache-ttl-ssh", GC_OPT_FLAG_RUNTIME,
525      GC_LEVEL_EXPERT, "gnupg", 
526      N_("|N|set maximum SSH key lifetime to N seconds"),
527      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
528    { "ignore-cache-for-signing", GC_OPT_FLAG_RUNTIME,
529      GC_LEVEL_BASIC, "gnupg", "do not use the PIN cache when signing",
530      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
531    { "allow-mark-trusted", GC_OPT_FLAG_RUNTIME,
532      GC_LEVEL_ADVANCED, "gnupg", "allow clients to mark keys as \"trusted\"",
533      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
534    { "no-grab", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT,
535      "gnupg", "do not grab keyboard and mouse",
536      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
537
538    { "Passphrase policy",
539      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
540      "gnupg", N_("Options enforcing a passphrase policy") },
541    { "enforce-passphrase-constraints", GC_OPT_FLAG_RUNTIME, 
542      GC_LEVEL_EXPERT, "gnupg", 
543      N_("do not allow to bypass the passphrase policy"),
544      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
545    { "min-passphrase-len", GC_OPT_FLAG_RUNTIME,
546      GC_LEVEL_ADVANCED, "gnupg", 
547      N_("|N|set minimal required length for new passphrases to N"),
548      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
549    { "min-passphrase-nonalpha", GC_OPT_FLAG_RUNTIME,
550      GC_LEVEL_EXPERT, "gnupg", 
551      N_("|N|require at least N non-alpha characters for a new passphrase"),
552      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
553    { "check-passphrase-pattern", GC_OPT_FLAG_RUNTIME,
554      GC_LEVEL_EXPERT,
555      "gnupg", N_("|FILE|check new passphrases against pattern in FILE"),
556      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG_AGENT },
557    { "max-passphrase-days", GC_OPT_FLAG_RUNTIME,
558      GC_LEVEL_EXPERT, "gnupg", 
559      N_("|N|expire the passphrase after N days"),
560      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
561    { "enable-passphrase-history", GC_OPT_FLAG_RUNTIME, 
562      GC_LEVEL_EXPERT, "gnupg", 
563      N_("do not allow the reuse of old passphrases"),
564      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
565
566    GC_OPTION_NULL
567  };
568
569
570 /* The options of the GC_COMPONENT_SCDAEMON component.  */
571 static gc_option_t gc_options_scdaemon[] =
572  {
573    /* The configuration file to which we write the changes.  */
574    { "gpgconf-scdaemon.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
575      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_SCDAEMON },
576
577    { "Monitor",
578      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
579      "gnupg", N_("Options controlling the diagnostic output") },
580    { "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
581      "gnupg", "verbose",
582      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
583    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
584      "gnupg", "be somewhat more quiet",
585      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
586    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
587      NULL, NULL,
588      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
589
590    { "Configuration",
591      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
592      "gnupg", N_("Options controlling the configuration") },
593    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
594      "gnupg", "|FILE|read options from FILE",
595      GC_ARG_TYPE_FILENAME, GC_BACKEND_SCDAEMON },
596    { "reader-port", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
597      "gnupg", "|N|connect to reader at port N",
598      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
599    { "ctapi-driver", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
600      "gnupg", "|NAME|use NAME as ct-API driver",
601      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
602    { "pcsc-driver", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
603      "gnupg", "|NAME|use NAME as PC/SC driver",
604      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
605    { "disable-ccid", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT,
606      "gnupg", "do not use the internal CCID driver",
607      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
608    { "disable-keypad", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
609      "gnupg", "do not use a reader's keypad",
610      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
611    { "card-timeout", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
612      "gnupg", "|N|disconnect the card after N seconds of inactivity",
613      GC_ARG_TYPE_UINT32, GC_BACKEND_SCDAEMON },
614
615    { "Debug",
616      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
617      "gnupg", N_("Options useful for debugging") },
618    { "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
619      "gnupg", "|LEVEL|set the debugging level to LEVEL",
620      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
621    { "log-file", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
622      "gnupg", N_("|FILE|write a log to FILE"),
623      GC_ARG_TYPE_FILENAME, GC_BACKEND_SCDAEMON },
624
625    { "Security",
626      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
627      "gnupg", N_("Options controlling the security") },
628    { "deny-admin", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
629      "gnupg", "deny the use of admin card commands",
630      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
631
632
633    GC_OPTION_NULL
634  };
635
636
637 /* The options of the GC_COMPONENT_GPG component.  */
638 static gc_option_t gc_options_gpg[] =
639  {
640    /* The configuration file to which we write the changes.  */
641    { "gpgconf-gpg.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
642      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG },
643
644    { "Monitor",
645      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
646      "gnupg", N_("Options controlling the diagnostic output") },
647    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
648      "gnupg", "verbose",
649      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
650    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
651      "gnupg", "be somewhat more quiet",
652      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
653    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
654      NULL, NULL,
655      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
656
657    { "Configuration",
658      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
659      "gnupg", N_("Options controlling the configuration") },
660    { "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
661      "gnupg", N_("|NAME|use NAME as default secret key"),
662      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
663    { "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
664      "gnupg", N_("|NAME|encrypt to user ID NAME as well"),
665      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
666    { "group", GC_OPT_FLAG_LIST, GC_LEVEL_ADVANCED,
667      "gnupg", N_("|SPEC|set up email aliases"),
668      GC_ARG_TYPE_ALIAS_LIST, GC_BACKEND_GPG },
669    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
670      "gnupg", "|FILE|read options from FILE",
671      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG },
672    { "default_pubkey_algo",
673      (GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_NO_CHANGE), GC_LEVEL_INVISIBLE,
674      NULL, NULL,
675      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
676    
677
678    { "Debug",
679      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
680      "gnupg", N_("Options useful for debugging") },
681    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
682      "gnupg", "|LEVEL|set the debugging level to LEVEL",
683      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
684    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
685      "gnupg", N_("|FILE|write server mode logs to FILE"),
686      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG },
687 /*    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE, */
688 /*      NULL, NULL, */
689 /*      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG }, */
690
691    { "Keyserver",
692      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
693      "gnupg", N_("Configuration for Keyservers") },
694    { "keyserver", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
695      "gnupg", N_("|URL|use keyserver at URL"),
696      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
697    { "allow-pka-lookup", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
698      "gnupg", N_("allow PKA lookups (DNS requests)"),
699      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
700    { "auto-key-locate", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
701      "gnupg", N_("|MECHANISMS|use MECHANISMS to locate keys by mail address"),
702      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
703
704
705
706
707    GC_OPTION_NULL
708  };
709
710
711
712 /* The options of the GC_COMPONENT_GPGSM component.  */
713 static gc_option_t gc_options_gpgsm[] =
714  {
715    /* The configuration file to which we write the changes.  */
716    { "gpgconf-gpgsm.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
717      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_GPGSM },
718
719    { "Monitor",
720      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
721      "gnupg", N_("Options controlling the diagnostic output") },
722    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
723      "gnupg", "verbose",
724      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
725    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
726      "gnupg", "be somewhat more quiet",
727      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
728    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
729      NULL, NULL,
730      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
731
732    { "Configuration",
733      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
734      "gnupg", N_("Options controlling the configuration") },
735    { "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
736      "gnupg", N_("|NAME|use NAME as default secret key"),
737      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
738    { "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
739      "gnupg", N_("|NAME|encrypt to user ID NAME as well"),
740      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
741    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
742      "gnupg", "|FILE|read options from FILE",
743      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPGSM },
744    { "prefer-system-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
745      "gnupg", "use system's dirmngr if available",
746      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
747    { "disable-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
748      "gnupg", N_("disable all access to the dirmngr"),
749      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
750    { "p12-charset", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
751      "gnupg", N_("|NAME|use encoding NAME for PKCS#12 passphrases"),
752      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
753    { "keyserver", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
754      "gnupg", N_("|SPEC|use this keyserver to lookup keys"),
755      GC_ARG_TYPE_LDAP_SERVER, GC_BACKEND_GPGSM },
756    { "default_pubkey_algo",
757      (GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_NO_CHANGE), GC_LEVEL_INVISIBLE,
758      NULL, NULL,
759      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
760
761    { "Debug",
762      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
763      "gnupg", N_("Options useful for debugging") },
764    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
765      "gnupg", "|LEVEL|set the debugging level to LEVEL",
766      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
767    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
768      "gnupg", N_("|FILE|write server mode logs to FILE"),
769      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPGSM },
770    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
771      NULL, NULL,
772      GC_ARG_TYPE_UINT32, GC_BACKEND_GPGSM },
773
774    { "Security",
775      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
776      "gnupg", N_("Options controlling the security") },
777    { "disable-crl-checks", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
778      "gnupg", "never consult a CRL",
779      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
780    { "disable-trusted-cert-crl-check", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
781      "gnupg", N_("do not check CRLs for root certificates"),
782      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
783    { "enable-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
784      "gnupg", "check validity using OCSP",
785      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
786    { "include-certs", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
787      "gnupg", "|N|number of certificates to include",
788      GC_ARG_TYPE_INT32, GC_BACKEND_GPGSM },
789    { "disable-policy-checks", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
790      "gnupg", "do not check certificate policies",
791      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
792    { "auto-issuer-key-retrieve", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
793      "gnupg", "fetch missing issuer certificates",
794      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
795    { "cipher-algo", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
796      "gnupg", "|NAME|use cipher algorithm NAME",
797      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
798
799    GC_OPTION_NULL
800  };
801
802
803 /* The options of the GC_COMPONENT_DIRMNGR component.  */
804 static gc_option_t gc_options_dirmngr[] =
805  {
806    /* The configuration file to which we write the changes.  */
807    { "gpgconf-dirmngr.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
808      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
809
810    { "Monitor",
811      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
812      "gnupg", N_("Options controlling the diagnostic output") },
813    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
814      "dirmngr", "verbose",
815      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
816    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
817      "dirmngr", "be somewhat more quiet",
818      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
819    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
820      NULL, NULL,
821      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
822
823    { "Format",
824      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
825      "gnupg", N_("Options controlling the format of the output") },
826    { "sh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
827      "dirmngr", "sh-style command output",
828      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
829    { "csh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
830      "dirmngr", "csh-style command output",
831      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
832    
833    { "Configuration",
834      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
835      "gnupg", N_("Options controlling the configuration") },
836    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
837      "dirmngr", "|FILE|read options from FILE",
838      GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
839
840    { "Debug",
841      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
842      "gnupg", N_("Options useful for debugging") },
843    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
844      "dirmngr", "|LEVEL|set the debugging level to LEVEL",
845      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
846    { "no-detach", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
847      "dirmngr", "do not detach from the console",
848      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
849    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
850      "dirmngr", N_("|FILE|write server mode logs to FILE"),
851      GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
852    { "debug-wait", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
853      NULL, NULL,
854      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
855    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
856      NULL, NULL,
857      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
858
859    { "Enforcement",
860      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
861      "gnupg", N_("Options controlling the interactivity and enforcement") },
862    { "batch", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
863      "dirmngr", "run without asking a user",
864      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
865    { "force", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
866      "dirmngr", "force loading of outdated CRLs",
867      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
868
869    { "HTTP",
870      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
871      "gnupg", N_("Configuration for HTTP servers") },
872    { "disable-http", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
873      "dirmngr", "inhibit the use of HTTP",
874       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
875    { "ignore-http-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
876      "dirmngr", "ignore HTTP CRL distribution points",
877       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
878    { "http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
879      "dirmngr", "|URL|redirect all HTTP requests to URL",
880      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
881    { "honor-http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
882      "gnupg", N_("use system's HTTP proxy setting"),
883      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
884
885    { "LDAP",
886      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
887      "gnupg", N_("Configuration of LDAP servers to use") },
888    { "disable-ldap", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
889      "dirmngr", "inhibit the use of LDAP",
890       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
891    { "ignore-ldap-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
892      "dirmngr", "ignore LDAP CRL distribution points",
893       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
894    { "ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
895      "dirmngr", "|HOST|use HOST for LDAP queries",
896      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
897    { "only-ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
898      "dirmngr", "do not use fallback hosts with --ldap-proxy",
899       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
900    { "add-servers", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
901      "dirmngr", "add new servers discovered in CRL distribution points"
902      " to serverlist", GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
903    { "ldaptimeout", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
904      "dirmngr", "|N|set LDAP timeout to N seconds",
905      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
906    /* The following entry must not be removed, as it is required for
907       the GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST.  */
908    { "ldapserverlist-file",
909      GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
910      "dirmngr", "|FILE|read LDAP server list from FILE",
911      GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
912    /* This entry must come after at least one entry for
913       GC_BACKEND_DIRMNGR in this component, so that the entry for
914       "ldapserverlist-file will be initialized before this one.  */
915    { "LDAP Server", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
916      "gnupg", N_("LDAP server list"),
917      GC_ARG_TYPE_LDAP_SERVER, GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST },
918    { "max-replies", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
919      "dirmngr", "|N|do not return more than N items in one query",
920      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
921
922    { "OCSP",
923      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
924      "gnupg", N_("Configuration for OCSP") },
925    { "allow-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
926      "dirmngr", "allow sending OCSP requests",
927      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
928    { "ignore-ocsp-service-url", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
929      "dirmngr", "ignore certificate contained OCSP service URLs",
930       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
931    { "ocsp-responder", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
932      "dirmngr", "|URL|use OCSP responder at URL",
933      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
934    { "ocsp-signer", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
935      "dirmngr", "|FPR|OCSP response signed by FPR",
936      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
937
938
939    GC_OPTION_NULL
940  };
941
942 \f
943 /* Component system.  Each component is a set of options that can be
944    configured at the same time.  If you change this, don't forget to
945    update GC_COMPONENT below.  */
946 typedef enum
947   {
948     /* The classic GPG for OpenPGP.  */
949     GC_COMPONENT_GPG,
950
951     /* The GPG Agent.  */
952     GC_COMPONENT_GPG_AGENT,
953
954     /* The Smardcard Daemon.  */
955     GC_COMPONENT_SCDAEMON,
956
957     /* GPG for S/MIME.  */
958     GC_COMPONENT_GPGSM,
959
960     /* The LDAP Directory Manager for CRLs.  */
961     GC_COMPONENT_DIRMNGR,
962
963     /* The number of components.  */
964     GC_COMPONENT_NR
965   } gc_component_t;
966
967
968 /* The information associated with each component.  */
969 static struct
970 {
971   /* The name of this component.  Must not contain a colon (':')
972      character.  */
973   const char *name;
974
975   /* The gettext domain for the description DESC.  If this is NULL,
976      then the description is not translated.  */
977   const char *desc_domain;
978
979   /* The description for this domain.  */
980   const char *desc;
981
982   /* The list of options for this component, terminated by
983      GC_OPTION_NULL.  */
984   gc_option_t *options;
985 } gc_component[] =
986   {
987     { "gpg", NULL,   "GPG for OpenPGP", gc_options_gpg },
988     { "gpg-agent", NULL, "GPG Agent", gc_options_gpg_agent },
989     { "scdaemon", NULL, "Smartcard Daemon", gc_options_scdaemon },
990     { "gpgsm", NULL, "GPG for S/MIME", gc_options_gpgsm },
991     { "dirmngr", NULL, "Directory Manager", gc_options_dirmngr }
992   };
993
994
995
996 /* Structure used to collect error output of the backend programs.  */
997 struct error_line_s;
998 typedef struct error_line_s *error_line_t;
999 struct error_line_s
1000 {
1001   error_line_t next;   /* Link to next item.  */
1002   const char *fname;   /* Name of the config file (points into BUFFER).  */
1003   unsigned int lineno; /* Line number of the config file.  */
1004   const char *errtext; /* Text of the error message (points into BUFFER).  */
1005   char buffer[1];  /* Helper buffer.  */
1006 };
1007
1008
1009 \f
1010 /* Engine specific support.  */
1011 static void
1012 gpg_agent_runtime_change (void)
1013 {
1014 #ifndef HAVE_W32_SYSTEM
1015   char *agent = getenv ("GPG_AGENT_INFO");
1016   char *pid_str;
1017   unsigned long pid_long;
1018   char *tail;
1019   pid_t pid;
1020
1021   if (!agent)
1022     return;
1023
1024   pid_str = strchr (agent, ':');
1025   if (!pid_str)
1026     return;
1027
1028   pid_str++;
1029   errno = 0;
1030   pid_long = strtoul (pid_str, &tail, 0);
1031   if (errno || (*tail != ':' && *tail != '\0'))
1032     return;
1033
1034   pid = (pid_t) pid_long;
1035
1036   /* Check for overflow.  */
1037   if (pid_long != (unsigned long) pid)
1038     return;
1039
1040   /* Ignore any errors here.  */
1041   kill (pid, SIGHUP);
1042 #else
1043   gpg_error_t err;
1044   const char *pgmname;
1045   const char *argv[2];
1046   pid_t pid;
1047   
1048   pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1049   argv[0] = "reloadagent";
1050   argv[1] = NULL;
1051   
1052   err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1053   if (!err)
1054     err = gnupg_wait_process (pgmname, pid, 0, NULL);
1055   if (err)
1056     gc_error (0, 0, "error running `%s%s': %s",
1057               pgmname, " reloadagent", gpg_strerror (err));
1058   gnupg_release_process (pid);
1059 #endif /*!HAVE_W32_SYSTEM*/
1060 }
1061
1062
1063 static void
1064 scdaemon_runtime_change (void)
1065 {
1066   gpg_error_t err;
1067   const char *pgmname;
1068   const char *argv[6];
1069   pid_t pid;
1070   
1071   /* We use "GETINFO app_running" to see whether the agent is already
1072      running and kill it only in this case.  This avoids an explicit
1073      starting of the agent in case it is not yet running.  There is
1074      obviously a race condition but that should not harm too much.  */
1075
1076   pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1077   argv[0] = "-s";
1078   argv[1] = "GETINFO scd_running";
1079   argv[2] = "/if ${! $?}";
1080   argv[3] = "scd killscd";
1081   argv[4] = "/end";
1082   argv[5] = NULL;
1083   
1084   err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1085   if (!err)
1086     err = gnupg_wait_process (pgmname, pid, 0, NULL);
1087   if (err)
1088     gc_error (0, 0, "error running `%s%s': %s",
1089               pgmname, " scd killscd", gpg_strerror (err));
1090   gnupg_release_process (pid);
1091 }
1092
1093
1094 /* Unconditionally reload COMPONENT or all components if COMPONENT is -1.  */
1095 void
1096 gc_component_reload (int component)
1097 {
1098   int runtime[GC_BACKEND_NR];
1099   gc_option_t *option;
1100   gc_backend_t backend;
1101
1102   /* Set a flag for the backends to be reloaded.  */
1103   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1104     runtime[backend] = 0;
1105   
1106   if (component == -1)
1107     {
1108       for (component = 0; component < GC_COMPONENT_NR; component++)
1109         {
1110           option = gc_component[component].options;
1111           for (; option && option->name; option++)
1112             runtime[option->backend] = 1;
1113         }
1114     }
1115   else
1116     {
1117       assert (component < GC_COMPONENT_NR);
1118       option = gc_component[component].options;
1119       for (; option && option->name; option++)
1120         runtime[option->backend] = 1;
1121     }
1122
1123   /* Do the reload for all selected backends.  */
1124   for (backend = 0; backend < GC_BACKEND_NR; backend++)  
1125     {
1126       if (runtime[backend] && gc_backend[backend].runtime_change)
1127         (*gc_backend[backend].runtime_change) ();
1128     }
1129 }
1130
1131
1132 \f
1133 /* More or less Robust version of dgettext.  It has the side effect of
1134    switching the codeset to utf-8 because this is what we want to
1135    output.  In theory it is posible to keep the orginal code set and
1136    switch back for regular disgnostic output (redefine "_(" for that)
1137    but given the natur of this tool, being something invoked from
1138    other pograms, it does not make much sense.  */
1139 static const char *
1140 my_dgettext (const char *domain, const char *msgid)
1141 {
1142 #ifdef USE_SIMPLE_GETTEXT
1143   if (domain)
1144     {
1145       static int switched_codeset;
1146       char *text;
1147       
1148       if (!switched_codeset)
1149         {
1150           switched_codeset = 1;
1151           gettext_use_utf8 (1);
1152         }
1153
1154       if (!strcmp (domain, "gnupg"))
1155         domain = PACKAGE_GT;
1156
1157       /* FIXME: we have no dgettext, thus we can't switch.  */
1158
1159       text = (char*)gettext (msgid);
1160       return text ? text : msgid;
1161     }
1162 #elif defined(ENABLE_NLS)
1163   if (domain)
1164     {
1165       static int switched_codeset;
1166       char *text;
1167       
1168       if (!switched_codeset)
1169         {
1170           switched_codeset = 1;
1171           bind_textdomain_codeset (PACKAGE_GT, "utf-8");
1172
1173           bindtextdomain ("dirmngr", LOCALEDIR);
1174           bind_textdomain_codeset ("dirmngr", "utf-8");
1175    
1176         }
1177
1178       /* Note: This is a hack to actually use the gnupg2 domain as
1179          long we are in a transition phase where gnupg 1.x and 1.9 may
1180          coexist. */
1181       if (!strcmp (domain, "gnupg"))
1182         domain = PACKAGE_GT;
1183
1184       text = dgettext (domain, msgid);
1185       return text ? text : msgid;
1186     }
1187   else
1188 #endif
1189     return msgid;
1190 }
1191
1192
1193 /* Percent-Escape special characters.  The string is valid until the
1194    next invocation of the function.  */
1195 char *
1196 gc_percent_escape (const char *src)
1197 {
1198   static char *esc_str;
1199   static int esc_str_len;
1200   int new_len = 3 * strlen (src) + 1;
1201   char *dst;
1202
1203   if (esc_str_len < new_len)
1204     {
1205       char *new_esc_str = realloc (esc_str, new_len);
1206       if (!new_esc_str)
1207         gc_error (1, errno, "can not escape string");
1208       esc_str = new_esc_str;
1209       esc_str_len = new_len;
1210     }
1211
1212   dst = esc_str;
1213   while (*src)
1214     {
1215       if (*src == '%')
1216         {
1217           *(dst++) = '%';
1218           *(dst++) = '2';
1219           *(dst++) = '5';
1220         }         
1221       else if (*src == ':')
1222         {
1223           /* The colon is used as field separator.  */
1224           *(dst++) = '%';
1225           *(dst++) = '3';
1226           *(dst++) = 'a';
1227         }
1228       else if (*src == ',')
1229         {
1230           /* The comma is used as list separator.  */
1231           *(dst++) = '%';
1232           *(dst++) = '2';
1233           *(dst++) = 'c';
1234         }
1235       else
1236         *(dst++) = *(src);
1237       src++;
1238     }
1239   *dst = '\0';
1240   return esc_str;
1241 }
1242
1243
1244
1245 /* Percent-Deescape special characters.  The string is valid until the
1246    next invocation of the function.  */
1247 static char *
1248 percent_deescape (const char *src)
1249 {
1250   static char *str;
1251   static int str_len;
1252   int new_len = 3 * strlen (src) + 1;
1253   char *dst;
1254
1255   if (str_len < new_len)
1256     {
1257       char *new_str = realloc (str, new_len);
1258       if (!new_str)
1259         gc_error (1, errno, "can not deescape string");
1260       str = new_str;
1261       str_len = new_len;
1262     }
1263
1264   dst = str;
1265   while (*src)
1266     {
1267       if (*src == '%')
1268         {
1269           int val = hextobyte (src + 1);
1270
1271           if (val < 0)
1272             gc_error (1, 0, "malformed end of string %s", src);
1273
1274           *(dst++) = (char) val;
1275           src += 3;
1276         }         
1277       else
1278         *(dst++) = *(src++);
1279     }
1280   *dst = '\0';
1281   return str;
1282 }
1283
1284 \f
1285 /* List all components that are available.  */
1286 void
1287 gc_component_list_components (FILE *out)
1288 {
1289   gc_component_t component;
1290   gc_option_t *option;
1291   gc_backend_t backend;
1292   int backend_seen[GC_BACKEND_NR];
1293   const char *desc;
1294   const char *pgmname;
1295
1296   for (component = 0; component < GC_COMPONENT_NR; component++)
1297     {
1298       option = gc_component[component].options;
1299       if (option)
1300         {
1301           for (backend = 0; backend < GC_BACKEND_NR; backend++)
1302             backend_seen[backend] = 0;
1303
1304           pgmname = "";
1305           for (; option && option->name; option++)
1306             {
1307               if ((option->flags & GC_OPT_FLAG_GROUP))
1308                 continue;
1309               backend = option->backend;
1310               if (backend_seen[backend])
1311                 continue;
1312               backend_seen[backend] = 1;
1313               assert (backend != GC_BACKEND_ANY);
1314               if (gc_backend[backend].program
1315                   && !gc_backend[backend].module_name)
1316                 continue;
1317               pgmname = gnupg_module_name (gc_backend[backend].module_name);
1318               break;
1319             }
1320
1321           desc = gc_component[component].desc;
1322           desc = my_dgettext (gc_component[component].desc_domain, desc);
1323           fprintf (out, "%s:%s:",
1324                    gc_component[component].name,  gc_percent_escape (desc));
1325           fprintf (out, "%s\n",  gc_percent_escape (pgmname));
1326         }
1327     }
1328 }
1329
1330
1331 \f
1332 static int
1333 all_digits_p (const char *p, size_t len)
1334 {
1335   if (!len)
1336     return 0; /* No. */
1337   for (; len; len--, p++)
1338     if (!isascii (*p) || !isdigit (*p))
1339       return 0; /* No.  */
1340   return 1; /* Yes.  */
1341 }
1342
1343
1344 /* Collect all error lines from file descriptor FD. Only lines
1345    prefixed with TAG are considered.  Close that file descriptor
1346    then.  Returns a list of error line items (which may be empty).
1347    There is no error return.  */
1348 static error_line_t
1349 collect_error_output (int fd, const char *tag)
1350 {
1351   FILE *fp;
1352   char buffer[1024];
1353   char *p, *p2, *p3;
1354   int c, cont_line;
1355   unsigned int pos;
1356   error_line_t eitem, errlines, *errlines_tail;
1357   size_t taglen = strlen (tag);
1358
1359   fp = fdopen (fd, "r");
1360   if (!fp)
1361     gc_error (1, errno, "can't fdopen pipe for reading");
1362
1363   errlines = NULL;
1364   errlines_tail = &errlines;
1365   pos = 0;
1366   cont_line = 0;
1367   while ((c=getc (fp)) != EOF)
1368     {
1369       buffer[pos++] = c;
1370       if (pos >= sizeof buffer - 5 || c == '\n')
1371         {
1372           buffer[pos - (c == '\n')] = 0;
1373           if (cont_line)
1374             ; /*Ignore continuations of previous line. */
1375           else if (!strncmp (buffer, tag, taglen) && buffer[taglen] == ':') 
1376             {
1377               /* "gpgsm: foo:4: bla" */
1378               /* Yep, we are interested in this line.  */
1379               p = buffer + taglen + 1;
1380               while (*p == ' ' || *p == '\t')
1381                 p++;
1382               if (!*p)
1383                 ; /* Empty lines are ignored.  */
1384               else if ( (p2 = strchr (p, ':')) && (p3 = strchr (p2+1, ':'))
1385                         && all_digits_p (p2+1, p3 - (p2+1)))
1386                 {
1387                   /* Line in standard compiler format.  */
1388                   p3++;
1389                   while (*p3 == ' ' || *p3 == '\t')
1390                     p3++;
1391                   eitem = xmalloc (sizeof *eitem + strlen (p));
1392                   eitem->next = NULL;
1393                   strcpy (eitem->buffer, p);
1394                   eitem->fname = eitem->buffer;
1395                   eitem->buffer[p2-p] = 0;
1396                   eitem->errtext = eitem->buffer + (p3 - p);
1397                   /* (we already checked that there are only ascii
1398                      digits followed by a colon) */
1399                   eitem->lineno = 0;
1400                   for (p2++; isdigit (*p2); p2++)
1401                     eitem->lineno = eitem->lineno*10 + (*p2 - '0');
1402                   *errlines_tail = eitem;
1403                   errlines_tail = &eitem->next;
1404                 }
1405               else
1406                 {
1407                   /* Other error output.  */
1408                   eitem = xmalloc (sizeof *eitem + strlen (p));
1409                   eitem->next = NULL;
1410                   strcpy (eitem->buffer, p);
1411                   eitem->fname = NULL;
1412                   eitem->errtext = eitem->buffer;
1413                   eitem->lineno = 0;
1414                   *errlines_tail = eitem;
1415                   errlines_tail = &eitem->next;
1416                 }
1417             }
1418           pos = 0;
1419           /* If this was not a complete line mark that we are in a
1420              continuation.  */
1421           cont_line = (c != '\n');
1422         }
1423     }
1424   
1425   /* We ignore error lines not terminated by a LF.  */
1426
1427   fclose (fp);
1428   return errlines;
1429 }
1430
1431
1432 /* Check the options of a single component.  Returns 0 if everything
1433    is OK.  */
1434 int
1435 gc_component_check_options (int component, FILE *out, const char *conf_file)
1436 {
1437   gpg_error_t err;
1438   unsigned int result;
1439   int backend_seen[GC_BACKEND_NR];
1440   gc_backend_t backend;
1441   gc_option_t *option;
1442   const char *pgmname;
1443   const char *argv[4];
1444   int i;
1445   pid_t pid;
1446   int exitcode;
1447   int filedes[2];
1448   error_line_t errlines;
1449
1450   /* We use a temporary file to collect the error output.  It would be
1451      better to use a pipe here but as of now we have no suitable
1452      fucntion to create a portable pipe outside of exechelp.  Thus it
1453      is easier to use the tempfile approach.  */
1454
1455   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1456     backend_seen[backend] = 0;
1457
1458   option = gc_component[component].options;
1459   for (; option && option->name; option++)
1460     {
1461       if ((option->flags & GC_OPT_FLAG_GROUP))
1462         continue;
1463       backend = option->backend;
1464       if (backend_seen[backend])
1465         continue;
1466       backend_seen[backend] = 1;
1467       assert (backend != GC_BACKEND_ANY);
1468       if (!gc_backend[backend].program)
1469         continue;
1470       if (!gc_backend[backend].module_name)
1471         continue;
1472
1473       break;
1474     }
1475   if (! option || ! option->name)
1476     return 0;
1477
1478   pgmname = gnupg_module_name (gc_backend[backend].module_name);
1479   i = 0;
1480   if (conf_file)
1481     {
1482       argv[i++] = "--options";
1483       argv[i++] = conf_file;
1484     }
1485   argv[i++] = "--gpgconf-test";
1486   argv[i++] = NULL;
1487   
1488   err = gnupg_create_inbound_pipe (filedes);
1489   if (err)
1490     gc_error (1, 0, _("error creating a pipe: %s\n"), 
1491               gpg_strerror (err));
1492   
1493   result = 0;
1494   errlines = NULL;
1495   if (gnupg_spawn_process_fd (pgmname, argv, -1, -1, filedes[1], &pid))
1496     {
1497       close (filedes[0]);
1498       close (filedes[1]);
1499       result |= 1; /* Program could not be run.  */
1500     }
1501   else 
1502     {
1503       close (filedes[1]);
1504       errlines = collect_error_output (filedes[0], 
1505                                        gc_component[component].name);
1506       if (gnupg_wait_process (pgmname, pid, 0, &exitcode))
1507         {
1508           if (exitcode == -1)
1509             result |= 1; /* Program could not be run or it
1510                             terminated abnormally.  */
1511           result |= 2; /* Program returned an error.  */
1512         }
1513       gnupg_release_process (pid);
1514     }
1515   
1516   /* If the program could not be run, we can't tell whether
1517      the config file is good.  */
1518   if (result & 1)
1519     result |= 2;  
1520   
1521   if (out)
1522     {
1523       const char *desc;
1524       error_line_t errptr;
1525
1526       desc = gc_component[component].desc;
1527       desc = my_dgettext (gc_component[component].desc_domain, desc);
1528       fprintf (out, "%s:%s:",
1529                gc_component[component].name, gc_percent_escape (desc));
1530       fputs (gc_percent_escape (pgmname), out);
1531       fprintf (out, ":%d:%d:", !(result & 1), !(result & 2));
1532       for (errptr = errlines; errptr; errptr = errptr->next)
1533         {
1534           if (errptr != errlines)
1535             fputs ("\n:::::", out); /* Continuation line.  */
1536           if (errptr->fname)
1537             fputs (gc_percent_escape (errptr->fname), out);
1538           putc (':', out);
1539           if (errptr->fname)
1540             fprintf (out, "%u", errptr->lineno);
1541           putc (':', out);
1542           fputs (gc_percent_escape (errptr->errtext), out);
1543           putc (':', out);
1544         }
1545       putc ('\n', out);
1546     }
1547
1548   while (errlines)
1549     {
1550       error_line_t tmp = errlines->next;
1551       xfree (errlines);
1552       errlines = tmp;
1553     }
1554
1555   return result;
1556 }
1557
1558
1559 /* Check all components that are available.  */
1560 void
1561 gc_check_programs (FILE *out)
1562 {
1563   gc_component_t component;
1564
1565   for (component = 0; component < GC_COMPONENT_NR; component++)
1566     gc_component_check_options (component, out, NULL);
1567 }
1568
1569
1570 \f
1571 /* Find the component with the name NAME.  Returns -1 if not
1572    found.  */
1573 int
1574 gc_component_find (const char *name)
1575 {
1576   gc_component_t idx;
1577
1578   for (idx = 0; idx < GC_COMPONENT_NR; idx++)
1579     {
1580       if (gc_component[idx].options
1581           && !strcmp (name, gc_component[idx].name))
1582         return idx;
1583     }
1584   return -1;
1585 }
1586
1587 \f
1588 /* List the option OPTION.  */
1589 static void
1590 list_one_option (const gc_option_t *option, FILE *out)
1591 {
1592   const char *desc = NULL;
1593   char *arg_name = NULL;
1594
1595   if (option->desc)
1596     {
1597       desc = my_dgettext (option->desc_domain, option->desc);
1598
1599       if (*desc == '|')
1600         {
1601           const char *arg_tail = strchr (&desc[1], '|');
1602
1603           if (arg_tail)
1604             {
1605               int arg_len = arg_tail - &desc[1];
1606               arg_name = xmalloc (arg_len + 1);
1607               memcpy (arg_name, &desc[1], arg_len);
1608               arg_name[arg_len] = '\0';
1609               desc = arg_tail + 1;
1610             }
1611         }
1612     }
1613
1614
1615   /* YOU MUST NOT REORDER THE FIELDS IN THIS OUTPUT, AS THEIR ORDER IS
1616      PART OF THE EXTERNAL INTERFACE.  YOU MUST NOT REMOVE ANY
1617      FIELDS.  */
1618
1619   /* The name field.  */
1620   fprintf (out, "%s", option->name);
1621
1622   /* The flags field.  */
1623   fprintf (out, ":%lu", option->flags);
1624   if (opt.verbose)
1625     {
1626       putc (' ', out);
1627           
1628       if (!option->flags)
1629         fprintf (out, "none");
1630       else
1631         {
1632           unsigned long flags = option->flags;
1633           unsigned long flag = 0;
1634           unsigned long first = 1;
1635
1636           while (flags)
1637             {
1638               if (flags & 1)
1639                 {
1640                   if (first)
1641                     first = 0;
1642                   else
1643                     putc (',', out);
1644                   fprintf (out, "%s", gc_flag[flag].name);
1645                 }
1646               flags >>= 1;
1647               flag++;
1648             }
1649         }
1650     }
1651
1652   /* The level field.  */
1653   fprintf (out, ":%u", option->level);
1654   if (opt.verbose)
1655     fprintf (out, " %s", gc_level[option->level].name);
1656
1657   /* The description field.  */
1658   fprintf (out, ":%s", desc ? gc_percent_escape (desc) : "");
1659   
1660   /* The type field.  */
1661   fprintf (out, ":%u", option->arg_type);
1662   if (opt.verbose)
1663     fprintf (out, " %s", gc_arg_type[option->arg_type].name);
1664
1665   /* The alternate type field.  */
1666   fprintf (out, ":%u", gc_arg_type[option->arg_type].fallback);
1667   if (opt.verbose)
1668     fprintf (out, " %s",
1669              gc_arg_type[gc_arg_type[option->arg_type].fallback].name);
1670
1671   /* The argument name field.  */
1672   fprintf (out, ":%s", arg_name ? gc_percent_escape (arg_name) : "");
1673   if (arg_name)
1674     xfree (arg_name);
1675
1676   /* The default value field.  */
1677   fprintf (out, ":%s", option->default_value ? option->default_value : "");
1678
1679   /* The default argument field.  */
1680   fprintf (out, ":%s", option->default_arg ? option->default_arg : "");
1681
1682   /* The value field.  */
1683   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
1684       && (option->flags & GC_OPT_FLAG_LIST)
1685       && option->value)
1686     /* The special format "1,1,1,1,...,1" is converted to a number
1687        here.  */
1688     fprintf (out, ":%u", (unsigned int)((strlen (option->value) + 1) / 2));
1689   else
1690     fprintf (out, ":%s", option->value ? option->value : "");
1691
1692   /* ADD NEW FIELDS HERE.  */
1693
1694   putc ('\n', out);
1695 }
1696
1697
1698 /* List all options of the component COMPONENT.  */
1699 void
1700 gc_component_list_options (int component, FILE *out)
1701 {  
1702   const gc_option_t *option = gc_component[component].options;
1703
1704   while (option && option->name)
1705     {
1706       /* Do not output unknown or internal options.  */
1707       if (!(option->flags & GC_OPT_FLAG_GROUP)
1708           && (!option->active || option->level == GC_LEVEL_INTERNAL))
1709         {
1710           option++;
1711           continue;
1712         }
1713
1714       if (option->flags & GC_OPT_FLAG_GROUP)
1715         {
1716           const gc_option_t *group_option = option + 1;
1717           gc_expert_level_t level = GC_LEVEL_NR;
1718
1719           /* The manual states that the group level is always the
1720              minimum of the levels of all contained options.  Due to
1721              different active options, and because it is hard to
1722              maintain manually, we calculate it here.  The value in
1723              the global static table is ignored.  */
1724           
1725           while (group_option->name)
1726             {
1727               if (group_option->flags & GC_OPT_FLAG_GROUP)
1728                 break;
1729               if (group_option->level < level)
1730                 level = group_option->level;
1731               group_option++;
1732             }
1733
1734           /* Check if group is empty.  */
1735           if (level != GC_LEVEL_NR)
1736             {
1737               gc_option_t opt_copy;
1738
1739               /* Fix up the group level.  */
1740               memcpy (&opt_copy, option, sizeof (opt_copy));
1741               opt_copy.level = level;
1742               list_one_option (&opt_copy, out);
1743             }
1744         }
1745       else
1746         list_one_option (option, out);
1747
1748       option++;
1749     }
1750 }
1751
1752
1753 /* Find the option NAME in component COMPONENT, for the backend
1754    BACKEND.  If BACKEND is GC_BACKEND_ANY, any backend will match.  */
1755 static gc_option_t *
1756 find_option (gc_component_t component, const char *name,
1757              gc_backend_t backend)
1758 {
1759   gc_option_t *option = gc_component[component].options;
1760   while (option->name)
1761     {
1762       if (!(option->flags & GC_OPT_FLAG_GROUP)
1763           && !strcmp (option->name, name)
1764           && (backend == GC_BACKEND_ANY || option->backend == backend))
1765         break;
1766       option++;
1767     }
1768   return option->name ? option : NULL;
1769 }
1770
1771 \f
1772 /* Determine the configuration filename for the component COMPONENT
1773    and backend BACKEND.  */
1774 static char *
1775 get_config_filename (gc_component_t component, gc_backend_t backend)
1776 {
1777   char *filename = NULL;
1778   gc_option_t *option = find_option
1779     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
1780   assert (option);
1781   assert (option->arg_type == GC_ARG_TYPE_FILENAME);
1782   assert (!(option->flags & GC_OPT_FLAG_LIST));
1783
1784   if (!option->active || !option->default_value)
1785     gc_error (1, 0, "Option %s, needed by backend %s, was not initialized",
1786               gc_backend[backend].option_config_filename,
1787               gc_backend[backend].name);
1788
1789   if (option->value && *option->value)
1790     filename = percent_deescape (&option->value[1]);
1791   else if (option->default_value && *option->default_value)
1792     filename = percent_deescape (&option->default_value[1]);
1793   else
1794     filename = "";
1795
1796 #ifdef HAVE_DOSISH_SYSTEM
1797   if (!(filename[0] 
1798         && filename[1] == ':'
1799         && (filename[2] == '/' || filename[2] == '\\')))
1800 #else
1801   if (filename[0] != '/')
1802 #endif
1803     gc_error (1, 0, "Option %s, needed by backend %s, is not absolute",
1804               gc_backend[backend].option_config_filename,
1805               gc_backend[backend].name);
1806
1807   return filename;
1808 }
1809
1810 \f
1811 /* Retrieve the options for the component COMPONENT from backend
1812    BACKEND, which we already know is a program-type backend.  */
1813 static void
1814 retrieve_options_from_program (gc_component_t component, gc_backend_t backend)
1815 {
1816   gpg_error_t err;
1817   int filedes[2];
1818   const char *pgmname;
1819   const char *argv[2];
1820   int exitcode;
1821   pid_t pid;
1822   char *line = NULL;
1823   size_t line_len = 0;
1824   ssize_t length;
1825   FILE *config;
1826   char *config_filename;
1827
1828   err = gnupg_create_inbound_pipe (filedes);
1829   if (err)
1830     gc_error (1, 0, _("error creating a pipe: %s\n"), gpg_strerror (err));
1831
1832   pgmname = (gc_backend[backend].module_name 
1833              ? gnupg_module_name (gc_backend[backend].module_name) 
1834              : gc_backend[backend].program );
1835   argv[0] = "--gpgconf-list";
1836   argv[1] = NULL;
1837
1838   err = gnupg_spawn_process_fd (pgmname, argv, -1, filedes[1], -1, &pid);
1839   if (err)
1840     {
1841       close (filedes[0]);
1842       close (filedes[1]);
1843       gc_error (1, 0, "could not gather active options from `%s': %s",
1844                 pgmname, gpg_strerror (err));
1845     }
1846   close (filedes[1]);
1847   config = fdopen (filedes[0], "r");
1848   if (!config)
1849     gc_error (1, errno, "can't fdopen pipe for reading");
1850
1851   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1852     {
1853       gc_option_t *option;
1854       char *linep;
1855       unsigned long flags = 0;
1856       char *default_value = NULL;
1857       
1858       /* Strip newline and carriage return, if present.  */
1859       while (length > 0
1860              && (line[length - 1] == '\n' || line[length - 1] == '\r'))
1861         line[--length] = '\0';
1862
1863       linep = strchr (line, ':');
1864       if (linep)
1865         *(linep++) = '\0';
1866       
1867       /* Extract additional flags.  Default to none.  */
1868       if (linep)
1869         {
1870           char *end;
1871           char *tail;
1872
1873           end = strchr (linep, ':');
1874           if (end)
1875             *(end++) = '\0';
1876
1877           gpg_err_set_errno (0);
1878           flags = strtoul (linep, &tail, 0);
1879           if (errno)
1880             gc_error (1, errno, "malformed flags in option %s from %s",
1881                       line, pgmname);
1882           if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
1883             gc_error (1, 0, "garbage after flags in option %s from %s",
1884                       line, pgmname);
1885
1886           linep = end;
1887         }
1888
1889       /* Extract default value, if present.  Default to empty if
1890          not.  */
1891       if (linep)
1892         {
1893           char *end;
1894
1895           end = strchr (linep, ':');
1896           if (end)
1897             *(end++) = '\0';
1898
1899           if (flags & GC_OPT_FLAG_DEFAULT)
1900             default_value = linep;
1901
1902           linep = end;
1903         }
1904
1905       /* Look up the option in the component and install the
1906          configuration data.  */
1907       option = find_option (component, line, backend);
1908       if (option)
1909         {
1910           if (option->active)
1911             gc_error (1, errno, "option %s returned twice from %s",
1912                       line, pgmname);
1913           option->active = 1;
1914
1915           option->flags |= flags;
1916           if (default_value && *default_value)
1917             option->default_value = xstrdup (default_value);
1918         }
1919     }
1920   if (length < 0 || ferror (config))
1921     gc_error (1, errno, "error reading from %s",pgmname);
1922   if (fclose (config) && ferror (config))
1923     gc_error (1, errno, "error closing %s", pgmname);
1924
1925   err = gnupg_wait_process (pgmname, pid, 0, &exitcode);
1926   if (err)
1927     gc_error (1, 0, "running %s failed (exitcode=%d): %s",
1928               pgmname, exitcode, gpg_strerror (err));
1929   gnupg_release_process (pid);
1930
1931
1932   /* At this point, we can parse the configuration file.  */
1933   config_filename = get_config_filename (component, backend);
1934
1935   config = fopen (config_filename, "r");
1936   if (!config)
1937     gc_error (0, errno, "warning: can not open config file %s",
1938               config_filename);
1939   else
1940     {
1941       while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1942         {
1943           char *name;
1944           char *value;
1945           gc_option_t *option;
1946           
1947           name = line;
1948           while (*name == ' ' || *name == '\t')
1949             name++;
1950           if (!*name || *name == '#' || *name == '\r' || *name == '\n')
1951             continue;
1952
1953           value = name;
1954           while (*value && *value != ' ' && *value != '\t'
1955                  && *value != '#' && *value != '\r' && *value != '\n')
1956             value++;
1957           if (*value == ' ' || *value == '\t')
1958             {
1959               char *end;
1960
1961               *(value++) = '\0';
1962               while (*value == ' ' || *value == '\t')
1963                 value++;
1964
1965               end = value;
1966               while (*end && *end != '#' && *end != '\r' && *end != '\n')
1967                 end++;
1968               while (end > value && (end[-1] == ' ' || end[-1] == '\t'))
1969                 end--;
1970               *end = '\0';
1971             }
1972           else
1973             *value = '\0';
1974
1975           /* Look up the option in the component and install the
1976              configuration data.  */
1977           option = find_option (component, line, backend);
1978           if (option)
1979             {
1980               char *opt_value;
1981
1982               if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
1983                 {
1984                   if (*value)
1985                     gc_error (0, 0,
1986                               "warning: ignoring argument %s for option %s",
1987                               value, name);
1988                   opt_value = xstrdup ("1");
1989                 }
1990               else if (gc_arg_type[option->arg_type].fallback
1991                        == GC_ARG_TYPE_STRING)
1992                 opt_value = xasprintf ("\"%s", gc_percent_escape (value));
1993               else
1994                 {
1995                   /* FIXME: Verify that the number is sane.  */
1996                   opt_value = xstrdup (value);
1997                 }
1998
1999               /* Now enter the option into the table.  */
2000               if (!(option->flags & GC_OPT_FLAG_LIST))
2001                 {
2002                   if (option->value)
2003                     free (option->value);
2004                   option->value = opt_value;
2005                 }
2006               else
2007                 {
2008                   if (!option->value)
2009                     option->value = opt_value;
2010                   else
2011                     {
2012                       char *opt_val = opt_value;
2013
2014                       option->value = xasprintf ("%s,%s", option->value,
2015                                                  opt_val);
2016                       xfree (opt_value);
2017                     }
2018                 }
2019             }
2020         }
2021
2022       if (length < 0 || ferror (config))
2023         gc_error (1, errno, "error reading from %s", config_filename);
2024       if (fclose (config) && ferror (config))
2025         gc_error (1, errno, "error closing %s", config_filename);
2026     }
2027
2028   xfree (line);
2029 }
2030
2031
2032 /* Retrieve the options for the component COMPONENT from backend
2033    BACKEND, which we already know is of type file list.  */ 
2034 static void
2035 retrieve_options_from_file (gc_component_t component, gc_backend_t backend)
2036 {
2037   gc_option_t *list_option;
2038   gc_option_t *config_option;
2039   char *list_filename;
2040   FILE *list_file;
2041   char *line = NULL;
2042   size_t line_len = 0;
2043   ssize_t length;
2044   char *list = NULL;
2045
2046   list_option = find_option (component,
2047                              gc_backend[backend].option_name, GC_BACKEND_ANY);
2048   assert (list_option);
2049   assert (!list_option->active);
2050
2051   list_filename = get_config_filename (component, backend);
2052   list_file = fopen (list_filename, "r");
2053   if (!list_file)
2054     gc_error (0, errno, "warning: can not open list file %s", list_filename);
2055   else
2056     {
2057
2058       while ((length = read_line (list_file, &line, &line_len, NULL)) > 0)
2059         {
2060           char *start;
2061           char *end;
2062           char *new_list;
2063
2064           start = line;
2065           while (*start == ' ' || *start == '\t')
2066             start++;
2067           if (!*start || *start == '#' || *start == '\r' || *start == '\n')
2068             continue;
2069
2070           end = start;
2071           while (*end && *end != '#' && *end != '\r' && *end != '\n')
2072             end++;
2073           /* Walk back to skip trailing white spaces.  Looks evil, but
2074              works because of the conditions on START and END imposed
2075              at this point (END is at least START + 1, and START is
2076              not a whitespace character).  */
2077           while (*(end - 1) == ' ' || *(end - 1) == '\t')
2078             end--;
2079           *end = '\0';
2080           /* FIXME: Oh, no!  This is so lame!  Should use realloc and
2081              really append.  */
2082           if (list)
2083             {
2084               new_list = xasprintf ("%s,\"%s", list, gc_percent_escape (start));
2085               xfree (list);
2086               list = new_list;
2087             }
2088           else
2089             list = xasprintf ("\"%s", gc_percent_escape (start));
2090         }
2091       if (length < 0 || ferror (list_file))
2092         gc_error (1, errno, "can not read list file %s", list_filename);
2093     }
2094
2095   list_option->active = 1;
2096   list_option->value = list;
2097
2098   /* Fix up the read-only flag.  */
2099   config_option = find_option
2100     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
2101   if (config_option->flags & GC_OPT_FLAG_NO_CHANGE)
2102     list_option->flags |= GC_OPT_FLAG_NO_CHANGE;
2103
2104   if (list_file && fclose (list_file) && ferror (list_file))
2105     gc_error (1, errno, "error closing %s", list_filename);
2106   xfree (line);
2107 }
2108
2109
2110 /* Retrieve the currently active options and their defaults from all
2111    involved backends for this component.  Using -1 for component will
2112    retrieve all options from all components. */
2113 void
2114 gc_component_retrieve_options (int component)
2115 {
2116   int process_all = 0;
2117   int backend_seen[GC_BACKEND_NR];
2118   gc_backend_t backend;
2119   gc_option_t *option;
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, FILE *in, FILE *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   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2997     {
2998       runtime[backend] = 0;
2999       src_filename[backend] = NULL;
3000       dest_filename[backend] = NULL;
3001       orig_filename[backend] = NULL;
3002     }
3003
3004   if (in)
3005     {
3006       /* Read options from the file IN.  */
3007       while ((length = read_line (in, &line, &line_len, NULL)) > 0)
3008         {
3009           char *linep;
3010           unsigned long flags = 0;
3011           char *new_value = "";
3012           
3013           /* Strip newline and carriage return, if present.  */
3014           while (length > 0
3015                  && (line[length - 1] == '\n' || line[length - 1] == '\r'))
3016             line[--length] = '\0';
3017           
3018           linep = strchr (line, ':');
3019           if (linep)
3020             *(linep++) = '\0';
3021           
3022           /* Extract additional flags.  Default to none.  */
3023           if (linep)
3024             {
3025               char *end;
3026               char *tail;
3027
3028               end = strchr (linep, ':');
3029               if (end)
3030                 *(end++) = '\0';
3031               
3032               gpg_err_set_errno (0);
3033               flags = strtoul (linep, &tail, 0);
3034               if (errno)
3035                 gc_error (1, errno, "malformed flags in option %s", line);
3036               if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
3037                 gc_error (1, 0, "garbage after flags in option %s", line);
3038               
3039               linep = end;
3040             }
3041
3042           /* Don't allow setting of the no change flag.  */
3043           flags &= ~GC_OPT_FLAG_NO_CHANGE;
3044           
3045           /* Extract default value, if present.  Default to empty if not.  */
3046           if (linep)
3047             {
3048               char *end;
3049               end = strchr (linep, ':');
3050               if (end)
3051                 *(end++) = '\0';
3052               new_value = linep;
3053               linep = end;
3054             }
3055           
3056           option = find_option (component, line, GC_BACKEND_ANY);
3057           if (!option)
3058             gc_error (1, 0, "unknown option %s", line);
3059           
3060           if ((option->flags & GC_OPT_FLAG_NO_CHANGE))
3061             {
3062               gc_error (0, 0, "ignoring new value for option %s",
3063                         option->name);
3064               continue;
3065             }
3066           
3067           change_one_value (option, runtime, flags, new_value);
3068         }
3069     }
3070
3071   /* Now that we have collected and locally verified the changes,
3072      write them out to new configuration files, verify them
3073      externally, and then commit them.  */
3074   option = gc_component[component].options;
3075   while (option && option->name)
3076     {
3077       /* Go on if we have already seen this backend, or if there is
3078          nothing to do.  */
3079       if (src_filename[option->backend]
3080           || !(option->new_flags || option->new_value))
3081         {
3082           option++;
3083           continue;
3084         }
3085
3086       if (gc_backend[option->backend].program)
3087         {
3088           err = change_options_program (component, option->backend,
3089                                         &src_filename[option->backend],
3090                                         &dest_filename[option->backend],
3091                                         &orig_filename[option->backend]);
3092           if (! err)
3093             {
3094               /* External verification.  */
3095               err = gc_component_check_options (component, out,
3096                                                 src_filename[option->backend]);
3097               if (err)
3098                 {
3099                   gc_error (0, 0,
3100                             _("External verification of component %s failed"),
3101                             gc_component[component].name);
3102                   gpg_err_set_errno (EINVAL);
3103                 }
3104             }
3105
3106         }
3107       else
3108         err = change_options_file (component, option->backend,
3109                                    &src_filename[option->backend],
3110                                    &dest_filename[option->backend],
3111                                    &orig_filename[option->backend]);
3112         
3113       if (err)
3114         break;
3115           
3116       option++;
3117     }
3118
3119   if (! err && ! opt.dry_run)
3120     {
3121       int i;
3122
3123       for (i = 0; i < GC_BACKEND_NR; i++)
3124         {
3125           if (src_filename[i])
3126             {
3127               /* FIXME: Make a verification here.  */
3128
3129               assert (dest_filename[i]);
3130
3131               if (orig_filename[i])
3132                 {
3133 #ifdef HAVE_W32_SYSTEM
3134                   /* There is no atomic update on W32.  */
3135                   err = unlink (dest_filename[i]);
3136 #endif /* HAVE_W32_SYSTEM */
3137                   if (!err)
3138                     err = rename (src_filename[i], dest_filename[i]);
3139                 }
3140               else
3141                 {
3142 #ifdef HAVE_W32_SYSTEM
3143                   /* We skip the unlink if we expect the file not to
3144                      be there.  */
3145                   err = rename (src_filename[i], dest_filename[i]);
3146 #else /* HAVE_W32_SYSTEM */
3147                   /* This is a bit safer than rename() because we
3148                      expect DEST_FILENAME not to be there.  If it
3149                      happens to be there, this will fail.  */
3150                   err = link (src_filename[i], dest_filename[i]);
3151                   if (!err)
3152                     err = unlink (src_filename[i]);
3153 #endif /* !HAVE_W32_SYSTEM */
3154                 }
3155               if (err)
3156                 break;
3157               src_filename[i] = NULL;
3158             }
3159         }
3160     }
3161
3162   if (err || opt.dry_run)
3163     {
3164       int i;
3165       int saved_errno = errno;
3166
3167       /* An error occured or a dry-run is requested.  */
3168       for (i = 0; i < GC_BACKEND_NR; i++)
3169         {
3170           if (src_filename[i])
3171             {
3172               /* The change was not yet committed.  */
3173               unlink (src_filename[i]);
3174               if (orig_filename[i])
3175                 unlink (orig_filename[i]);
3176             }
3177           else
3178             {
3179               /* The changes were already committed.  FIXME: This is a
3180                  tad dangerous, as we don't know if we don't overwrite
3181                  a version of the file that is even newer than the one
3182                  we just installed.  */
3183               if (orig_filename[i])
3184                 {
3185 #ifdef HAVE_W32_SYSTEM
3186                   /* There is no atomic update on W32.  */
3187                   unlink (dest_filename[i]);
3188 #endif /* HAVE_W32_SYSTEM */
3189                   rename (orig_filename[i], dest_filename[i]);
3190                 }
3191               else
3192                 unlink (dest_filename[i]);
3193             }
3194         }
3195       if (err)
3196         gc_error (1, saved_errno, "could not commit changes");
3197
3198       /* Fall-through for dry run.  */
3199       goto leave;
3200     }
3201
3202   /* If it all worked, notify the daemons of the changes.  */
3203   if (opt.runtime)
3204     for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3205       {
3206         if (runtime[backend] && gc_backend[backend].runtime_change)
3207           (*gc_backend[backend].runtime_change) ();
3208       }
3209
3210   /* Move the per-process backup file into its place.  */
3211   for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3212     if (orig_filename[backend])
3213       {
3214         char *backup_filename;
3215
3216         assert (dest_filename[backend]);
3217
3218         backup_filename = xasprintf ("%s.gpgconf.bak", dest_filename[backend]);
3219
3220 #ifdef HAVE_W32_SYSTEM
3221         /* There is no atomic update on W32.  */
3222         unlink (backup_filename);
3223 #endif /* HAVE_W32_SYSTEM */
3224         rename (orig_filename[backend], backup_filename);
3225       }
3226
3227  leave:
3228   xfree (line);
3229 }
3230
3231
3232 /* Check whether USER matches the current user of one of its group.
3233    This function may change USER.  Returns true is there is a
3234    match.  */
3235 static int
3236 key_matches_user_or_group (char *user)
3237 {
3238   char *group;
3239
3240   if (*user == '*' && user[1] == 0)
3241     return 1; /* A single asterisk matches all users.  */
3242
3243   group = strchr (user, ':');
3244   if (group)
3245     *group++ = 0;
3246
3247 #ifdef HAVE_W32_SYSTEM
3248   /* Under Windows we don't support groups. */   
3249   if (group && *group)
3250     gc_error (0, 0, _("Note that group specifications are ignored\n"));
3251 #ifndef HAVE_W32CE_SYSTEM
3252   if (*user)
3253     {
3254       static char *my_name;
3255
3256       if (!my_name)
3257         {
3258           char tmp[1];
3259           DWORD size = 1;
3260
3261           GetUserNameA (tmp, &size);
3262           my_name = xmalloc (size);
3263           if (!GetUserNameA (my_name, &size))
3264             gc_error (1,0, "error getting current user name: %s",
3265                       w32_strerror (-1));
3266         }
3267
3268       if (!strcmp (user, my_name))
3269         return 1; /* Found.  */
3270     }
3271 #endif /*HAVE_W32CE_SYSTEM*/
3272 #else /*!HAVE_W32_SYSTEM*/
3273   /* First check whether the user matches.  */
3274   if (*user)
3275     {
3276       static char *my_name;
3277
3278       if (!my_name)
3279         {
3280           struct passwd *pw = getpwuid ( getuid () );
3281           if (!pw)
3282             gc_error (1, errno, "getpwuid failed for current user");
3283           my_name = xstrdup (pw->pw_name);
3284         }
3285       if (!strcmp (user, my_name))
3286         return 1; /* Found.  */
3287     }
3288
3289   /* If that failed, check whether a group matches.  */
3290   if (group && *group)
3291     {
3292       static char *my_group;
3293       static char **my_supgroups;
3294       int n;
3295
3296       if (!my_group)
3297         {
3298           struct group *gr = getgrgid ( getgid () );
3299           if (!gr)
3300             gc_error (1, errno, "getgrgid failed for current user");
3301           my_group = xstrdup (gr->gr_name);
3302         }
3303       if (!strcmp (group, my_group))
3304         return 1; /* Found.  */
3305
3306       if (!my_supgroups)
3307         {
3308           int ngids;
3309           gid_t *gids;
3310
3311           ngids = getgroups (0, NULL);
3312           gids  = xcalloc (ngids+1, sizeof *gids);
3313           ngids = getgroups (ngids, gids);
3314           if (ngids < 0)
3315             gc_error (1, errno, "getgroups failed for current user");
3316           my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
3317           for (n=0; n < ngids; n++)
3318             {
3319               struct group *gr = getgrgid ( gids[n] );
3320               if (!gr)
3321                 gc_error (1, errno, "getgrgid failed for supplementary group");
3322               my_supgroups[n] = xstrdup (gr->gr_name);
3323             }
3324           xfree (gids);
3325         }
3326
3327       for (n=0; my_supgroups[n]; n++)
3328         if (!strcmp (group, my_supgroups[n]))
3329           return 1; /* Found.  */
3330     }
3331 #endif /*!HAVE_W32_SYSTEM*/
3332   return 0; /* No match.  */
3333 }
3334
3335
3336
3337 /* Read and process the global configuration file for gpgconf.  This
3338    optional file is used to update our internal tables at runtime and
3339    may also be used to set new default values.  If FNAME is NULL the
3340    default name will be used.  With UPDATE set to true the internal
3341    tables are actually updated; if not set, only a syntax check is
3342    done.  If DEFAULTS is true the global options are written to the
3343    configuration files.  If LISTFP is set, no changes are done but the
3344    configuration file is printed to LISTFP in a colon separated format.
3345
3346    Returns 0 on success or if the config file is not present; -1 is
3347    returned on error. */
3348 int
3349 gc_process_gpgconf_conf (const char *fname_arg, int update, int defaults,
3350                          FILE *listfp)
3351 {
3352   int result = 0;
3353   char *line = NULL;
3354   size_t line_len = 0;
3355   ssize_t length;
3356   FILE *config;
3357   int lineno = 0;
3358   int in_rule = 0;
3359   int got_match = 0;
3360   int runtime[GC_BACKEND_NR];
3361   int used_components[GC_COMPONENT_NR];
3362   int backend_id, component_id;
3363   char *fname;
3364
3365   if (fname_arg)
3366     fname = xstrdup (fname_arg);
3367   else
3368     fname = make_filename (gnupg_sysconfdir (), "gpgconf.conf", NULL);
3369
3370   for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3371     runtime[backend_id] = 0;
3372   for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3373     used_components[component_id] = 0;
3374
3375   config = fopen (fname, "r");
3376   if (!config)
3377     {
3378       /* Do not print an error if the file is not available, except
3379          when running in syntax check mode.  */
3380       if (errno != ENOENT || !update)
3381         {
3382           gc_error (0, errno, "can not open global config file `%s'", fname);
3383           result = -1;
3384         }
3385       xfree (fname);
3386       return result;
3387     }
3388
3389   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
3390     {
3391       char *key, *component, *option, *flags, *value;
3392       char *empty;
3393       gc_option_t *option_info = NULL;
3394       char *p;
3395       int is_continuation;
3396       
3397       lineno++;
3398       key = line;
3399       while (*key == ' ' || *key == '\t')
3400         key++;
3401       if (!*key || *key == '#' || *key == '\r' || *key == '\n')
3402         continue;
3403
3404       is_continuation = (key != line);
3405
3406       /* Parse the key field.  */
3407       if (!is_continuation && got_match)
3408         break;  /* Finish after the first match.  */
3409       else if (!is_continuation)
3410         {
3411           in_rule = 0;
3412           for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
3413             ;
3414           if (!*p)
3415             {
3416               gc_error (0, 0, "missing rule at `%s', line %d", fname, lineno);
3417               result = -1;
3418               continue;
3419             }
3420           *p++ = 0;
3421           component = p;
3422         }
3423       else if (!in_rule)
3424         {
3425           gc_error (0, 0, "continuation but no rule at `%s', line %d",
3426                     fname, lineno);
3427           result = -1;
3428           continue;
3429         }
3430       else
3431         {
3432           component = key;
3433           key = NULL;
3434         }
3435
3436       in_rule = 1;
3437
3438       /* Parse the component.  */
3439       while (*component == ' ' || *component == '\t')
3440         component++;
3441       for (p=component; *p && !strchr (" \t\r\n", *p); p++)
3442         ;
3443       if (p == component)
3444         {
3445           gc_error (0, 0, "missing component at `%s', line %d",
3446                     fname, lineno);
3447           result = -1;
3448           continue;
3449         }
3450       empty = p;
3451       *p++ = 0;
3452       option = p;
3453       component_id = gc_component_find (component);
3454       if (component_id < 0)
3455         {
3456           gc_error (0, 0, "unknown component at `%s', line %d",
3457                     fname, lineno);
3458           result = -1;
3459         }
3460
3461       /* Parse the option name.  */
3462       while (*option == ' ' || *option == '\t')
3463         option++;
3464       for (p=option; *p && !strchr (" \t\r\n", *p); p++)
3465         ;
3466       if (p == option)
3467         {
3468           gc_error (0, 0, "missing option at `%s', line %d",
3469                     fname, lineno);
3470           result = -1;
3471           continue;
3472         }
3473       *p++ = 0;
3474       flags = p;
3475       if ( component_id != -1)
3476         {
3477           option_info = find_option (component_id, option, GC_BACKEND_ANY);
3478           if (!option_info)
3479             {
3480               gc_error (0, 0, "unknown option at `%s', line %d",
3481                         fname, lineno);
3482               result = -1;
3483             }
3484         }
3485
3486
3487       /* Parse the optional flags.  */
3488       while (*flags == ' ' || *flags == '\t')
3489         flags++;
3490       if (*flags == '[')
3491         {
3492           flags++;
3493           p = strchr (flags, ']');
3494           if (!p)
3495             {
3496               gc_error (0, 0, "syntax error in rule at `%s', line %d",
3497                         fname, lineno);
3498               result = -1;
3499               continue;
3500             }
3501           *p++ = 0;
3502           value = p;
3503         }
3504       else  /* No flags given.  */
3505         {
3506           value = flags;
3507           flags = NULL;
3508         }
3509
3510       /* Parse the optional value.  */
3511       while (*value == ' ' || *value == '\t')
3512        value++;
3513       for (p=value; *p && !strchr ("\r\n", *p); p++)
3514         ;
3515       if (p == value)
3516         value = empty; /* No value given; let it point to an empty string.  */
3517       else
3518         {
3519           /* Strip trailing white space.  */
3520           *p = 0;
3521           for (p--; p > value && (*p == ' ' || *p == '\t'); p--)
3522             *p = 0;
3523         }
3524
3525       /* Check flag combinations.  */
3526       if (!flags)
3527         ;
3528       else if (!strcmp (flags, "default"))
3529         {
3530           if (*value)
3531             {
3532               gc_error (0, 0, "flag \"default\" may not be combined "
3533                         "with a value at `%s', line %d",
3534                         fname, lineno);
3535               result = -1;
3536             }
3537         }
3538       else if (!strcmp (flags, "change"))
3539         ;
3540       else if (!strcmp (flags, "no-change"))
3541         ;
3542       else
3543         {
3544           gc_error (0, 0, "unknown flag at `%s', line %d",
3545                     fname, lineno);
3546           result = -1;
3547         }
3548
3549       /* In list mode we print out all records.  */
3550       if (listfp && !result)
3551         {
3552           /* If this is a new ruleset, print a key record.  */
3553           if (!is_continuation)
3554             {
3555               char *group = strchr (key, ':');
3556               if (group)
3557                 {
3558                   *group++ = 0;
3559                   if ((p = strchr (group, ':')))
3560                     *p = 0; /* We better strip any extra stuff. */
3561                 }                    
3562               
3563               fprintf (listfp, "k:%s:", gc_percent_escape (key));
3564               fprintf (listfp, "%s\n", group? gc_percent_escape (group):"");
3565             }
3566
3567           /* All other lines are rule records.  */
3568           fprintf (listfp, "r:::%s:%s:%s:",
3569                    gc_component[component_id].name,                     
3570                    option_info->name? option_info->name : "",
3571                    flags? flags : "");
3572           if (value != empty)
3573             fprintf (listfp, "\"%s", gc_percent_escape (value));
3574           
3575           putc ('\n', listfp);
3576         }
3577
3578       /* Check whether the key matches but do this only if we are not
3579          running in syntax check mode. */
3580       if ( update 
3581            && !result && !listfp
3582            && (got_match || (key && key_matches_user_or_group (key))) )
3583         {
3584           int newflags = 0;
3585
3586           got_match = 1;
3587
3588           /* Apply the flags from gpgconf.conf.  */
3589           if (!flags)
3590             ;
3591           else if (!strcmp (flags, "default"))
3592             newflags |= GC_OPT_FLAG_DEFAULT;
3593           else if (!strcmp (flags, "no-change"))
3594             option_info->flags |= GC_OPT_FLAG_NO_CHANGE;
3595           else if (!strcmp (flags, "change"))
3596             option_info->flags &= ~GC_OPT_FLAG_NO_CHANGE;
3597
3598           if (defaults)
3599             {
3600               assert (component_id >= 0 && component_id < GC_COMPONENT_NR);
3601               used_components[component_id] = 1;
3602
3603               /* Here we explicitly allow to update the value again.  */
3604               if (newflags)
3605                 {
3606                   option_info->new_flags = 0;
3607                 }
3608               if (*value)
3609                 {
3610                   xfree (option_info->new_value);
3611                   option_info->new_value = NULL;
3612                 }
3613               change_one_value (option_info, runtime, newflags, value);
3614             }
3615         }
3616     }
3617
3618   if (length < 0 || ferror (config))
3619     {
3620       gc_error (0, errno, "error reading from `%s'", fname);
3621       result = -1;
3622     }
3623   if (fclose (config) && ferror (config))
3624     gc_error (0, errno, "error closing `%s'", fname);
3625
3626   xfree (line);
3627
3628   /* If it all worked, process the options. */
3629   if (!result && update && defaults && !listfp)
3630     {
3631       /* We need to switch off the runtime update, so that we can do
3632          it later all at once. */
3633       int save_opt_runtime = opt.runtime;
3634       opt.runtime = 0;
3635
3636       for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3637         {
3638           gc_component_change_options (component_id, NULL, NULL);
3639         }
3640       opt.runtime = save_opt_runtime;
3641
3642       if (opt.runtime)
3643         {
3644           for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)  
3645             if (runtime[backend_id] && gc_backend[backend_id].runtime_change)
3646               (*gc_backend[backend_id].runtime_change) ();
3647         }
3648     }
3649
3650   xfree (fname);
3651   return result;
3652 }