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