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