2010-04-23 Marcus Brinkmann <marcus@g10code.de>
[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, NULL);
1055   if (err)
1056     gc_error (0, 0, "error running `%s%s': %s",
1057               pgmname, " reloadagent", gpg_strerror (err));
1058 #endif /*!HAVE_W32_SYSTEM*/
1059 }
1060
1061
1062 static void
1063 scdaemon_runtime_change (void)
1064 {
1065   gpg_error_t err;
1066   const char *pgmname;
1067   const char *argv[6];
1068   pid_t pid;
1069   
1070   /* We use "GETINFO app_running" to see whether the agent is already
1071      running and kill it only in this case.  This avoids an explicit
1072      starting of the agent in case it is not yet running.  There is
1073      obviously a race condition but that should not harm too much.  */
1074
1075   pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1076   argv[0] = "-s";
1077   argv[1] = "GETINFO scd_running";
1078   argv[2] = "/if ${! $?}";
1079   argv[3] = "scd killscd";
1080   argv[4] = "/end";
1081   argv[5] = NULL;
1082   
1083   err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1084   if (!err)
1085     err = gnupg_wait_process (pgmname, pid, NULL);
1086   if (err)
1087     gc_error (0, 0, "error running `%s%s': %s",
1088               pgmname, " scd killscd", gpg_strerror (err));
1089 }
1090
1091
1092 /* Unconditionally reload COMPONENT or all components if COMPONENT is -1.  */
1093 void
1094 gc_component_reload (int component)
1095 {
1096   int runtime[GC_BACKEND_NR];
1097   gc_option_t *option;
1098   gc_backend_t backend;
1099
1100   /* Set a flag for the backends to be reloaded.  */
1101   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1102     runtime[backend] = 0;
1103   
1104   if (component == -1)
1105     {
1106       for (component = 0; component < GC_COMPONENT_NR; component++)
1107         {
1108           option = gc_component[component].options;
1109           for (; option && option->name; option++)
1110             runtime[option->backend] = 1;
1111         }
1112     }
1113   else
1114     {
1115       assert (component < GC_COMPONENT_NR);
1116       option = gc_component[component].options;
1117       for (; option && option->name; option++)
1118         runtime[option->backend] = 1;
1119     }
1120
1121   /* Do the reload for all selected backends.  */
1122   for (backend = 0; backend < GC_BACKEND_NR; backend++)  
1123     {
1124       if (runtime[backend] && gc_backend[backend].runtime_change)
1125         (*gc_backend[backend].runtime_change) ();
1126     }
1127 }
1128
1129
1130 \f
1131 /* More or less Robust version of dgettext.  It has the side effect of
1132    switching the codeset to utf-8 because this is what we want to
1133    output.  In theory it is posible to keep the orginal code set and
1134    switch back for regular disgnostic output (redefine "_(" for that)
1135    but given the natur of this tool, being something invoked from
1136    other pograms, it does not make much sense.  */
1137 static const char *
1138 my_dgettext (const char *domain, const char *msgid)
1139 {
1140 #ifdef USE_SIMPLE_GETTEXT
1141   if (domain)
1142     {
1143       static int switched_codeset;
1144       char *text;
1145       
1146       if (!switched_codeset)
1147         {
1148           switched_codeset = 1;
1149           gettext_use_utf8 (1);
1150         }
1151
1152       if (!strcmp (domain, "gnupg"))
1153         domain = PACKAGE_GT;
1154
1155       /* FIXME: we have no dgettext, thus we can't switch.  */
1156
1157       text = (char*)gettext (msgid);
1158       return text ? text : msgid;
1159     }
1160 #elif defined(ENABLE_NLS)
1161   if (domain)
1162     {
1163       static int switched_codeset;
1164       char *text;
1165       
1166       if (!switched_codeset)
1167         {
1168           switched_codeset = 1;
1169           bind_textdomain_codeset (PACKAGE_GT, "utf-8");
1170
1171           bindtextdomain ("dirmngr", LOCALEDIR);
1172           bind_textdomain_codeset ("dirmngr", "utf-8");
1173    
1174         }
1175
1176       /* Note: This is a hack to actually use the gnupg2 domain as
1177          long we are in a transition phase where gnupg 1.x and 1.9 may
1178          coexist. */
1179       if (!strcmp (domain, "gnupg"))
1180         domain = PACKAGE_GT;
1181
1182       text = dgettext (domain, msgid);
1183       return text ? text : msgid;
1184     }
1185   else
1186 #endif
1187     return msgid;
1188 }
1189
1190
1191 /* Percent-Escape special characters.  The string is valid until the
1192    next invocation of the function.  */
1193 char *
1194 gc_percent_escape (const char *src)
1195 {
1196   static char *esc_str;
1197   static int esc_str_len;
1198   int new_len = 3 * strlen (src) + 1;
1199   char *dst;
1200
1201   if (esc_str_len < new_len)
1202     {
1203       char *new_esc_str = realloc (esc_str, new_len);
1204       if (!new_esc_str)
1205         gc_error (1, errno, "can not escape string");
1206       esc_str = new_esc_str;
1207       esc_str_len = new_len;
1208     }
1209
1210   dst = esc_str;
1211   while (*src)
1212     {
1213       if (*src == '%')
1214         {
1215           *(dst++) = '%';
1216           *(dst++) = '2';
1217           *(dst++) = '5';
1218         }         
1219       else if (*src == ':')
1220         {
1221           /* The colon is used as field separator.  */
1222           *(dst++) = '%';
1223           *(dst++) = '3';
1224           *(dst++) = 'a';
1225         }
1226       else if (*src == ',')
1227         {
1228           /* The comma is used as list separator.  */
1229           *(dst++) = '%';
1230           *(dst++) = '2';
1231           *(dst++) = 'c';
1232         }
1233       else
1234         *(dst++) = *(src);
1235       src++;
1236     }
1237   *dst = '\0';
1238   return esc_str;
1239 }
1240
1241
1242
1243 /* Percent-Deescape special characters.  The string is valid until the
1244    next invocation of the function.  */
1245 static char *
1246 percent_deescape (const char *src)
1247 {
1248   static char *str;
1249   static int str_len;
1250   int new_len = 3 * strlen (src) + 1;
1251   char *dst;
1252
1253   if (str_len < new_len)
1254     {
1255       char *new_str = realloc (str, new_len);
1256       if (!new_str)
1257         gc_error (1, errno, "can not deescape string");
1258       str = new_str;
1259       str_len = new_len;
1260     }
1261
1262   dst = str;
1263   while (*src)
1264     {
1265       if (*src == '%')
1266         {
1267           int val = hextobyte (src + 1);
1268
1269           if (val < 0)
1270             gc_error (1, 0, "malformed end of string %s", src);
1271
1272           *(dst++) = (char) val;
1273           src += 3;
1274         }         
1275       else
1276         *(dst++) = *(src++);
1277     }
1278   *dst = '\0';
1279   return str;
1280 }
1281
1282 \f
1283 /* List all components that are available.  */
1284 void
1285 gc_component_list_components (FILE *out)
1286 {
1287   gc_component_t component;
1288   gc_option_t *option;
1289   gc_backend_t backend;
1290   int backend_seen[GC_BACKEND_NR];
1291   const char *desc;
1292   const char *pgmname;
1293
1294   for (component = 0; component < GC_COMPONENT_NR; component++)
1295     {
1296       option = gc_component[component].options;
1297       if (option)
1298         {
1299           for (backend = 0; backend < GC_BACKEND_NR; backend++)
1300             backend_seen[backend] = 0;
1301
1302           pgmname = "";
1303           for (; option && option->name; option++)
1304             {
1305               if ((option->flags & GC_OPT_FLAG_GROUP))
1306                 continue;
1307               backend = option->backend;
1308               if (backend_seen[backend])
1309                 continue;
1310               backend_seen[backend] = 1;
1311               assert (backend != GC_BACKEND_ANY);
1312               if (gc_backend[backend].program
1313                   && !gc_backend[backend].module_name)
1314                 continue;
1315               pgmname = gnupg_module_name (gc_backend[backend].module_name);
1316               break;
1317             }
1318
1319           desc = gc_component[component].desc;
1320           desc = my_dgettext (gc_component[component].desc_domain, desc);
1321           fprintf (out, "%s:%s:",
1322                    gc_component[component].name,  gc_percent_escape (desc));
1323           fprintf (out, "%s\n",  gc_percent_escape (pgmname));
1324         }
1325     }
1326 }
1327
1328
1329 \f
1330 static int
1331 all_digits_p (const char *p, size_t len)
1332 {
1333   if (!len)
1334     return 0; /* No. */
1335   for (; len; len--, p++)
1336     if (!isascii (*p) || !isdigit (*p))
1337       return 0; /* No.  */
1338   return 1; /* Yes.  */
1339 }
1340
1341
1342 /* Collect all error lines from file descriptor FD. Only lines
1343    prefixed with TAG are considered.  Close that file descriptor
1344    then.  Returns a list of error line items (which may be empty).
1345    There is no error return.  */
1346 static error_line_t
1347 collect_error_output (int fd, const char *tag)
1348 {
1349   FILE *fp;
1350   char buffer[1024];
1351   char *p, *p2, *p3;
1352   int c, cont_line;
1353   unsigned int pos;
1354   error_line_t eitem, errlines, *errlines_tail;
1355   size_t taglen = strlen (tag);
1356
1357   fp = fdopen (fd, "r");
1358   if (!fp)
1359     gc_error (1, errno, "can't fdopen pipe for reading");
1360
1361   errlines = NULL;
1362   errlines_tail = &errlines;
1363   pos = 0;
1364   cont_line = 0;
1365   while ((c=getc (fp)) != EOF)
1366     {
1367       buffer[pos++] = c;
1368       if (pos >= sizeof buffer - 5 || c == '\n')
1369         {
1370           buffer[pos - (c == '\n')] = 0;
1371           if (cont_line)
1372             ; /*Ignore continuations of previous line. */
1373           else if (!strncmp (buffer, tag, taglen) && buffer[taglen] == ':') 
1374             {
1375               /* "gpgsm: foo:4: bla" */
1376               /* Yep, we are interested in this line.  */
1377               p = buffer + taglen + 1;
1378               while (*p == ' ' || *p == '\t')
1379                 p++;
1380               if (!*p)
1381                 ; /* Empty lines are ignored.  */
1382               else if ( (p2 = strchr (p, ':')) && (p3 = strchr (p2+1, ':'))
1383                         && all_digits_p (p2+1, p3 - (p2+1)))
1384                 {
1385                   /* Line in standard compiler format.  */
1386                   p3++;
1387                   while (*p3 == ' ' || *p3 == '\t')
1388                     p3++;
1389                   eitem = xmalloc (sizeof *eitem + strlen (p));
1390                   eitem->next = NULL;
1391                   strcpy (eitem->buffer, p);
1392                   eitem->fname = eitem->buffer;
1393                   eitem->buffer[p2-p] = 0;
1394                   eitem->errtext = eitem->buffer + (p3 - p);
1395                   /* (we already checked that there are only ascii
1396                      digits followed by a colon) */
1397                   eitem->lineno = 0;
1398                   for (p2++; isdigit (*p2); p2++)
1399                     eitem->lineno = eitem->lineno*10 + (*p2 - '0');
1400                   *errlines_tail = eitem;
1401                   errlines_tail = &eitem->next;
1402                 }
1403               else
1404                 {
1405                   /* Other error output.  */
1406                   eitem = xmalloc (sizeof *eitem + strlen (p));
1407                   eitem->next = NULL;
1408                   strcpy (eitem->buffer, p);
1409                   eitem->fname = NULL;
1410                   eitem->errtext = eitem->buffer;
1411                   eitem->lineno = 0;
1412                   *errlines_tail = eitem;
1413                   errlines_tail = &eitem->next;
1414                 }
1415             }
1416           pos = 0;
1417           /* If this was not a complete line mark that we are in a
1418              continuation.  */
1419           cont_line = (c != '\n');
1420         }
1421     }
1422   
1423   /* We ignore error lines not terminated by a LF.  */
1424
1425   fclose (fp);
1426   return errlines;
1427 }
1428
1429
1430 /* Check the options of a single component.  Returns 0 if everything
1431    is OK.  */
1432 int
1433 gc_component_check_options (int component, FILE *out, const char *conf_file)
1434 {
1435   gpg_error_t err;
1436   unsigned int result;
1437   int backend_seen[GC_BACKEND_NR];
1438   gc_backend_t backend;
1439   gc_option_t *option;
1440   const char *pgmname;
1441   const char *argv[4];
1442   int i;
1443   pid_t pid;
1444   int exitcode;
1445   int filedes[2];
1446   error_line_t errlines;
1447
1448   /* We use a temporary file to collect the error output.  It would be
1449      better to use a pipe here but as of now we have no suitable
1450      fucntion to create a portable pipe outside of exechelp.  Thus it
1451      is easier to use the tempfile approach.  */
1452
1453   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1454     backend_seen[backend] = 0;
1455
1456   option = gc_component[component].options;
1457   for (; option && option->name; option++)
1458     {
1459       if ((option->flags & GC_OPT_FLAG_GROUP))
1460         continue;
1461       backend = option->backend;
1462       if (backend_seen[backend])
1463         continue;
1464       backend_seen[backend] = 1;
1465       assert (backend != GC_BACKEND_ANY);
1466       if (!gc_backend[backend].program)
1467         continue;
1468       if (!gc_backend[backend].module_name)
1469         continue;
1470
1471       break;
1472     }
1473   if (! option || ! option->name)
1474     return 0;
1475
1476   pgmname = gnupg_module_name (gc_backend[backend].module_name);
1477   i = 0;
1478   if (conf_file)
1479     {
1480       argv[i++] = "--options";
1481       argv[i++] = conf_file;
1482     }
1483   argv[i++] = "--gpgconf-test";
1484   argv[i++] = NULL;
1485   
1486   err = gnupg_create_inbound_pipe (filedes);
1487   if (err)
1488     gc_error (1, 0, _("error creating a pipe: %s\n"), 
1489               gpg_strerror (err));
1490   
1491   result = 0;
1492   errlines = NULL;
1493   if (gnupg_spawn_process_fd (pgmname, argv, -1, -1, filedes[1], &pid))
1494     {
1495       close (filedes[0]);
1496       close (filedes[1]);
1497       result |= 1; /* Program could not be run.  */
1498     }
1499   else 
1500     {
1501       close (filedes[1]);
1502       errlines = collect_error_output (filedes[0], 
1503                                        gc_component[component].name);
1504       if (gnupg_wait_process (pgmname, pid, &exitcode))
1505         {
1506           if (exitcode == -1)
1507             result |= 1; /* Program could not be run or it
1508                             terminated abnormally.  */
1509           result |= 2; /* Program returned an error.  */
1510         }
1511     }
1512   
1513   /* If the program could not be run, we can't tell whether
1514      the config file is good.  */
1515   if (result & 1)
1516     result |= 2;  
1517   
1518   if (out)
1519     {
1520       const char *desc;
1521       error_line_t errptr;
1522
1523       desc = gc_component[component].desc;
1524       desc = my_dgettext (gc_component[component].desc_domain, desc);
1525       fprintf (out, "%s:%s:",
1526                gc_component[component].name, gc_percent_escape (desc));
1527       fputs (gc_percent_escape (pgmname), out);
1528       fprintf (out, ":%d:%d:", !(result & 1), !(result & 2));
1529       for (errptr = errlines; errptr; errptr = errptr->next)
1530         {
1531           if (errptr != errlines)
1532             fputs ("\n:::::", out); /* Continuation line.  */
1533           if (errptr->fname)
1534             fputs (gc_percent_escape (errptr->fname), out);
1535           putc (':', out);
1536           if (errptr->fname)
1537             fprintf (out, "%u", errptr->lineno);
1538           putc (':', out);
1539           fputs (gc_percent_escape (errptr->errtext), out);
1540           putc (':', out);
1541         }
1542       putc ('\n', out);
1543     }
1544
1545   while (errlines)
1546     {
1547       error_line_t tmp = errlines->next;
1548       xfree (errlines);
1549       errlines = tmp;
1550     }
1551
1552   return result;
1553 }
1554
1555
1556 /* Check all components that are available.  */
1557 void
1558 gc_check_programs (FILE *out)
1559 {
1560   gc_component_t component;
1561
1562   for (component = 0; component < GC_COMPONENT_NR; component++)
1563     gc_component_check_options (component, out, NULL);
1564 }
1565
1566
1567 \f
1568 /* Find the component with the name NAME.  Returns -1 if not
1569    found.  */
1570 int
1571 gc_component_find (const char *name)
1572 {
1573   gc_component_t idx;
1574
1575   for (idx = 0; idx < GC_COMPONENT_NR; idx++)
1576     {
1577       if (gc_component[idx].options
1578           && !strcmp (name, gc_component[idx].name))
1579         return idx;
1580     }
1581   return -1;
1582 }
1583
1584 \f
1585 /* List the option OPTION.  */
1586 static void
1587 list_one_option (const gc_option_t *option, FILE *out)
1588 {
1589   const char *desc = NULL;
1590   char *arg_name = NULL;
1591
1592   if (option->desc)
1593     {
1594       desc = my_dgettext (option->desc_domain, option->desc);
1595
1596       if (*desc == '|')
1597         {
1598           const char *arg_tail = strchr (&desc[1], '|');
1599
1600           if (arg_tail)
1601             {
1602               int arg_len = arg_tail - &desc[1];
1603               arg_name = xmalloc (arg_len + 1);
1604               memcpy (arg_name, &desc[1], arg_len);
1605               arg_name[arg_len] = '\0';
1606               desc = arg_tail + 1;
1607             }
1608         }
1609     }
1610
1611
1612   /* YOU MUST NOT REORDER THE FIELDS IN THIS OUTPUT, AS THEIR ORDER IS
1613      PART OF THE EXTERNAL INTERFACE.  YOU MUST NOT REMOVE ANY
1614      FIELDS.  */
1615
1616   /* The name field.  */
1617   fprintf (out, "%s", option->name);
1618
1619   /* The flags field.  */
1620   fprintf (out, ":%lu", option->flags);
1621   if (opt.verbose)
1622     {
1623       putc (' ', out);
1624           
1625       if (!option->flags)
1626         fprintf (out, "none");
1627       else
1628         {
1629           unsigned long flags = option->flags;
1630           unsigned long flag = 0;
1631           unsigned long first = 1;
1632
1633           while (flags)
1634             {
1635               if (flags & 1)
1636                 {
1637                   if (first)
1638                     first = 0;
1639                   else
1640                     putc (',', out);
1641                   fprintf (out, "%s", gc_flag[flag].name);
1642                 }
1643               flags >>= 1;
1644               flag++;
1645             }
1646         }
1647     }
1648
1649   /* The level field.  */
1650   fprintf (out, ":%u", option->level);
1651   if (opt.verbose)
1652     fprintf (out, " %s", gc_level[option->level].name);
1653
1654   /* The description field.  */
1655   fprintf (out, ":%s", desc ? gc_percent_escape (desc) : "");
1656   
1657   /* The type field.  */
1658   fprintf (out, ":%u", option->arg_type);
1659   if (opt.verbose)
1660     fprintf (out, " %s", gc_arg_type[option->arg_type].name);
1661
1662   /* The alternate type field.  */
1663   fprintf (out, ":%u", gc_arg_type[option->arg_type].fallback);
1664   if (opt.verbose)
1665     fprintf (out, " %s",
1666              gc_arg_type[gc_arg_type[option->arg_type].fallback].name);
1667
1668   /* The argument name field.  */
1669   fprintf (out, ":%s", arg_name ? gc_percent_escape (arg_name) : "");
1670   if (arg_name)
1671     xfree (arg_name);
1672
1673   /* The default value field.  */
1674   fprintf (out, ":%s", option->default_value ? option->default_value : "");
1675
1676   /* The default argument field.  */
1677   fprintf (out, ":%s", option->default_arg ? option->default_arg : "");
1678
1679   /* The value field.  */
1680   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
1681       && (option->flags & GC_OPT_FLAG_LIST)
1682       && option->value)
1683     /* The special format "1,1,1,1,...,1" is converted to a number
1684        here.  */
1685     fprintf (out, ":%u", (unsigned int)((strlen (option->value) + 1) / 2));
1686   else
1687     fprintf (out, ":%s", option->value ? option->value : "");
1688
1689   /* ADD NEW FIELDS HERE.  */
1690
1691   putc ('\n', out);
1692 }
1693
1694
1695 /* List all options of the component COMPONENT.  */
1696 void
1697 gc_component_list_options (int component, FILE *out)
1698 {  
1699   const gc_option_t *option = gc_component[component].options;
1700
1701   while (option && option->name)
1702     {
1703       /* Do not output unknown or internal options.  */
1704       if (!(option->flags & GC_OPT_FLAG_GROUP)
1705           && (!option->active || option->level == GC_LEVEL_INTERNAL))
1706         {
1707           option++;
1708           continue;
1709         }
1710
1711       if (option->flags & GC_OPT_FLAG_GROUP)
1712         {
1713           const gc_option_t *group_option = option + 1;
1714           gc_expert_level_t level = GC_LEVEL_NR;
1715
1716           /* The manual states that the group level is always the
1717              minimum of the levels of all contained options.  Due to
1718              different active options, and because it is hard to
1719              maintain manually, we calculate it here.  The value in
1720              the global static table is ignored.  */
1721           
1722           while (group_option->name)
1723             {
1724               if (group_option->flags & GC_OPT_FLAG_GROUP)
1725                 break;
1726               if (group_option->level < level)
1727                 level = group_option->level;
1728               group_option++;
1729             }
1730
1731           /* Check if group is empty.  */
1732           if (level != GC_LEVEL_NR)
1733             {
1734               gc_option_t opt_copy;
1735
1736               /* Fix up the group level.  */
1737               memcpy (&opt_copy, option, sizeof (opt_copy));
1738               opt_copy.level = level;
1739               list_one_option (&opt_copy, out);
1740             }
1741         }
1742       else
1743         list_one_option (option, out);
1744
1745       option++;
1746     }
1747 }
1748
1749
1750 /* Find the option NAME in component COMPONENT, for the backend
1751    BACKEND.  If BACKEND is GC_BACKEND_ANY, any backend will match.  */
1752 static gc_option_t *
1753 find_option (gc_component_t component, const char *name,
1754              gc_backend_t backend)
1755 {
1756   gc_option_t *option = gc_component[component].options;
1757   while (option->name)
1758     {
1759       if (!(option->flags & GC_OPT_FLAG_GROUP)
1760           && !strcmp (option->name, name)
1761           && (backend == GC_BACKEND_ANY || option->backend == backend))
1762         break;
1763       option++;
1764     }
1765   return option->name ? option : NULL;
1766 }
1767
1768 \f
1769 /* Determine the configuration filename for the component COMPONENT
1770    and backend BACKEND.  */
1771 static char *
1772 get_config_filename (gc_component_t component, gc_backend_t backend)
1773 {
1774   char *filename = NULL;
1775   gc_option_t *option = find_option
1776     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
1777   assert (option);
1778   assert (option->arg_type == GC_ARG_TYPE_FILENAME);
1779   assert (!(option->flags & GC_OPT_FLAG_LIST));
1780
1781   if (!option->active || !option->default_value)
1782     gc_error (1, 0, "Option %s, needed by backend %s, was not initialized",
1783               gc_backend[backend].option_config_filename,
1784               gc_backend[backend].name);
1785
1786   if (option->value && *option->value)
1787     filename = percent_deescape (&option->value[1]);
1788   else if (option->default_value && *option->default_value)
1789     filename = percent_deescape (&option->default_value[1]);
1790   else
1791     filename = "";
1792
1793 #ifdef HAVE_DOSISH_SYSTEM
1794   if (!(filename[0] 
1795         && filename[1] == ':'
1796         && (filename[2] == '/' || filename[2] == '\\')))
1797 #else
1798   if (filename[0] != '/')
1799 #endif
1800     gc_error (1, 0, "Option %s, needed by backend %s, is not absolute",
1801               gc_backend[backend].option_config_filename,
1802               gc_backend[backend].name);
1803
1804   return filename;
1805 }
1806
1807 \f
1808 /* Retrieve the options for the component COMPONENT from backend
1809    BACKEND, which we already know is a program-type backend.  */
1810 static void
1811 retrieve_options_from_program (gc_component_t component, gc_backend_t backend)
1812 {
1813   gpg_error_t err;
1814   int filedes[2];
1815   const char *pgmname;
1816   const char *argv[2];
1817   int exitcode;
1818   pid_t pid;
1819   char *line = NULL;
1820   size_t line_len = 0;
1821   ssize_t length;
1822   FILE *config;
1823   char *config_filename;
1824
1825   err = gnupg_create_inbound_pipe (filedes);
1826   if (err)
1827     gc_error (1, 0, _("error creating a pipe: %s\n"), gpg_strerror (err));
1828
1829   pgmname = (gc_backend[backend].module_name 
1830              ? gnupg_module_name (gc_backend[backend].module_name) 
1831              : gc_backend[backend].program );
1832   argv[0] = "--gpgconf-list";
1833   argv[1] = NULL;
1834
1835   err = gnupg_spawn_process_fd (pgmname, argv, -1, filedes[1], -1, &pid);
1836   if (err)
1837     {
1838       close (filedes[0]);
1839       close (filedes[1]);
1840       gc_error (1, 0, "could not gather active options from `%s': %s",
1841                 pgmname, gpg_strerror (err));
1842     }
1843   close (filedes[1]);
1844   config = fdopen (filedes[0], "r");
1845   if (!config)
1846     gc_error (1, errno, "can't fdopen pipe for reading");
1847
1848   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1849     {
1850       gc_option_t *option;
1851       char *linep;
1852       unsigned long flags = 0;
1853       char *default_value = NULL;
1854       
1855       /* Strip newline and carriage return, if present.  */
1856       while (length > 0
1857              && (line[length - 1] == '\n' || line[length - 1] == '\r'))
1858         line[--length] = '\0';
1859
1860       linep = strchr (line, ':');
1861       if (linep)
1862         *(linep++) = '\0';
1863       
1864       /* Extract additional flags.  Default to none.  */
1865       if (linep)
1866         {
1867           char *end;
1868           char *tail;
1869
1870           end = strchr (linep, ':');
1871           if (end)
1872             *(end++) = '\0';
1873
1874           gpg_err_set_errno (0);
1875           flags = strtoul (linep, &tail, 0);
1876           if (errno)
1877             gc_error (1, errno, "malformed flags in option %s from %s",
1878                       line, pgmname);
1879           if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
1880             gc_error (1, 0, "garbage after flags in option %s from %s",
1881                       line, pgmname);
1882
1883           linep = end;
1884         }
1885
1886       /* Extract default value, if present.  Default to empty if
1887          not.  */
1888       if (linep)
1889         {
1890           char *end;
1891
1892           end = strchr (linep, ':');
1893           if (end)
1894             *(end++) = '\0';
1895
1896           if (flags & GC_OPT_FLAG_DEFAULT)
1897             default_value = linep;
1898
1899           linep = end;
1900         }
1901
1902       /* Look up the option in the component and install the
1903          configuration data.  */
1904       option = find_option (component, line, backend);
1905       if (option)
1906         {
1907           if (option->active)
1908             gc_error (1, errno, "option %s returned twice from %s",
1909                       line, pgmname);
1910           option->active = 1;
1911
1912           option->flags |= flags;
1913           if (default_value && *default_value)
1914             option->default_value = xstrdup (default_value);
1915         }
1916     }
1917   if (length < 0 || ferror (config))
1918     gc_error (1, errno, "error reading from %s",pgmname);
1919   if (fclose (config) && ferror (config))
1920     gc_error (1, errno, "error closing %s", pgmname);
1921
1922   err = gnupg_wait_process (pgmname, pid, &exitcode);
1923   if (err)
1924     gc_error (1, 0, "running %s failed (exitcode=%d): %s",
1925               pgmname, exitcode, gpg_strerror (err));
1926
1927
1928   /* At this point, we can parse the configuration file.  */
1929   config_filename = get_config_filename (component, backend);
1930
1931   config = fopen (config_filename, "r");
1932   if (!config)
1933     gc_error (0, errno, "warning: can not open config file %s",
1934               config_filename);
1935   else
1936     {
1937       while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1938         {
1939           char *name;
1940           char *value;
1941           gc_option_t *option;
1942           
1943           name = line;
1944           while (*name == ' ' || *name == '\t')
1945             name++;
1946           if (!*name || *name == '#' || *name == '\r' || *name == '\n')
1947             continue;
1948
1949           value = name;
1950           while (*value && *value != ' ' && *value != '\t'
1951                  && *value != '#' && *value != '\r' && *value != '\n')
1952             value++;
1953           if (*value == ' ' || *value == '\t')
1954             {
1955               char *end;
1956
1957               *(value++) = '\0';
1958               while (*value == ' ' || *value == '\t')
1959                 value++;
1960
1961               end = value;
1962               while (*end && *end != '#' && *end != '\r' && *end != '\n')
1963                 end++;
1964               while (end > value && (end[-1] == ' ' || end[-1] == '\t'))
1965                 end--;
1966               *end = '\0';
1967             }
1968           else
1969             *value = '\0';
1970
1971           /* Look up the option in the component and install the
1972              configuration data.  */
1973           option = find_option (component, line, backend);
1974           if (option)
1975             {
1976               char *opt_value;
1977
1978               if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
1979                 {
1980                   if (*value)
1981                     gc_error (0, 0,
1982                               "warning: ignoring argument %s for option %s",
1983                               value, name);
1984                   opt_value = xstrdup ("1");
1985                 }
1986               else if (gc_arg_type[option->arg_type].fallback
1987                        == GC_ARG_TYPE_STRING)
1988                 opt_value = xasprintf ("\"%s", gc_percent_escape (value));
1989               else
1990                 {
1991                   /* FIXME: Verify that the number is sane.  */
1992                   opt_value = xstrdup (value);
1993                 }
1994
1995               /* Now enter the option into the table.  */
1996               if (!(option->flags & GC_OPT_FLAG_LIST))
1997                 {
1998                   if (option->value)
1999                     free (option->value);
2000                   option->value = opt_value;
2001                 }
2002               else
2003                 {
2004                   if (!option->value)
2005                     option->value = opt_value;
2006                   else
2007                     {
2008                       char *opt_val = opt_value;
2009
2010                       option->value = xasprintf ("%s,%s", option->value,
2011                                                  opt_val);
2012                       xfree (opt_value);
2013                     }
2014                 }
2015             }
2016         }
2017
2018       if (length < 0 || ferror (config))
2019         gc_error (1, errno, "error reading from %s", config_filename);
2020       if (fclose (config) && ferror (config))
2021         gc_error (1, errno, "error closing %s", config_filename);
2022     }
2023
2024   xfree (line);
2025 }
2026
2027
2028 /* Retrieve the options for the component COMPONENT from backend
2029    BACKEND, which we already know is of type file list.  */ 
2030 static void
2031 retrieve_options_from_file (gc_component_t component, gc_backend_t backend)
2032 {
2033   gc_option_t *list_option;
2034   gc_option_t *config_option;
2035   char *list_filename;
2036   FILE *list_file;
2037   char *line = NULL;
2038   size_t line_len = 0;
2039   ssize_t length;
2040   char *list = NULL;
2041
2042   list_option = find_option (component,
2043                              gc_backend[backend].option_name, GC_BACKEND_ANY);
2044   assert (list_option);
2045   assert (!list_option->active);
2046
2047   list_filename = get_config_filename (component, backend);
2048   list_file = fopen (list_filename, "r");
2049   if (!list_file)
2050     gc_error (0, errno, "warning: can not open list file %s", list_filename);
2051   else
2052     {
2053
2054       while ((length = read_line (list_file, &line, &line_len, NULL)) > 0)
2055         {
2056           char *start;
2057           char *end;
2058           char *new_list;
2059
2060           start = line;
2061           while (*start == ' ' || *start == '\t')
2062             start++;
2063           if (!*start || *start == '#' || *start == '\r' || *start == '\n')
2064             continue;
2065
2066           end = start;
2067           while (*end && *end != '#' && *end != '\r' && *end != '\n')
2068             end++;
2069           /* Walk back to skip trailing white spaces.  Looks evil, but
2070              works because of the conditions on START and END imposed
2071              at this point (END is at least START + 1, and START is
2072              not a whitespace character).  */
2073           while (*(end - 1) == ' ' || *(end - 1) == '\t')
2074             end--;
2075           *end = '\0';
2076           /* FIXME: Oh, no!  This is so lame!  Should use realloc and
2077              really append.  */
2078           if (list)
2079             {
2080               new_list = xasprintf ("%s,\"%s", list, gc_percent_escape (start));
2081               xfree (list);
2082               list = new_list;
2083             }
2084           else
2085             list = xasprintf ("\"%s", gc_percent_escape (start));
2086         }
2087       if (length < 0 || ferror (list_file))
2088         gc_error (1, errno, "can not read list file %s", list_filename);
2089     }
2090
2091   list_option->active = 1;
2092   list_option->value = list;
2093
2094   /* Fix up the read-only flag.  */
2095   config_option = find_option
2096     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
2097   if (config_option->flags & GC_OPT_FLAG_NO_CHANGE)
2098     list_option->flags |= GC_OPT_FLAG_NO_CHANGE;
2099
2100   if (list_file && fclose (list_file) && ferror (list_file))
2101     gc_error (1, errno, "error closing %s", list_filename);
2102   xfree (line);
2103 }
2104
2105
2106 /* Retrieve the currently active options and their defaults from all
2107    involved backends for this component.  Using -1 for component will
2108    retrieve all options from all components. */
2109 void
2110 gc_component_retrieve_options (int component)
2111 {
2112   int process_all = 0;
2113   int backend_seen[GC_BACKEND_NR];
2114   gc_backend_t backend;
2115   gc_option_t *option;
2116
2117   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2118     backend_seen[backend] = 0;
2119
2120   if (component == -1)
2121     {
2122       process_all = 1;
2123       component = 0;
2124       assert (component < GC_COMPONENT_NR);
2125     }
2126       
2127   do
2128     {
2129       option = gc_component[component].options;
2130
2131       while (option && option->name)
2132         {
2133           if (!(option->flags & GC_OPT_FLAG_GROUP))
2134             {
2135               backend = option->backend;
2136               
2137               if (backend_seen[backend])
2138                 {
2139                   option++;
2140                   continue;
2141                 }
2142               backend_seen[backend] = 1;
2143               
2144               assert (backend != GC_BACKEND_ANY);
2145               
2146               if (gc_backend[backend].program)
2147                 retrieve_options_from_program (component, backend);
2148               else
2149                 retrieve_options_from_file (component, backend);
2150             }
2151           option++;
2152         }
2153     }
2154   while (process_all && ++component < GC_COMPONENT_NR);
2155
2156 }
2157
2158
2159 \f
2160 /* Perform a simple validity check based on the type.  Return in
2161    NEW_VALUE_NR the value of the number in NEW_VALUE if OPTION is of
2162    type GC_ARG_TYPE_NONE.  */
2163 static void
2164 option_check_validity (gc_option_t *option, unsigned long flags,
2165                        char *new_value, unsigned long *new_value_nr)
2166 {
2167   char *arg;
2168
2169   if (!option->active)
2170     gc_error (1, 0, "option %s not supported by backend %s",
2171               option->name, gc_backend[option->backend].name);
2172       
2173   if (option->new_flags || option->new_value)
2174     gc_error (1, 0, "option %s already changed", option->name);
2175
2176   if (flags & GC_OPT_FLAG_DEFAULT)
2177     {
2178       if (*new_value)
2179         gc_error (1, 0, "argument %s provided for deleted option %s",
2180                   new_value, option->name);
2181
2182       return;
2183     }
2184
2185   /* GC_ARG_TYPE_NONE options have special list treatment.  */
2186   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
2187     {
2188       char *tail;
2189
2190       gpg_err_set_errno (0);
2191       *new_value_nr = strtoul (new_value, &tail, 0);
2192
2193       if (errno)
2194         gc_error (1, errno, "invalid argument for option %s",
2195                   option->name);
2196       if (*tail)
2197         gc_error (1, 0, "garbage after argument for option %s",
2198                       option->name);
2199
2200       if (!(option->flags & GC_OPT_FLAG_LIST))
2201         {
2202           if (*new_value_nr != 1)
2203             gc_error (1, 0, "argument for non-list option %s of type 0 "
2204                       "(none) must be 1", option->name);
2205         }
2206       else
2207         {
2208           if (*new_value_nr == 0)
2209             gc_error (1, 0, "argument for option %s of type 0 (none) "
2210                       "must be positive", option->name);
2211         }
2212
2213       return;
2214     }
2215
2216   arg = new_value;
2217   do
2218     {
2219       if (*arg == '\0' || *arg == ',')
2220         {
2221           if (!(option->flags & GC_OPT_FLAG_ARG_OPT))
2222             gc_error (1, 0, "argument required for option %s", option->name);
2223
2224           if (*arg == ',' && !(option->flags & GC_OPT_FLAG_LIST))
2225             gc_error (1, 0, "list found for non-list option %s", option->name);
2226         }
2227       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_STRING)
2228         {
2229           if (*arg != '"')
2230             gc_error (1, 0, "string argument for option %s must begin "
2231                       "with a quote (\") character", option->name);
2232
2233           /* FIXME: We do not allow empty string arguments for now, as
2234              we do not quote arguments in configuration files, and
2235              thus no argument is indistinguishable from the empty
2236              string.  */
2237           if (arg[1] == '\0' || arg[1] == ',')
2238             gc_error (1, 0, "empty string argument for option %s is "
2239                       "currently not allowed.  Please report this!",
2240                       option->name);
2241         }
2242       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2243         {
2244           long res;
2245
2246           gpg_err_set_errno (0);
2247           res = strtol (arg, &arg, 0);
2248           (void) res;
2249
2250           if (errno)
2251             gc_error (1, errno, "invalid argument for option %s",
2252                       option->name);
2253
2254           if (*arg != '\0' && *arg != ',')
2255             gc_error (1, 0, "garbage after argument for option %s",
2256                       option->name);
2257         }
2258       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2259         {
2260           unsigned long res;
2261
2262           gpg_err_set_errno (0);
2263           res = strtoul (arg, &arg, 0);
2264           (void) res;
2265
2266           if (errno)
2267             gc_error (1, errno, "invalid argument for option %s",
2268                       option->name);
2269
2270           if (*arg != '\0' && *arg != ',')
2271             gc_error (1, 0, "garbage after argument for option %s",
2272                       option->name);
2273         }
2274       arg = strchr (arg, ',');
2275       if (arg)
2276         arg++;
2277     }
2278   while (arg && *arg);
2279 }
2280
2281 #ifdef HAVE_W32_SYSTEM
2282 int
2283 copy_file (const char *src_name, const char *dst_name)
2284 {
2285 #define BUF_LEN 4096
2286   char buffer[BUF_LEN];
2287   int len;
2288   FILE *src;
2289   FILE *dst;
2290
2291   src = fopen (src_name, "r");
2292   if (src == NULL)
2293     return -1;
2294
2295   dst = fopen (dst_name, "w");
2296   if (dst == NULL)
2297     {
2298       int saved_err = errno;
2299       fclose (src);
2300       gpg_err_set_errno (saved_err);
2301       return -1;
2302     }
2303
2304   do
2305     {
2306       int written;
2307
2308       len = fread (buffer, 1, BUF_LEN, src);
2309       if (len == 0)
2310         break;
2311       written = fwrite (buffer, 1, len, dst);
2312       if (written != len)
2313         break;
2314     }
2315   while (!feof (src) && !ferror (src) && !ferror (dst));
2316
2317   if (ferror (src) || ferror (dst) || !feof (src))
2318     {
2319       int saved_errno = errno;
2320       fclose (src);
2321       fclose (dst);
2322       unlink (dst_name);
2323       gpg_err_set_errno (saved_errno);
2324       return -1;
2325     }
2326
2327   if (fclose (dst) && ferror (dst))
2328     gc_error (1, errno, "error closing %s", dst_name);
2329   if (fclose (src) && ferror (src))
2330     gc_error (1, errno, "error closing %s", src_name);
2331
2332   return 0;
2333 }
2334 #endif /* HAVE_W32_SYSTEM */
2335
2336
2337 /* Create and verify the new configuration file for the specified
2338    backend and component.  Returns 0 on success and -1 on error.  */
2339 static int
2340 change_options_file (gc_component_t component, gc_backend_t backend,
2341                      char **src_filenamep, char **dest_filenamep,
2342                      char **orig_filenamep)
2343 {
2344   static const char marker[] = "###+++--- GPGConf ---+++###";
2345   /* True if we are within the marker in the config file.  */
2346   int in_marker = 0;
2347   gc_option_t *option;
2348   char *line = NULL;
2349   size_t line_len;
2350   ssize_t length;
2351   int res;
2352   int fd;
2353   FILE *src_file = NULL;
2354   FILE *dest_file = NULL;
2355   char *src_filename;
2356   char *dest_filename;
2357   char *orig_filename;
2358   char *arg;
2359   char *cur_arg = NULL;
2360
2361   option = find_option (component,
2362                         gc_backend[backend].option_name, GC_BACKEND_ANY);
2363   assert (option);
2364   assert (option->active);
2365   assert (gc_arg_type[option->arg_type].fallback != GC_ARG_TYPE_NONE);
2366
2367   /* FIXME.  Throughout the function, do better error reporting.  */
2368   /* Note that get_config_filename() calls percent_deescape(), so we
2369      call this before processing the arguments.  */
2370   dest_filename = xstrdup (get_config_filename (component, backend));
2371   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, (int)getpid ());
2372   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename,(int)getpid ());
2373
2374   arg = option->new_value;
2375   if (arg && arg[0] == '\0')
2376     arg = NULL;
2377   else if (arg)
2378     {
2379       char *end;
2380
2381       arg++;
2382       end = strchr (arg, ',');
2383       if (end)
2384         *end = '\0';
2385
2386       cur_arg = percent_deescape (arg);
2387       if (end)
2388         {
2389           *end = ',';
2390           arg = end + 1;
2391         }
2392       else
2393         arg = NULL;
2394     }
2395
2396 #ifdef HAVE_W32_SYSTEM
2397   res = copy_file (dest_filename, orig_filename);
2398 #else
2399   res = link (dest_filename, orig_filename);
2400 #endif
2401   if (res < 0 && errno != ENOENT)
2402     return -1;
2403   if (res < 0)
2404     {
2405       xfree (orig_filename);
2406       orig_filename = NULL;
2407     }
2408
2409   /* We now initialize the return strings, so the caller can do the
2410      cleanup for us.  */
2411   *src_filenamep = src_filename;
2412   *dest_filenamep = dest_filename;
2413   *orig_filenamep = orig_filename;
2414
2415   /* Use open() so that we can use O_EXCL.  */
2416   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2417   if (fd < 0)
2418     return -1;
2419   src_file = fdopen (fd, "w");
2420   res = errno;
2421   if (!src_file)
2422     {
2423       gpg_err_set_errno (res);
2424       return -1;
2425     }
2426
2427   /* Only if ORIG_FILENAME is not NULL did the configuration file
2428      exist already.  In this case, we will copy its content into the
2429      new configuration file, changing it to our liking in the
2430      process.  */
2431   if (orig_filename)
2432     {
2433       dest_file = fopen (dest_filename, "r");
2434       if (!dest_file)
2435         goto change_file_one_err;
2436
2437       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2438         {
2439           int disable = 0;
2440           char *start;
2441
2442           if (!strncmp (marker, line, sizeof (marker) - 1))
2443             {
2444               if (!in_marker)
2445                 in_marker = 1;
2446               else
2447                 break;
2448             }
2449
2450           start = line;
2451           while (*start == ' ' || *start == '\t')
2452             start++;
2453           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2454             {
2455               char *end;
2456               char *endp;
2457               char saved_end;
2458
2459               endp = start;
2460               end = endp;
2461
2462               /* Search for the end of the line.  */
2463               while (*endp && *endp != '#' && *endp != '\r' && *endp != '\n')
2464                 {
2465                   endp++;
2466                   if (*endp && *endp != ' ' && *endp != '\t'
2467                       && *endp != '\r' && *endp != '\n' && *endp != '#')
2468                     end = endp + 1;
2469                 }
2470               saved_end = *end;
2471               *end = '\0';
2472
2473               if ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2474                   || !cur_arg || strcmp (start, cur_arg))
2475                 disable = 1;
2476               else
2477                 {
2478                   /* Find next argument.  */
2479                   if (arg)
2480                     {
2481                       char *arg_end;
2482
2483                       arg++;
2484                       arg_end = strchr (arg, ',');
2485                       if (arg_end)
2486                         *arg_end = '\0';
2487
2488                       cur_arg = percent_deescape (arg);
2489                       if (arg_end)
2490                         {
2491                           *arg_end = ',';
2492                           arg = arg_end + 1;
2493                         }
2494                       else
2495                         arg = NULL;
2496                     }
2497                   else
2498                     cur_arg = NULL;
2499                 }
2500
2501               *end = saved_end;
2502             }
2503
2504           if (disable)
2505             {
2506               if (!in_marker)
2507                 {
2508                   fprintf (src_file,
2509                            "# GPGConf disabled this option here at %s\n",
2510                            asctimestamp (gnupg_get_time ()));
2511                   if (ferror (src_file))
2512                     goto change_file_one_err;
2513                   fprintf (src_file, "# %s", line);
2514                   if (ferror (src_file))
2515                     goto change_file_one_err;
2516                 }
2517             }
2518           else
2519             {
2520               fprintf (src_file, "%s", line);
2521               if (ferror (src_file))
2522                 goto change_file_one_err;
2523             }
2524         }
2525       if (length < 0 || ferror (dest_file))
2526         goto change_file_one_err;
2527     }
2528
2529   if (!in_marker)
2530     {
2531       /* There was no marker.  This is the first time we edit the
2532          file.  We add our own marker at the end of the file and
2533          proceed.  Note that we first write a newline, this guards us
2534          against files which lack the newline at the end of the last
2535          line, while it doesn't hurt us in all other cases.  */
2536       fprintf (src_file, "\n%s\n", marker);
2537       if (ferror (src_file))
2538         goto change_file_one_err;
2539     }
2540
2541   /* At this point, we have copied everything up to the end marker
2542      into the new file, except for the arguments we are going to add.
2543      Now, dump the new arguments and write the end marker, possibly
2544      followed by the rest of the original file.  */
2545   while (cur_arg)
2546     {
2547       fprintf (src_file, "%s\n", cur_arg);
2548
2549       /* Find next argument.  */
2550       if (arg)
2551         {
2552           char *end;
2553
2554           arg++;
2555           end = strchr (arg, ',');
2556           if (end)
2557             *end = '\0';
2558
2559           cur_arg = percent_deescape (arg);
2560           if (end)
2561             {
2562               *end = ',';
2563               arg = end + 1;
2564             }
2565           else
2566             arg = NULL;
2567         }
2568       else
2569         cur_arg = NULL;
2570     }
2571
2572   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2573   if (ferror (src_file))
2574     goto change_file_one_err;
2575
2576   if (!in_marker)
2577     {
2578       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2579       if (ferror (src_file))
2580         goto change_file_one_err;
2581       fprintf (src_file, "# It will disable options before this marked "
2582                "block, but it will\n");
2583       if (ferror (src_file))
2584         goto change_file_one_err;
2585       fprintf (src_file, "# never change anything below these lines.\n");
2586       if (ferror (src_file))
2587         goto change_file_one_err;
2588     }
2589   if (dest_file)
2590     {
2591       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2592         {
2593           fprintf (src_file, "%s", line);
2594           if (ferror (src_file))
2595             goto change_file_one_err;
2596         }
2597       if (length < 0 || ferror (dest_file))
2598         goto change_file_one_err;
2599     }
2600   xfree (line);
2601   line = NULL;
2602
2603   res = fclose (src_file);
2604   if (res)
2605     {
2606       res = errno;
2607       close (fd);
2608       if (dest_file)
2609         fclose (dest_file);
2610       gpg_err_set_errno (res);
2611       return -1;
2612     }
2613   close (fd);
2614   if (dest_file)
2615     {
2616       res = fclose (dest_file);
2617       if (res)
2618         return -1;
2619     }
2620   return 0;
2621
2622  change_file_one_err:
2623   xfree (line);
2624   res = errno;
2625   if (src_file)
2626     {
2627       fclose (src_file);
2628       close (fd);
2629     }
2630   if (dest_file)
2631     fclose (dest_file);
2632   gpg_err_set_errno (res);
2633   return -1;
2634 }
2635
2636
2637 /* Create and verify the new configuration file for the specified
2638    backend and component.  Returns 0 on success and -1 on error.  */
2639 static int
2640 change_options_program (gc_component_t component, gc_backend_t backend,
2641                         char **src_filenamep, char **dest_filenamep,
2642                         char **orig_filenamep)
2643 {
2644   static const char marker[] = "###+++--- GPGConf ---+++###";
2645   /* True if we are within the marker in the config file.  */
2646   int in_marker = 0;
2647   gc_option_t *option;
2648   char *line = NULL;
2649   size_t line_len;
2650   ssize_t length;
2651   int res;
2652   int fd;
2653   FILE *src_file = NULL;
2654   FILE *dest_file = NULL;
2655   char *src_filename;
2656   char *dest_filename;
2657   char *orig_filename;
2658   /* Special hack for gpg, see below.  */
2659   int utf8strings_seen = 0;
2660
2661   /* FIXME.  Throughout the function, do better error reporting.  */
2662   dest_filename = xstrdup (get_config_filename (component, backend));
2663   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, (int)getpid ());
2664   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename,(int)getpid ());
2665
2666 #ifdef HAVE_W32_SYSTEM
2667   res = copy_file (dest_filename, orig_filename);
2668 #else
2669   res = link (dest_filename, orig_filename);
2670 #endif
2671   if (res < 0 && errno != ENOENT)
2672     return -1;
2673   if (res < 0)
2674     {
2675       xfree (orig_filename);
2676       orig_filename = NULL;
2677     }
2678
2679   /* We now initialize the return strings, so the caller can do the
2680      cleanup for us.  */
2681   *src_filenamep = src_filename;
2682   *dest_filenamep = dest_filename;
2683   *orig_filenamep = orig_filename;
2684
2685   /* Use open() so that we can use O_EXCL.  */
2686   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2687   if (fd < 0)
2688     return -1;
2689   src_file = fdopen (fd, "w");
2690   res = errno;
2691   if (!src_file)
2692     {
2693       gpg_err_set_errno (res);
2694       return -1;
2695     }
2696
2697   /* Only if ORIG_FILENAME is not NULL did the configuration file
2698      exist already.  In this case, we will copy its content into the
2699      new configuration file, changing it to our liking in the
2700      process.  */
2701   if (orig_filename)
2702     {
2703       dest_file = fopen (dest_filename, "r");
2704       if (!dest_file)
2705         goto change_one_err;
2706
2707       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2708         {
2709           int disable = 0;
2710           char *start;
2711
2712           if (!strncmp (marker, line, sizeof (marker) - 1))
2713             {
2714               if (!in_marker)
2715                 in_marker = 1;
2716               else
2717                 break;
2718             }
2719           else if (backend == GC_BACKEND_GPG && in_marker
2720                    && ! strcmp ("utf8-strings\n", line))
2721             {
2722               /* Strip duplicated entries.  */
2723               if (utf8strings_seen)
2724                 disable = 1;
2725               else
2726                 utf8strings_seen = 1;
2727             }
2728
2729           start = line;
2730           while (*start == ' ' || *start == '\t')
2731             start++;
2732           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2733             {
2734               char *end;
2735               char saved_end;
2736
2737               end = start;
2738               while (*end && *end != ' ' && *end != '\t'
2739                      && *end != '\r' && *end != '\n' && *end != '#')
2740                 end++;
2741               saved_end = *end;
2742               *end = '\0';
2743
2744               option = find_option (component, start, backend);
2745               *end = saved_end;
2746               if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2747                              || option->new_value))
2748                 disable = 1;
2749             }
2750           if (disable)
2751             {
2752               if (!in_marker)
2753                 {
2754                   fprintf (src_file,
2755                            "# GPGConf disabled this option here at %s\n",
2756                            asctimestamp (gnupg_get_time ()));
2757                   if (ferror (src_file))
2758                     goto change_one_err;
2759                   fprintf (src_file, "# %s", line);
2760                   if (ferror (src_file))
2761                     goto change_one_err;
2762                 }
2763             }
2764           else
2765             {
2766               fprintf (src_file, "%s", line);
2767               if (ferror (src_file))
2768                 goto change_one_err;
2769             }
2770         }
2771       if (length < 0 || ferror (dest_file))
2772         goto change_one_err;
2773     }
2774
2775   if (!in_marker)
2776     {
2777       /* There was no marker.  This is the first time we edit the
2778          file.  We add our own marker at the end of the file and
2779          proceed.  Note that we first write a newline, this guards us
2780          against files which lack the newline at the end of the last
2781          line, while it doesn't hurt us in all other cases.  */
2782       fprintf (src_file, "\n%s\n", marker);
2783       if (ferror (src_file))
2784         goto change_one_err;
2785     }
2786   /* At this point, we have copied everything up to the end marker
2787      into the new file, except for the options we are going to change.
2788      Now, dump the changed options (except for those we are going to
2789      revert to their default), and write the end marker, possibly
2790      followed by the rest of the original file.  */
2791
2792   /* We have to turn on UTF8 strings for GnuPG.  */
2793   if (backend == GC_BACKEND_GPG && ! utf8strings_seen)
2794     fprintf (src_file, "utf8-strings\n");
2795
2796   option = gc_component[component].options;
2797   while (option->name)
2798     {
2799       if (!(option->flags & GC_OPT_FLAG_GROUP)
2800           && option->backend == backend
2801           && option->new_value)
2802         {
2803           char *arg = option->new_value;
2804
2805           do
2806             {
2807               if (*arg == '\0' || *arg == ',')
2808                 {
2809                   fprintf (src_file, "%s\n", option->name);
2810                   if (ferror (src_file))
2811                     goto change_one_err;
2812                 }
2813               else if (gc_arg_type[option->arg_type].fallback
2814                        == GC_ARG_TYPE_NONE)
2815                 {
2816                   assert (*arg == '1');
2817                   fprintf (src_file, "%s\n", option->name);
2818                   if (ferror (src_file))
2819                     goto change_one_err;
2820
2821                   arg++;
2822                 }
2823               else if (gc_arg_type[option->arg_type].fallback
2824                        == GC_ARG_TYPE_STRING)
2825                 {
2826                   char *end;
2827                   
2828                   assert (*arg == '"');
2829                   arg++;
2830                   
2831                   end = strchr (arg, ',');
2832                   if (end)
2833                     *end = '\0';
2834
2835                   fprintf (src_file, "%s %s\n", option->name,
2836                            percent_deescape (arg));
2837                   if (ferror (src_file))
2838                     goto change_one_err;
2839
2840                   if (end)
2841                     *end = ',';
2842                   arg = end;
2843                 }
2844               else
2845                 {
2846                   char *end;
2847
2848                   end = strchr (arg, ',');
2849                   if (end)
2850                     *end = '\0';
2851
2852                   fprintf (src_file, "%s %s\n", option->name, arg);
2853                   if (ferror (src_file))
2854                     goto change_one_err;
2855
2856                   if (end)
2857                     *end = ',';
2858                   arg = end;
2859                 }
2860
2861               assert (arg == NULL || *arg == '\0' || *arg == ',');
2862               if (arg && *arg == ',')
2863                 arg++;
2864             }
2865           while (arg && *arg);
2866         }
2867       option++;
2868     }
2869
2870   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2871   if (ferror (src_file))
2872     goto change_one_err;
2873
2874   if (!in_marker)
2875     {
2876       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2877       if (ferror (src_file))
2878         goto change_one_err;
2879       fprintf (src_file, "# It will disable options before this marked "
2880                "block, but it will\n");
2881       if (ferror (src_file))
2882         goto change_one_err;
2883       fprintf (src_file, "# never change anything below these lines.\n");
2884       if (ferror (src_file))
2885         goto change_one_err;
2886     }
2887   if (dest_file)
2888     {
2889       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2890         {
2891           fprintf (src_file, "%s", line);
2892           if (ferror (src_file))
2893             goto change_one_err;
2894         }
2895       if (length < 0 || ferror (dest_file))
2896         goto change_one_err;
2897     }
2898   xfree (line);
2899   line = NULL;
2900
2901   res = fclose (src_file);
2902   if (res)
2903     {
2904       res = errno;
2905       close (fd);
2906       if (dest_file)
2907         fclose (dest_file);
2908       gpg_err_set_errno (res);
2909       return -1;
2910     }
2911   close (fd);
2912   if (dest_file)
2913     {
2914       res = fclose (dest_file);
2915       if (res)
2916         return -1;
2917     }
2918   return 0;
2919
2920  change_one_err:
2921   xfree (line);
2922   res = errno;
2923   if (src_file)
2924     {
2925       fclose (src_file);
2926       close (fd);
2927     }
2928   if (dest_file)
2929     fclose (dest_file);
2930   gpg_err_set_errno (res);
2931   return -1;
2932 }
2933
2934
2935 /* Common code for gc_component_change_options and
2936    gc_process_gpgconf_conf.  */
2937 static void
2938 change_one_value (gc_option_t *option, int *runtime,
2939                   unsigned long flags, char *new_value)
2940 {
2941   unsigned long new_value_nr = 0;
2942
2943   option_check_validity (option, flags, new_value, &new_value_nr);
2944
2945   if (option->flags & GC_OPT_FLAG_RUNTIME)
2946     runtime[option->backend] = 1;
2947
2948   option->new_flags = flags;
2949   if (!(flags & GC_OPT_FLAG_DEFAULT))
2950     {
2951       if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
2952           && (option->flags & GC_OPT_FLAG_LIST))
2953         {
2954           char *str;
2955
2956           /* We convert the number to a list of 1's for convenient
2957              list handling.  */
2958           assert (new_value_nr > 0);
2959           option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
2960           str = option->new_value;
2961           *(str++) = '1';
2962           while (--new_value_nr > 0)
2963             {
2964               *(str++) = ',';
2965               *(str++) = '1';
2966             }
2967           *(str++) = '\0';
2968         }
2969       else
2970         option->new_value = xstrdup (new_value);
2971     }
2972 }
2973
2974
2975 /* Read the modifications from IN and apply them.  If IN is NULL the
2976    modifications are expected to already have been set to the global
2977    table. */
2978 void
2979 gc_component_change_options (int component, FILE *in, FILE *out)
2980 {
2981   int err = 0;
2982   int runtime[GC_BACKEND_NR];
2983   char *src_filename[GC_BACKEND_NR];
2984   char *dest_filename[GC_BACKEND_NR];
2985   char *orig_filename[GC_BACKEND_NR];
2986   gc_backend_t backend;
2987   gc_option_t *option;
2988   char *line = NULL;
2989   size_t line_len = 0;
2990   ssize_t length;
2991
2992   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2993     {
2994       runtime[backend] = 0;
2995       src_filename[backend] = NULL;
2996       dest_filename[backend] = NULL;
2997       orig_filename[backend] = NULL;
2998     }
2999
3000   if (in)
3001     {
3002       /* Read options from the file IN.  */
3003       while ((length = read_line (in, &line, &line_len, NULL)) > 0)
3004         {
3005           char *linep;
3006           unsigned long flags = 0;
3007           char *new_value = "";
3008           
3009           /* Strip newline and carriage return, if present.  */
3010           while (length > 0
3011                  && (line[length - 1] == '\n' || line[length - 1] == '\r'))
3012             line[--length] = '\0';
3013           
3014           linep = strchr (line, ':');
3015           if (linep)
3016             *(linep++) = '\0';
3017           
3018           /* Extract additional flags.  Default to none.  */
3019           if (linep)
3020             {
3021               char *end;
3022               char *tail;
3023
3024               end = strchr (linep, ':');
3025               if (end)
3026                 *(end++) = '\0';
3027               
3028               gpg_err_set_errno (0);
3029               flags = strtoul (linep, &tail, 0);
3030               if (errno)
3031                 gc_error (1, errno, "malformed flags in option %s", line);
3032               if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
3033                 gc_error (1, 0, "garbage after flags in option %s", line);
3034               
3035               linep = end;
3036             }
3037
3038           /* Don't allow setting of the no change flag.  */
3039           flags &= ~GC_OPT_FLAG_NO_CHANGE;
3040           
3041           /* Extract default value, if present.  Default to empty if not.  */
3042           if (linep)
3043             {
3044               char *end;
3045               end = strchr (linep, ':');
3046               if (end)
3047                 *(end++) = '\0';
3048               new_value = linep;
3049               linep = end;
3050             }
3051           
3052           option = find_option (component, line, GC_BACKEND_ANY);
3053           if (!option)
3054             gc_error (1, 0, "unknown option %s", line);
3055           
3056           if ((option->flags & GC_OPT_FLAG_NO_CHANGE))
3057             {
3058               gc_error (0, 0, "ignoring new value for option %s",
3059                         option->name);
3060               continue;
3061             }
3062           
3063           change_one_value (option, runtime, flags, new_value);
3064         }
3065     }
3066
3067   /* Now that we have collected and locally verified the changes,
3068      write them out to new configuration files, verify them
3069      externally, and then commit them.  */
3070   option = gc_component[component].options;
3071   while (option && option->name)
3072     {
3073       /* Go on if we have already seen this backend, or if there is
3074          nothing to do.  */
3075       if (src_filename[option->backend]
3076           || !(option->new_flags || option->new_value))
3077         {
3078           option++;
3079           continue;
3080         }
3081
3082       if (gc_backend[option->backend].program)
3083         {
3084           err = change_options_program (component, option->backend,
3085                                         &src_filename[option->backend],
3086                                         &dest_filename[option->backend],
3087                                         &orig_filename[option->backend]);
3088           if (! err)
3089             {
3090               /* External verification.  */
3091               err = gc_component_check_options (component, out,
3092                                                 src_filename[option->backend]);
3093               if (err)
3094                 {
3095                   gc_error (0, 0,
3096                             _("External verification of component %s failed"),
3097                             gc_component[component].name);
3098                   gpg_err_set_errno (EINVAL);
3099                 }
3100             }
3101
3102         }
3103       else
3104         err = change_options_file (component, option->backend,
3105                                    &src_filename[option->backend],
3106                                    &dest_filename[option->backend],
3107                                    &orig_filename[option->backend]);
3108         
3109       if (err)
3110         break;
3111           
3112       option++;
3113     }
3114
3115   if (! err && ! opt.dry_run)
3116     {
3117       int i;
3118
3119       for (i = 0; i < GC_BACKEND_NR; i++)
3120         {
3121           if (src_filename[i])
3122             {
3123               /* FIXME: Make a verification here.  */
3124
3125               assert (dest_filename[i]);
3126
3127               if (orig_filename[i])
3128                 {
3129 #ifdef HAVE_W32_SYSTEM
3130                   /* There is no atomic update on W32.  */
3131                   err = unlink (dest_filename[i]);
3132 #endif /* HAVE_W32_SYSTEM */
3133                   if (!err)
3134                     err = rename (src_filename[i], dest_filename[i]);
3135                 }
3136               else
3137                 {
3138 #ifdef HAVE_W32_SYSTEM
3139                   /* We skip the unlink if we expect the file not to
3140                      be there.  */
3141                   err = rename (src_filename[i], dest_filename[i]);
3142 #else /* HAVE_W32_SYSTEM */
3143                   /* This is a bit safer than rename() because we
3144                      expect DEST_FILENAME not to be there.  If it
3145                      happens to be there, this will fail.  */
3146                   err = link (src_filename[i], dest_filename[i]);
3147                   if (!err)
3148                     err = unlink (src_filename[i]);
3149 #endif /* !HAVE_W32_SYSTEM */
3150                 }
3151               if (err)
3152                 break;
3153               src_filename[i] = NULL;
3154             }
3155         }
3156     }
3157
3158   if (err || opt.dry_run)
3159     {
3160       int i;
3161       int saved_errno = errno;
3162
3163       /* An error occured or a dry-run is requested.  */
3164       for (i = 0; i < GC_BACKEND_NR; i++)
3165         {
3166           if (src_filename[i])
3167             {
3168               /* The change was not yet committed.  */
3169               unlink (src_filename[i]);
3170               if (orig_filename[i])
3171                 unlink (orig_filename[i]);
3172             }
3173           else
3174             {
3175               /* The changes were already committed.  FIXME: This is a
3176                  tad dangerous, as we don't know if we don't overwrite
3177                  a version of the file that is even newer than the one
3178                  we just installed.  */
3179               if (orig_filename[i])
3180                 {
3181 #ifdef HAVE_W32_SYSTEM
3182                   /* There is no atomic update on W32.  */
3183                   unlink (dest_filename[i]);
3184 #endif /* HAVE_W32_SYSTEM */
3185                   rename (orig_filename[i], dest_filename[i]);
3186                 }
3187               else
3188                 unlink (dest_filename[i]);
3189             }
3190         }
3191       if (err)
3192         gc_error (1, saved_errno, "could not commit changes");
3193
3194       /* Fall-through for dry run.  */
3195       goto leave;
3196     }
3197
3198   /* If it all worked, notify the daemons of the changes.  */
3199   if (opt.runtime)
3200     for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3201       {
3202         if (runtime[backend] && gc_backend[backend].runtime_change)
3203           (*gc_backend[backend].runtime_change) ();
3204       }
3205
3206   /* Move the per-process backup file into its place.  */
3207   for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3208     if (orig_filename[backend])
3209       {
3210         char *backup_filename;
3211
3212         assert (dest_filename[backend]);
3213
3214         backup_filename = xasprintf ("%s.gpgconf.bak", dest_filename[backend]);
3215
3216 #ifdef HAVE_W32_SYSTEM
3217         /* There is no atomic update on W32.  */
3218         unlink (backup_filename);
3219 #endif /* HAVE_W32_SYSTEM */
3220         rename (orig_filename[backend], backup_filename);
3221       }
3222
3223  leave:
3224   xfree (line);
3225 }
3226
3227
3228 /* Check whether USER matches the current user of one of its group.
3229    This function may change USER.  Returns true is there is a
3230    match.  */
3231 static int
3232 key_matches_user_or_group (char *user)
3233 {
3234   char *group;
3235
3236   if (*user == '*' && user[1] == 0)
3237     return 1; /* A single asterisk matches all users.  */
3238
3239   group = strchr (user, ':');
3240   if (group)
3241     *group++ = 0;
3242
3243 #ifdef HAVE_W32_SYSTEM
3244   /* Under Windows we don't support groups. */   
3245   if (group && *group)
3246     gc_error (0, 0, _("Note that group specifications are ignored\n"));
3247 #ifndef HAVE_W32CE_SYSTEM
3248   if (*user)
3249     {
3250       static char *my_name;
3251
3252       if (!my_name)
3253         {
3254           char tmp[1];
3255           DWORD size = 1;
3256
3257           GetUserNameA (tmp, &size);
3258           my_name = xmalloc (size);
3259           if (!GetUserNameA (my_name, &size))
3260             gc_error (1,0, "error getting current user name: %s",
3261                       w32_strerror (-1));
3262         }
3263
3264       if (!strcmp (user, my_name))
3265         return 1; /* Found.  */
3266     }
3267 #endif /*HAVE_W32CE_SYSTEM*/
3268 #else /*!HAVE_W32_SYSTEM*/
3269   /* First check whether the user matches.  */
3270   if (*user)
3271     {
3272       static char *my_name;
3273
3274       if (!my_name)
3275         {
3276           struct passwd *pw = getpwuid ( getuid () );
3277           if (!pw)
3278             gc_error (1, errno, "getpwuid failed for current user");
3279           my_name = xstrdup (pw->pw_name);
3280         }
3281       if (!strcmp (user, my_name))
3282         return 1; /* Found.  */
3283     }
3284
3285   /* If that failed, check whether a group matches.  */
3286   if (group && *group)
3287     {
3288       static char *my_group;
3289       static char **my_supgroups;
3290       int n;
3291
3292       if (!my_group)
3293         {
3294           struct group *gr = getgrgid ( getgid () );
3295           if (!gr)
3296             gc_error (1, errno, "getgrgid failed for current user");
3297           my_group = xstrdup (gr->gr_name);
3298         }
3299       if (!strcmp (group, my_group))
3300         return 1; /* Found.  */
3301
3302       if (!my_supgroups)
3303         {
3304           int ngids;
3305           gid_t *gids;
3306
3307           ngids = getgroups (0, NULL);
3308           gids  = xcalloc (ngids+1, sizeof *gids);
3309           ngids = getgroups (ngids, gids);
3310           if (ngids < 0)
3311             gc_error (1, errno, "getgroups failed for current user");
3312           my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
3313           for (n=0; n < ngids; n++)
3314             {
3315               struct group *gr = getgrgid ( gids[n] );
3316               if (!gr)
3317                 gc_error (1, errno, "getgrgid failed for supplementary group");
3318               my_supgroups[n] = xstrdup (gr->gr_name);
3319             }
3320           xfree (gids);
3321         }
3322
3323       for (n=0; my_supgroups[n]; n++)
3324         if (!strcmp (group, my_supgroups[n]))
3325           return 1; /* Found.  */
3326     }
3327 #endif /*!HAVE_W32_SYSTEM*/
3328   return 0; /* No match.  */
3329 }
3330
3331
3332
3333 /* Read and process the global configuration file for gpgconf.  This
3334    optional file is used to update our internal tables at runtime and
3335    may also be used to set new default values.  If FNAME is NULL the
3336    default name will be used.  With UPDATE set to true the internal
3337    tables are actually updated; if not set, only a syntax check is
3338    done.  If DEFAULTS is true the global options are written to the
3339    configuration files.  If LISTFP is set, no changes are done but the
3340    configuration file is printed to LISTFP in a colon separated format.
3341
3342    Returns 0 on success or if the config file is not present; -1 is
3343    returned on error. */
3344 int
3345 gc_process_gpgconf_conf (const char *fname_arg, int update, int defaults,
3346                          FILE *listfp)
3347 {
3348   int result = 0;
3349   char *line = NULL;
3350   size_t line_len = 0;
3351   ssize_t length;
3352   FILE *config;
3353   int lineno = 0;
3354   int in_rule = 0;
3355   int got_match = 0;
3356   int runtime[GC_BACKEND_NR];
3357   int used_components[GC_COMPONENT_NR];
3358   int backend_id, component_id;
3359   char *fname;
3360
3361   if (fname_arg)
3362     fname = xstrdup (fname_arg);
3363   else
3364     fname = make_filename (gnupg_sysconfdir (), "gpgconf.conf", NULL);
3365
3366   for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3367     runtime[backend_id] = 0;
3368   for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3369     used_components[component_id] = 0;
3370
3371   config = fopen (fname, "r");
3372   if (!config)
3373     {
3374       /* Do not print an error if the file is not available, except
3375          when running in syntax check mode.  */
3376       if (errno != ENOENT || !update)
3377         {
3378           gc_error (0, errno, "can not open global config file `%s'", fname);
3379           result = -1;
3380         }
3381       xfree (fname);
3382       return result;
3383     }
3384
3385   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
3386     {
3387       char *key, *component, *option, *flags, *value;
3388       char *empty;
3389       gc_option_t *option_info = NULL;
3390       char *p;
3391       int is_continuation;
3392       
3393       lineno++;
3394       key = line;
3395       while (*key == ' ' || *key == '\t')
3396         key++;
3397       if (!*key || *key == '#' || *key == '\r' || *key == '\n')
3398         continue;
3399
3400       is_continuation = (key != line);
3401
3402       /* Parse the key field.  */
3403       if (!is_continuation && got_match)
3404         break;  /* Finish after the first match.  */
3405       else if (!is_continuation)
3406         {
3407           in_rule = 0;
3408           for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
3409             ;
3410           if (!*p)
3411             {
3412               gc_error (0, 0, "missing rule at `%s', line %d", fname, lineno);
3413               result = -1;
3414               continue;
3415             }
3416           *p++ = 0;
3417           component = p;
3418         }
3419       else if (!in_rule)
3420         {
3421           gc_error (0, 0, "continuation but no rule at `%s', line %d",
3422                     fname, lineno);
3423           result = -1;
3424           continue;
3425         }
3426       else
3427         {
3428           component = key;
3429           key = NULL;
3430         }
3431
3432       in_rule = 1;
3433
3434       /* Parse the component.  */
3435       while (*component == ' ' || *component == '\t')
3436         component++;
3437       for (p=component; *p && !strchr (" \t\r\n", *p); p++)
3438         ;
3439       if (p == component)
3440         {
3441           gc_error (0, 0, "missing component at `%s', line %d",
3442                     fname, lineno);
3443           result = -1;
3444           continue;
3445         }
3446       empty = p;
3447       *p++ = 0;
3448       option = p;
3449       component_id = gc_component_find (component);
3450       if (component_id < 0)
3451         {
3452           gc_error (0, 0, "unknown component at `%s', line %d",
3453                     fname, lineno);
3454           result = -1;
3455         }
3456
3457       /* Parse the option name.  */
3458       while (*option == ' ' || *option == '\t')
3459         option++;
3460       for (p=option; *p && !strchr (" \t\r\n", *p); p++)
3461         ;
3462       if (p == option)
3463         {
3464           gc_error (0, 0, "missing option at `%s', line %d",
3465                     fname, lineno);
3466           result = -1;
3467           continue;
3468         }
3469       *p++ = 0;
3470       flags = p;
3471       if ( component_id != -1)
3472         {
3473           option_info = find_option (component_id, option, GC_BACKEND_ANY);
3474           if (!option_info)
3475             {
3476               gc_error (0, 0, "unknown option at `%s', line %d",
3477                         fname, lineno);
3478               result = -1;
3479             }
3480         }
3481
3482
3483       /* Parse the optional flags.  */
3484       while (*flags == ' ' || *flags == '\t')
3485         flags++;
3486       if (*flags == '[')
3487         {
3488           flags++;
3489           p = strchr (flags, ']');
3490           if (!p)
3491             {
3492               gc_error (0, 0, "syntax error in rule at `%s', line %d",
3493                         fname, lineno);
3494               result = -1;
3495               continue;
3496             }
3497           *p++ = 0;