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