* gpgsm.texi (Configuration Options): Add --log-file.
[gnupg.git] / tools / gpgconf-comp.c
1 /* gpgconf-comp.c - Configuration utility for GnuPG.
2    Copyright (C) 2004 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 2 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, write to the Free Software Foundation,
18    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
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 #include <signal.h>
34
35 /* For log_logv(), asctimestamp(), gnupg_get_time ().  */
36 #define JNLIB_NEED_LOG_LOGV
37 #include "util.h"
38 #include "i18n.h"
39
40 #include "gpgconf.h"
41
42
43 \f
44 /* TODO:
45    Components: Add more components and their options.
46    Robustness: Do more validation.  Call programs to do validation for us.
47    Don't use popen, as this will not tell us if the program had a
48    non-zero exit code.
49    Add options to change backend binary path.
50    Extract binary path for some backends from gpgsm/gpg config.
51 */
52
53 \f
54 #if (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
55 void gc_error (int status, int errnum, const char *fmt, ...) \
56   __attribute__ ((format (printf, 3, 4)));
57 #endif
58
59 /* Output a diagnostic message.  If ERRNUM is not 0, then the output
60    is followed by a colon, a white space, and the error string for the
61    error number ERRNUM.  In any case the output is finished by a
62    newline.  The message is prepended by the program name, a colon,
63    and a whitespace.  The output may be further formatted or
64    redirected by the jnlib logging facility.  */
65 void
66 gc_error (int status, int errnum, const char *fmt, ...)
67 {
68   va_list arg_ptr;
69
70   va_start (arg_ptr, fmt);
71   log_logv (JNLIB_LOG_ERROR, fmt, arg_ptr);
72   va_end (arg_ptr);
73
74   if (errnum)
75     log_printf (": %s\n", strerror (errnum));
76   else
77     log_printf ("\n");
78
79   if (status)
80     {
81       log_printf (NULL);
82       log_printf ("fatal error (exit status %i)\n", status);
83       exit (status);
84     }
85 }
86
87 \f
88 /* Forward declaration.  */
89 void gpg_agent_runtime_change (void);
90
91 /* Backend configuration.  Backends are used to decide how the default
92    and current value of an option can be determined, and how the
93    option can be changed.  To every option in every component belongs
94    exactly one backend that controls and determines the option.  Some
95    backends are programs from the GPG system.  Others might be
96    implemented by GPGConf itself.  If you change this enum, don't
97    forget to update GC_BACKEND below.  */
98 typedef enum
99   {
100     /* Any backend, used for find_option ().  */
101     GC_BACKEND_ANY,
102
103     /* The Gnu Privacy Guard.  */
104     GC_BACKEND_GPG,
105
106     /* The Gnu Privacy Guard for S/MIME.  */
107     GC_BACKEND_GPGSM,
108
109     /* The GPG Agent.  */
110     GC_BACKEND_GPG_AGENT,
111
112     /* The GnuPG SCDaemon.  */
113     GC_BACKEND_SCDAEMON,
114
115     /* The Aegypten directory manager.  */
116     GC_BACKEND_DIRMNGR,
117
118     /* The LDAP server list file for the Aegypten director manager.  */
119     GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST,
120
121     /* The number of the above entries.  */
122     GC_BACKEND_NR
123   } gc_backend_t;
124
125
126 /* To be able to implement generic algorithms for the various
127    backends, we collect all information about them in this struct.  */
128 static struct
129 {
130   /* The name of the backend.  */
131   const char *name;
132
133   /* The name of the program that acts as the backend.  Some backends
134      don't have an associated program, but are implemented directly by
135      GPGConf.  In this case, PROGRAM is NULL.  */
136   char *program;
137
138   /* The runtime change callback.  */
139   void (*runtime_change) (void);
140
141   /* The option name for the configuration filename of this backend.
142      This must be an absolute pathname.  It can be an option from a
143      different backend (but then ordering of the options might
144      matter).  */
145   const char *option_config_filename;
146
147   /* If this is a file backend rather than a program backend, then
148      this is the name of the option associated with the file.  */
149   const char *option_name;
150 } gc_backend[GC_BACKEND_NR] =
151   {
152     { NULL },           /* GC_BACKEND_ANY dummy entry.  */
153     { "GnuPG", "gpg", NULL, "gpgconf-gpg.conf" },
154     { "GPGSM", "gpgsm", NULL, "gpgconf-gpgsm.conf" },
155     { "GPG Agent", "gpg-agent", gpg_agent_runtime_change,
156       "gpgconf-gpg-agent.conf" },
157     { "SCDaemon", "scdaemon", NULL, "gpgconf-scdaemon.conf" },
158     { "DirMngr", "dirmngr", NULL, "gpgconf-dirmngr.conf" },
159     { "DirMngr LDAP Server List", NULL, NULL, "ldapserverlist-file",
160       "LDAP Server" },
161   };
162
163 \f
164 /* Option configuration.  */
165
166 /* An option might take an argument, or not.  Argument types can be
167    basic or complex.  Basic types are generic and easy to validate.
168    Complex types provide more specific information about the intended
169    use, but can be difficult to validate.  If you add to this enum,
170    don't forget to update GC_ARG_TYPE below.  YOU MUST NOT CHANGE THE
171    NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE EXTERNAL
172    INTERFACE.  */
173 typedef enum
174   {
175     /* Basic argument types.  */
176
177     /* No argument.  */
178     GC_ARG_TYPE_NONE = 0,
179
180     /* A String argument.  */
181     GC_ARG_TYPE_STRING = 1,
182
183     /* A signed integer argument.  */
184     GC_ARG_TYPE_INT32 = 2,
185
186     /* An unsigned integer argument.  */
187     GC_ARG_TYPE_UINT32 = 3,
188
189     /* ADD NEW BASIC TYPE ENTRIES HERE.  */
190
191     /* Complex argument types.  */
192
193     /* A complete pathname.  */
194     GC_ARG_TYPE_PATHNAME = 32,
195
196     /* An LDAP server in the format
197        HOSTNAME:PORT:USERNAME:PASSWORD:BASE_DN.  */
198     GC_ARG_TYPE_LDAP_SERVER = 33,
199
200     /* A 40 character fingerprint.  */
201     GC_ARG_TYPE_KEY_FPR = 34,
202
203     /* ADD NEW COMPLEX TYPE ENTRIES HERE.  */
204
205     /* The number of the above entries.  */
206     GC_ARG_TYPE_NR
207   } gc_arg_type_t;
208
209
210 /* For every argument, we record some information about it in the
211    following struct.  */
212 static struct
213 {
214   /* For every argument type exists a basic argument type that can be
215      used as a fallback for input and validation purposes.  */
216   gc_arg_type_t fallback;
217
218   /* Human-readable name of the type.  */
219   const char *name;
220 } gc_arg_type[GC_ARG_TYPE_NR] =
221   {
222     /* The basic argument types have their own types as fallback.  */
223     { GC_ARG_TYPE_NONE, "none" },
224     { GC_ARG_TYPE_STRING, "string" },
225     { GC_ARG_TYPE_INT32, "int32" },
226     { GC_ARG_TYPE_UINT32, "uint32" },
227
228     /* Reserved basic type entries for future extension.  */
229     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
230     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
231     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
232     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
233     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
234     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
235     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
236     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
237     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
238     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
239     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
240     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
241     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
242     { GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
243
244     /* The complex argument types have a basic type as fallback.  */
245     { GC_ARG_TYPE_STRING, "pathname" },
246     { GC_ARG_TYPE_STRING, "ldap server" },
247     { GC_ARG_TYPE_STRING, "key fpr" },
248   };
249
250
251 /* Every option has an associated expert level, than can be used to
252    hide advanced and expert options from beginners.  If you add to
253    this list, don't forget to update GC_LEVEL below.  YOU MUST NOT
254    CHANGE THE NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE
255    EXTERNAL INTERFACE.  */
256 typedef enum
257   {
258     /* The basic options should always be displayed.  */
259     GC_LEVEL_BASIC,
260
261     /* The advanced options may be hidden from beginners.  */
262     GC_LEVEL_ADVANCED,
263
264     /* The expert options should only be displayed to experts.  */
265     GC_LEVEL_EXPERT,
266
267     /* The invisible options should normally never be displayed.  */
268     GC_LEVEL_INVISIBLE,
269
270     /* The internal options are never exported, they mark options that
271        are recorded for internal use only.  */
272     GC_LEVEL_INTERNAL,
273
274     /* ADD NEW ENTRIES HERE.  */
275
276     /* The number of the above entries.  */
277     GC_LEVEL_NR
278   } gc_expert_level_t;
279
280 /* A description for each expert level.  */
281 static struct
282 {
283   const char *name;
284 } gc_level[] =
285   {
286     { "basic" },
287     { "advanced" },
288     { "expert" },
289     { "invisible" },
290     { "internal" }
291   };
292
293
294 /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
295    FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
296 #define GC_OPT_FLAG_NONE        0UL
297 /* Some entries in the option list are not options, but mark the
298    beginning of a new group of options.  These entries have the GROUP
299    flag set.  */
300 #define GC_OPT_FLAG_GROUP       (1UL << 0)
301 /* The ARG_OPT flag for an option indicates that the argument is
302    optional.  This is never set for GC_ARG_TYPE_NONE options.  */
303 #define GC_OPT_FLAG_ARG_OPT     (1UL << 1)
304 /* The LIST flag for an option indicates that the option can occur
305    several times.  A comma separated list of arguments is used as the
306    argument value.  */
307 #define GC_OPT_FLAG_LIST        (1UL << 2)
308 /* The RUNTIME flag for an option indicates that the option can be
309    changed at runtime.  */
310 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
311
312 /* The following flags are incorporated from the backend.  */
313 /* The DEFAULT flag for an option indicates that the option has a
314    default value.  */
315 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
316 /* The DEF_DESC flag for an option indicates that the option has a
317    default, which is described by the value of the default field.  */
318 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
319 /* The NO_ARG_DESC flag for an option indicates that the argument has
320    a default, which is described by the value of the ARGDEF field.  */
321 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
322
323 /* A human-readable description for each flag.  */
324 static struct
325 {
326   const char *name;
327 } gc_flag[] =
328   {
329     { "group" },
330     { "optional arg" },
331     { "list" },
332     { "runtime" },
333     { "default" },
334     { "default desc" },
335     { "no arg desc" }
336   };
337
338
339 /* To each option, or group marker, the information in the GC_OPTION
340    struct is provided.  If you change this, don't forget to update the
341    option list of each component.  */
342 struct gc_option
343 {
344   /* If this is NULL, then this is a terminator in an array of unknown
345      length.  Otherwise, if this entry is a group marker (see FLAGS),
346      then this is the name of the group described by this entry.
347      Otherwise it is the name of the option described by this
348      entry.  The name must not contain a colon.  */
349   const char *name;
350
351   /* The option flags.  If the GROUP flag is set, then this entry is a
352      group marker, not an option, and only the fields LEVEL,
353      DESC_DOMAIN and DESC are valid.  In all other cases, this entry
354      describes a new option and all fields are valid.  */
355   unsigned long flags;
356
357   /* The expert level.  This field is valid for options and groups.  A
358      group has the expert level of the lowest-level option in the
359      group.  */
360   gc_expert_level_t level;
361
362   /* A gettext domain in which the following description can be found.
363      If this is NULL, then DESC is not translated.  Valid for groups
364      and options.
365      
366      Note that we try to keep the description of groups within the
367      gnupg domain.  */
368   const char *desc_domain;
369
370   /* A gettext description for this group or option.  If it starts
371      with a '|', then the string up to the next '|' describes the
372      argument, and the description follows the second '|'. 
373
374      In general enclosing these description in N_() is not required
375      because the description should be identical to the one in the
376      help menu of the respective program. */
377   const char *desc;
378
379   /* The following fields are only valid for options.  */
380
381   /* The type of the option argument.  */
382   gc_arg_type_t arg_type;
383
384   /* The backend that implements this option.  */
385   gc_backend_t backend;
386
387   /* The following fields are set to NULL at startup (because all
388      option's are declared as static variables).  They are at the end
389      of the list so that they can be omitted from the option
390      declarations.  */
391
392   /* This is true if the option is supported by this version of the
393      backend.  */
394   int active;
395
396   /* The default value for this option.  This is NULL if the option is
397      not present in the backend, the empty string if no default is
398      available, and otherwise a quoted string.  */
399   char *default_value;
400
401   /* The default argument is only valid if the "optional arg" flag is
402      set, and specifies the default argument (value) that is used if
403      the argument is omitted.  */
404   char *default_arg;
405
406   /* The current value of this option.  */
407   char *value;
408
409   /* The new flags for this option.  The only defined flag is actually
410      GC_OPT_FLAG_DEFAULT, and it means that the option should be
411      deleted.  In this case, NEW_VALUE is NULL.  */
412   unsigned long new_flags;
413
414   /* The new value of this option.  */
415   char *new_value;
416 };
417 typedef struct gc_option gc_option_t;
418
419 /* Use this macro to terminate an option list.  */
420 #define GC_OPTION_NULL { NULL }
421
422 \f
423 /* The options of the GC_COMPONENT_GPG_AGENT component.  */
424 static gc_option_t gc_options_gpg_agent[] =
425  {
426    /* The configuration file to which we write the changes.  */
427    { "gpgconf-gpg-agent.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
428      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG_AGENT },
429
430    { "Monitor",
431      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
432      "gnupg", N_("Options controlling the diagnostic output") },
433    { "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
434      "gnupg", "verbose",
435      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
436    { "quiet", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
437      "gnupg", "be somewhat more quiet",
438      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
439    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
440      NULL, NULL,
441      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
442
443    { "Configuration",
444      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
445      "gnupg", N_("Options controlling the configuration") },
446    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
447      "gnupg", "|FILE|read options from FILE",
448      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG_AGENT },
449
450    { "Debug",
451      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
452      "gnupg", N_("Options useful for debugging") },
453    { "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
454      "gnupg", "|LEVEL|set the debugging level to LEVEL",
455      GC_ARG_TYPE_STRING, GC_BACKEND_GPG_AGENT },
456    { "log-file", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
457      "gnupg", "|FILE|write logs to FILE",
458      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG_AGENT },
459    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
460      NULL, NULL,
461      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
462
463    { "Security",
464      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
465      "gnupg", N_("Options controlling the security") },
466    { "default-cache-ttl", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
467      "gnupg", "|N|expire cached PINs after N seconds",
468      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
469    { "ignore-cache-for-signing", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
470      "gnupg", "do not use the PIN cache when signing",
471      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
472    { "allow-mark-trusted", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
473      "gnupg", "allow clients to mark keys as \"trusted\"",
474      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
475    { "no-grab", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT,
476      "gnupg", "do not grab keyboard and mouse",
477      GC_ARG_TYPE_NONE, GC_BACKEND_GPG_AGENT },
478
479
480    GC_OPTION_NULL
481  };
482
483
484 /* The options of the GC_COMPONENT_SCDAEMON component.  */
485 static gc_option_t gc_options_scdaemon[] =
486  {
487    /* The configuration file to which we write the changes.  */
488    { "gpgconf-scdaemon.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
489      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_SCDAEMON },
490
491    { "Monitor",
492      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
493      "gnupg", N_("Options controlling the diagnostic output") },
494    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
495      "gnupg", "verbose",
496      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
497    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
498      "gnupg", "be somewhat more quiet",
499      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
500    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
501      NULL, NULL,
502      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
503
504    { "Configuration",
505      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
506      "gnupg", N_("Options controlling the configuration") },
507    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
508      "gnupg", "|FILE|read options from FILE",
509      GC_ARG_TYPE_PATHNAME, GC_BACKEND_SCDAEMON },
510    { "reader-port", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
511      "gnupg", "|N|connect to reader at port N",
512      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
513    { "ctapi-driver", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
514      "gnupg", "|NAME|use NAME as ct-API driver",
515      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
516    { "pcsc-driver", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
517      "gnupg", "|NAME|use NAME as PC/SC driver",
518      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
519    { "disable-opensc", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
520      "gnupg", "do not use the OpenSC layer",
521      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
522    { "disable-ccid", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
523      "gnupg", "do not use the internal CCID driver",
524      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
525
526
527    { "Debug",
528      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
529      "gnupg", N_("Options useful for debugging") },
530    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
531      "gnupg", "|LEVEL|set the debugging level to LEVEL",
532      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
533    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
534      "gnupg", "|FILE|write logs to FILE",
535      GC_ARG_TYPE_PATHNAME, GC_BACKEND_SCDAEMON },
536
537    { "Security",
538      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
539      "gnupg", N_("Options controlling the security") },
540    { "allow-admin", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
541      "gnupg", "allow the use of admin card commands",
542      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
543
544
545    GC_OPTION_NULL
546  };
547
548
549 /* The options of the GC_COMPONENT_GPG component.  */
550 static gc_option_t gc_options_gpg[] =
551  {
552    /* The configuration file to which we write the changes.  */
553    { "gpgconf-gpg.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
554      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG },
555
556    { "Monitor",
557      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
558      "gnupg", N_("Options controlling the diagnostic output") },
559    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
560      "gnupg", "verbose",
561      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
562    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
563      "gnupg", "be somewhat more quiet",
564      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
565    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
566      NULL, NULL,
567      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
568
569    { "Configuration",
570      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
571      "gnupg", N_("Options controlling the configuration") },
572    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
573      "gnupg", "|FILE|read options from FILE",
574      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG },
575
576    { "Debug",
577      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
578      "gnupg", N_("Options useful for debugging") },
579    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
580      "gnupg", "|LEVEL|set the debugging level to LEVEL",
581      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
582    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
583      "gnupg", "|FILE|write logs to FILE",
584      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPG },
585 /*    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE, */
586 /*      NULL, NULL, */
587 /*      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG }, */
588
589    { "Keyserver",
590      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
591      "gnupg", N_("Configuration for Keyservers") },
592    { "keyserver", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
593      "gnupg", "|URL|use keyserver at URL",
594      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
595
596
597    GC_OPTION_NULL
598  };
599
600
601
602 /* The options of the GC_COMPONENT_GPGSM component.  */
603 static gc_option_t gc_options_gpgsm[] =
604  {
605    /* The configuration file to which we write the changes.  */
606    { "gpgconf-gpgsm.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
607      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPGSM },
608
609    { "Monitor",
610      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
611      "gnupg", N_("Options controlling the diagnostic output") },
612    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
613      "gnupg", "verbose",
614      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
615    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
616      "gnupg", "be somewhat more quiet",
617      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
618    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
619      NULL, NULL,
620      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
621
622    { "Configuration",
623      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
624      "gnupg", N_("Options controlling the configuration") },
625    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
626      "gnupg", "|FILE|read options from FILE",
627      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPGSM },
628
629    { "Debug",
630      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
631      "gnupg", N_("Options useful for debugging") },
632    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
633      "gnupg", "|LEVEL|set the debugging level to LEVEL",
634      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
635    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
636      "gnupg", "|FILE|write logs to FILE",
637      GC_ARG_TYPE_PATHNAME, GC_BACKEND_GPGSM },
638    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
639      NULL, NULL,
640      GC_ARG_TYPE_UINT32, GC_BACKEND_GPGSM },
641
642    { "Security",
643      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
644      "gnupg", N_("Options controlling the security") },
645    { "disable-crl-checks", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
646      "gnupg", "never consult a CRL",
647      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
648    { "enable-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
649      "gnupg", "check validity using OCSP",
650      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
651    { "include-certs", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
652      "gnupg", "|N|number of certificates to include",
653      GC_ARG_TYPE_INT32, GC_BACKEND_GPGSM },
654    { "disable-policy-checks", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
655      "gnupg", "do not check certificate policies",
656      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
657    { "auto-issuer-key-retrieve", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
658      "gnupg", "fetch missing issuer certificates",
659      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
660
661    GC_OPTION_NULL
662  };
663
664
665 /* The options of the GC_COMPONENT_DIRMNGR component.  */
666 static gc_option_t gc_options_dirmngr[] =
667  {
668    /* The configuration file to which we write the changes.  */
669    { "gpgconf-dirmngr.conf", GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
670      NULL, NULL, GC_ARG_TYPE_PATHNAME, GC_BACKEND_DIRMNGR },
671
672    { "Monitor",
673      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
674      "gnupg", N_("Options controlling the diagnostic output") },
675    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
676      "dirmngr", "verbose",
677      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
678    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
679      "dirmngr", "be somewhat more quiet",
680      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
681    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
682      NULL, NULL,
683      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
684
685    { "Format",
686      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
687      "gnupg", N_("Options controlling the format of the output") },
688    { "sh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
689      "dirmngr", "sh-style command output",
690      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
691    { "csh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
692      "dirmngr", "csh-style command output",
693      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
694    
695    { "Configuration",
696      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
697      "gnupg", N_("Options controlling the configuration") },
698    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
699      "dirmngr", "|FILE|read options from FILE",
700      GC_ARG_TYPE_PATHNAME, GC_BACKEND_DIRMNGR },
701
702    { "Debug",
703      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
704      "gnupg", N_("Options useful for debugging") },
705    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
706      "dirmngr", "|LEVEL|set the debugging level to LEVEL",
707      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
708    { "no-detach", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
709      "dirmngr", "do not detach from the console",
710      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
711    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
712      "dirmngr", "|FILE|write logs to FILE",
713      GC_ARG_TYPE_PATHNAME, GC_BACKEND_DIRMNGR },
714    { "debug-wait", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
715      NULL, NULL,
716      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
717    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
718      NULL, NULL,
719      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
720
721    { "Enforcement",
722      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
723      "gnupg", N_("Options controlling the interactivity and enforcement") },
724    { "batch", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
725      "dirmngr", "run without asking a user",
726      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
727    { "force", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
728      "dirmngr", "force loading of outdated CRLs",
729      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
730
731    { "LDAP",
732      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
733      "gnupg", N_("Configuration of LDAP servers to use") },
734    { "add-servers", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
735      "dirmngr", "add new servers discovered in CRL distribution points"
736      " to serverlist", GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
737    { "ldaptimeout", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
738      "dirmngr", "|N|set LDAP timeout to N seconds",
739      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
740    /* The following entry must not be removed, as it is required for
741       the GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST.  */
742    { "ldapserverlist-file",
743      GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
744      "dirmngr", "|FILE|read LDAP server list from FILE",
745      GC_ARG_TYPE_PATHNAME, GC_BACKEND_DIRMNGR },
746    /* This entry must come after at least one entry for
747       GC_BACKEND_DIRMNGR in this component, so that the entry for
748       "ldapserverlist-file will be initialized before this one.  */
749    { "LDAP Server", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
750      NULL, "LDAP server list",
751      GC_ARG_TYPE_LDAP_SERVER, GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST },
752    { "max-replies", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
753      "dirmngr", "|N|do not return more than N items in one query",
754      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
755
756    { "OCSP",
757      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
758      "gnupg", N_("Configuration for OCSP") },
759    { "allow-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
760      "dirmngr", "allow sending OCSP requests",
761      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
762    { "ocsp-responder", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
763      "dirmngr", "|URL|use OCSP responder URL",
764      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
765    { "ocsp-signer", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
766      "dirmngr", "|FPR|OCSP response signed by FPR",
767      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
768
769
770    GC_OPTION_NULL
771  };
772
773 \f
774 /* Component system.  Each component is a set of options that can be
775    configured at the same time.  If you change this, don't forget to
776    update GC_COMPONENT below.  */
777 typedef enum
778   {
779     /* The classic GPG for OpenPGP.  */
780     GC_COMPONENT_GPG,
781
782     /* The GPG Agent.  */
783     GC_COMPONENT_GPG_AGENT,
784
785     /* The Smardcard Daemon.  */
786     GC_COMPONENT_SCDAEMON,
787
788     /* GPG for S/MIME.  */
789     GC_COMPONENT_GPGSM,
790
791     /* The LDAP Directory Manager for CRLs.  */
792     GC_COMPONENT_DIRMNGR,
793
794     /* The number of components.  */
795     GC_COMPONENT_NR
796   } gc_component_t;
797
798
799 /* The information associated with each component.  */
800 static struct
801 {
802   /* The name of this component.  Must not contain a colon (':')
803      character.  */
804   const char *name;
805
806   /* The gettext domain for the description DESC.  If this is NULL,
807      then the description is not translated.  */
808   const char *desc_domain;
809
810   /* The description for this domain.  */
811   const char *desc;
812
813   /* The list of options for this component, terminated by
814      GC_OPTION_NULL.  */
815   gc_option_t *options;
816 } gc_component[] =
817   {
818     { "gpg", NULL,   "GPG for OpenPGP", gc_options_gpg },
819     { "gpg-agent", NULL, "GPG Agent", gc_options_gpg_agent },
820     { "scdaemon", NULL, "Smartcard Daemon", gc_options_scdaemon },
821     { "gpgsm", NULL, "GPG for S/MIME", gc_options_gpgsm },
822     { "dirmngr", NULL, "Directory Manager", gc_options_dirmngr }
823   };
824
825 \f
826 /* Engine specific support.  */
827 void
828 gpg_agent_runtime_change (void)
829 {
830   char *agent = getenv ("GPG_AGENT_INFO");
831   char *pid_str;
832   unsigned long pid_long;
833   char *tail;
834   pid_t pid;
835
836   if (!agent)
837     return;
838
839   pid_str = strchr (agent, ':');
840   if (!pid_str)
841     return;
842
843   pid_str++;
844   errno = 0;
845   pid_long = strtoul (pid_str, &tail, 0);
846   if (errno || (*tail != ':' && *tail != '\0'))
847     return;
848
849   pid = (pid_t) pid_long;
850
851   /* Check for overflow.  */
852   if (pid_long != (unsigned long) pid)
853     return;
854
855   /* Ignore any errors here.  */
856   kill (pid, SIGHUP);
857 }
858
859 \f
860 /* More or less Robust version of dgettext.  It has the side effect of
861    switching the codeset to utf-8 because this is what we want to
862    output.  In theory it is posible to keep the orginal code set and
863    switch back for regular disgnostic output (redefine "_(" for that)
864    but given the natur of this tool, being something invoked from
865    other pograms, it does not make much sense.  */
866 static const char *
867 my_dgettext (const char *domain, const char *msgid)
868 {
869 #ifdef ENABLE_NLS
870   if (domain)
871     {
872       static int switched_codeset;
873       char *text;
874       
875       if (!switched_codeset)
876         {
877           bind_textdomain_codeset (PACKAGE_GT, "utf-8");
878           switched_codeset = 1;
879         }
880
881       /* Note: This is a hack to actually use the gnupg2 domain as
882          long we are in a transition phase where gnupg 1.x and 1.9 may
883          coexist. */
884       if (!strcmp (domain, "gnupg"))
885         domain = PACKAGE_GT;
886
887       text = dgettext (domain, msgid);
888       return text ? text : msgid;
889     }
890   else
891 #endif
892     return msgid;
893 }
894
895
896 /* Percent-Escape special characters.  The string is valid until the
897    next invocation of the function.  */
898 static char *
899 percent_escape (const char *src)
900 {
901   static char *esc_str;
902   static int esc_str_len;
903   int new_len = 3 * strlen (src) + 1;
904   char *dst;
905
906   if (esc_str_len < new_len)
907     {
908       char *new_esc_str = realloc (esc_str, new_len);
909       if (!new_esc_str)
910         gc_error (1, errno, "can not escape string");
911       esc_str = new_esc_str;
912       esc_str_len = new_len;
913     }
914
915   dst = esc_str;
916   while (*src)
917     {
918       if (*src == '%')
919         {
920           *(dst++) = '%';
921           *(dst++) = '2';
922           *(dst++) = '5';
923         }         
924       else if (*src == ':')
925         {
926           /* The colon is used as field separator.  */
927           *(dst++) = '%';
928           *(dst++) = '3';
929           *(dst++) = 'a';
930         }
931       else if (*src == ',')
932         {
933           /* The comma is used as list separator.  */
934           *(dst++) = '%';
935           *(dst++) = '2';
936           *(dst++) = 'c';
937         }
938       else
939         *(dst++) = *(src);
940       src++;
941     }
942   *dst = '\0';
943   return esc_str;
944 }
945
946
947 /* Convert two hexadecimal digits from STR to the value they
948    represent.  Returns -1 if one of the characters is not a
949    hexadecimal digit.  */
950 static int
951 hextobyte (const char *str)
952 {
953   int val = 0;
954   int i;
955
956 #define NROFHEXDIGITS 2
957   for (i = 0; i < NROFHEXDIGITS; i++)
958     {
959       if (*str >= '0' && *str <= '9')
960         val += *str - '0';
961       else if (*str >= 'A' && *str <= 'F')
962         val += 10 + *str - 'A';
963       else if (*str >= 'a' && *str <= 'f')
964         val += 10 + *str - 'a';
965       else
966         return -1;
967       if (i < NROFHEXDIGITS - 1)
968         val *= 16;
969       str++;
970     }
971   return val;
972 }
973
974
975
976 /* Percent-Deescape special characters.  The string is valid until the
977    next invocation of the function.  */
978 static char *
979 percent_deescape (const char *src)
980 {
981   static char *str;
982   static int str_len;
983   int new_len = 3 * strlen (src) + 1;
984   char *dst;
985
986   if (str_len < new_len)
987     {
988       char *new_str = realloc (str, new_len);
989       if (!new_str)
990         gc_error (1, errno, "can not deescape string");
991       str = new_str;
992       str_len = new_len;
993     }
994
995   dst = str;
996   while (*src)
997     {
998       if (*src == '%')
999         {
1000           int val = hextobyte (src + 1);
1001
1002           if (val < 0)
1003             gc_error (1, 0, "malformed end of string %s", src);
1004
1005           *(dst++) = (char) val;
1006           src += 3;
1007         }         
1008       else
1009         *(dst++) = *(src++);
1010     }
1011   *dst = '\0';
1012   return str;
1013 }
1014
1015 \f
1016 /* List all components that are available.  */
1017 void
1018 gc_component_list_components (FILE *out)
1019 {
1020   gc_component_t idx;
1021
1022   for (idx = 0; idx < GC_COMPONENT_NR; idx++)
1023     {
1024       const char *desc = gc_component[idx].desc;
1025       desc = my_dgettext (gc_component[idx].desc_domain, desc);
1026       fprintf (out, "%s:%s\n", gc_component[idx].name, percent_escape (desc));
1027     }
1028 }
1029
1030 \f
1031 /* Find the component with the name NAME.  Returns -1 if not
1032    found.  */
1033 int
1034 gc_component_find (const char *name)
1035 {
1036   gc_component_t idx;
1037
1038   for (idx = 0; idx < GC_COMPONENT_NR; idx++)
1039     {
1040       if (!strcmp (name, gc_component[idx].name))
1041         return idx;
1042     }
1043   return -1;
1044 }
1045
1046 \f
1047 /* List the option OPTION.  */
1048 static void
1049 list_one_option (const gc_option_t *option, FILE *out)
1050 {
1051   const char *desc = NULL;
1052   char *arg_name = NULL;
1053
1054   if (option->desc)
1055     {
1056       desc = my_dgettext (option->desc_domain, option->desc);
1057
1058       if (*desc == '|')
1059         {
1060           const char *arg_tail = strchr (&desc[1], '|');
1061
1062           if (arg_tail)
1063             {
1064               int arg_len = arg_tail - &desc[1];
1065               arg_name = xmalloc (arg_len + 1);
1066               memcpy (arg_name, &desc[1], arg_len);
1067               arg_name[arg_len] = '\0';
1068               desc = arg_tail + 1;
1069             }
1070         }
1071     }
1072
1073
1074   /* YOU MUST NOT REORDER THE FIELDS IN THIS OUTPUT, AS THEIR ORDER IS
1075      PART OF THE EXTERNAL INTERFACE.  YOU MUST NOT REMOVE ANY
1076      FIELDS.  */
1077
1078   /* The name field.  */
1079   fprintf (out, "%s", option->name);
1080
1081   /* The flags field.  */
1082   fprintf (out, ":%lu", option->flags);
1083   if (opt.verbose)
1084     {
1085       putc (' ', out);
1086           
1087       if (!option->flags)
1088         fprintf (out, "none");
1089       else
1090         {
1091           unsigned long flags = option->flags;
1092           unsigned long flag = 0;
1093           unsigned long first = 1;
1094
1095           while (flags)
1096             {
1097               if (flags & 1)
1098                 {
1099                   if (first)
1100                     first = 0;
1101                   else
1102                     putc (',', out);
1103                   fprintf (out, "%s", gc_flag[flag].name);
1104                 }
1105               flags >>= 1;
1106               flag++;
1107             }
1108         }
1109     }
1110
1111   /* The level field.  */
1112   fprintf (out, ":%u", option->level);
1113   if (opt.verbose)
1114     fprintf (out, " %s", gc_level[option->level].name);
1115
1116   /* The description field.  */
1117   fprintf (out, ":%s", desc ? percent_escape (desc) : "");
1118   
1119   /* The type field.  */
1120   fprintf (out, ":%u", option->arg_type);
1121   if (opt.verbose)
1122     fprintf (out, " %s", gc_arg_type[option->arg_type].name);
1123
1124   /* The alternate type field.  */
1125   fprintf (out, ":%u", gc_arg_type[option->arg_type].fallback);
1126   if (opt.verbose)
1127     fprintf (out, " %s",
1128              gc_arg_type[gc_arg_type[option->arg_type].fallback].name);
1129
1130   /* The argument name field.  */
1131   fprintf (out, ":%s", arg_name ? percent_escape (arg_name) : "");
1132   if (arg_name)
1133     xfree (arg_name);
1134
1135   /* The default value field.  */
1136   fprintf (out, ":%s", option->default_value ? option->default_value : "");
1137
1138   /* The default argument field.  */
1139   fprintf (out, ":%s", option->default_arg ? option->default_arg : "");
1140
1141   /* The value field.  */
1142   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
1143       && (option->flags & GC_OPT_FLAG_LIST)
1144       && option->value)
1145     /* The special format "1,1,1,1,...,1" is converted to a number
1146        here.  */
1147     fprintf (out, ":%u", (strlen (option->value) + 1) / 2);
1148   else
1149     fprintf (out, ":%s", option->value ? option->value : "");
1150
1151   /* ADD NEW FIELDS HERE.  */
1152
1153   putc ('\n', out);
1154 }
1155
1156
1157 /* List all options of the component COMPONENT.  */
1158 void
1159 gc_component_list_options (int component, FILE *out)
1160 {  
1161   const gc_option_t *option = gc_component[component].options;
1162   const gc_option_t *group_option = NULL;
1163
1164   while (option->name)
1165     {
1166       /* Do not output unknown or internal options.  */
1167       if (!(option->flags & GC_OPT_FLAG_GROUP)
1168           && (!option->active || option->level == GC_LEVEL_INTERNAL))
1169         {
1170           option++;
1171           continue;
1172         }
1173
1174       if (option->flags & GC_OPT_FLAG_GROUP)
1175         group_option = option;
1176       else
1177         {
1178           if (group_option)
1179             {
1180               list_one_option (group_option, out);
1181               group_option = NULL;
1182             }
1183
1184           list_one_option (option, out);
1185         }
1186
1187       option++;
1188     }
1189 }
1190
1191
1192 /* Find the option NAME in component COMPONENT, for the backend
1193    BACKEND.  If BACKEND is GC_BACKEND_ANY, any backend will match.  */
1194 static gc_option_t *
1195 find_option (gc_component_t component, const char *name,
1196              gc_backend_t backend)
1197 {
1198   gc_option_t *option = gc_component[component].options;
1199   while (option->name)
1200     {
1201       if (!(option->flags & GC_OPT_FLAG_GROUP)
1202           && !strcmp (option->name, name)
1203           && (backend == GC_BACKEND_ANY || option->backend == backend))
1204         break;
1205       option++;
1206     }
1207   return option->name ? option : NULL;
1208 }
1209
1210 \f
1211 /* Determine the configuration pathname for the component COMPONENT
1212    and backend BACKEND.  */
1213 static char *
1214 get_config_pathname (gc_component_t component, gc_backend_t backend)
1215 {
1216   char *pathname = NULL;
1217   gc_option_t *option = find_option
1218     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
1219   assert (option);
1220   assert (option->arg_type == GC_ARG_TYPE_PATHNAME);
1221   assert (!(option->flags & GC_OPT_FLAG_LIST));
1222
1223   if (!option->active || !option->default_value)
1224     gc_error (1, 0, "Option %s, needed by backend %s, was not initialized",
1225               gc_backend[backend].option_config_filename,
1226               gc_backend[backend].name);
1227
1228   if (option->value && *option->value)
1229     pathname = percent_deescape (&option->value[1]);
1230   else if (option->default_value && *option->default_value)
1231     pathname = percent_deescape (&option->default_value[1]);
1232   else
1233     pathname = "";
1234
1235   if (pathname[0] != '/')
1236     gc_error (1, 0, "Option %s, needed by backend %s, is not absolute",
1237               gc_backend[backend].option_config_filename,
1238               gc_backend[backend].name);
1239
1240   return pathname;
1241 }
1242
1243 \f
1244 /* Retrieve the options for the component COMPONENT from backend
1245    BACKEND, which we already know is a program-type backend.  */
1246 static void
1247 retrieve_options_from_program (gc_component_t component, gc_backend_t backend)
1248 {
1249   char *cmd_line;
1250   char *line = NULL;
1251   size_t line_len = 0;
1252   ssize_t length;
1253   FILE *config;
1254   char *config_pathname;
1255
1256   cmd_line = xasprintf ("%s --gpgconf-list", gc_backend[backend].program);
1257
1258   config = popen (cmd_line, "r");
1259   if (!config)
1260     gc_error (1, errno, "could not gather active options from %s", cmd_line);
1261
1262   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1263     {
1264       gc_option_t *option;
1265       char *linep;
1266       unsigned long flags = 0;
1267       char *default_value = NULL;
1268       
1269       /* Strip newline and carriage return, if present.  */
1270       while (length > 0
1271              && (line[length - 1] == '\n' || line[length - 1] == '\r'))
1272         line[--length] = '\0';
1273
1274       linep = strchr (line, ':');
1275       if (linep)
1276         *(linep++) = '\0';
1277       
1278       /* Extract additional flags.  Default to none.  */
1279       if (linep)
1280         {
1281           char *end;
1282           char *tail;
1283
1284           end = strchr (linep, ':');
1285           if (end)
1286             *(end++) = '\0';
1287
1288           errno = 0;
1289           flags = strtoul (linep, &tail, 0);
1290           if (errno)
1291             gc_error (1, errno, "malformed flags in option %s from %s", line, cmd_line);
1292           if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
1293             gc_error (1, 0, "garbage after flags in option %s from %s", line, cmd_line);
1294
1295           linep = end;
1296         }
1297
1298       /* Extract default value, if present.  Default to empty if
1299          not.  */
1300       if (linep)
1301         {
1302           char *end;
1303
1304           end = strchr (linep, ':');
1305           if (end)
1306             *(end++) = '\0';
1307
1308           if (flags & GC_OPT_FLAG_DEFAULT)
1309             default_value = linep;
1310
1311           linep = end;
1312         }
1313
1314       /* Look up the option in the component and install the
1315          configuration data.  */
1316       option = find_option (component, line, backend);
1317       if (option)
1318         {
1319           if (option->active)
1320             gc_error (1, errno, "option %s returned twice from %s",
1321                       line, cmd_line);
1322           option->active = 1;
1323
1324           option->flags |= flags;
1325           if (default_value && *default_value)
1326             option->default_value = xstrdup (default_value);
1327         }
1328     }
1329   if (length < 0 || ferror (config))
1330     gc_error (1, errno, "error reading from %s", cmd_line);
1331   if (fclose (config) && ferror (config))
1332     gc_error (1, errno, "error closing %s", cmd_line);
1333   xfree (cmd_line);
1334
1335   /* At this point, we can parse the configuration file.  */
1336   config_pathname = get_config_pathname (component, backend);
1337
1338   config = fopen (config_pathname, "r");
1339   if (!config)
1340     gc_error (0, errno, "warning: can not open config file %s",
1341               config_pathname);
1342   else
1343     {
1344       while ((length = read_line (config, &line, &line_len, NULL)) > 0)
1345         {
1346           char *name;
1347           char *value;
1348           gc_option_t *option;
1349           
1350           name = line;
1351           while (*name == ' ' || *name == '\t')
1352             name++;
1353           if (!*name || *name == '#' || *name == '\r' || *name == '\n')
1354             continue;
1355
1356           value = name;
1357           while (*value && *value != ' ' && *value != '\t'
1358                  && *value != '#' && *value != '\r' && *value != '\n')
1359             value++;
1360           if (*value == ' ' || *value == '\t')
1361             {
1362               char *end;
1363
1364               *(value++) = '\0';
1365               while (*value == ' ' || *value == '\t')
1366                 value++;
1367
1368               end = value;
1369               while (*end && *end != '#' && *end != '\r' && *end != '\n')
1370                 end++;
1371               while (end > value && (end[-1] == ' ' || end[-1] == '\t'))
1372                 end--;
1373               *end = '\0';
1374             }
1375           else
1376             *value = '\0';
1377
1378           /* Look up the option in the component and install the
1379              configuration data.  */
1380           option = find_option (component, line, backend);
1381           if (option)
1382             {
1383               char *opt_value;
1384
1385               if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
1386                 {
1387                   if (*value)
1388                     gc_error (0, 0,
1389                               "warning: ignoring argument %s for option %s",
1390                               value, name);
1391                   opt_value = xstrdup ("1");
1392                 }
1393               else if (gc_arg_type[option->arg_type].fallback
1394                        == GC_ARG_TYPE_STRING)
1395                 opt_value = xasprintf ("\"%s", percent_escape (value));
1396               else
1397                 {
1398                   /* FIXME: Verify that the number is sane.  */
1399                   opt_value = xstrdup (value);
1400                 }
1401
1402               /* Now enter the option into the table.  */
1403               if (!(option->flags & GC_OPT_FLAG_LIST))
1404                 {
1405                   if (option->value)
1406                     free (option->value);
1407                   option->value = opt_value;
1408                 }
1409               else
1410                 {
1411                   if (!option->value)
1412                     option->value = opt_value;
1413                   else
1414                     {
1415                       char *opt_val = opt_value;
1416
1417                       option->value = xasprintf ("%s,%s", option->value,
1418                                                  opt_val);
1419                       xfree (opt_value);
1420                     }
1421                 }
1422             }
1423         }
1424
1425       if (length < 0 || ferror (config))
1426         gc_error (1, errno, "error reading from %s", config_pathname);
1427       if (fclose (config) && ferror (config))
1428         gc_error (1, errno, "error closing %s", config_pathname);
1429     }
1430
1431   xfree (line);
1432 }
1433
1434
1435 /* Retrieve the options for the component COMPONENT from backend
1436    BACKEND, which we already know is of type file list.  */ 
1437 static void
1438 retrieve_options_from_file (gc_component_t component, gc_backend_t backend)
1439 {
1440   gc_option_t *list_option;
1441   char *list_pathname;
1442   FILE *list_file;
1443   char *line = NULL;
1444   size_t line_len = 0;
1445   ssize_t length;
1446   char *list = NULL;
1447
1448   list_option = find_option (component,
1449                              gc_backend[backend].option_name, GC_BACKEND_ANY);
1450   assert (list_option);
1451   assert (!list_option->active);
1452
1453   list_pathname = get_config_pathname (component, backend);
1454   list_file = fopen (list_pathname, "r");
1455   if (!list_file)
1456     gc_error (0, errno, "warning: can not open list file %s", list_pathname);
1457   else
1458     {
1459
1460       while ((length = read_line (list_file, &line, &line_len, NULL)) > 0)
1461         {
1462           char *start;
1463           char *end;
1464           char *new_list;
1465
1466           start = line;
1467           while (*start == ' ' || *start == '\t')
1468             start++;
1469           if (!*start || *start == '#' || *start == '\r' || *start == '\n')
1470             continue;
1471
1472           end = start;
1473           while (*end && *end != '#' && *end != '\r' && *end != '\n')
1474             end++;
1475           /* Walk back to skip trailing white spaces.  Looks evil, but
1476              works because of the conditions on START and END imposed
1477              at this point (END is at least START + 1, and START is
1478              not a whitespace character).  */
1479           while (*(end - 1) == ' ' || *(end - 1) == '\t')
1480             end--;
1481           *end = '\0';
1482           /* FIXME: Oh, no!  This is so lame!  Should use realloc and
1483              really append.  */
1484           if (list)
1485             {
1486               new_list = xasprintf ("%s,\"%s", list, percent_escape (start));
1487               xfree (list);
1488               list = new_list;
1489             }
1490           else
1491             list = xasprintf ("\"%s", percent_escape (start));
1492         }
1493       if (length < 0 || ferror (list_file))
1494         gc_error (1, errno, "can not read list file %s", list_pathname);
1495     }
1496
1497   list_option->active = 1;
1498   list_option->value = list;
1499
1500   xfree (line);
1501 }
1502
1503
1504 /* Retrieve the currently active options and their defaults from all
1505    involved backends for this component.  */
1506 void
1507 gc_component_retrieve_options (int component)
1508 {
1509   int backend_seen[GC_BACKEND_NR];
1510   gc_backend_t backend;
1511   gc_option_t *option = gc_component[component].options;
1512
1513   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1514     backend_seen[backend] = 0;
1515
1516   while (option->name)
1517     {
1518       if (!(option->flags & GC_OPT_FLAG_GROUP))
1519         {
1520           backend = option->backend;
1521
1522           if (backend_seen[backend])
1523             {
1524               option++;
1525               continue;
1526             }
1527           backend_seen[backend] = 1;
1528
1529           assert (backend != GC_BACKEND_ANY);
1530
1531           if (gc_backend[backend].program)
1532             retrieve_options_from_program (component, backend);
1533           else
1534             retrieve_options_from_file (component, backend);
1535         }
1536       option++;
1537     }
1538 }
1539
1540 \f
1541 /* Perform a simple validity check based on the type.  Return in
1542    NEW_VALUE_NR the value of the number in NEW_VALUE if OPTION is of
1543    type GC_ARG_TYPE_NONE.  */
1544 static void
1545 option_check_validity (gc_option_t *option, unsigned long flags,
1546                        char *new_value, unsigned long *new_value_nr)
1547 {
1548   char *arg;
1549
1550   if (!option->active)
1551     gc_error (1, 0, "option %s not supported by backend", option->name);
1552       
1553   if (option->new_flags || option->new_value)
1554     gc_error (1, 0, "option %s already changed", option->name);
1555
1556   if (flags & GC_OPT_FLAG_DEFAULT)
1557     {
1558       if (*new_value)
1559         gc_error (1, 0, "argument %s provided for deleted option %s",
1560                   new_value, option->name);
1561
1562       return;
1563     }
1564
1565   /* GC_ARG_TYPE_NONE options have special list treatment.  */
1566   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
1567     {
1568       char *tail;
1569
1570       errno = 0;
1571       *new_value_nr = strtoul (new_value, &tail, 0);
1572
1573       if (errno)
1574         gc_error (1, errno, "invalid argument for option %s",
1575                   option->name);
1576       if (*tail)
1577         gc_error (1, 0, "garbage after argument for option %s",
1578                       option->name);
1579
1580       if (!(option->flags & GC_OPT_FLAG_LIST))
1581         {
1582           if (*new_value_nr != 1)
1583             gc_error (1, 0, "argument for non-list option %s of type 0 "
1584                       "(none) must be 1", option->name);
1585         }
1586       else
1587         {
1588           if (*new_value_nr == 0)
1589             gc_error (1, 0, "argument for option %s of type 0 (none) "
1590                       "must be positive", option->name);
1591         }
1592
1593       return;
1594     }
1595
1596   arg = new_value;
1597   do
1598     {
1599       if (*arg == '\0' || *arg == ',')
1600         {
1601           if (!(option->flags & GC_OPT_FLAG_ARG_OPT))
1602             gc_error (1, 0, "argument required for option %s", option->name);
1603
1604           if (*arg == ',' && !(option->flags & GC_OPT_FLAG_LIST))
1605             gc_error (1, 0, "list found for non-list option %s", option->name);
1606         }
1607       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_STRING)
1608         {
1609           if (*arg != '"')
1610             gc_error (1, 0, "string argument for option %s must begin "
1611                       "with a quote (\") character", option->name);
1612         }
1613       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
1614         {
1615           errno = 0;
1616           (void) strtol (arg, &arg, 0);
1617
1618           if (errno)
1619             gc_error (1, errno, "invalid argument for option %s",
1620                       option->name);
1621
1622           if (*arg != '\0' && *arg != ',')
1623             gc_error (1, 0, "garbage after argument for option %s",
1624                       option->name);
1625         }
1626       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
1627         {
1628           errno = 0;
1629           (void) strtoul (arg, &arg, 0);
1630
1631           if (errno)
1632             gc_error (1, errno, "invalid argument for option %s",
1633                       option->name);
1634
1635           if (*arg != '\0' && *arg != ',')
1636             gc_error (1, 0, "garbage after argument for option %s",
1637                       option->name);
1638         }
1639       arg = strchr (arg, ',');
1640       if (arg)
1641         arg++;
1642     }
1643   while (arg && *arg);
1644 }
1645
1646
1647 /* Create and verify the new configuration file for the specified
1648    backend and component.  Returns 0 on success and -1 on error.  */
1649 static int
1650 change_options_file (gc_component_t component, gc_backend_t backend,
1651                      char **src_filenamep, char **dest_filenamep,
1652                      char **orig_filenamep)
1653 {
1654   static const char marker[] = "###+++--- GPGConf ---+++###";
1655   /* True if we are within the marker in the config file.  */
1656   int in_marker = 0;
1657   gc_option_t *option;
1658   char *line = NULL;
1659   size_t line_len;
1660   ssize_t length;
1661   int res;
1662   int fd;
1663   FILE *src_file = NULL;
1664   FILE *dest_file = NULL;
1665   char *src_filename;
1666   char *dest_filename;
1667   char *orig_filename;
1668   char *arg;
1669   char *cur_arg = NULL;
1670
1671   option = find_option (component,
1672                         gc_backend[backend].option_name, GC_BACKEND_ANY);
1673   assert (option);
1674   assert (option->active);
1675   assert (gc_arg_type[option->arg_type].fallback != GC_ARG_TYPE_NONE);
1676
1677   /* FIXME.  Throughout the function, do better error reporting.  */
1678   /* Note that get_config_pathname() calls percent_deescape(), so we
1679      call this before processing the arguments.  */
1680   dest_filename = xstrdup (get_config_pathname (component, backend));
1681   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, getpid ());
1682   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename, getpid ());
1683
1684   arg = option->new_value;
1685   if (arg && arg[0] == '\0')
1686     arg = NULL;
1687   else if (arg)
1688     {
1689       char *end;
1690
1691       arg++;
1692       end = strchr (arg, ',');
1693       if (end)
1694         *end = '\0';
1695
1696       cur_arg = percent_deescape (arg);
1697       if (end)
1698         {
1699           *end = ',';
1700           arg = end + 1;
1701         }
1702       else
1703         arg = NULL;
1704     }
1705
1706   res = link (dest_filename, orig_filename);
1707   if (res < 0 && errno != ENOENT)
1708     return -1;
1709   if (res < 0)
1710     {
1711       xfree (orig_filename);
1712       orig_filename = NULL;
1713     }
1714
1715   /* We now initialize the return strings, so the caller can do the
1716      cleanup for us.  */
1717   *src_filenamep = src_filename;
1718   *dest_filenamep = dest_filename;
1719   *orig_filenamep = orig_filename;
1720
1721   /* Use open() so that we can use O_EXCL.  */
1722   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
1723   if (fd < 0)
1724     return -1;
1725   src_file = fdopen (fd, "w");
1726   res = errno;
1727   if (!src_file)
1728     {
1729       errno = res;
1730       return -1;
1731     }
1732
1733   /* Only if ORIG_FILENAME is not NULL did the configuration file
1734      exist already.  In this case, we will copy its content into the
1735      new configuration file, changing it to our liking in the
1736      process.  */
1737   if (orig_filename)
1738     {
1739       dest_file = fopen (dest_filename, "r");
1740       if (!dest_file)
1741         goto change_file_one_err;
1742
1743       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
1744         {
1745           int disable = 0;
1746           char *start;
1747
1748           if (!strncmp (marker, line, sizeof (marker) - 1))
1749             {
1750               if (!in_marker)
1751                 in_marker = 1;
1752               else
1753                 break;
1754             }
1755
1756           start = line;
1757           while (*start == ' ' || *start == '\t')
1758             start++;
1759           if (*start && *start != '\r' && *start != '\n' && *start != '#')
1760             {
1761               char *end;
1762               char *endp;
1763               char saved_end;
1764
1765               endp = start;
1766               end = endp;
1767
1768               /* Search for the end of the line.  */
1769               while (*endp && *endp != '#' && *endp != '\r' && *endp != '\n')
1770                 {
1771                   endp++;
1772                   if (*endp && *endp != ' ' && *endp != '\t'
1773                       && *endp != '\r' && *endp != '\n' && *endp != '#')
1774                     end = endp + 1;
1775                 }
1776               saved_end = *end;
1777               *end = '\0';
1778
1779               if ((option->new_flags & GC_OPT_FLAG_DEFAULT)
1780                   || !cur_arg || strcmp (start, cur_arg))
1781                 disable = 1;
1782               else
1783                 {
1784                   /* Find next argument.  */
1785                   if (arg)
1786                     {
1787                       char *arg_end;
1788
1789                       arg++;
1790                       arg_end = strchr (arg, ',');
1791                       if (arg_end)
1792                         *arg_end = '\0';
1793
1794                       cur_arg = percent_deescape (arg);
1795                       if (arg_end)
1796                         {
1797                           *arg_end = ',';
1798                           arg = arg_end + 1;
1799                         }
1800                       else
1801                         arg = NULL;
1802                     }
1803                   else
1804                     cur_arg = NULL;
1805                 }
1806
1807               *end = saved_end;
1808             }
1809
1810           if (disable)
1811             {
1812               if (!in_marker)
1813                 {
1814                   fprintf (src_file,
1815                            "# GPGConf disabled this option here at %s\n",
1816                            asctimestamp (gnupg_get_time ()));
1817                   if (ferror (src_file))
1818                     goto change_file_one_err;
1819                   fprintf (src_file, "# %s", line);
1820                   if (ferror (src_file))
1821                     goto change_file_one_err;
1822                 }
1823             }
1824           else
1825             {
1826               fprintf (src_file, "%s", line);
1827               if (ferror (src_file))
1828                 goto change_file_one_err;
1829             }
1830         }
1831       if (length < 0 || ferror (dest_file))
1832         goto change_file_one_err;
1833     }
1834
1835   if (!in_marker)
1836     {
1837       /* There was no marker.  This is the first time we edit the
1838          file.  We add our own marker at the end of the file and
1839          proceed.  Note that we first write a newline, this guards us
1840          against files which lack the newline at the end of the last
1841          line, while it doesn't hurt us in all other cases.  */
1842       fprintf (src_file, "\n%s\n", marker);
1843       if (ferror (src_file))
1844         goto change_file_one_err;
1845     }
1846
1847   /* At this point, we have copied everything up to the end marker
1848      into the new file, except for the arguments we are going to add.
1849      Now, dump the new arguments and write the end marker, possibly
1850      followed by the rest of the original file.  */
1851   while (cur_arg)
1852     {
1853       fprintf (src_file, "%s\n", cur_arg);
1854
1855       /* Find next argument.  */
1856       if (arg)
1857         {
1858           char *end;
1859
1860           arg++;
1861           end = strchr (arg, ',');
1862           if (end)
1863             *end = '\0';
1864
1865           cur_arg = percent_deescape (arg);
1866           if (end)
1867             {
1868               *end = ',';
1869               arg = end + 1;
1870             }
1871           else
1872             arg = NULL;
1873         }
1874       else
1875         cur_arg = NULL;
1876     }
1877
1878   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
1879   if (ferror (src_file))
1880     goto change_file_one_err;
1881
1882   if (!in_marker)
1883     {
1884       fprintf (src_file, "# GPGConf edited this configuration file.\n");
1885       if (ferror (src_file))
1886         goto change_file_one_err;
1887       fprintf (src_file, "# It will disable options before this marked "
1888                "block, but it will\n");
1889       if (ferror (src_file))
1890         goto change_file_one_err;
1891       fprintf (src_file, "# never change anything below these lines.\n");
1892       if (ferror (src_file))
1893         goto change_file_one_err;
1894     }
1895   if (dest_file)
1896     {
1897       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
1898         {
1899           fprintf (src_file, "%s", line);
1900           if (ferror (src_file))
1901             goto change_file_one_err;
1902         }
1903       if (length < 0 || ferror (dest_file))
1904         goto change_file_one_err;
1905     }
1906   xfree (line);
1907   line = NULL;
1908
1909   res = fclose (src_file);
1910   if (res)
1911     {
1912       res = errno;
1913       close (fd);
1914       if (dest_file)
1915         fclose (dest_file);
1916       errno = res;
1917       return -1;
1918     }
1919   close (fd);
1920   if (dest_file)
1921     {
1922       res = fclose (dest_file);
1923       if (res)
1924         return -1;
1925     }
1926   return 0;
1927
1928  change_file_one_err:
1929   xfree (line);
1930   res = errno;
1931   if (src_file)
1932     {
1933       fclose (src_file);
1934       close (fd);
1935     }
1936   if (dest_file)
1937     fclose (dest_file);
1938   errno = res;
1939   return -1;
1940 }
1941
1942
1943 /* Create and verify the new configuration file for the specified
1944    backend and component.  Returns 0 on success and -1 on error.  */
1945 static int
1946 change_options_program (gc_component_t component, gc_backend_t backend,
1947                         char **src_filenamep, char **dest_filenamep,
1948                         char **orig_filenamep)
1949 {
1950   static const char marker[] = "###+++--- GPGConf ---+++###";
1951   /* True if we are within the marker in the config file.  */
1952   int in_marker = 0;
1953   gc_option_t *option;
1954   char *line = NULL;
1955   size_t line_len;
1956   ssize_t length;
1957   int res;
1958   int fd;
1959   FILE *src_file = NULL;
1960   FILE *dest_file = NULL;
1961   char *src_filename;
1962   char *dest_filename;
1963   char *orig_filename;
1964
1965   /* FIXME.  Throughout the function, do better error reporting.  */
1966   dest_filename = xstrdup (get_config_pathname (component, backend));
1967   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, getpid ());
1968   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename, getpid ());
1969
1970   res = link (dest_filename, orig_filename);
1971   if (res < 0 && errno != ENOENT)
1972     return -1;
1973   if (res < 0)
1974     {
1975       xfree (orig_filename);
1976       orig_filename = NULL;
1977     }
1978
1979   /* We now initialize the return strings, so the caller can do the
1980      cleanup for us.  */
1981   *src_filenamep = src_filename;
1982   *dest_filenamep = dest_filename;
1983   *orig_filenamep = orig_filename;
1984
1985   /* Use open() so that we can use O_EXCL.  */
1986   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
1987   if (fd < 0)
1988     return -1;
1989   src_file = fdopen (fd, "w");
1990   res = errno;
1991   if (!src_file)
1992     {
1993       errno = res;
1994       return -1;
1995     }
1996
1997   /* Only if ORIG_FILENAME is not NULL did the configuration file
1998      exist already.  In this case, we will copy its content into the
1999      new configuration file, changing it to our liking in the
2000      process.  */
2001   if (orig_filename)
2002     {
2003       dest_file = fopen (dest_filename, "r");
2004       if (!dest_file)
2005         goto change_one_err;
2006
2007       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2008         {
2009           int disable = 0;
2010           char *start;
2011
2012           if (!strncmp (marker, line, sizeof (marker) - 1))
2013             {
2014               if (!in_marker)
2015                 in_marker = 1;
2016               else
2017                 break;
2018             }
2019
2020           start = line;
2021           while (*start == ' ' || *start == '\t')
2022             start++;
2023           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2024             {
2025               char *end;
2026               char saved_end;
2027
2028               end = start;
2029               while (*end && *end != ' ' && *end != '\t'
2030                      && *end != '\r' && *end != '\n' && *end != '#')
2031                 end++;
2032               saved_end = *end;
2033               *end = '\0';
2034
2035               option = find_option (component, start, backend);
2036               *end = saved_end;
2037               if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2038                              || option->new_value))
2039                 disable = 1;
2040             }
2041           if (disable)
2042             {
2043               if (!in_marker)
2044                 {
2045                   fprintf (src_file,
2046                            "# GPGConf disabled this option here at %s\n",
2047                            asctimestamp (gnupg_get_time ()));
2048                   if (ferror (src_file))
2049                     goto change_one_err;
2050                   fprintf (src_file, "# %s", line);
2051                   if (ferror (src_file))
2052                     goto change_one_err;
2053                 }
2054             }
2055           else
2056             {
2057               fprintf (src_file, "%s", line);
2058               if (ferror (src_file))
2059                 goto change_one_err;
2060             }
2061         }
2062       if (length < 0 || ferror (dest_file))
2063         goto change_one_err;
2064     }
2065
2066   if (!in_marker)
2067     {
2068       /* There was no marker.  This is the first time we edit the
2069          file.  We add our own marker at the end of the file and
2070          proceed.  Note that we first write a newline, this guards us
2071          against files which lack the newline at the end of the last
2072          line, while it doesn't hurt us in all other cases.  */
2073       fprintf (src_file, "\n%s\n", marker);
2074       if (ferror (src_file))
2075         goto change_one_err;
2076     }
2077   /* At this point, we have copied everything up to the end marker
2078      into the new file, except for the options we are going to change.
2079      Now, dump the changed options (except for those we are going to
2080      revert to their default), and write the end marker, possibly
2081      followed by the rest of the original file.  */
2082
2083   /* We have to turn on UTF8 strings for GnuPG.  */
2084   if (backend == GC_BACKEND_GPG)
2085     fprintf (src_file, "utf8-strings\n");
2086
2087   option = gc_component[component].options;
2088   while (option->name)
2089     {
2090       if (!(option->flags & GC_OPT_FLAG_GROUP)
2091           && option->backend == backend
2092           && option->new_value)
2093         {
2094           char *arg = option->new_value;
2095
2096           do
2097             {
2098               if (*arg == '\0' || *arg == ',')
2099                 {
2100                   fprintf (src_file, "%s\n", option->name);
2101                   if (ferror (src_file))
2102                     goto change_one_err;
2103                 }
2104               else if (gc_arg_type[option->arg_type].fallback
2105                        == GC_ARG_TYPE_NONE)
2106                 {
2107                   assert (*arg == '1');
2108                   fprintf (src_file, "%s\n", option->name);
2109                   if (ferror (src_file))
2110                     goto change_one_err;
2111
2112                   arg++;
2113                 }
2114               else if (gc_arg_type[option->arg_type].fallback
2115                        == GC_ARG_TYPE_STRING)
2116                 {
2117                   char *end;
2118                   
2119                   assert (*arg == '"');
2120                   arg++;
2121                   
2122                   end = strchr (arg, ',');
2123                   if (end)
2124                     *end = '\0';
2125
2126                   fprintf (src_file, "%s %s\n", option->name,
2127                            percent_deescape (arg));
2128                   if (ferror (src_file))
2129                     goto change_one_err;
2130
2131                   if (end)
2132                     *end = ',';
2133                   arg = end;
2134                 }
2135               else
2136                 {
2137                   char *end;
2138
2139                   end = strchr (arg, ',');
2140                   if (end)
2141                     *end = '\0';
2142
2143                   fprintf (src_file, "%s %s\n", option->name, arg);
2144                   if (ferror (src_file))
2145                     goto change_one_err;
2146
2147                   if (end)
2148                     *end = ',';
2149                   arg = end;
2150                 }
2151
2152               assert (arg == NULL || *arg == '\0' || *arg == ',');
2153               if (arg && *arg == ',')
2154                 arg++;
2155             }
2156           while (arg && *arg);
2157         }
2158       option++;
2159     }
2160
2161   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2162   if (ferror (src_file))
2163     goto change_one_err;
2164
2165   if (!in_marker)
2166     {
2167       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2168       if (ferror (src_file))
2169         goto change_one_err;
2170       fprintf (src_file, "# It will disable options before this marked "
2171                "block, but it will\n");
2172       if (ferror (src_file))
2173         goto change_one_err;
2174       fprintf (src_file, "# never change anything below these lines.\n");
2175       if (ferror (src_file))
2176         goto change_one_err;
2177     }
2178   if (dest_file)
2179     {
2180       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2181         {
2182           fprintf (src_file, "%s", line);
2183           if (ferror (src_file))
2184             goto change_one_err;
2185         }
2186       if (length < 0 || ferror (dest_file))
2187         goto change_one_err;
2188     }
2189   xfree (line);
2190   line = NULL;
2191
2192   res = fclose (src_file);
2193   if (res)
2194     {
2195       res = errno;
2196       close (fd);
2197       if (dest_file)
2198         fclose (dest_file);
2199       errno = res;
2200       return -1;
2201     }
2202   close (fd);
2203   if (dest_file)
2204     {
2205       res = fclose (dest_file);
2206       if (res)
2207         return -1;
2208     }
2209   return 0;
2210
2211  change_one_err:
2212   xfree (line);
2213   res = errno;
2214   if (src_file)
2215     {
2216       fclose (src_file);
2217       close (fd);
2218     }
2219   if (dest_file)
2220     fclose (dest_file);
2221   errno = res;
2222   return -1;
2223 }
2224
2225
2226 /* Read the modifications from IN and apply them.  */
2227 void
2228 gc_component_change_options (int component, FILE *in)
2229 {
2230   int err = 0;
2231   int runtime[GC_BACKEND_NR];
2232   char *src_pathname[GC_BACKEND_NR];
2233   char *dest_pathname[GC_BACKEND_NR];
2234   char *orig_pathname[GC_BACKEND_NR];
2235   gc_backend_t backend;
2236   gc_option_t *option;
2237   char *line = NULL;
2238   size_t line_len = 0;
2239   ssize_t length;
2240
2241   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2242     {
2243       runtime[backend] = 0;
2244       src_pathname[backend] = NULL;
2245       dest_pathname[backend] = NULL;
2246       orig_pathname[backend] = NULL;
2247     }
2248
2249   while ((length = read_line (in, &line, &line_len, NULL)) > 0)
2250     {
2251       char *linep;
2252       unsigned long flags = 0;
2253       char *new_value = "";
2254       unsigned long new_value_nr;
2255
2256       /* Strip newline and carriage return, if present.  */
2257       while (length > 0
2258              && (line[length - 1] == '\n' || line[length - 1] == '\r'))
2259         line[--length] = '\0';
2260
2261       linep = strchr (line, ':');
2262       if (linep)
2263         *(linep++) = '\0';
2264
2265       /* Extract additional flags.  Default to none.  */
2266       if (linep)
2267         {
2268           char *end;
2269           char *tail;
2270
2271           end = strchr (linep, ':');
2272           if (end)
2273             *(end++) = '\0';
2274
2275           errno = 0;
2276           flags = strtoul (linep, &tail, 0);
2277           if (errno)
2278             gc_error (1, errno, "malformed flags in option %s", line);
2279           if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
2280             gc_error (1, 0, "garbage after flags in option %s", line);
2281
2282           linep = end;
2283         }
2284
2285       /* Extract default value, if present.  Default to empty if
2286          not.  */
2287       if (linep)
2288         {
2289           char *end;
2290
2291           end = strchr (linep, ':');
2292           if (end)
2293             *(end++) = '\0';
2294
2295           new_value = linep;
2296
2297           linep = end;
2298         }
2299
2300       option = find_option (component, line, GC_BACKEND_ANY);
2301       if (!option)
2302         gc_error (1, 0, "unknown option %s", line);
2303
2304       option_check_validity (option, flags, new_value, &new_value_nr);
2305
2306       if (option->flags & GC_OPT_FLAG_RUNTIME)
2307         runtime[option->backend] = 1;
2308
2309       option->new_flags = flags;
2310       if (!(flags & GC_OPT_FLAG_DEFAULT))
2311         {
2312           if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
2313               && (option->flags & GC_OPT_FLAG_LIST))
2314             {
2315               char *str;
2316
2317               /* We convert the number to a list of 1's for
2318                  convenient list handling.  */
2319               assert (new_value_nr > 0);
2320               option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
2321               str = option->new_value;
2322               *(str++) = '1';
2323               while (--new_value_nr > 0)
2324                 {
2325                   *(str++) = ',';
2326                   *(str++) = '1';
2327                 }
2328               *(str++) = '\0';
2329             }
2330           else
2331             option->new_value = xstrdup (new_value);
2332         }
2333     }
2334
2335   /* Now that we have collected and locally verified the changes,
2336      write them out to new configuration files, verify them
2337      externally, and then commit them.  */
2338   option = gc_component[component].options;
2339   while (option->name)
2340     {
2341       /* Go on if we have already seen this backend, or if there is
2342          nothing to do.  */
2343       if (src_pathname[option->backend]
2344           || !(option->new_flags || option->new_value))
2345         {
2346           option++;
2347           continue;
2348         }
2349
2350       if (gc_backend[option->backend].program)
2351         err = change_options_program (component, option->backend,
2352                                       &src_pathname[option->backend],
2353                                       &dest_pathname[option->backend],
2354                                       &orig_pathname[option->backend]);
2355       else
2356         err = change_options_file (component, option->backend,
2357                                    &src_pathname[option->backend],
2358                                    &dest_pathname[option->backend],
2359                                    &orig_pathname[option->backend]);
2360         
2361       if (err)
2362         break;
2363           
2364       option++;
2365     }
2366
2367   if (!err)
2368     {
2369       int i;
2370
2371       for (i = 0; i < GC_BACKEND_NR; i++)
2372         {
2373           if (src_pathname[i])
2374             {
2375               /* FIXME: Make a verification here.  */
2376
2377               assert (dest_pathname[i]);
2378
2379               if (orig_pathname[i])
2380                 err = rename (src_pathname[i], dest_pathname[i]);
2381               else
2382                 {
2383                   /* This is a bit safer than rename() because we
2384                      expect DEST_PATHNAME not to be there.  If it
2385                      happens to be there, this will fail.  */
2386                   err = link (src_pathname[i], dest_pathname[i]);
2387                   if (!err)
2388                     unlink (src_pathname[i]);
2389                 }
2390               if (err)
2391                 break;
2392               src_pathname[i] = NULL;
2393             }
2394         }
2395     }
2396
2397   if (err)
2398     {
2399       int i;
2400       int saved_errno = errno;
2401
2402       /* An error occured.  */
2403       for (i = 0; i < GC_BACKEND_NR; i++)
2404         {
2405           if (src_pathname[i])
2406             {
2407               /* The change was not yet committed.  */
2408               unlink (src_pathname[i]);
2409               if (orig_pathname[i])
2410                 unlink (orig_pathname[i]);
2411             }
2412           else
2413             {
2414               /* The changes were already committed.  FIXME: This is a
2415                  tad dangerous, as we don't know if we don't overwrite
2416                  a version of the file that is even newer than the one
2417                  we just installed.  */
2418               if (orig_pathname[i])
2419                 rename (orig_pathname[i], dest_pathname[i]);
2420               else
2421                 unlink (dest_pathname[i]);
2422             }
2423         }
2424       gc_error (1, saved_errno, "could not commit changes");
2425     }
2426
2427   /* If it all worked, notify the daemons of the changes.  */
2428   if (opt.runtime)
2429     for (backend = 0; backend < GC_BACKEND_NR; backend++)  
2430       {
2431         if (runtime[backend] && gc_backend[backend].runtime_change)
2432           (*gc_backend[backend].runtime_change) ();
2433       }
2434
2435   /* Move the per-process backup file into its place.  */
2436   for (backend = 0; backend < GC_BACKEND_NR; backend++)  
2437     if (orig_pathname[backend])
2438       {
2439         char *backup_pathname;
2440
2441         assert (dest_pathname[backend]);
2442
2443         backup_pathname = xasprintf ("%s.gpgconf.bak", dest_pathname[backend]);
2444         rename (orig_pathname[backend], backup_pathname);
2445       }
2446
2447   xfree (line);
2448 }