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