First steps towards supporting W32.
[gnupg.git] / tools / gpgconf-comp.c
1 /* gpgconf-comp.c - Configuration utility for GnuPG.
2  * Copyright (C) 2004 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with GnuPG; if not, write to the Free Software Foundation,
18  * 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
1729 /* Create and verify the new configuration file for the specified
1730    backend and component.  Returns 0 on success and -1 on error.  */
1731 static int
1732 change_options_file (gc_component_t component, gc_backend_t backend,
1733                      char **src_filenamep, char **dest_filenamep,
1734                      char **orig_filenamep)
1735 {
1736   static const char marker[] = "###+++--- GPGConf ---+++###";
1737   /* True if we are within the marker in the config file.  */
1738   int in_marker = 0;
1739   gc_option_t *option;
1740   char *line = NULL;
1741   size_t line_len;
1742   ssize_t length;
1743   int res;
1744   int fd;
1745   FILE *src_file = NULL;
1746   FILE *dest_file = NULL;
1747   char *src_filename;
1748   char *dest_filename;
1749   char *orig_filename;
1750   char *arg;
1751   char *cur_arg = NULL;
1752
1753   option = find_option (component,
1754                         gc_backend[backend].option_name, GC_BACKEND_ANY);
1755   assert (option);
1756   assert (option->active);
1757   assert (gc_arg_type[option->arg_type].fallback != GC_ARG_TYPE_NONE);
1758
1759   /* FIXME.  Throughout the function, do better error reporting.  */
1760   /* Note that get_config_pathname() calls percent_deescape(), so we
1761      call this before processing the arguments.  */
1762   dest_filename = xstrdup (get_config_pathname (component, backend));
1763   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, getpid ());
1764   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename, getpid ());
1765
1766   arg = option->new_value;
1767   if (arg && arg[0] == '\0')
1768     arg = NULL;
1769   else if (arg)
1770     {
1771       char *end;
1772
1773       arg++;
1774       end = strchr (arg, ',');
1775       if (end)
1776         *end = '\0';
1777
1778       cur_arg = percent_deescape (arg);
1779       if (end)
1780         {
1781           *end = ',';
1782           arg = end + 1;
1783         }
1784       else
1785         arg = NULL;
1786     }
1787
1788 #if HAVE_W32_SYSTEM
1789   res = 0; 
1790 #warning no backups for W32 yet - need to write a copy function
1791 #else
1792   res = link (dest_filename, orig_filename);
1793 #endif
1794   if (res < 0 && errno != ENOENT)
1795     return -1;
1796   if (res < 0)
1797     {
1798       xfree (orig_filename);
1799       orig_filename = NULL;
1800     }
1801
1802   /* We now initialize the return strings, so the caller can do the
1803      cleanup for us.  */
1804   *src_filenamep = src_filename;
1805   *dest_filenamep = dest_filename;
1806   *orig_filenamep = orig_filename;
1807
1808   /* Use open() so that we can use O_EXCL.  */
1809   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
1810   if (fd < 0)
1811     return -1;
1812   src_file = fdopen (fd, "w");
1813   res = errno;
1814   if (!src_file)
1815     {
1816       errno = res;
1817       return -1;
1818     }
1819
1820   /* Only if ORIG_FILENAME is not NULL did the configuration file
1821      exist already.  In this case, we will copy its content into the
1822      new configuration file, changing it to our liking in the
1823      process.  */
1824   if (orig_filename)
1825     {
1826       dest_file = fopen (dest_filename, "r");
1827       if (!dest_file)
1828         goto change_file_one_err;
1829
1830       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
1831         {
1832           int disable = 0;
1833           char *start;
1834
1835           if (!strncmp (marker, line, sizeof (marker) - 1))
1836             {
1837               if (!in_marker)
1838                 in_marker = 1;
1839               else
1840                 break;
1841             }
1842
1843           start = line;
1844           while (*start == ' ' || *start == '\t')
1845             start++;
1846           if (*start && *start != '\r' && *start != '\n' && *start != '#')
1847             {
1848               char *end;
1849               char *endp;
1850               char saved_end;
1851
1852               endp = start;
1853               end = endp;
1854
1855               /* Search for the end of the line.  */
1856               while (*endp && *endp != '#' && *endp != '\r' && *endp != '\n')
1857                 {
1858                   endp++;
1859                   if (*endp && *endp != ' ' && *endp != '\t'
1860                       && *endp != '\r' && *endp != '\n' && *endp != '#')
1861                     end = endp + 1;
1862                 }
1863               saved_end = *end;
1864               *end = '\0';
1865
1866               if ((option->new_flags & GC_OPT_FLAG_DEFAULT)
1867                   || !cur_arg || strcmp (start, cur_arg))
1868                 disable = 1;
1869               else
1870                 {
1871                   /* Find next argument.  */
1872                   if (arg)
1873                     {
1874                       char *arg_end;
1875
1876                       arg++;
1877                       arg_end = strchr (arg, ',');
1878                       if (arg_end)
1879                         *arg_end = '\0';
1880
1881                       cur_arg = percent_deescape (arg);
1882                       if (arg_end)
1883                         {
1884                           *arg_end = ',';
1885                           arg = arg_end + 1;
1886                         }
1887                       else
1888                         arg = NULL;
1889                     }
1890                   else
1891                     cur_arg = NULL;
1892                 }
1893
1894               *end = saved_end;
1895             }
1896
1897           if (disable)
1898             {
1899               if (!in_marker)
1900                 {
1901                   fprintf (src_file,
1902                            "# GPGConf disabled this option here at %s\n",
1903                            asctimestamp (gnupg_get_time ()));
1904                   if (ferror (src_file))
1905                     goto change_file_one_err;
1906                   fprintf (src_file, "# %s", line);
1907                   if (ferror (src_file))
1908                     goto change_file_one_err;
1909                 }
1910             }
1911           else
1912             {
1913               fprintf (src_file, "%s", line);
1914               if (ferror (src_file))
1915                 goto change_file_one_err;
1916             }
1917         }
1918       if (length < 0 || ferror (dest_file))
1919         goto change_file_one_err;
1920     }
1921
1922   if (!in_marker)
1923     {
1924       /* There was no marker.  This is the first time we edit the
1925          file.  We add our own marker at the end of the file and
1926          proceed.  Note that we first write a newline, this guards us
1927          against files which lack the newline at the end of the last
1928          line, while it doesn't hurt us in all other cases.  */
1929       fprintf (src_file, "\n%s\n", marker);
1930       if (ferror (src_file))
1931         goto change_file_one_err;
1932     }
1933
1934   /* At this point, we have copied everything up to the end marker
1935      into the new file, except for the arguments we are going to add.
1936      Now, dump the new arguments and write the end marker, possibly
1937      followed by the rest of the original file.  */
1938   while (cur_arg)
1939     {
1940       fprintf (src_file, "%s\n", cur_arg);
1941
1942       /* Find next argument.  */
1943       if (arg)
1944         {
1945           char *end;
1946
1947           arg++;
1948           end = strchr (arg, ',');
1949           if (end)
1950             *end = '\0';
1951
1952           cur_arg = percent_deescape (arg);
1953           if (end)
1954             {
1955               *end = ',';
1956               arg = end + 1;
1957             }
1958           else
1959             arg = NULL;
1960         }
1961       else
1962         cur_arg = NULL;
1963     }
1964
1965   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
1966   if (ferror (src_file))
1967     goto change_file_one_err;
1968
1969   if (!in_marker)
1970     {
1971       fprintf (src_file, "# GPGConf edited this configuration file.\n");
1972       if (ferror (src_file))
1973         goto change_file_one_err;
1974       fprintf (src_file, "# It will disable options before this marked "
1975                "block, but it will\n");
1976       if (ferror (src_file))
1977         goto change_file_one_err;
1978       fprintf (src_file, "# never change anything below these lines.\n");
1979       if (ferror (src_file))
1980         goto change_file_one_err;
1981     }
1982   if (dest_file)
1983     {
1984       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
1985         {
1986           fprintf (src_file, "%s", line);
1987           if (ferror (src_file))
1988             goto change_file_one_err;
1989         }
1990       if (length < 0 || ferror (dest_file))
1991         goto change_file_one_err;
1992     }
1993   xfree (line);
1994   line = NULL;
1995
1996   res = fclose (src_file);
1997   if (res)
1998     {
1999       res = errno;
2000       close (fd);
2001       if (dest_file)
2002         fclose (dest_file);
2003       errno = res;
2004       return -1;
2005     }
2006   close (fd);
2007   if (dest_file)
2008     {
2009       res = fclose (dest_file);
2010       if (res)
2011         return -1;
2012     }
2013   return 0;
2014
2015  change_file_one_err:
2016   xfree (line);
2017   res = errno;
2018   if (src_file)
2019     {
2020       fclose (src_file);
2021       close (fd);
2022     }
2023   if (dest_file)
2024     fclose (dest_file);
2025   errno = res;
2026   return -1;
2027 }
2028
2029
2030 /* Create and verify the new configuration file for the specified
2031    backend and component.  Returns 0 on success and -1 on error.  */
2032 static int
2033 change_options_program (gc_component_t component, gc_backend_t backend,
2034                         char **src_filenamep, char **dest_filenamep,
2035                         char **orig_filenamep)
2036 {
2037   static const char marker[] = "###+++--- GPGConf ---+++###";
2038   /* True if we are within the marker in the config file.  */
2039   int in_marker = 0;
2040   gc_option_t *option;
2041   char *line = NULL;
2042   size_t line_len;
2043   ssize_t length;
2044   int res;
2045   int fd;
2046   FILE *src_file = NULL;
2047   FILE *dest_file = NULL;
2048   char *src_filename;
2049   char *dest_filename;
2050   char *orig_filename;
2051
2052   /* FIXME.  Throughout the function, do better error reporting.  */
2053   dest_filename = xstrdup (get_config_pathname (component, backend));
2054   src_filename = xasprintf ("%s.gpgconf.%i.new", dest_filename, getpid ());
2055   orig_filename = xasprintf ("%s.gpgconf.%i.bak", dest_filename, getpid ());
2056
2057 #if HAVE_W32_SYSTEM
2058   res = 0; 
2059 #warning no backups for W32 yet - need to write a copy function
2060 #else
2061   res = link (dest_filename, orig_filename);
2062 #endif
2063   if (res < 0 && errno != ENOENT)
2064     return -1;
2065   if (res < 0)
2066     {
2067       xfree (orig_filename);
2068       orig_filename = NULL;
2069     }
2070
2071   /* We now initialize the return strings, so the caller can do the
2072      cleanup for us.  */
2073   *src_filenamep = src_filename;
2074   *dest_filenamep = dest_filename;
2075   *orig_filenamep = orig_filename;
2076
2077   /* Use open() so that we can use O_EXCL.  */
2078   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2079   if (fd < 0)
2080     return -1;
2081   src_file = fdopen (fd, "w");
2082   res = errno;
2083   if (!src_file)
2084     {
2085       errno = res;
2086       return -1;
2087     }
2088
2089   /* Only if ORIG_FILENAME is not NULL did the configuration file
2090      exist already.  In this case, we will copy its content into the
2091      new configuration file, changing it to our liking in the
2092      process.  */
2093   if (orig_filename)
2094     {
2095       dest_file = fopen (dest_filename, "r");
2096       if (!dest_file)
2097         goto change_one_err;
2098
2099       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2100         {
2101           int disable = 0;
2102           char *start;
2103
2104           if (!strncmp (marker, line, sizeof (marker) - 1))
2105             {
2106               if (!in_marker)
2107                 in_marker = 1;
2108               else
2109                 break;
2110             }
2111
2112           start = line;
2113           while (*start == ' ' || *start == '\t')
2114             start++;
2115           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2116             {
2117               char *end;
2118               char saved_end;
2119
2120               end = start;
2121               while (*end && *end != ' ' && *end != '\t'
2122                      && *end != '\r' && *end != '\n' && *end != '#')
2123                 end++;
2124               saved_end = *end;
2125               *end = '\0';
2126
2127               option = find_option (component, start, backend);
2128               *end = saved_end;
2129               if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2130                              || option->new_value))
2131                 disable = 1;
2132             }
2133           if (disable)
2134             {
2135               if (!in_marker)
2136                 {
2137                   fprintf (src_file,
2138                            "# GPGConf disabled this option here at %s\n",
2139                            asctimestamp (gnupg_get_time ()));
2140                   if (ferror (src_file))
2141                     goto change_one_err;
2142                   fprintf (src_file, "# %s", line);
2143                   if (ferror (src_file))
2144                     goto change_one_err;
2145                 }
2146             }
2147           else
2148             {
2149               fprintf (src_file, "%s", line);
2150               if (ferror (src_file))
2151                 goto change_one_err;
2152             }
2153         }
2154       if (length < 0 || ferror (dest_file))
2155         goto change_one_err;
2156     }
2157
2158   if (!in_marker)
2159     {
2160       /* There was no marker.  This is the first time we edit the
2161          file.  We add our own marker at the end of the file and
2162          proceed.  Note that we first write a newline, this guards us
2163          against files which lack the newline at the end of the last
2164          line, while it doesn't hurt us in all other cases.  */
2165       fprintf (src_file, "\n%s\n", marker);
2166       if (ferror (src_file))
2167         goto change_one_err;
2168     }
2169   /* At this point, we have copied everything up to the end marker
2170      into the new file, except for the options we are going to change.
2171      Now, dump the changed options (except for those we are going to
2172      revert to their default), and write the end marker, possibly
2173      followed by the rest of the original file.  */
2174
2175   /* We have to turn on UTF8 strings for GnuPG.  */
2176   if (backend == GC_BACKEND_GPG)
2177     fprintf (src_file, "utf8-strings\n");
2178
2179   option = gc_component[component].options;
2180   while (option->name)
2181     {
2182       if (!(option->flags & GC_OPT_FLAG_GROUP)
2183           && option->backend == backend
2184           && option->new_value)
2185         {
2186           char *arg = option->new_value;
2187
2188           do
2189             {
2190               if (*arg == '\0' || *arg == ',')
2191                 {
2192                   fprintf (src_file, "%s\n", option->name);
2193                   if (ferror (src_file))
2194                     goto change_one_err;
2195                 }
2196               else if (gc_arg_type[option->arg_type].fallback
2197                        == GC_ARG_TYPE_NONE)
2198                 {
2199                   assert (*arg == '1');
2200                   fprintf (src_file, "%s\n", option->name);
2201                   if (ferror (src_file))
2202                     goto change_one_err;
2203
2204                   arg++;
2205                 }
2206               else if (gc_arg_type[option->arg_type].fallback
2207                        == GC_ARG_TYPE_STRING)
2208                 {
2209                   char *end;
2210                   
2211                   assert (*arg == '"');
2212                   arg++;
2213                   
2214                   end = strchr (arg, ',');
2215                   if (end)
2216                     *end = '\0';
2217
2218                   fprintf (src_file, "%s %s\n", option->name,
2219                            percent_deescape (arg));
2220                   if (ferror (src_file))
2221                     goto change_one_err;
2222
2223                   if (end)
2224                     *end = ',';
2225                   arg = end;
2226                 }
2227               else
2228                 {
2229                   char *end;
2230
2231                   end = strchr (arg, ',');
2232                   if (end)
2233                     *end = '\0';
2234
2235                   fprintf (src_file, "%s %s\n", option->name, arg);
2236                   if (ferror (src_file))
2237                     goto change_one_err;
2238
2239                   if (end)
2240                     *end = ',';
2241                   arg = end;
2242                 }
2243
2244               assert (arg == NULL || *arg == '\0' || *arg == ',');
2245               if (arg && *arg == ',')
2246                 arg++;
2247             }
2248           while (arg && *arg);
2249         }
2250       option++;
2251     }
2252
2253   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2254   if (ferror (src_file))
2255     goto change_one_err;
2256
2257   if (!in_marker)
2258     {
2259       fprintf (src_file, "# GPGConf edited this configuration file.\n");
2260       if (ferror (src_file))
2261         goto change_one_err;
2262       fprintf (src_file, "# It will disable options before this marked "
2263                "block, but it will\n");
2264       if (ferror (src_file))
2265         goto change_one_err;
2266       fprintf (src_file, "# never change anything below these lines.\n");
2267       if (ferror (src_file))
2268         goto change_one_err;
2269     }
2270   if (dest_file)
2271     {
2272       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2273         {
2274           fprintf (src_file, "%s", line);
2275           if (ferror (src_file))
2276             goto change_one_err;
2277         }
2278       if (length < 0 || ferror (dest_file))
2279         goto change_one_err;
2280     }
2281   xfree (line);
2282   line = NULL;
2283
2284   res = fclose (src_file);
2285   if (res)
2286     {
2287       res = errno;
2288       close (fd);
2289       if (dest_file)
2290         fclose (dest_file);
2291       errno = res;
2292       return -1;
2293     }
2294   close (fd);
2295   if (dest_file)
2296     {
2297       res = fclose (dest_file);
2298       if (res)
2299         return -1;
2300     }
2301   return 0;
2302
2303  change_one_err:
2304   xfree (line);
2305   res = errno;
2306   if (src_file)
2307     {
2308       fclose (src_file);
2309       close (fd);
2310     }
2311   if (dest_file)
2312     fclose (dest_file);
2313   errno = res;
2314   return -1;
2315 }
2316
2317
2318 /* Common code for gc_component_change_options and
2319    gc_process_gpgconf_conf.  */
2320 static void
2321 change_one_value (gc_option_t *option, int *runtime,
2322                   unsigned long flags, char *new_value)
2323 {
2324   unsigned long new_value_nr = 0;
2325
2326   option_check_validity (option, flags, new_value, &new_value_nr);
2327
2328   if (option->flags & GC_OPT_FLAG_RUNTIME)
2329     runtime[option->backend] = 1;
2330
2331   option->new_flags = flags;
2332   if (!(flags & GC_OPT_FLAG_DEFAULT))
2333     {
2334       if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
2335           && (option->flags & GC_OPT_FLAG_LIST))
2336         {
2337           char *str;
2338
2339           /* We convert the number to a list of 1's for convenient
2340              list handling.  */
2341           assert (new_value_nr > 0);
2342           option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
2343           str = option->new_value;
2344           *(str++) = '1';
2345           while (--new_value_nr > 0)
2346             {
2347               *(str++) = ',';
2348               *(str++) = '1';
2349             }
2350           *(str++) = '\0';
2351         }
2352       else
2353         option->new_value = xstrdup (new_value);
2354     }
2355 }
2356
2357
2358 /* Read the modifications from IN and apply them.  If IN is NULL the
2359    modifications are expected to already have been set to the global
2360    table. */
2361 void
2362 gc_component_change_options (int component, FILE *in)
2363 {
2364   int err = 0;
2365   int runtime[GC_BACKEND_NR];
2366   char *src_pathname[GC_BACKEND_NR];
2367   char *dest_pathname[GC_BACKEND_NR];
2368   char *orig_pathname[GC_BACKEND_NR];
2369   gc_backend_t backend;
2370   gc_option_t *option;
2371   char *line = NULL;
2372   size_t line_len = 0;
2373   ssize_t length;
2374
2375   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2376     {
2377       runtime[backend] = 0;
2378       src_pathname[backend] = NULL;
2379       dest_pathname[backend] = NULL;
2380       orig_pathname[backend] = NULL;
2381     }
2382
2383   if (in)
2384     {
2385       /* Read options from the file IN.  */
2386       while ((length = read_line (in, &line, &line_len, NULL)) > 0)
2387         {
2388           char *linep;
2389           unsigned long flags = 0;
2390           char *new_value = "";
2391           
2392           /* Strip newline and carriage return, if present.  */
2393           while (length > 0
2394                  && (line[length - 1] == '\n' || line[length - 1] == '\r'))
2395             line[--length] = '\0';
2396           
2397           linep = strchr (line, ':');
2398           if (linep)
2399             *(linep++) = '\0';
2400           
2401           /* Extract additional flags.  Default to none.  */
2402           if (linep)
2403             {
2404               char *end;
2405               char *tail;
2406
2407               end = strchr (linep, ':');
2408               if (end)
2409                 *(end++) = '\0';
2410               
2411               errno = 0;
2412               flags = strtoul (linep, &tail, 0);
2413               if (errno)
2414                 gc_error (1, errno, "malformed flags in option %s", line);
2415               if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
2416                 gc_error (1, 0, "garbage after flags in option %s", line);
2417               
2418               linep = end;
2419             }
2420
2421           /* Don't allow setting of the no change flag.  */
2422           flags &= ~GC_OPT_FLAG_NO_CHANGE;
2423           
2424           /* Extract default value, if present.  Default to empty if not.  */
2425           if (linep)
2426             {
2427               char *end;
2428               end = strchr (linep, ':');
2429               if (end)
2430                 *(end++) = '\0';
2431               new_value = linep;
2432               linep = end;
2433             }
2434           
2435           option = find_option (component, line, GC_BACKEND_ANY);
2436           if (!option)
2437             gc_error (1, 0, "unknown option %s", line);
2438           
2439           if ((option->flags & GC_OPT_FLAG_NO_CHANGE))
2440             {
2441               gc_error (0, 0, "ignoring new value for option %s",
2442                         option->name);
2443               continue;
2444             }
2445           
2446           change_one_value (option, runtime, flags, new_value);
2447         }
2448     }
2449
2450   /* Now that we have collected and locally verified the changes,
2451      write them out to new configuration files, verify them
2452      externally, and then commit them.  */
2453   option = gc_component[component].options;
2454   while (option->name)
2455     {
2456       /* Go on if we have already seen this backend, or if there is
2457          nothing to do.  */
2458       if (src_pathname[option->backend]
2459           || !(option->new_flags || option->new_value))
2460         {
2461           option++;
2462           continue;
2463         }
2464
2465       if (gc_backend[option->backend].program)
2466         err = change_options_program (component, option->backend,
2467                                       &src_pathname[option->backend],
2468                                       &dest_pathname[option->backend],
2469                                       &orig_pathname[option->backend]);
2470       else
2471         err = change_options_file (component, option->backend,
2472                                    &src_pathname[option->backend],
2473                                    &dest_pathname[option->backend],
2474                                    &orig_pathname[option->backend]);
2475         
2476       if (err)
2477         break;
2478           
2479       option++;
2480     }
2481
2482   if (!err)
2483     {
2484       int i;
2485
2486       for (i = 0; i < GC_BACKEND_NR; i++)
2487         {
2488           if (src_pathname[i])
2489             {
2490               /* FIXME: Make a verification here.  */
2491
2492               assert (dest_pathname[i]);
2493
2494               if (orig_pathname[i])
2495                 err = rename (src_pathname[i], dest_pathname[i]);
2496               else
2497                 {
2498 #ifdef HAVE_W32_SYSTEM
2499                   /* FIXME: Won't work becuase W32 doesn't silently
2500                      overwrite. Fix it by creating a backup copy and
2501                      deliting the orginal file first. */
2502                   err = rename (src_pathname[i], dest_pathname[i]);
2503 #else /*!HAVE_W32_SYSTEM*/
2504                   /* This is a bit safer than rename() because we
2505                      expect DEST_PATHNAME not to be there.  If it
2506                      happens to be there, this will fail.  */
2507                   err = link (src_pathname[i], dest_pathname[i]);
2508                   if (!err)
2509                     unlink (src_pathname[i]);
2510 #endif /*!HAVE_W32_SYSTEM*/
2511                 }
2512               if (err)
2513                 break;
2514               src_pathname[i] = NULL;
2515             }
2516         }
2517     }
2518
2519   if (err)
2520     {
2521       int i;
2522       int saved_errno = errno;
2523
2524       /* An error occured.  */
2525       for (i = 0; i < GC_BACKEND_NR; i++)
2526         {
2527           if (src_pathname[i])
2528             {
2529               /* The change was not yet committed.  */
2530               unlink (src_pathname[i]);
2531               if (orig_pathname[i])
2532                 unlink (orig_pathname[i]);
2533             }
2534           else
2535             {
2536               /* The changes were already committed.  FIXME: This is a
2537                  tad dangerous, as we don't know if we don't overwrite
2538                  a version of the file that is even newer than the one
2539                  we just installed.  */
2540               if (orig_pathname[i])
2541                 rename (orig_pathname[i], dest_pathname[i]);
2542               else
2543                 unlink (dest_pathname[i]);
2544             }
2545         }
2546       gc_error (1, saved_errno, "could not commit changes");
2547     }
2548
2549   /* If it all worked, notify the daemons of the changes.  */
2550   if (opt.runtime)
2551     for (backend = 0; backend < GC_BACKEND_NR; backend++)  
2552       {
2553         if (runtime[backend] && gc_backend[backend].runtime_change)
2554           (*gc_backend[backend].runtime_change) ();
2555       }
2556
2557   /* Move the per-process backup file into its place.  */
2558   for (backend = 0; backend < GC_BACKEND_NR; backend++)  
2559     if (orig_pathname[backend])
2560       {
2561         char *backup_pathname;
2562
2563         assert (dest_pathname[backend]);
2564
2565         backup_pathname = xasprintf ("%s.gpgconf.bak", dest_pathname[backend]);
2566         rename (orig_pathname[backend], backup_pathname);
2567       }
2568
2569   xfree (line);
2570 }
2571
2572
2573 /* Check whether USER matches the current user of one of its group.
2574    This function may change USER.  Returns true is there is a
2575    match.  */
2576 static int
2577 key_matches_user_or_group (char *user)
2578 {
2579 #ifdef HAVE_W32_SYSTEM
2580 # warning We need a real user and group lookup.
2581 #else
2582   char *group;
2583   int n;
2584
2585   if (*user == '*' && user[1] == 0)
2586     return 1; /* A single asterisk matches all users.  */
2587
2588   group = strchr (user, ':');
2589   if (group)
2590     *group++ = 0;
2591
2592   /* First check whether the user matches.  */
2593   if (*user)
2594     {
2595       static char *my_name;
2596
2597       if (!my_name)
2598         {
2599           struct passwd *pw = getpwuid ( getuid () );
2600           if (!pw)
2601             gc_error (1, errno, "getpwuid failed for current user");
2602           my_name = xstrdup (pw->pw_name);
2603         }
2604       if (!strcmp (user, my_name))
2605         return 1; /* Found.  */
2606     }
2607
2608   /* If that failed, check whether a group matches.  */
2609   if (group && *group)
2610     {
2611       static char *my_group;
2612       static char **my_supgroups;
2613
2614       if (!my_group)
2615         {
2616           struct group *gr = getgrgid ( getgid () );
2617           if (!gr)
2618             gc_error (1, errno, "getgrgid failed for current user");
2619           my_group = xstrdup (gr->gr_name);
2620         }
2621       if (!strcmp (group, my_group))
2622         return 1; /* Found.  */
2623
2624       if (!my_supgroups)
2625         {
2626           int ngids;
2627           gid_t *gids;
2628
2629           ngids = getgroups (0, NULL);
2630           gids  = xcalloc (ngids+1, sizeof *gids);
2631           ngids = getgroups (ngids, gids);
2632           if (ngids < 0)
2633             gc_error (1, errno, "getgroups failed for current user");
2634           my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
2635           for (n=0; n < ngids; n++)
2636             {
2637               struct group *gr = getgrgid ( gids[n] );
2638               if (!gr)
2639                 gc_error (1, errno, "getgrgid failed for supplementary group");
2640               my_supgroups[n] = xstrdup (gr->gr_name);
2641             }
2642           xfree (gids);
2643         }
2644
2645       for (n=0; my_supgroups[n]; n++)
2646         if (!strcmp (group, my_supgroups[n]))
2647           return 1; /* Found.  */
2648     }
2649 #endif
2650   return 0; /* No match.  */
2651 }
2652
2653
2654
2655 /* Read and process the global configuration file for gpgconf.  This
2656    optional file is used to update our internal tables at runtime and
2657    may also be used to set new default values.  If FNAME is NULL the
2658    default name will be used.  With UPDATE set to true the internal
2659    tables are actually updated; if not set, only a syntax check is
2660    done.  If DEFAULTS is true the global options are written to the
2661    configuration files.
2662
2663    Returns 0 on success or if the config file is not present; -1 is
2664    returned on error. */
2665 int
2666 gc_process_gpgconf_conf (const char *fname, int update, int defaults)
2667 {
2668   int result = 0;
2669   char *line = NULL;
2670   size_t line_len = 0;
2671   ssize_t length;
2672   FILE *config;
2673   int lineno = 0;
2674   int in_rule = 0;
2675   int got_match = 0;
2676   int runtime[GC_BACKEND_NR];
2677   int used_components[GC_COMPONENT_NR];
2678   int backend_id, component_id;
2679
2680   if (!fname)
2681     fname = GNUPG_SYSCONFDIR "/gpgconf.conf";
2682
2683   for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
2684     runtime[backend_id] = 0;
2685   for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
2686     used_components[component_id] = 0;
2687
2688   config = fopen (fname, "r");
2689   if (!config)
2690     {
2691       /* Do not print an error if the file is not available, except
2692          when runnign in syntax check mode.  */
2693       if (errno != ENOENT || !update)
2694         {
2695           gc_error (0, errno, "can not open global config file `%s'", fname);
2696           result = -1;
2697         }
2698       return result;
2699     }
2700
2701   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
2702     {
2703       char *key, *component, *option, *flags, *value;
2704       char *empty;
2705       gc_option_t *option_info = NULL;
2706       char *p;
2707       int is_continuation;
2708       
2709       lineno++;
2710       key = line;
2711       while (*key == ' ' || *key == '\t')
2712         key++;
2713       if (!*key || *key == '#' || *key == '\r' || *key == '\n')
2714         continue;
2715
2716       is_continuation = (key != line);
2717
2718       /* Parse the key field.  */
2719       if (!is_continuation && got_match)
2720         break;  /* Finish after the first match.  */
2721       else if (!is_continuation)
2722         {
2723           in_rule = 0;
2724           for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
2725             ;
2726           if (!*p)
2727             {
2728               gc_error (0, 0, "missing rule at `%s', line %d", fname, lineno);
2729               result = -1;
2730               continue;
2731             }
2732           *p++ = 0;
2733           component = p;
2734         }
2735       else if (!in_rule)
2736         {
2737           gc_error (0, 0, "continuation but no rule at `%s', line %d",
2738                     fname, lineno);
2739           result = -1;
2740           continue;
2741         }
2742       else
2743         {
2744           component = key;
2745           key = NULL;
2746         }
2747
2748       in_rule = 1;
2749
2750       /* Parse the component.  */
2751       while (*component == ' ' || *component == '\t')
2752         component++;
2753       for (p=component; *p && !strchr (" \t\r\n", *p); p++)
2754         ;
2755       if (p == component)
2756         {
2757           gc_error (0, 0, "missing component at `%s', line %d",
2758                     fname, lineno);
2759           result = -1;
2760           continue;
2761         }
2762       empty = p;
2763       *p++ = 0;
2764       option = p;
2765       component_id = gc_component_find (component);
2766       if (component_id < 0)
2767         {
2768           gc_error (0, 0, "unknown component at `%s', line %d",
2769                     fname, lineno);
2770           result = -1;
2771         }
2772
2773       /* Parse the option name.  */
2774       while (*option == ' ' || *option == '\t')
2775         option++;
2776       for (p=option; *p && !strchr (" \t\r\n", *p); p++)
2777         ;
2778       if (p == option)
2779         {
2780           gc_error (0, 0, "missing option at `%s', line %d",
2781                     fname, lineno);
2782           result = -1;
2783           continue;
2784         }
2785       *p++ = 0;
2786       flags = p;
2787       if ( component_id != -1)
2788         {
2789           option_info = find_option (component_id, option, GC_BACKEND_ANY);
2790           if (!option_info)
2791             {
2792               gc_error (0, 0, "unknown option at `%s', line %d",
2793                         fname, lineno);
2794               result = -1;
2795             }
2796         }
2797
2798
2799       /* Parse the optional flags.  */
2800       while (*flags == ' ' || *flags == '\t')
2801         flags++;
2802       if (*flags == '[')
2803         {
2804           flags++;
2805           p = strchr (flags, ']');
2806           if (!p)
2807             {
2808               gc_error (0, 0, "syntax error in rule at `%s', line %d",
2809                         fname, lineno);
2810               result = -1;
2811               continue;
2812             }
2813           *p++ = 0;
2814           value = p;
2815         }
2816       else  /* No flags given.  */
2817         {
2818           value = flags;
2819           flags = NULL;
2820         }
2821
2822       /* Parse the optional value.  */
2823       while (*value == ' ' || *value == '\t')
2824        value++;
2825       for (p=value; *p && !strchr ("\r\n", *p); p++)
2826         ;
2827       if (p == value)
2828         value = empty; /* No value given; let it point to an empty string.  */
2829       else
2830         {
2831           /* Strip trailing white space.  */
2832           *p = 0;
2833           for (p--; p > value && (*p == ' ' || *p == '\t'); p--)
2834             *p = 0;
2835         }
2836
2837       /* Check flag combinations.  */
2838       if (!flags)
2839         ;
2840       else if (!strcmp (flags, "default"))
2841         {
2842           if (*value)
2843             {
2844               gc_error (0, 0, "flag \"default\" may not be combined "
2845                         "with a value at `%s', line %d",
2846                         fname, lineno);
2847               result = -1;
2848             }
2849         }
2850       else if (!strcmp (flags, "change"))
2851         ;
2852       else if (!strcmp (flags, "no-change"))
2853         ;
2854       else
2855         {
2856           gc_error (0, 0, "unknown flag at `%s', line %d",
2857                     fname, lineno);
2858           result = -1;
2859         }
2860       
2861           
2862       /* Check whether the key matches but do this only if we are not
2863          running in syntax check mode. */
2864       if ( update 
2865            && !result
2866            && (got_match || (key && key_matches_user_or_group (key))) )
2867         {
2868           int newflags = 0;
2869
2870           got_match = 1;
2871
2872           /* Apply the flags from gpgconf.conf.  */
2873           if (!flags)
2874             ;
2875           else if (!strcmp (flags, "default"))
2876             newflags |= GC_OPT_FLAG_DEFAULT;
2877           else if (!strcmp (flags, "no-change"))
2878             option_info->flags |= GC_OPT_FLAG_NO_CHANGE;
2879           else if (!strcmp (flags, "change"))
2880             option_info->flags &= ~GC_OPT_FLAG_NO_CHANGE;
2881
2882           if (defaults)
2883             {
2884               assert (component_id >= 0 && component_id < GC_COMPONENT_NR);
2885               used_components[component_id] = 1;
2886
2887               /* Here we explicitly allow to update the value again.  */
2888               if (newflags)
2889                 {
2890                   option_info->new_flags = 0;
2891                 }
2892               if (*value)
2893                 {
2894                   xfree (option_info->new_value);
2895                   option_info->new_value = NULL;
2896                 }
2897               change_one_value (option_info, runtime, newflags, value);
2898             }
2899         }
2900     }
2901
2902   if (length < 0 || ferror (config))
2903     {
2904       gc_error (0, errno, "error reading from `%s'", fname);
2905       result = -1;
2906     }
2907   if (fclose (config) && ferror (config))
2908     gc_error (0, errno, "error closing `%s'", fname);
2909
2910   xfree (line);
2911
2912   /* If it all worked, process the options. */
2913   if (!result && update && defaults)
2914     {
2915       /* We need to switch off the runtime update, so that we can do
2916          it later all at once. */
2917       int save_opt_runtime = opt.runtime;
2918       opt.runtime = 0;
2919
2920       for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
2921         {
2922           gc_component_change_options (component_id, NULL);
2923         }
2924       opt.runtime = save_opt_runtime;
2925
2926       if (opt.runtime)
2927         {
2928           for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)  
2929             if (runtime[backend_id] && gc_backend[backend_id].runtime_change)
2930               (*gc_backend[backend_id].runtime_change) ();
2931         }
2932     }
2933
2934   return result;
2935 }