tools/gpgconf-comp.c

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