Minor cleanups
[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           gpg_err_set_errno (0);
2245           (void) strtol (arg, &arg, 0);
2246
2247           if (errno)
2248             gc_error (1, errno, "invalid argument for option %s",
2249                       option->name);
2250
2251           if (*arg != '\0' && *arg != ',')
2252             gc_error (1, 0, "garbage after argument for option %s",
2253                       option->name);
2254         }
2255       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2256         {
2257           gpg_err_set_errno (0);
2258           (void) strtoul (arg, &arg, 0);
2259
2260           if (errno)
2261             gc_error (1, errno, "invalid argument for option %s",
2262                       option->name);
2263
2264           if (*arg != '\0' && *arg != ',')
2265             gc_error (1, 0, "garbage after argument for option %s",
2266                       option->name);
2267         }
2268       arg = strchr (arg, ',');
2269       if (arg)
2270         arg++;
2271     }
2272   while (arg && *arg);
2273 }
2274
2275 #ifdef HAVE_W32_SYSTEM
2276 int
2277 copy_file (const char *src_name, const char *dst_name)
2278 {
2279 #define BUF_LEN 4096
2280   char buffer[BUF_LEN];
2281   int len;
2282   FILE *src;
2283   FILE *dst;
2284
2285   src = fopen (src_name, "r");
2286   if (src == NULL)
2287     return -1;
2288
2289   dst = fopen (dst_name, "w");
2290   if (dst == NULL)
2291     {
2292       int saved_err = errno;
2293       fclose (src);
2294       gpg_err_set_errno (saved_err);
2295       return -1;
2296     }
2297
2298   do
2299     {
2300       int written;
2301
2302       len = fread (buffer, 1, BUF_LEN, src);
2303       if (len == 0)
2304         break;
2305       written = fwrite (buffer, 1, len, dst);
2306       if (written != len)
2307         break;
2308     }
2309   while (!feof (src) && !ferror (src) && !ferror (dst));
2310
2311   if (ferror (src) || ferror (dst) || !feof (src))
2312     {
2313       int saved_errno = errno;
2314       fclose (src);
2315       fclose (dst);
2316       unlink (dst_name);
2317       gpg_err_set_errno (saved_errno);
2318       return -1;
2319     }
2320
2321   if (fclose (dst) && ferror (dst))
2322     gc_error (1, errno, "error closing %s", dst_name);
2323   if (fclose (src) && ferror (src))
2324     gc_error (1, errno, "error closing %s", src_name);
2325
2326   return 0;
2327 }
2328 #endif /* HAVE_W32_SYSTEM */
2329
2330
2331 /* Create and verify the new configuration file for the specified
2332    backend and component.  Returns 0 on success and -1 on error.  */
2333 static int
2334 change_options_file (gc_component_t component, gc_backend_t backend,
2335                      char **src_filenamep, char **dest_filenamep,
2336                      char **orig_filenamep)
2337 {
2338   static const char marker[] = "###+++--- GPGConf ---+++###";
2339   /* True if we are within the marker in the config file.  */
2340   int in_marker = 0;
2341   gc_option_t *option;
2342   char *line = NULL;
2343   size_t line_len;
2344   ssize_t length;
2345   int res;
2346   int fd;
2347   FILE *src_file = NULL;
2348   FILE *dest_file = NULL;
2349   char *src_filename;
2350   char *dest_filename;
2351   char *orig_filename;
2352   char *arg;
2353   char *cur_arg = NULL;
2354
2355   option = find_option (component,
2356                         gc_backend[backend].option_name, GC_BACKEND_ANY);
2357   assert (option);
2358   assert (option->active);
2359   assert (gc_arg_type[option->arg_type].fallback != GC_ARG_TYPE_NONE);
2360
2361   /* FIXME.  Throughout the function, do better error reporting.  */
2362   /* Note that get_config_filename() calls percent_deescape(), so we
2363      call this before processing the arguments.  */
2364   dest_filename = xstrdup (get_config_filename (component, backend));
2365   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, (int)getpid ());
2366   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename,(int)getpid ());
2367
2368   arg = option->new_value;
2369   if (arg && arg[0] == '\0')
2370     arg = NULL;
2371   else if (arg)
2372     {
2373       char *end;
2374
2375       arg++;
2376       end = strchr (arg, ',');
2377       if (end)
2378         *end = '\0';
2379
2380       cur_arg = percent_deescape (arg);
2381       if (end)
2382         {
2383           *end = ',';
2384           arg = end + 1;
2385         }
2386       else
2387         arg = NULL;
2388     }
2389
2390 #ifdef HAVE_W32_SYSTEM
2391   res = copy_file (dest_filename, orig_filename);
2392 #else
2393   res = link (dest_filename, orig_filename);
2394 #endif
2395   if (res < 0 && errno != ENOENT)
2396     return -1;
2397   if (res < 0)
2398     {
2399       xfree (orig_filename);
2400       orig_filename = NULL;
2401     }
2402
2403   /* We now initialize the return strings, so the caller can do the
2404      cleanup for us.  */
2405   *src_filenamep = src_filename;
2406   *dest_filenamep = dest_filename;
2407   *orig_filenamep = orig_filename;
2408
2409   /* Use open() so that we can use O_EXCL.  */
2410   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2411   if (fd < 0)
2412     return -1;
2413   src_file = fdopen (fd, "w");
2414   res = errno;
2415   if (!src_file)
2416     {
2417       gpg_err_set_errno (res);
2418       return -1;
2419     }
2420
2421   /* Only if ORIG_FILENAME is not NULL did the configuration file
2422      exist already.  In this case, we will copy its content into the
2423      new configuration file, changing it to our liking in the
2424      process.  */
2425   if (orig_filename)
2426     {
2427       dest_file = fopen (dest_filename, "r");
2428       if (!dest_file)
2429         goto change_file_one_err;
2430
2431       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2432         {
2433           int disable = 0;
2434           char *start;
2435
2436           if (!strncmp (marker, line, sizeof (marker) - 1))
2437             {
2438               if (!in_marker)
2439                 in_marker = 1;
2440               else
2441                 break;
2442             }
2443
2444           start = line;
2445           while (*start == ' ' || *start == '\t')
2446             start++;
2447           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2448             {
2449               char *end;
2450               char *endp;
2451               char saved_end;
2452
2453               endp = start;
2454               end = endp;
2455
2456               /* Search for the end of the line.  */
2457               while (*endp && *endp != '#' && *endp != '\r' && *endp != '\n')
2458                 {
2459                   endp++;
2460                   if (*endp && *endp != ' ' && *endp != '\t'
2461                       && *endp != '\r' && *endp != '\n' && *endp != '#')
2462                     end = endp + 1;
2463                 }
2464               saved_end = *end;
2465               *end = '\0';
2466
2467               if ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2468                   || !cur_arg || strcmp (start, cur_arg))
2469                 disable = 1;
2470               else
2471                 {
2472                   /* Find next argument.  */
2473                   if (arg)
2474                     {
2475                       char *arg_end;
2476
2477                       arg++;
2478                       arg_end = strchr (arg, ',');
2479                       if (arg_end)
2480                         *arg_end = '\0';
2481
2482                       cur_arg = percent_deescape (arg);
2483                       if (arg_end)
2484                         {
2485                           *arg_end = ',';
2486                           arg = arg_end + 1;
2487                         }
2488                       else
2489                         arg = NULL;
2490                     }
2491                   else
2492                     cur_arg = NULL;
2493                 }
2494
2495               *end = saved_end;
2496             }
2497
2498           if (disable)
2499             {
2500               if (!in_marker)
2501                 {
2502                   fprintf (src_file,
2503                            "# GPGConf disabled this option here at %s\n",
2504                            asctimestamp (gnupg_get_time ()));
2505                   if (ferror (src_file))
2506                     goto change_file_one_err;
2507                   fprintf (src_file, "# %s", line);
2508                   if (ferror (src_file))
2509                     goto change_file_one_err;
2510                 }
2511             }
2512           else
2513             {
2514               fprintf (src_file, "%s", line);
2515               if (ferror (src_file))
2516                 goto change_file_one_err;
2517             }
2518         }
2519       if (length < 0 || ferror (dest_file))
2520         goto change_file_one_err;
2521     }
2522
2523   if (!in_marker)
2524     {
2525       /* There was no marker.  This is the first time we edit the
2526          file.  We add our own marker at the end of the file and
2527          proceed.  Note that we first write a newline, this guards us
2528          against files which lack the newline at the end of the last
2529          line, while it doesn't hurt us in all other cases.  */
2530       fprintf (src_file, "\n%s\n", marker);
2531       if (ferror (src_file))
2532         goto change_file_one_err;
2533     }
2534
2535   /* At this point, we have copied everything up to the end marker
2536      into the new file, except for the arguments we are going to add.
2537      Now, dump the new arguments and write the end marker, possibly
2538      followed by the rest of the original file.  */
2539   while (cur_arg)
2540     {
2541       fprintf (src_file, "%s\n", cur_arg);
2542
2543       /* Find next argument.  */
2544       if (arg)
2545         {
2546           char *end;
2547
2548           arg++;
2549           end = strchr (arg, ',');
2550           if (end)
2551             *end = '\0';
2552
2553           cur_arg = percent_deescape (arg);
2554           if (end)
2555             {
2556               *end = ',';
2557               arg = end + 1;
2558             }
2559           else
2560             arg = NULL;
2561         }
2562       else
2563         cur_arg = NULL;
2564     }
2565
2566   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2567   if (ferror (src_file))
2568     goto change_file_one_err;
2569
2570   if (!in_marker)
2571     {
2572       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2573       if (ferror (src_file))
2574         goto change_file_one_err;
2575       fprintf (src_file, "# It will disable options before this marked "
2576                "block, but it will\n");
2577       if (ferror (src_file))
2578         goto change_file_one_err;
2579       fprintf (src_file, "# never change anything below these lines.\n");
2580       if (ferror (src_file))
2581         goto change_file_one_err;
2582     }
2583   if (dest_file)
2584     {
2585       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2586         {
2587           fprintf (src_file, "%s", line);
2588           if (ferror (src_file))
2589             goto change_file_one_err;
2590         }
2591       if (length < 0 || ferror (dest_file))
2592         goto change_file_one_err;
2593     }
2594   xfree (line);
2595   line = NULL;
2596
2597   res = fclose (src_file);
2598   if (res)
2599     {
2600       res = errno;
2601       close (fd);
2602       if (dest_file)
2603         fclose (dest_file);
2604       gpg_err_set_errno (res);
2605       return -1;
2606     }
2607   close (fd);
2608   if (dest_file)
2609     {
2610       res = fclose (dest_file);
2611       if (res)
2612         return -1;
2613     }
2614   return 0;
2615
2616  change_file_one_err:
2617   xfree (line);
2618   res = errno;
2619   if (src_file)
2620     {
2621       fclose (src_file);
2622       close (fd);
2623     }
2624   if (dest_file)
2625     fclose (dest_file);
2626   gpg_err_set_errno (res);
2627   return -1;
2628 }
2629
2630
2631 /* Create and verify the new configuration file for the specified
2632    backend and component.  Returns 0 on success and -1 on error.  */
2633 static int
2634 change_options_program (gc_component_t component, gc_backend_t backend,
2635                         char **src_filenamep, char **dest_filenamep,
2636                         char **orig_filenamep)
2637 {
2638   static const char marker[] = "###+++--- GPGConf ---+++###";
2639   /* True if we are within the marker in the config file.  */
2640   int in_marker = 0;
2641   gc_option_t *option;
2642   char *line = NULL;
2643   size_t line_len;
2644   ssize_t length;
2645   int res;
2646   int fd;
2647   FILE *src_file = NULL;
2648   FILE *dest_file = NULL;
2649   char *src_filename;
2650   char *dest_filename;
2651   char *orig_filename;
2652   /* Special hack for gpg, see below.  */
2653   int utf8strings_seen = 0;
2654
2655   /* FIXME.  Throughout the function, do better error reporting.  */
2656   dest_filename = xstrdup (get_config_filename (component, backend));
2657   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, (int)getpid ());
2658   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename,(int)getpid ());
2659
2660 #ifdef HAVE_W32_SYSTEM
2661   res = copy_file (dest_filename, orig_filename);
2662 #else
2663   res = link (dest_filename, orig_filename);
2664 #endif
2665   if (res < 0 && errno != ENOENT)
2666     return -1;
2667   if (res < 0)
2668     {
2669       xfree (orig_filename);
2670       orig_filename = NULL;
2671     }
2672
2673   /* We now initialize the return strings, so the caller can do the
2674      cleanup for us.  */
2675   *src_filenamep = src_filename;
2676   *dest_filenamep = dest_filename;
2677   *orig_filenamep = orig_filename;
2678
2679   /* Use open() so that we can use O_EXCL.  */
2680   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2681   if (fd < 0)
2682     return -1;
2683   src_file = fdopen (fd, "w");
2684   res = errno;
2685   if (!src_file)
2686     {
2687       gpg_err_set_errno (res);
2688       return -1;
2689     }
2690
2691   /* Only if ORIG_FILENAME is not NULL did the configuration file
2692      exist already.  In this case, we will copy its content into the
2693      new configuration file, changing it to our liking in the
2694      process.  */
2695   if (orig_filename)
2696     {
2697       dest_file = fopen (dest_filename, "r");
2698       if (!dest_file)
2699         goto change_one_err;
2700
2701       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2702         {
2703           int disable = 0;
2704           char *start;
2705
2706           if (!strncmp (marker, line, sizeof (marker) - 1))
2707             {
2708               if (!in_marker)
2709                 in_marker = 1;
2710               else
2711                 break;
2712             }
2713           else if (backend == GC_BACKEND_GPG && in_marker
2714                    && ! strcmp ("utf8-strings\n", line))
2715             {
2716               /* Strip duplicated entries.  */
2717               if (utf8strings_seen)
2718                 disable = 1;
2719               else
2720                 utf8strings_seen = 1;
2721             }
2722
2723           start = line;
2724           while (*start == ' ' || *start == '\t')
2725             start++;
2726           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2727             {
2728               char *end;
2729               char saved_end;
2730
2731               end = start;
2732               while (*end && *end != ' ' && *end != '\t'
2733                      && *end != '\r' && *end != '\n' && *end != '#')
2734                 end++;
2735               saved_end = *end;
2736               *end = '\0';
2737
2738               option = find_option (component, start, backend);
2739               *end = saved_end;
2740               if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2741                              || option->new_value))
2742                 disable = 1;
2743             }
2744           if (disable)
2745             {
2746               if (!in_marker)
2747                 {
2748                   fprintf (src_file,
2749                            "# GPGConf disabled this option here at %s\n",
2750                            asctimestamp (gnupg_get_time ()));
2751                   if (ferror (src_file))
2752                     goto change_one_err;
2753                   fprintf (src_file, "# %s", line);
2754                   if (ferror (src_file))
2755                     goto change_one_err;
2756                 }
2757             }
2758           else
2759             {
2760               fprintf (src_file, "%s", line);
2761               if (ferror (src_file))
2762                 goto change_one_err;
2763             }
2764         }
2765       if (length < 0 || ferror (dest_file))
2766         goto change_one_err;
2767     }
2768
2769   if (!in_marker)
2770     {
2771       /* There was no marker.  This is the first time we edit the
2772          file.  We add our own marker at the end of the file and
2773          proceed.  Note that we first write a newline, this guards us
2774          against files which lack the newline at the end of the last
2775          line, while it doesn't hurt us in all other cases.  */
2776       fprintf (src_file, "\n%s\n", marker);
2777       if (ferror (src_file))
2778         goto change_one_err;
2779     }
2780   /* At this point, we have copied everything up to the end marker
2781      into the new file, except for the options we are going to change.
2782      Now, dump the changed options (except for those we are going to
2783      revert to their default), and write the end marker, possibly
2784      followed by the rest of the original file.  */
2785
2786   /* We have to turn on UTF8 strings for GnuPG.  */
2787   if (backend == GC_BACKEND_GPG && ! utf8strings_seen)
2788     fprintf (src_file, "utf8-strings\n");
2789
2790   option = gc_component[component].options;
2791   while (option->name)
2792     {
2793       if (!(option->flags & GC_OPT_FLAG_GROUP)
2794           && option->backend == backend
2795           && option->new_value)
2796         {
2797           char *arg = option->new_value;
2798
2799           do
2800             {
2801               if (*arg == '\0' || *arg == ',')
2802                 {
2803                   fprintf (src_file, "%s\n", option->name);
2804                   if (ferror (src_file))
2805                     goto change_one_err;
2806                 }
2807               else if (gc_arg_type[option->arg_type].fallback
2808                        == GC_ARG_TYPE_NONE)
2809                 {
2810                   assert (*arg == '1');
2811                   fprintf (src_file, "%s\n", option->name);
2812                   if (ferror (src_file))
2813                     goto change_one_err;
2814
2815                   arg++;
2816                 }
2817               else if (gc_arg_type[option->arg_type].fallback
2818                        == GC_ARG_TYPE_STRING)
2819                 {
2820                   char *end;
2821                   
2822                   assert (*arg == '"');
2823                   arg++;
2824                   
2825                   end = strchr (arg, ',');
2826                   if (end)
2827                     *end = '\0';
2828
2829                   fprintf (src_file, "%s %s\n", option->name,
2830                            percent_deescape (arg));
2831                   if (ferror (src_file))
2832                     goto change_one_err;
2833
2834                   if (end)
2835                     *end = ',';
2836                   arg = end;
2837                 }
2838               else
2839                 {
2840                   char *end;
2841
2842                   end = strchr (arg, ',');
2843                   if (end)
2844                     *end = '\0';
2845
2846                   fprintf (src_file, "%s %s\n", option->name, arg);
2847                   if (ferror (src_file))
2848                     goto change_one_err;
2849
2850                   if (end)
2851                     *end = ',';
2852                   arg = end;
2853                 }
2854
2855               assert (arg == NULL || *arg == '\0' || *arg == ',');
2856               if (arg && *arg == ',')
2857                 arg++;
2858             }
2859           while (arg && *arg);
2860         }
2861       option++;
2862     }
2863
2864   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2865   if (ferror (src_file))
2866     goto change_one_err;
2867
2868   if (!in_marker)
2869     {
2870       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2871       if (ferror (src_file))
2872         goto change_one_err;
2873       fprintf (src_file, "# It will disable options before this marked "
2874                "block, but it will\n");
2875       if (ferror (src_file))
2876         goto change_one_err;
2877       fprintf (src_file, "# never change anything below these lines.\n");
2878       if (ferror (src_file))
2879         goto change_one_err;
2880     }
2881   if (dest_file)
2882     {
2883       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2884         {
2885           fprintf (src_file, "%s", line);
2886           if (ferror (src_file))
2887             goto change_one_err;
2888         }
2889       if (length < 0 || ferror (dest_file))
2890         goto change_one_err;
2891     }
2892   xfree (line);
2893   line = NULL;
2894
2895   res = fclose (src_file);
2896   if (res)
2897     {
2898       res = errno;
2899       close (fd);
2900       if (dest_file)
2901         fclose (dest_file);
2902       gpg_err_set_errno (res);
2903       return -1;
2904     }
2905   close (fd);
2906   if (dest_file)
2907     {
2908       res = fclose (dest_file);
2909       if (res)
2910         return -1;
2911     }
2912   return 0;
2913
2914  change_one_err:
2915   xfree (line);
2916   res = errno;
2917   if (src_file)
2918     {
2919       fclose (src_file);
2920       close (fd);
2921     }
2922   if (dest_file)
2923     fclose (dest_file);
2924   gpg_err_set_errno (res);
2925   return -1;
2926 }
2927
2928
2929 /* Common code for gc_component_change_options and
2930    gc_process_gpgconf_conf.  */
2931 static void
2932 change_one_value (gc_option_t *option, int *runtime,
2933                   unsigned long flags, char *new_value)
2934 {
2935   unsigned long new_value_nr = 0;
2936
2937   option_check_validity (option, flags, new_value, &new_value_nr);
2938
2939   if (option->flags & GC_OPT_FLAG_RUNTIME)
2940     runtime[option->backend] = 1;
2941
2942   option->new_flags = flags;
2943   if (!(flags & GC_OPT_FLAG_DEFAULT))
2944     {
2945       if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
2946           && (option->flags & GC_OPT_FLAG_LIST))
2947         {
2948           char *str;
2949
2950           /* We convert the number to a list of 1's for convenient
2951              list handling.  */
2952           assert (new_value_nr > 0);
2953           option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
2954           str = option->new_value;
2955           *(str++) = '1';
2956           while (--new_value_nr > 0)
2957             {
2958               *(str++) = ',';
2959               *(str++) = '1';
2960             }
2961           *(str++) = '\0';
2962         }
2963       else
2964         option->new_value = xstrdup (new_value);
2965     }
2966 }
2967
2968
2969 /* Read the modifications from IN and apply them.  If IN is NULL the
2970    modifications are expected to already have been set to the global
2971    table. */
2972 void
2973 gc_component_change_options (int component, FILE *in, FILE *out)
2974 {
2975   int err = 0;
2976   int runtime[GC_BACKEND_NR];
2977   char *src_filename[GC_BACKEND_NR];
2978   char *dest_filename[GC_BACKEND_NR];
2979   char *orig_filename[GC_BACKEND_NR];
2980   gc_backend_t backend;
2981   gc_option_t *option;
2982   char *line = NULL;
2983   size_t line_len = 0;
2984   ssize_t length;
2985
2986   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2987     {
2988       runtime[backend] = 0;
2989       src_filename[backend] = NULL;
2990       dest_filename[backend] = NULL;
2991       orig_filename[backend] = NULL;
2992     }
2993
2994   if (in)
2995     {
2996       /* Read options from the file IN.  */
2997       while ((length = read_line (in, &line, &line_len, NULL)) > 0)
2998         {
2999           char *linep;
3000           unsigned long flags = 0;
3001           char *new_value = "";
3002           
3003           /* Strip newline and carriage return, if present.  */
3004           while (length > 0
3005                  && (line[length - 1] == '\n' || line[length - 1] == '\r'))
3006             line[--length] = '\0';
3007           
3008           linep = strchr (line, ':');
3009           if (linep)
3010             *(linep++) = '\0';
3011           
3012           /* Extract additional flags.  Default to none.  */
3013           if (linep)
3014             {
3015               char *end;
3016               char *tail;
3017
3018               end = strchr (linep, ':');
3019               if (end)
3020                 *(end++) = '\0';
3021               
3022               gpg_err_set_errno (0);
3023               flags = strtoul (linep, &tail, 0);
3024               if (errno)
3025                 gc_error (1, errno, "malformed flags in option %s", line);
3026               if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
3027                 gc_error (1, 0, "garbage after flags in option %s", line);
3028               
3029               linep = end;
3030             }
3031
3032           /* Don't allow setting of the no change flag.  */
3033           flags &= ~GC_OPT_FLAG_NO_CHANGE;
3034           
3035           /* Extract default value, if present.  Default to empty if not.  */
3036           if (linep)
3037             {
3038               char *end;
3039               end = strchr (linep, ':');
3040               if (end)
3041                 *(end++) = '\0';
3042               new_value = linep;
3043               linep = end;
3044             }
3045           
3046           option = find_option (component, line, GC_BACKEND_ANY);
3047           if (!option)
3048             gc_error (1, 0, "unknown option %s", line);
3049           
3050           if ((option->flags & GC_OPT_FLAG_NO_CHANGE))
3051             {
3052               gc_error (0, 0, "ignoring new value for option %s",
3053                         option->name);
3054               continue;
3055             }
3056           
3057           change_one_value (option, runtime, flags, new_value);
3058         }
3059     }
3060
3061   /* Now that we have collected and locally verified the changes,
3062      write them out to new configuration files, verify them
3063      externally, and then commit them.  */
3064   option = gc_component[component].options;
3065   while (option && option->name)
3066     {
3067       /* Go on if we have already seen this backend, or if there is
3068          nothing to do.  */
3069       if (src_filename[option->backend]
3070           || !(option->new_flags || option->new_value))
3071         {
3072           option++;
3073           continue;
3074         }
3075
3076       if (gc_backend[option->backend].program)
3077         {
3078           err = change_options_program (component, option->backend,
3079                                         &src_filename[option->backend],
3080                                         &dest_filename[option->backend],
3081                                         &orig_filename[option->backend]);
3082           if (! err)
3083             {
3084               /* External verification.  */
3085               err = gc_component_check_options (component, out,
3086                                                 src_filename[option->backend]);
3087               if (err)
3088                 {
3089                   gc_error (0, 0,
3090                             _("External verification of component %s failed"),
3091                             gc_component[component].name);
3092                   gpg_err_set_errno (EINVAL);
3093                 }
3094             }
3095
3096         }
3097       else
3098         err = change_options_file (component, option->backend,
3099                                    &src_filename[option->backend],
3100                                    &dest_filename[option->backend],
3101                                    &orig_filename[option->backend]);
3102         
3103       if (err)
3104         break;
3105           
3106       option++;
3107     }
3108
3109   if (! err && ! opt.dry_run)
3110     {
3111       int i;
3112
3113       for (i = 0; i < GC_BACKEND_NR; i++)
3114         {
3115           if (src_filename[i])
3116             {
3117               /* FIXME: Make a verification here.  */
3118
3119               assert (dest_filename[i]);
3120
3121               if (orig_filename[i])
3122                 {
3123 #ifdef HAVE_W32_SYSTEM
3124                   /* There is no atomic update on W32.  */
3125                   err = unlink (dest_filename[i]);
3126 #endif /* HAVE_W32_SYSTEM */
3127                   if (!err)
3128                     err = rename (src_filename[i], dest_filename[i]);
3129                 }
3130               else
3131                 {
3132 #ifdef HAVE_W32_SYSTEM
3133                   /* We skip the unlink if we expect the file not to
3134                      be there.  */
3135                   err = rename (src_filename[i], dest_filename[i]);
3136 #else /* HAVE_W32_SYSTEM */
3137                   /* This is a bit safer than rename() because we
3138                      expect DEST_FILENAME not to be there.  If it
3139                      happens to be there, this will fail.  */
3140                   err = link (src_filename[i], dest_filename[i]);
3141                   if (!err)
3142                     err = unlink (src_filename[i]);
3143 #endif /* !HAVE_W32_SYSTEM */
3144                 }
3145               if (err)
3146                 break;
3147               src_filename[i] = NULL;
3148             }
3149         }
3150     }
3151
3152   if (err || opt.dry_run)
3153     {
3154       int i;
3155       int saved_errno = errno;
3156
3157       /* An error occured or a dry-run is requested.  */
3158       for (i = 0; i < GC_BACKEND_NR; i++)
3159         {
3160           if (src_filename[i])
3161             {
3162               /* The change was not yet committed.  */
3163               unlink (src_filename[i]);
3164               if (orig_filename[i])
3165                 unlink (orig_filename[i]);
3166             }
3167           else
3168             {
3169               /* The changes were already committed.  FIXME: This is a
3170                  tad dangerous, as we don't know if we don't overwrite
3171                  a version of the file that is even newer than the one
3172                  we just installed.  */
3173               if (orig_filename[i])
3174                 {
3175 #ifdef HAVE_W32_SYSTEM
3176                   /* There is no atomic update on W32.  */
3177                   unlink (dest_filename[i]);
3178 #endif /* HAVE_W32_SYSTEM */
3179                   rename (orig_filename[i], dest_filename[i]);
3180                 }
3181               else
3182                 unlink (dest_filename[i]);
3183             }
3184         }
3185       if (err)
3186         gc_error (1, saved_errno, "could not commit changes");
3187
3188       /* Fall-through for dry run.  */
3189       goto leave;
3190     }
3191
3192   /* If it all worked, notify the daemons of the changes.  */
3193   if (opt.runtime)
3194     for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3195       {
3196         if (runtime[backend] && gc_backend[backend].runtime_change)
3197           (*gc_backend[backend].runtime_change) ();
3198       }
3199
3200   /* Move the per-process backup file into its place.  */
3201   for (backend = 0; backend < GC_BACKEND_NR; backend++)  
3202     if (orig_filename[backend])
3203       {
3204         char *backup_filename;
3205
3206         assert (dest_filename[backend]);
3207
3208         backup_filename = xasprintf ("%s.gpgconf.bak", dest_filename[backend]);
3209
3210 #ifdef HAVE_W32_SYSTEM
3211         /* There is no atomic update on W32.  */
3212         unlink (backup_filename);
3213 #endif /* HAVE_W32_SYSTEM */
3214         rename (orig_filename[backend], backup_filename);
3215       }
3216
3217  leave:
3218   xfree (line);
3219 }
3220
3221
3222 /* Check whether USER matches the current user of one of its group.
3223    This function may change USER.  Returns true is there is a
3224    match.  */
3225 static int
3226 key_matches_user_or_group (char *user)
3227 {
3228   char *group;
3229
3230   if (*user == '*' && user[1] == 0)
3231     return 1; /* A single asterisk matches all users.  */
3232
3233   group = strchr (user, ':');
3234   if (group)
3235     *group++ = 0;
3236
3237 #ifdef HAVE_W32_SYSTEM
3238   /* Under Windows we don't support groups. */   
3239   if (group && *group)
3240     gc_error (0, 0, _("Note that group specifications are ignored\n"));
3241 #ifndef HAVE_W32CE_SYSTEM
3242   if (*user)
3243     {
3244       static char *my_name;
3245
3246       if (!my_name)
3247         {
3248           char tmp[1];
3249           DWORD size = 1;
3250
3251           GetUserNameA (tmp, &size);
3252           my_name = xmalloc (size);
3253           if (!GetUserNameA (my_name, &size))
3254             gc_error (1,0, "error getting current user name: %s",
3255                       w32_strerror (-1));
3256         }
3257
3258       if (!strcmp (user, my_name))
3259         return 1; /* Found.  */
3260     }
3261 #endif /*HAVE_W32CE_SYSTEM*/
3262 #else /*!HAVE_W32_SYSTEM*/
3263   /* First check whether the user matches.  */
3264   if (*user)
3265     {
3266       static char *my_name;
3267
3268       if (!my_name)
3269         {
3270           struct passwd *pw = getpwuid ( getuid () );
3271           if (!pw)
3272             gc_error (1, errno, "getpwuid failed for current user");
3273           my_name = xstrdup (pw->pw_name);
3274         }
3275       if (!strcmp (user, my_name))
3276         return 1; /* Found.  */
3277     }
3278
3279   /* If that failed, check whether a group matches.  */
3280   if (group && *group)
3281     {
3282       static char *my_group;
3283       static char **my_supgroups;
3284       int n;
3285
3286       if (!my_group)
3287         {
3288           struct group *gr = getgrgid ( getgid () );
3289           if (!gr)
3290             gc_error (1, errno, "getgrgid failed for current user");
3291           my_group = xstrdup (gr->gr_name);
3292         }
3293       if (!strcmp (group, my_group))
3294         return 1; /* Found.  */
3295
3296       if (!my_supgroups)
3297         {
3298           int ngids;
3299           gid_t *gids;
3300
3301           ngids = getgroups (0, NULL);
3302           gids  = xcalloc (ngids+1, sizeof *gids);
3303           ngids = getgroups (ngids, gids);
3304           if (ngids < 0)
3305             gc_error (1, errno, "getgroups failed for current user");
3306           my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
3307           for (n=0; n < ngids; n++)
3308             {
3309               struct group *gr = getgrgid ( gids[n] );
3310               if (!gr)
3311                 gc_error (1, errno, "getgrgid failed for supplementary group");
3312               my_supgroups[n] = xstrdup (gr->gr_name);
3313             }
3314           xfree (gids);
3315         }
3316
3317       for (n=0; my_supgroups[n]; n++)
3318         if (!strcmp (group, my_supgroups[n]))
3319           return 1; /* Found.  */
3320     }
3321 #endif /*!HAVE_W32_SYSTEM*/
3322   return 0; /* No match.  */
3323 }
3324
3325
3326
3327 /* Read and process the global configuration file for gpgconf.  This
3328    optional file is used to update our internal tables at runtime and
3329    may also be used to set new default values.  If FNAME is NULL the
3330    default name will be used.  With UPDATE set to true the internal
3331    tables are actually updated; if not set, only a syntax check is
3332    done.  If DEFAULTS is true the global options are written to the
3333    configuration files.  If LISTFP is set, no changes are done but the
3334    configuration file is printed to LISTFP in a colon separated format.
3335
3336    Returns 0 on success or if the config file is not present; -1 is
3337    returned on error. */
3338 int
3339 gc_process_gpgconf_conf (const char *fname_arg, int update, int defaults,
3340                          FILE *listfp)
3341 {
3342   int result = 0;
3343   char *line = NULL;
3344   size_t line_len = 0;
3345   ssize_t length;
3346   FILE *config;
3347   int lineno = 0;
3348   int in_rule = 0;
3349   int got_match = 0;
3350   int runtime[GC_BACKEND_NR];
3351   int used_components[GC_COMPONENT_NR];
3352   int backend_id, component_id;
3353   char *fname;
3354
3355   if (fname_arg)
3356     fname = xstrdup (fname_arg);
3357   else
3358     fname = make_filename (gnupg_sysconfdir (), "gpgconf.conf", NULL);
3359
3360   for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3361     runtime[backend_id] = 0;
3362   for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3363     used_components[component_id] = 0;
3364
3365   config = fopen (fname, "r");
3366   if (!config)
3367     {
3368       /* Do not print an error if the file is not available, except
3369          when running in syntax check mode.  */
3370       if (errno != ENOENT || !update)
3371         {
3372           gc_error (0, errno, "can not open global config file `%s'", fname);
3373           result = -1;
3374         }
3375       xfree (fname);
3376       return result;
3377     }
3378
3379   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
3380     {
3381       char *key, *component, *option, *flags, *value;
3382       char *empty;
3383       gc_option_t *option_info = NULL;
3384       char *p;
3385       int is_continuation;
3386       
3387       lineno++;
3388       key = line;
3389       while (*key == ' ' || *key == '\t')
3390         key++;
3391       if (!*key || *key == '#' || *key == '\r' || *key == '\n')
3392         continue;
3393
3394       is_continuation = (key != line);
3395
3396       /* Parse the key field.  */
3397       if (!is_continuation && got_match)
3398         break;  /* Finish after the first match.  */
3399       else if (!is_continuation)
3400         {
3401           in_rule = 0;
3402           for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
3403             ;
3404           if (!*p)
3405             {
3406               gc_error (0, 0, "missing rule at `%s', line %d", fname, lineno);
3407               result = -1;
3408               continue;
3409             }
3410           *p++ = 0;
3411           component = p;
3412         }
3413       else if (!in_rule)
3414         {
3415           gc_error (0, 0, "continuation but no rule at `%s', line %d",
3416                     fname, lineno);
3417           result = -1;
3418           continue;
3419         }
3420       else
3421         {
3422           component = key;
3423           key = NULL;
3424         }
3425
3426       in_rule = 1;
3427
3428       /* Parse the component.  */
3429       while (*component == ' ' || *component == '\t')
3430         component++;
3431       for (p=component; *p && !strchr (" \t\r\n", *p); p++)
3432         ;
3433       if (p == component)
3434         {
3435           gc_error (0, 0, "missing component at `%s', line %d",
3436                     fname, lineno);
3437           result = -1;
3438           continue;
3439         }
3440       empty = p;
3441       *p++ = 0;
3442       option = p;
3443       component_id = gc_component_find (component);
3444       if (component_id < 0)
3445         {
3446           gc_error (0, 0, "unknown component at `%s', line %d",
3447                     fname, lineno);
3448           result = -1;
3449         }
3450
3451       /* Parse the option name.  */
3452       while (*option == ' ' || *option == '\t')
3453         option++;
3454       for (p=option; *p && !strchr (" \t\r\n", *p); p++)
3455         ;
3456       if (p == option)
3457         {
3458           gc_error (0, 0, "missing option at `%s', line %d",
3459                     fname, lineno);
3460           result = -1;
3461           continue;
3462         }
3463       *p++ = 0;
3464       flags = p;
3465       if ( component_id != -1)
3466         {
3467           option_info = find_option (component_id, option, GC_BACKEND_ANY);
3468           if (!option_info)
3469             {
3470               gc_error (0, 0, "unknown option at `%s', line %d",
3471                         fname, lineno);
3472               result = -1;
3473             }
3474         }
3475
3476
3477       /* Parse the optional flags.  */
3478       while (*flags == ' ' || *flags == '\t')
3479         flags++;
3480       if (*flags == '[')
3481         {
3482           flags++;
3483           p = strchr (flags, ']');
3484           if (!p)
3485             {
3486               gc_error (0, 0, "syntax error in rule at `%s', line %d",
3487                         fname, lineno);
3488               result = -1;
3489               continue;
3490             }
3491           *p++ = 0;
3492           value = p;
3493         }
3494       else  /* No flags given.  */
3495         {
3496           value = flags;
3497           flags = NULL;
3498         }
3499
3500       /* Parse the optional value.  */
3501       while (*value == ' ' || *value == '\t')
3502        value++;
3503       for (p=value; *p && !strchr ("\r\n", *p); p++)
3504         ;
3505       if (p == value)
3506         value = empty; /* No value given; let it point to an empty string.  */
3507       else
3508         {
3509           /* Strip trailing white space.  */
3510           *p = 0;
3511           for (p--; p > value && (*p == ' ' || *p == '\t'); p--)
3512             *p = 0;
3513         }
3514
3515       /* Check flag combinations.  */
3516       if (!flags)
3517         ;
3518       else if (!strcmp (flags, "default"))
3519         {
3520           if (*value)
3521             {
3522               gc_error (0, 0, "flag \"default\" may not be combined "
3523                         "with a value at `%s', line %d",
3524                         fname, lineno);
3525               result = -1;
3526             }
3527         }
3528       else if (!strcmp (flags, "change"))
3529         ;
3530       else if (!strcmp (flags, "no-change"))
3531         ;
3532       else
3533         {
3534           gc_error (0, 0, "unknown flag at `%s', line %d",
3535                     fname, lineno);
3536           result = -1;
3537         }
3538
3539       /* In list mode we print out all records.  */
3540       if (listfp && !result)
3541         {
3542           /* If this is a new ruleset, print a key record.  */
3543           if (!is_continuation)
3544             {
3545               char *group = strchr (key, ':');
3546               if (group)
3547                 {
3548                   *group++ = 0;
3549                   if ((p = strchr (group, ':')))
3550                     *p = 0; /* We better strip any extra stuff. */
3551                 }                    
3552               
3553               fprintf (listfp, "k:%s:", gc_percent_escape (key));
3554               fprintf (listfp, "%s\n", group? gc_percent_escape (group):"");
3555             }
3556
3557           /* All other lines are rule records.  */
3558           fprintf (listfp, "r:::%s:%s:%s:",
3559                    gc_component[component_id].name,                     
3560                    option_info->name? option_info->name : "",
3561                    flags? flags : "");
3562           if (value != empty)
3563             fprintf (listfp, "\"%s", gc_percent_escape (value));
3564           
3565           putc ('\n', listfp);
3566         }
3567
3568       /* Check whether the key matches but do this only if we are not
3569          running in syntax check mode. */
3570       if ( update 
3571            && !result && !listfp
3572            && (got_match || (key && key_matches_user_or_group (key))) )
3573         {
3574           int newflags = 0;
3575
3576           got_match = 1;
3577
3578           /* Apply the flags from gpgconf.conf.  */
3579           if (!flags)
3580             ;
3581           else if (!strcmp (flags, "default"))
3582             newflags |= GC_OPT_FLAG_DEFAULT;
3583           else if (!strcmp (flags, "no-change"))
3584             option_info->flags |= GC_OPT_FLAG_NO_CHANGE;
3585           else if (!strcmp (flags, "change"))
3586             option_info->flags &= ~GC_OPT_FLAG_NO_CHANGE;
3587
3588           if (defaults)
3589             {
3590               assert (component_id >= 0 && component_id < GC_COMPONENT_NR);
3591               used_components[component_id] = 1;
3592
3593               /* Here we explicitly allow to update the value again.  */
3594               if (newflags)
3595                 {
3596                   option_info->new_flags = 0;
3597                 }
3598               if (*value)
3599                 {
3600                   xfree (option_info->new_value);
3601                   option_info->new_value = NULL;
3602                 }
3603               change_one_value (option_info, runtime, newflags, value);
3604             }
3605         }
3606     }
3607
3608   if (length < 0 || ferror (config))
3609     {
3610       gc_error (0, errno, "error reading from `%s'", fname);
3611       result = -1;
3612     }
3613   if (fclose (config) && ferror (config))
3614     gc_error (0, errno, "error closing `%s'", fname);
3615
3616   xfree (line);
3617
3618   /* If it all worked, process the options. */
3619   if (!result && update && defaults && !listfp)
3620     {
3621       /* We need to switch off the runtime update, so that we can do
3622          it later all at once. */
3623       int save_opt_runtime = opt.runtime;
3624       opt.runtime = 0;
3625
3626       for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3627         {
3628           gc_component_change_options (component_id, NULL, NULL);
3629         }
3630       opt.runtime = save_opt_runtime;
3631
3632       if (opt.runtime)
3633         {
3634           for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)  
3635             if (runtime[backend_id] && gc_backend[backend_id].runtime_change)
3636               (*gc_backend[backend_id].runtime_change) ();
3637         }
3638     }
3639
3640   xfree (fname);
3641   return result;
3642 }