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