tools/gpgconf-comp.c

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