tools/gpgconf-comp.c

   1 /* gpgconf-comp.c - Configuration utility for GnuPG.
   2  * Copyright (C) 2004, 2007-2011 Free Software Foundation, Inc.
   3  * Copyright (C) 2016 Werner Koch
   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 <https://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    { "no-allow-loopback-pinentry", GC_OPT_FLAG_RUNTIME,
 552      GC_LEVEL_EXPERT, "gnupg", "disallow 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 bypassing 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    { "pinentry-timeout", GC_OPT_FLAG_RUNTIME,
 586      GC_LEVEL_ADVANCED, "gnupg",
 587      N_("|N|set the Pinentry timeout to N seconds"),
 588      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG_AGENT },
 589
 590    GC_OPTION_NULL
 591  };
 592 #endif /*BUILD_WITH_AGENT*/
 593
 594
 595 #ifndef BUILD_WITH_SCDAEMON
 596 #define gc_options_scdaemon NULL
 597 #else
 598 /* The options of the GC_COMPONENT_SCDAEMON component.  */
 599 static gc_option_t gc_options_scdaemon[] =
 600  {
 601    /* The configuration file to which we write the changes.  */
 602    { GPGCONF_NAME"-"SCDAEMON_NAME".conf",
 603      GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
 604      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_SCDAEMON },
 605
 606    { "Monitor",
 607      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 608      "gnupg", N_("Options controlling the diagnostic output") },
 609    { "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
 610      "gnupg", "verbose",
 611      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
 612    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 613      "gnupg", "be somewhat more quiet",
 614      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
 615    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 616      NULL, NULL,
 617      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
 618
 619    { "Configuration",
 620      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
 621      "gnupg", N_("Options controlling the configuration") },
 622    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
 623      "gnupg", "|FILE|read options from FILE",
 624      GC_ARG_TYPE_FILENAME, GC_BACKEND_SCDAEMON },
 625    { "reader-port", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
 626      "gnupg", "|N|connect to reader at port N",
 627      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
 628    { "ctapi-driver", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
 629      "gnupg", "|NAME|use NAME as ct-API driver",
 630      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
 631    { "pcsc-driver", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
 632      "gnupg", "|NAME|use NAME as PC/SC driver",
 633      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
 634    { "disable-ccid", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT,
 635      "gnupg", "do not use the internal CCID driver",
 636      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
 637    { "disable-pinpad", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
 638      "gnupg", "do not use a reader's pinpad",
 639      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
 640    { "enable-pinpad-varlen",
 641      GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
 642      "gnupg", "use variable length input for pinpad",
 643      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
 644    { "card-timeout", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
 645      "gnupg", "|N|disconnect the card after N seconds of inactivity",
 646      GC_ARG_TYPE_UINT32, GC_BACKEND_SCDAEMON },
 647
 648    { "Debug",
 649      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
 650      "gnupg", N_("Options useful for debugging") },
 651    { "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
 652      "gnupg", "|LEVEL|set the debugging level to LEVEL",
 653      GC_ARG_TYPE_STRING, GC_BACKEND_SCDAEMON },
 654    { "log-file", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
 655      "gnupg", N_("|FILE|write a log to FILE"),
 656      GC_ARG_TYPE_FILENAME, GC_BACKEND_SCDAEMON },
 657
 658    { "Security",
 659      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 660      "gnupg", N_("Options controlling the security") },
 661    { "deny-admin", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC,
 662      "gnupg", "deny the use of admin card commands",
 663      GC_ARG_TYPE_NONE, GC_BACKEND_SCDAEMON },
 664
 665
 666    GC_OPTION_NULL
 667  };
 668 #endif /*BUILD_WITH_SCDAEMON*/
 669
 670 #ifndef BUILD_WITH_GPG
 671 #define gc_options_gpg NULL
 672 #else
 673 /* The options of the GC_COMPONENT_GPG component.  */
 674 static gc_option_t gc_options_gpg[] =
 675  {
 676    /* The configuration file to which we write the changes.  */
 677    { GPGCONF_NAME"-"GPG_NAME".conf",
 678      GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
 679      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG },
 680
 681    { "Monitor",
 682      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 683      "gnupg", N_("Options controlling the diagnostic output") },
 684    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
 685      "gnupg", "verbose",
 686      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
 687    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 688      "gnupg", "be somewhat more quiet",
 689      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
 690    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 691      NULL, NULL,
 692      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
 693
 694    { "Configuration",
 695      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
 696      "gnupg", N_("Options controlling the configuration") },
 697    { "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 698      "gnupg", N_("|NAME|use NAME as default secret key"),
 699      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
 700    { "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 701      "gnupg", N_("|NAME|encrypt to user ID NAME as well"),
 702      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
 703    { "group", GC_OPT_FLAG_LIST, GC_LEVEL_ADVANCED,
 704      "gnupg", N_("|SPEC|set up email aliases"),
 705      GC_ARG_TYPE_ALIAS_LIST, GC_BACKEND_GPG },
 706    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 707      NULL, NULL,
 708      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG },
 709    { "compliance", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 710      NULL, NULL,
 711      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
 712    { "default-new-key-algo", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 713      NULL, NULL,
 714      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
 715    { "default_pubkey_algo",
 716      (GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_NO_CHANGE), GC_LEVEL_INVISIBLE,
 717      NULL, NULL,
 718      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
 719
 720
 721    { "Debug",
 722      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
 723      "gnupg", N_("Options useful for debugging") },
 724    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
 725      "gnupg", "|LEVEL|set the debugging level to LEVEL",
 726      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
 727    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 728      "gnupg", N_("|FILE|write server mode logs to FILE"),
 729      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPG },
 730 /*    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE, */
 731 /*      NULL, NULL, */
 732 /*      GC_ARG_TYPE_UINT32, GC_BACKEND_GPG }, */
 733
 734    { "Keyserver",
 735      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 736      "gnupg", N_("Configuration for Keyservers") },
 737    { "keyserver", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
 738      "gnupg", N_("|URL|use keyserver at URL"), /* Deprecated - use dirmngr */
 739      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
 740    { "allow-pka-lookup", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 741      "gnupg", N_("allow PKA lookups (DNS requests)"),
 742      GC_ARG_TYPE_NONE, GC_BACKEND_GPG },
 743    { "auto-key-locate", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 744      "gnupg", N_("|MECHANISMS|use MECHANISMS to locate keys by mail address"),
 745      GC_ARG_TYPE_STRING, GC_BACKEND_GPG },
 746
 747
 748    GC_OPTION_NULL
 749  };
 750 #endif /*BUILD_WITH_GPG*/
 751
 752
 753 #ifndef BUILD_WITH_GPGSM
 754 #define gc_options_gpgsm NULL
 755 #else
 756 /* The options of the GC_COMPONENT_GPGSM component.  */
 757 static gc_option_t gc_options_gpgsm[] =
 758  {
 759    /* The configuration file to which we write the changes.  */
 760    { GPGCONF_NAME"-"GPGSM_NAME".conf",
 761      GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
 762      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_GPGSM },
 763
 764    { "Monitor",
 765      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 766      "gnupg", N_("Options controlling the diagnostic output") },
 767    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
 768      "gnupg", "verbose",
 769      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 770    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 771      "gnupg", "be somewhat more quiet",
 772      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 773    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 774      NULL, NULL,
 775      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 776
 777    { "Configuration",
 778      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
 779      "gnupg", N_("Options controlling the configuration") },
 780    { "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 781      "gnupg", N_("|NAME|use NAME as default secret key"),
 782      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
 783    { "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 784      "gnupg", N_("|NAME|encrypt to user ID NAME as well"),
 785      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
 786    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
 787      "gnupg", "|FILE|read options from FILE",
 788      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPGSM },
 789    { "prefer-system-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 790      "gnupg", "use system's dirmngr if available",
 791      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 792    { "disable-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
 793      "gnupg", N_("disable all access to the dirmngr"),
 794      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 795    { "p12-charset", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 796      "gnupg", N_("|NAME|use encoding NAME for PKCS#12 passphrases"),
 797      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
 798    { "keyserver", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
 799      "gnupg", N_("|SPEC|use this keyserver to lookup keys"),
 800      GC_ARG_TYPE_LDAP_SERVER, GC_BACKEND_GPGSM },
 801    { "default_pubkey_algo",
 802      (GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_NO_CHANGE), GC_LEVEL_INVISIBLE,
 803      NULL, NULL,
 804      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
 805
 806    { "Debug",
 807      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
 808      "gnupg", N_("Options useful for debugging") },
 809    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
 810      "gnupg", "|LEVEL|set the debugging level to LEVEL",
 811      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
 812    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 813      "gnupg", N_("|FILE|write server mode logs to FILE"),
 814      GC_ARG_TYPE_FILENAME, GC_BACKEND_GPGSM },
 815    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 816      NULL, NULL,
 817      GC_ARG_TYPE_UINT32, GC_BACKEND_GPGSM },
 818
 819    { "Security",
 820      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 821      "gnupg", N_("Options controlling the security") },
 822    { "disable-crl-checks", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 823      "gnupg", "never consult a CRL",
 824      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 825    { "enable-crl-checks", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 826      NULL, NULL,
 827      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 828    { "disable-trusted-cert-crl-check", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
 829      "gnupg", N_("do not check CRLs for root certificates"),
 830      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 831    { "enable-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 832      "gnupg", "check validity using OCSP",
 833      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 834    { "include-certs", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
 835      "gnupg", "|N|number of certificates to include",
 836      GC_ARG_TYPE_INT32, GC_BACKEND_GPGSM },
 837    { "disable-policy-checks", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 838      "gnupg", "do not check certificate policies",
 839      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 840    { "auto-issuer-key-retrieve", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 841      "gnupg", "fetch missing issuer certificates",
 842      GC_ARG_TYPE_NONE, GC_BACKEND_GPGSM },
 843    { "cipher-algo", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 844      "gnupg", "|NAME|use cipher algorithm NAME",
 845      GC_ARG_TYPE_STRING, GC_BACKEND_GPGSM },
 846
 847    GC_OPTION_NULL
 848  };
 849 #endif /*BUILD_WITH_GPGSM*/
 850
 851
 852 #ifndef BUILD_WITH_DIRMNGR
 853 #define gc_options_dirmngr NULL
 854 #else
 855 /* The options of the GC_COMPONENT_DIRMNGR component.  */
 856 static gc_option_t gc_options_dirmngr[] =
 857  {
 858    /* The configuration file to which we write the changes.  */
 859    { GPGCONF_NAME"-"DIRMNGR_NAME".conf",
 860      GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
 861      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
 862
 863    { "Monitor",
 864      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 865      "gnupg", N_("Options controlling the diagnostic output") },
 866    { "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
 867      "dirmngr", "verbose",
 868      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 869    { "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 870      "dirmngr", "be somewhat more quiet",
 871      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 872    { "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 873      NULL, NULL,
 874      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 875
 876    { "Format",
 877      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 878      "gnupg", N_("Options controlling the format of the output") },
 879    { "sh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 880      "dirmngr", "sh-style command output",
 881      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 882    { "csh", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 883      "dirmngr", "csh-style command output",
 884      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 885
 886    { "Configuration",
 887      GC_OPT_FLAG_GROUP, GC_LEVEL_EXPERT,
 888      "gnupg", N_("Options controlling the configuration") },
 889    { "options", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT,
 890      "dirmngr", "|FILE|read options from FILE",
 891      GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
 892    { "resolver-timeout", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 893      NULL, NULL,
 894      GC_ARG_TYPE_INT32, GC_BACKEND_DIRMNGR },
 895    { "nameserver", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 896      NULL, NULL,
 897      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
 898
 899    { "Debug",
 900      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
 901      "gnupg", N_("Options useful for debugging") },
 902    { "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED,
 903      "dirmngr", "|LEVEL|set the debugging level to LEVEL",
 904      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
 905    { "no-detach", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 906      "dirmngr", "do not detach from the console",
 907      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 908    { "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 909      "dirmngr", N_("|FILE|write server mode logs to FILE"),
 910      GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
 911    { "debug-wait", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 912      NULL, NULL,
 913      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
 914    { "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE,
 915      NULL, NULL,
 916      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
 917
 918    { "Enforcement",
 919      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 920      "gnupg", N_("Options controlling the interactivity and enforcement") },
 921    { "batch", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 922      "dirmngr", "run without asking a user",
 923      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 924    { "force", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 925      "dirmngr", "force loading of outdated CRLs",
 926      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 927    { "allow-version-check", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 928      "dirmngr", "allow online software version check",
 929      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 930
 931    { "Tor",
 932      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 933      "gnupg", N_("Options controlling the use of Tor") },
 934    { "use-tor", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 935      "dirmngr", "route all network traffic via TOR",
 936       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 937
 938    { "Keyserver",
 939      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 940      "gnupg", N_("Configuration for Keyservers") },
 941    { "keyserver", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 942      "gnupg", N_("|URL|use keyserver at URL"),
 943      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
 944
 945    { "HTTP",
 946      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
 947      "gnupg", N_("Configuration for HTTP servers") },
 948    { "disable-http", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 949      "dirmngr", "inhibit the use of HTTP",
 950       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 951    { "ignore-http-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 952      "dirmngr", "ignore HTTP CRL distribution points",
 953       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 954    { "http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 955      "dirmngr", "|URL|redirect all HTTP requests to URL",
 956      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
 957    { "honor-http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 958      "gnupg", N_("use system's HTTP proxy setting"),
 959      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 960
 961    { "LDAP",
 962      GC_OPT_FLAG_GROUP, GC_LEVEL_BASIC,
 963      "gnupg", N_("Configuration of LDAP servers to use") },
 964    { "disable-ldap", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 965      "dirmngr", "inhibit the use of LDAP",
 966       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 967    { "ignore-ldap-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 968      "dirmngr", "ignore LDAP CRL distribution points",
 969       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 970    { "ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 971      "dirmngr", "|HOST|use HOST for LDAP queries",
 972      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
 973    { "only-ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 974      "dirmngr", "do not use fallback hosts with --ldap-proxy",
 975       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 976    { "add-servers", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
 977      "dirmngr", "add new servers discovered in CRL distribution points"
 978      " to serverlist", GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
 979    { "ldaptimeout", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 980      "dirmngr", "|N|set LDAP timeout to N seconds",
 981      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
 982    /* The following entry must not be removed, as it is required for
 983       the GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST.  */
 984    { "ldapserverlist-file",
 985      GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
 986      "dirmngr", "|FILE|read LDAP server list from FILE",
 987      GC_ARG_TYPE_FILENAME, GC_BACKEND_DIRMNGR },
 988    /* This entry must come after at least one entry for
 989       GC_BACKEND_DIRMNGR in this component, so that the entry for
 990       "ldapserverlist-file will be initialized before this one.  */
 991    { "LDAP Server", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
 992      "gnupg", N_("LDAP server list"),
 993      GC_ARG_TYPE_LDAP_SERVER, GC_BACKEND_DIRMNGR_LDAP_SERVER_LIST },
 994    { "max-replies", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
 995      "dirmngr", "|N|do not return more than N items in one query",
 996      GC_ARG_TYPE_UINT32, GC_BACKEND_DIRMNGR },
 997
 998    { "OCSP",
 999      GC_OPT_FLAG_GROUP, GC_LEVEL_ADVANCED,
1000      "gnupg", N_("Configuration for OCSP") },
1001    { "allow-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC,
1002      "dirmngr", "allow sending OCSP requests",
1003      GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
1004    { "ignore-ocsp-service-url", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
1005      "dirmngr", "ignore certificate contained OCSP service URLs",
1006       GC_ARG_TYPE_NONE, GC_BACKEND_DIRMNGR },
1007    { "ocsp-responder", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
1008      "dirmngr", "|URL|use OCSP responder at URL",
1009      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
1010    { "ocsp-signer", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
1011      "dirmngr", "|FPR|OCSP response signed by FPR",
1012      GC_ARG_TYPE_STRING, GC_BACKEND_DIRMNGR },
1013
1014
1015    GC_OPTION_NULL
1016  };
1017 #endif /*BUILD_WITH_DIRMNGR*/
1018
1019
1020 /* The options of the GC_COMPONENT_PINENTRY component.  */
1021 static gc_option_t gc_options_pinentry[] =
1022  {
1023    /* A dummy option to allow gc_component_list_components to find the
1024       pinentry backend.  Needs to be a conf file. */
1025    { GPGCONF_NAME"-pinentry.conf",
1026      GC_OPT_FLAG_NONE, GC_LEVEL_INTERNAL,
1027      NULL, NULL, GC_ARG_TYPE_FILENAME, GC_BACKEND_PINENTRY },
1028
1029    GC_OPTION_NULL
1030  };
1031
1032
1033 \f
1034 /* Component system.  Each component is a set of options that can be
1035    configured at the same time.  If you change this, don't forget to
1036    update GC_COMPONENT below.  */
1037 typedef enum
1038   {
1039     /* The classic GPG for OpenPGP.  */
1040     GC_COMPONENT_GPG,
1041
1042     /* The GPG Agent.  */
1043     GC_COMPONENT_GPG_AGENT,
1044
1045     /* The Smardcard Daemon.  */
1046     GC_COMPONENT_SCDAEMON,
1047
1048     /* GPG for S/MIME.  */
1049     GC_COMPONENT_GPGSM,
1050
1051     /* The LDAP Directory Manager for CRLs.  */
1052     GC_COMPONENT_DIRMNGR,
1053
1054     /* The external Pinentry.  */
1055     GC_COMPONENT_PINENTRY,
1056
1057     /* The number of components.  */
1058     GC_COMPONENT_NR
1059   } gc_component_t;
1060
1061
1062 /* The information associated with each component.  */
1063 static struct
1064 {
1065   /* The name of this component.  Must not contain a colon (':')
1066      character.  */
1067   const char *name;
1068
1069   /* The gettext domain for the description DESC.  If this is NULL,
1070      then the description is not translated.  */
1071   const char *desc_domain;
1072
1073   /* The description for this domain.  */
1074   const char *desc;
1075
1076   /* The list of options for this component, terminated by
1077      GC_OPTION_NULL.  */
1078   gc_option_t *options;
1079 } gc_component[] =
1080   {
1081     { "gpg",      "gnupg", N_("OpenPGP"), gc_options_gpg },
1082     { "gpg-agent","gnupg", N_("Private Keys"), gc_options_gpg_agent },
1083     { "scdaemon", "gnupg", N_("Smartcards"), gc_options_scdaemon },
1084     { "gpgsm",    "gnupg", N_("S/MIME"), gc_options_gpgsm },
1085     { "dirmngr",  "gnupg", N_("Network"), gc_options_dirmngr },
1086     { "pinentry", "gnupg", N_("Passphrase Entry"), gc_options_pinentry }
1087   };
1088
1089
1090
1091 /* Structure used to collect error output of the backend programs.  */
1092 struct error_line_s;
1093 typedef struct error_line_s *error_line_t;
1094 struct error_line_s
1095 {
1096   error_line_t next;   /* Link to next item.  */
1097   const char *fname;   /* Name of the config file (points into BUFFER).  */
1098   unsigned int lineno; /* Line number of the config file.  */
1099   const char *errtext; /* Text of the error message (points into BUFFER).  */
1100   char buffer[1];  /* Helper buffer.  */
1101 };
1102
1103
1104 \f
1105
1106 /* Initialization and finalization.  */
1107
1108 static void
1109 gc_option_free (gc_option_t *o)
1110 {
1111   if (o == NULL || o->name == NULL)
1112     return;
1113
1114   xfree (o->value);
1115   gc_option_free (o + 1);
1116 }
1117
1118 static void
1119 gc_components_free (void)
1120 {
1121   int i;
1122   for (i = 0; i < DIM (gc_component); i++)
1123     gc_option_free (gc_component[i].options);
1124 }
1125
1126 void
1127 gc_components_init (void)
1128 {
1129   atexit (gc_components_free);
1130 }
1131
1132 \f
1133
1134 /* Engine specific support.  */
1135 static void
1136 gpg_agent_runtime_change (int killflag)
1137 {
1138   gpg_error_t err = 0;
1139   const char *pgmname;
1140   const char *argv[5];
1141   pid_t pid = (pid_t)(-1);
1142   char *abs_homedir = NULL;
1143   int i = 0;
1144
1145   pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1146   if (!gnupg_default_homedir_p ())
1147     {
1148       abs_homedir = make_absfilename_try (gnupg_homedir (), NULL);
1149       if (!abs_homedir)
1150         err = gpg_error_from_syserror ();
1151
1152       argv[i++] = "--homedir";
1153       argv[i++] = abs_homedir;
1154     }
1155   argv[i++] = "--no-autostart";
1156   argv[i++] = killflag? "KILLAGENT" : "RELOADAGENT";
1157   argv[i++] = NULL;
1158
1159   if (!err)
1160     err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1161   if (!err)
1162     err = gnupg_wait_process (pgmname, pid, 1, NULL);
1163   if (err)
1164     gc_error (0, 0, "error running '%s %s': %s",
1165               pgmname, argv[1], gpg_strerror (err));
1166   gnupg_release_process (pid);
1167   xfree (abs_homedir);
1168 }
1169
1170
1171 static void
1172 scdaemon_runtime_change (int killflag)
1173 {
1174   gpg_error_t err = 0;
1175   const char *pgmname;
1176   const char *argv[9];
1177   pid_t pid = (pid_t)(-1);
1178   char *abs_homedir = NULL;
1179   int i = 0;
1180
1181   (void)killflag;  /* For scdaemon kill and reload are synonyms.  */
1182
1183   /* We use "GETINFO app_running" to see whether the agent is already
1184      running and kill it only in this case.  This avoids an explicit
1185      starting of the agent in case it is not yet running.  There is
1186      obviously a race condition but that should not harm too much.  */
1187
1188   pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1189   if (!gnupg_default_homedir_p ())
1190     {
1191       abs_homedir = make_absfilename_try (gnupg_homedir (), NULL);
1192       if (!abs_homedir)
1193         err = gpg_error_from_syserror ();
1194
1195       argv[i++] = "--homedir";
1196       argv[i++] = abs_homedir;
1197     }
1198   argv[i++] = "-s";
1199   argv[i++] = "--no-autostart";
1200   argv[i++] = "GETINFO scd_running";
1201   argv[i++] = "/if ${! $?}";
1202   argv[i++] = "scd killscd";
1203   argv[i++] = "/end";
1204   argv[i++] = NULL;
1205
1206   if (!err)
1207     err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1208   if (!err)
1209     err = gnupg_wait_process (pgmname, pid, 1, NULL);
1210   if (err)
1211     gc_error (0, 0, "error running '%s %s': %s",
1212               pgmname, argv[4], gpg_strerror (err));
1213   gnupg_release_process (pid);
1214   xfree (abs_homedir);
1215 }
1216
1217
1218 static void
1219 dirmngr_runtime_change (int killflag)
1220 {
1221   gpg_error_t err = 0;
1222   const char *pgmname;
1223   const char *argv[6];
1224   pid_t pid = (pid_t)(-1);
1225   char *abs_homedir = NULL;
1226
1227   pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1228   argv[0] = "--no-autostart";
1229   argv[1] = "--dirmngr";
1230   argv[2] = killflag? "KILLDIRMNGR" : "RELOADDIRMNGR";
1231   if (gnupg_default_homedir_p ())
1232     argv[3] = NULL;
1233   else
1234     {
1235       abs_homedir = make_absfilename_try (gnupg_homedir (), NULL);
1236       if (!abs_homedir)
1237         err = gpg_error_from_syserror ();
1238
1239       argv[3] = "--homedir";
1240       argv[4] = abs_homedir;
1241       argv[5] = NULL;
1242     }
1243
1244   if (!err)
1245     err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1246   if (!err)
1247     err = gnupg_wait_process (pgmname, pid, 1, NULL);
1248   if (err)
1249     gc_error (0, 0, "error running '%s %s': %s",
1250               pgmname, argv[2], gpg_strerror (err));
1251   gnupg_release_process (pid);
1252   xfree (abs_homedir);
1253 }
1254
1255
1256 /* Launch the gpg-agent or the dirmngr if not already running.  */
1257 gpg_error_t
1258 gc_component_launch (int component)
1259 {
1260   gpg_error_t err;
1261   const char *pgmname;
1262   const char *argv[3];
1263   int i;
1264   pid_t pid;
1265
1266   if (component < 0)
1267     {
1268       err = gc_component_launch (GC_COMPONENT_GPG_AGENT);
1269       if (!err)
1270         err = gc_component_launch (GC_COMPONENT_DIRMNGR);
1271       return err;
1272     }
1273
1274   if (!(component == GC_COMPONENT_GPG_AGENT
1275         || component == GC_COMPONENT_DIRMNGR))
1276     {
1277       es_fputs (_("Component not suitable for launching"), es_stderr);
1278       es_putc ('\n', es_stderr);
1279       exit (1);
1280     }
1281
1282   pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
1283   i = 0;
1284   if (component == GC_COMPONENT_DIRMNGR)
1285     argv[i++] = "--dirmngr";
1286   argv[i++] = "NOP";
1287   argv[i] = NULL;
1288
1289   err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
1290   if (!err)
1291     err = gnupg_wait_process (pgmname, pid, 1, NULL);
1292   if (err)
1293     gc_error (0, 0, "error running '%s%s%s': %s",
1294               pgmname,
1295               component == GC_COMPONENT_DIRMNGR? " --dirmngr":"",
1296               " NOP",
1297               gpg_strerror (err));
1298   gnupg_release_process (pid);
1299   return err;
1300 }
1301
1302
1303 /* Unconditionally restart COMPONENT.  */
1304 void
1305 gc_component_kill (int component)
1306 {
1307   int runtime[GC_BACKEND_NR];
1308   gc_option_t *option;
1309   gc_backend_t backend;
1310
1311   /* Set a flag for the backends to be reloaded.  */
1312   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1313     runtime[backend] = 0;
1314
1315   if (component < 0)
1316     {
1317       for (component = 0; component < GC_COMPONENT_NR; component++)
1318         {
1319           option = gc_component[component].options;
1320           for (; option && option->name; option++)
1321             runtime[option->backend] = 1;
1322         }
1323     }
1324   else
1325     {
1326       assert (component < GC_COMPONENT_NR);
1327       option = gc_component[component].options;
1328       for (; option && option->name; option++)
1329         runtime[option->backend] = 1;
1330     }
1331
1332   /* Do the restart for the selected backends.  */
1333   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1334     {
1335       if (runtime[backend] && gc_backend[backend].runtime_change)
1336         (*gc_backend[backend].runtime_change) (1);
1337     }
1338 }
1339
1340
1341 /* Unconditionally reload COMPONENT or all components if COMPONENT is -1.  */
1342 void
1343 gc_component_reload (int component)
1344 {
1345   int runtime[GC_BACKEND_NR];
1346   gc_option_t *option;
1347   gc_backend_t backend;
1348
1349   /* Set a flag for the backends to be reloaded.  */
1350   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1351     runtime[backend] = 0;
1352
1353   if (component < 0)
1354     {
1355       for (component = 0; component < GC_COMPONENT_NR; component++)
1356         {
1357           option = gc_component[component].options;
1358           for (; option && option->name; option++)
1359             runtime[option->backend] = 1;
1360         }
1361     }
1362   else
1363     {
1364       assert (component < GC_COMPONENT_NR);
1365       option = gc_component[component].options;
1366       for (; option && option->name; option++)
1367         runtime[option->backend] = 1;
1368     }
1369
1370   /* Do the reload for all selected backends.  */
1371   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1372     {
1373       if (runtime[backend] && gc_backend[backend].runtime_change)
1374         (*gc_backend[backend].runtime_change) (0);
1375     }
1376 }
1377
1378
1379 \f
1380 /* More or less Robust version of dgettext.  It has the side effect of
1381    switching the codeset to utf-8 because this is what we want to
1382    output.  In theory it is posible to keep the original code set and
1383    switch back for regular disgnostic output (redefine "_(" for that)
1384    but given the natur of this tool, being something invoked from
1385    other pograms, it does not make much sense.  */
1386 static const char *
1387 my_dgettext (const char *domain, const char *msgid)
1388 {
1389 #ifdef USE_SIMPLE_GETTEXT
1390   if (domain)
1391     {
1392       static int switched_codeset;
1393       char *text;
1394
1395       if (!switched_codeset)
1396         {
1397           switched_codeset = 1;
1398           gettext_use_utf8 (1);
1399         }
1400
1401       if (!strcmp (domain, "gnupg"))
1402         domain = PACKAGE_GT;
1403
1404       /* FIXME: we have no dgettext, thus we can't switch.  */
1405
1406       text = (char*)gettext (msgid);
1407       return text ? text : msgid;
1408     }
1409   else
1410     return msgid;
1411 #elif defined(ENABLE_NLS)
1412   if (domain)
1413     {
1414       static int switched_codeset;
1415       char *text;
1416
1417       if (!switched_codeset)
1418         {
1419           switched_codeset = 1;
1420           bind_textdomain_codeset (PACKAGE_GT, "utf-8");
1421
1422           bindtextdomain (DIRMNGR_NAME, LOCALEDIR);
1423           bind_textdomain_codeset (DIRMNGR_NAME, "utf-8");
1424
1425         }
1426
1427       /* Note: This is a hack to actually use the gnupg2 domain as
1428          long we are in a transition phase where gnupg 1.x and 1.9 may
1429          coexist. */
1430       if (!strcmp (domain, "gnupg"))
1431         domain = PACKAGE_GT;
1432
1433       text = dgettext (domain, msgid);
1434       return text ? text : msgid;
1435     }
1436   else
1437     return msgid;
1438 #else
1439   (void)domain;
1440   return msgid;
1441 #endif
1442 }
1443
1444
1445 /* Percent-Escape special characters.  The string is valid until the
1446    next invocation of the function.  */
1447 char *
1448 gc_percent_escape (const char *src)
1449 {
1450   static char *esc_str;
1451   static int esc_str_len;
1452   int new_len = 3 * strlen (src) + 1;
1453   char *dst;
1454
1455   if (esc_str_len < new_len)
1456     {
1457       char *new_esc_str = realloc (esc_str, new_len);
1458       if (!new_esc_str)
1459         gc_error (1, errno, "can not escape string");
1460       esc_str = new_esc_str;
1461       esc_str_len = new_len;
1462     }
1463
1464   dst = esc_str;
1465   while (*src)
1466     {
1467       if (*src == '%')
1468         {
1469           *(dst++) = '%';
1470           *(dst++) = '2';
1471           *(dst++) = '5';
1472         }
1473       else if (*src == ':')
1474         {
1475           /* The colon is used as field separator.  */
1476           *(dst++) = '%';
1477           *(dst++) = '3';
1478           *(dst++) = 'a';
1479         }
1480       else if (*src == ',')
1481         {
1482           /* The comma is used as list separator.  */
1483           *(dst++) = '%';
1484           *(dst++) = '2';
1485           *(dst++) = 'c';
1486         }
1487       else
1488         *(dst++) = *(src);
1489       src++;
1490     }
1491   *dst = '\0';
1492   return esc_str;
1493 }
1494
1495
1496
1497 /* Percent-Deescape special characters.  The string is valid until the
1498    next invocation of the function.  */
1499 static char *
1500 percent_deescape (const char *src)
1501 {
1502   static char *str;
1503   static int str_len;
1504   int new_len = 3 * strlen (src) + 1;
1505   char *dst;
1506
1507   if (str_len < new_len)
1508     {
1509       char *new_str = realloc (str, new_len);
1510       if (!new_str)
1511         gc_error (1, errno, "can not deescape string");
1512       str = new_str;
1513       str_len = new_len;
1514     }
1515
1516   dst = str;
1517   while (*src)
1518     {
1519       if (*src == '%')
1520         {
1521           int val = hextobyte (src + 1);
1522
1523           if (val < 0)
1524             gc_error (1, 0, "malformed end of string %s", src);
1525
1526           *(dst++) = (char) val;
1527           src += 3;
1528         }
1529       else
1530         *(dst++) = *(src++);
1531     }
1532   *dst = '\0';
1533   return str;
1534 }
1535
1536 \f
1537 /* List all components that are available.  */
1538 void
1539 gc_component_list_components (estream_t out)
1540 {
1541   gc_component_t component;
1542   gc_option_t *option;
1543   gc_backend_t backend;
1544   int backend_seen[GC_BACKEND_NR];
1545   const char *desc;
1546   const char *pgmname;
1547
1548   for (component = 0; component < GC_COMPONENT_NR; component++)
1549     {
1550       option = gc_component[component].options;
1551       if (option)
1552         {
1553           for (backend = 0; backend < GC_BACKEND_NR; backend++)
1554             backend_seen[backend] = 0;
1555
1556           pgmname = "";
1557           for (; option && option->name; option++)
1558             {
1559               if ((option->flags & GC_OPT_FLAG_GROUP))
1560                 continue;
1561               backend = option->backend;
1562               if (backend_seen[backend])
1563                 continue;
1564               backend_seen[backend] = 1;
1565               assert (backend != GC_BACKEND_ANY);
1566               if (gc_backend[backend].program
1567                   && !gc_backend[backend].module_name)
1568                 continue;
1569               pgmname = gnupg_module_name (gc_backend[backend].module_name);
1570               break;
1571             }
1572
1573           desc = gc_component[component].desc;
1574           desc = my_dgettext (gc_component[component].desc_domain, desc);
1575           es_fprintf (out, "%s:%s:",
1576                       gc_component[component].name,  gc_percent_escape (desc));
1577           es_fprintf (out, "%s\n",  gc_percent_escape (pgmname));
1578         }
1579     }
1580 }
1581
1582
1583 \f
1584 static int
1585 all_digits_p (const char *p, size_t len)
1586 {
1587   if (!len)
1588     return 0; /* No. */
1589   for (; len; len--, p++)
1590     if (!isascii (*p) || !isdigit (*p))
1591       return 0; /* No.  */
1592   return 1; /* Yes.  */
1593 }
1594
1595
1596 /* Collect all error lines from stream FP. Only lines prefixed with
1597    TAG are considered.  Returns a list of error line items (which may
1598    be empty).  There is no error return.  */
1599 static error_line_t
1600 collect_error_output (estream_t fp, const char *tag)
1601 {
1602   char buffer[1024];
1603   char *p, *p2, *p3;
1604   int c, cont_line;
1605   unsigned int pos;
1606   error_line_t eitem, errlines, *errlines_tail;
1607   size_t taglen = strlen (tag);
1608
1609   errlines = NULL;
1610   errlines_tail = &errlines;
1611   pos = 0;
1612   cont_line = 0;
1613   while ((c=es_getc (fp)) != EOF)
1614     {
1615       buffer[pos++] = c;
1616       if (pos >= sizeof buffer - 5 || c == '\n')
1617         {
1618           buffer[pos - (c == '\n')] = 0;
1619           if (cont_line)
1620             ; /*Ignore continuations of previous line. */
1621           else if (!strncmp (buffer, tag, taglen) && buffer[taglen] == ':')
1622             {
1623               /* "gpgsm: foo:4: bla" */
1624               /* Yep, we are interested in this line.  */
1625               p = buffer + taglen + 1;
1626               while (*p == ' ' || *p == '\t')
1627                 p++;
1628               trim_trailing_spaces (p); /* Get rid of extra CRs.  */
1629               if (!*p)
1630                 ; /* Empty lines are ignored.  */
1631               else if ( (p2 = strchr (p, ':')) && (p3 = strchr (p2+1, ':'))
1632                         && all_digits_p (p2+1, p3 - (p2+1)))
1633                 {
1634                   /* Line in standard compiler format.  */
1635                   p3++;
1636                   while (*p3 == ' ' || *p3 == '\t')
1637                     p3++;
1638                   eitem = xmalloc (sizeof *eitem + strlen (p));
1639                   eitem->next = NULL;
1640                   strcpy (eitem->buffer, p);
1641                   eitem->fname = eitem->buffer;
1642                   eitem->buffer[p2-p] = 0;
1643                   eitem->errtext = eitem->buffer + (p3 - p);
1644                   /* (we already checked that there are only ascii
1645                      digits followed by a colon) */
1646                   eitem->lineno = 0;
1647                   for (p2++; isdigit (*p2); p2++)
1648                     eitem->lineno = eitem->lineno*10 + (*p2 - '0');
1649                   *errlines_tail = eitem;
1650                   errlines_tail = &eitem->next;
1651                 }
1652               else
1653                 {
1654                   /* Other error output.  */
1655                   eitem = xmalloc (sizeof *eitem + strlen (p));
1656                   eitem->next = NULL;
1657                   strcpy (eitem->buffer, p);
1658                   eitem->fname = NULL;
1659                   eitem->errtext = eitem->buffer;
1660                   eitem->lineno = 0;
1661                   *errlines_tail = eitem;
1662                   errlines_tail = &eitem->next;
1663                 }
1664             }
1665           pos = 0;
1666           /* If this was not a complete line mark that we are in a
1667              continuation.  */
1668           cont_line = (c != '\n');
1669         }
1670     }
1671
1672   /* We ignore error lines not terminated by a LF.  */
1673   return errlines;
1674 }
1675
1676
1677 /* Check the options of a single component.  Returns 0 if everything
1678    is OK.  */
1679 int
1680 gc_component_check_options (int component, estream_t out, const char *conf_file)
1681 {
1682   gpg_error_t err;
1683   unsigned int result;
1684   int backend_seen[GC_BACKEND_NR];
1685   gc_backend_t backend;
1686   gc_option_t *option;
1687   const char *pgmname;
1688   const char *argv[4];
1689   int i;
1690   pid_t pid;
1691   int exitcode;
1692   estream_t errfp;
1693   error_line_t errlines;
1694
1695   for (backend = 0; backend < GC_BACKEND_NR; backend++)
1696     backend_seen[backend] = 0;
1697
1698   option = gc_component[component].options;
1699   for (; option && option->name; option++)
1700     {
1701       if ((option->flags & GC_OPT_FLAG_GROUP))
1702         continue;
1703       backend = option->backend;
1704       if (backend_seen[backend])
1705         continue;
1706       backend_seen[backend] = 1;
1707       assert (backend != GC_BACKEND_ANY);
1708       if (!gc_backend[backend].program)
1709         continue;
1710       if (!gc_backend[backend].module_name)
1711         continue;
1712
1713       break;
1714     }
1715   if (! option || ! option->name)
1716     return 0;
1717
1718   pgmname = gnupg_module_name (gc_backend[backend].module_name);
1719   i = 0;
1720   if (conf_file)
1721     {
1722       argv[i++] = "--options";
1723       argv[i++] = conf_file;
1724     }
1725   if (component == GC_COMPONENT_PINENTRY)
1726     argv[i++] = "--version";
1727   else
1728     argv[i++] = "--gpgconf-test";
1729   argv[i++] = NULL;
1730
1731   result = 0;
1732   errlines = NULL;
1733   err = gnupg_spawn_process (pgmname, argv, NULL, NULL, 0,
1734                              NULL, NULL, &errfp, &pid);
1735   if (err)
1736     result |= 1; /* Program could not be run.  */
1737   else
1738     {
1739       errlines = collect_error_output (errfp,
1740                                        gc_component[component].name);
1741       if (gnupg_wait_process (pgmname, pid, 1, &exitcode))
1742         {
1743           if (exitcode == -1)
1744             result |= 1; /* Program could not be run or it
1745                             terminated abnormally.  */
1746           result |= 2; /* Program returned an error.  */
1747         }
1748       gnupg_release_process (pid);
1749       es_fclose (errfp);
1750     }
1751
1752   /* If the program could not be run, we can't tell whether
1753      the config file is good.  */
1754   if (result & 1)
1755     result |= 2;
1756
1757   if (out)
1758     {
1759       const char *desc;
1760       error_line_t errptr;
1761
1762       desc = gc_component[component].desc;
1763       desc = my_dgettext (gc_component[component].desc_domain, desc);
1764       es_fprintf (out, "%s:%s:",
1765                   gc_component[component].name, gc_percent_escape (desc));
1766       es_fputs (gc_percent_escape (pgmname), out);
1767       es_fprintf (out, ":%d:%d:", !(result & 1), !(result & 2));
1768       for (errptr = errlines; errptr; errptr = errptr->next)
1769         {
1770           if (errptr != errlines)
1771             es_fputs ("\n:::::", out); /* Continuation line.  */
1772           if (errptr->fname)
1773             es_fputs (gc_percent_escape (errptr->fname), out);
1774           es_putc (':', out);
1775           if (errptr->fname)
1776             es_fprintf (out, "%u", errptr->lineno);
1777           es_putc (':', out);
1778           es_fputs (gc_percent_escape (errptr->errtext), out);
1779           es_putc (':', out);
1780         }
1781       es_putc ('\n', out);
1782     }
1783
1784   while (errlines)
1785     {
1786       error_line_t tmp = errlines->next;
1787       xfree (errlines);
1788       errlines = tmp;
1789     }
1790
1791   return result;
1792 }
1793
1794
1795
1796 /* Check all components that are available.  */
1797 void
1798 gc_check_programs (estream_t out)
1799 {
1800   gc_component_t component;
1801
1802   for (component = 0; component < GC_COMPONENT_NR; component++)
1803     gc_component_check_options (component, out, NULL);
1804 }
1805
1806
1807 \f
1808 /* Find the component with the name NAME.  Returns -1 if not
1809    found.  */
1810 int
1811 gc_component_find (const char *name)
1812 {
1813   gc_component_t idx;
1814
1815   for (idx = 0; idx < GC_COMPONENT_NR; idx++)
1816     {
1817       if (gc_component[idx].options
1818           && !strcmp (name, gc_component[idx].name))
1819         return idx;
1820     }
1821   return -1;
1822 }
1823
1824 \f
1825 /* List the option OPTION.  */
1826 static void
1827 list_one_option (const gc_option_t *option, estream_t out)
1828 {
1829   const char *desc = NULL;
1830   char *arg_name = NULL;
1831
1832   if (option->desc)
1833     {
1834       desc = my_dgettext (option->desc_domain, option->desc);
1835
1836       if (*desc == '|')
1837         {
1838           const char *arg_tail = strchr (&desc[1], '|');
1839
1840           if (arg_tail)
1841             {
1842               int arg_len = arg_tail - &desc[1];
1843               arg_name = xmalloc (arg_len + 1);
1844               memcpy (arg_name, &desc[1], arg_len);
1845               arg_name[arg_len] = '\0';
1846               desc = arg_tail + 1;
1847             }
1848         }
1849     }
1850
1851
1852   /* YOU MUST NOT REORDER THE FIELDS IN THIS OUTPUT, AS THEIR ORDER IS
1853      PART OF THE EXTERNAL INTERFACE.  YOU MUST NOT REMOVE ANY
1854      FIELDS.  */
1855
1856   /* The name field.  */
1857   es_fprintf (out, "%s", option->name);
1858
1859   /* The flags field.  */
1860   es_fprintf (out, ":%lu", option->flags);
1861   if (opt.verbose)
1862     {
1863       es_putc (' ', out);
1864
1865       if (!option->flags)
1866         es_fprintf (out, "none");
1867       else
1868         {
1869           unsigned long flags = option->flags;
1870           unsigned long flag = 0;
1871           unsigned long first = 1;
1872
1873           while (flags)
1874             {
1875               if (flags & 1)
1876                 {
1877                   if (first)
1878                     first = 0;
1879                   else
1880                     es_putc (',', out);
1881                   es_fprintf (out, "%s", gc_flag[flag].name);
1882                 }
1883               flags >>= 1;
1884               flag++;
1885             }
1886         }
1887     }
1888
1889   /* The level field.  */
1890   es_fprintf (out, ":%u", option->level);
1891   if (opt.verbose)
1892     es_fprintf (out, " %s", gc_level[option->level].name);
1893
1894   /* The description field.  */
1895   es_fprintf (out, ":%s", desc ? gc_percent_escape (desc) : "");
1896
1897   /* The type field.  */
1898   es_fprintf (out, ":%u", option->arg_type);
1899   if (opt.verbose)
1900     es_fprintf (out, " %s", gc_arg_type[option->arg_type].name);
1901
1902   /* The alternate type field.  */
1903   es_fprintf (out, ":%u", gc_arg_type[option->arg_type].fallback);
1904   if (opt.verbose)
1905     es_fprintf (out, " %s",
1906                 gc_arg_type[gc_arg_type[option->arg_type].fallback].name);
1907
1908   /* The argument name field.  */
1909   es_fprintf (out, ":%s", arg_name ? gc_percent_escape (arg_name) : "");
1910   xfree (arg_name);
1911
1912   /* The default value field.  */
1913   es_fprintf (out, ":%s", option->default_value ? option->default_value : "");
1914
1915   /* The default argument field.  */
1916   es_fprintf (out, ":%s", option->default_arg ? option->default_arg : "");
1917
1918   /* The value field.  */
1919   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
1920       && (option->flags & GC_OPT_FLAG_LIST)
1921       && option->value)
1922     /* The special format "1,1,1,1,...,1" is converted to a number
1923        here.  */
1924     es_fprintf (out, ":%u", (unsigned int)((strlen (option->value) + 1) / 2));
1925   else
1926     es_fprintf (out, ":%s", option->value ? option->value : "");
1927
1928   /* ADD NEW FIELDS HERE.  */
1929
1930   es_putc ('\n', out);
1931 }
1932
1933
1934 /* List all options of the component COMPONENT.  */
1935 void
1936 gc_component_list_options (int component, estream_t out)
1937 {
1938   const gc_option_t *option = gc_component[component].options;
1939
1940   while (option && option->name)
1941     {
1942       /* Do not output unknown or internal options.  */
1943       if (!(option->flags & GC_OPT_FLAG_GROUP)
1944           && (!option->active || option->level == GC_LEVEL_INTERNAL))
1945         {
1946           option++;
1947           continue;
1948         }
1949
1950       if (option->flags & GC_OPT_FLAG_GROUP)
1951         {
1952           const gc_option_t *group_option = option + 1;
1953           gc_expert_level_t level = GC_LEVEL_NR;
1954
1955           /* The manual states that the group level is always the
1956              minimum of the levels of all contained options.  Due to
1957              different active options, and because it is hard to
1958              maintain manually, we calculate it here.  The value in
1959              the global static table is ignored.  */
1960
1961           while (group_option->name)
1962             {
1963               if (group_option->flags & GC_OPT_FLAG_GROUP)
1964                 break;
1965               if (group_option->level < level)
1966                 level = group_option->level;
1967               group_option++;
1968             }
1969
1970           /* Check if group is empty.  */
1971           if (level != GC_LEVEL_NR)
1972             {
1973               gc_option_t opt_copy;
1974
1975               /* Fix up the group level.  */
1976               memcpy (&opt_copy, option, sizeof (opt_copy));
1977               opt_copy.level = level;
1978               list_one_option (&opt_copy, out);
1979             }
1980         }
1981       else
1982         list_one_option (option, out);
1983
1984       option++;
1985     }
1986 }
1987
1988
1989 /* Find the option NAME in component COMPONENT, for the backend
1990    BACKEND.  If BACKEND is GC_BACKEND_ANY, any backend will match.  */
1991 static gc_option_t *
1992 find_option (gc_component_t component, const char *name,
1993              gc_backend_t backend)
1994 {
1995   gc_option_t *option = gc_component[component].options;
1996   while (option->name)
1997     {
1998       if (!(option->flags & GC_OPT_FLAG_GROUP)
1999           && !strcmp (option->name, name)
2000           && (backend == GC_BACKEND_ANY || option->backend == backend))
2001         break;
2002       option++;
2003     }
2004   return option->name ? option : NULL;
2005 }
2006
2007 \f
2008 /* Determine the configuration filename for the component COMPONENT
2009    and backend BACKEND.  */
2010 static char *
2011 get_config_filename (gc_component_t component, gc_backend_t backend)
2012 {
2013   char *filename = NULL;
2014   gc_option_t *option = find_option
2015     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
2016   assert (option);
2017   assert (option->arg_type == GC_ARG_TYPE_FILENAME);
2018   assert (!(option->flags & GC_OPT_FLAG_LIST));
2019
2020   if (!option->active || !option->default_value)
2021     gc_error (1, 0, "Option %s, needed by backend %s, was not initialized",
2022               gc_backend[backend].option_config_filename,
2023               gc_backend[backend].name);
2024
2025   if (option->value && *option->value)
2026     filename = percent_deescape (&option->value[1]);
2027   else if (option->default_value && *option->default_value)
2028     filename = percent_deescape (&option->default_value[1]);
2029   else
2030     filename = "";
2031
2032 #if HAVE_W32CE_SYSTEM
2033   if (!(filename[0] == '/' || filename[0] == '\\'))
2034 #elif defined(HAVE_DOSISH_SYSTEM)
2035   if (!(filename[0]
2036         && filename[1] == ':'
2037         && (filename[2] == '/' || filename[2] == '\\')))
2038 #else
2039   if (filename[0] != '/')
2040 #endif
2041     gc_error (1, 0, "Option %s, needed by backend %s, is not absolute",
2042               gc_backend[backend].option_config_filename,
2043               gc_backend[backend].name);
2044
2045   return filename;
2046 }
2047
2048 \f
2049 /* Retrieve the options for the component COMPONENT from backend
2050    BACKEND, which we already know is a program-type backend.  */
2051 static void
2052 retrieve_options_from_program (gc_component_t component, gc_backend_t backend)
2053 {
2054   gpg_error_t err;
2055   const char *pgmname;
2056   const char *argv[2];
2057   estream_t outfp;
2058   int exitcode;
2059   pid_t pid;
2060   char *line = NULL;
2061   size_t line_len = 0;
2062   ssize_t length;
2063   estream_t config;
2064   char *config_filename;
2065
2066   pgmname = (gc_backend[backend].module_name
2067              ? gnupg_module_name (gc_backend[backend].module_name)
2068              : gc_backend[backend].program );
2069   argv[0] = "--gpgconf-list";
2070   argv[1] = NULL;
2071
2072   err = gnupg_spawn_process (pgmname, argv, NULL, NULL, 0,
2073                              NULL, &outfp, NULL, &pid);
2074   if (err)
2075     {
2076       gc_error (1, 0, "could not gather active options from '%s': %s",
2077                 pgmname, gpg_strerror (err));
2078     }
2079
2080   while ((length = es_read_line (outfp, &line, &line_len, NULL)) > 0)
2081     {
2082       gc_option_t *option;
2083       char *linep;
2084       unsigned long flags = 0;
2085       char *default_value = NULL;
2086
2087       /* Strip newline and carriage return, if present.  */
2088       while (length > 0
2089              && (line[length - 1] == '\n' || line[length - 1] == '\r'))
2090         line[--length] = '\0';
2091
2092       linep = strchr (line, ':');
2093       if (linep)
2094         *(linep++) = '\0';
2095
2096       /* Extract additional flags.  Default to none.  */
2097       if (linep)
2098         {
2099           char *end;
2100           char *tail;
2101
2102           end = strchr (linep, ':');
2103           if (end)
2104             *(end++) = '\0';
2105
2106           gpg_err_set_errno (0);
2107           flags = strtoul (linep, &tail, 0);
2108           if (errno)
2109             gc_error (1, errno, "malformed flags in option %s from %s",
2110                       line, pgmname);
2111           if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
2112             gc_error (1, 0, "garbage after flags in option %s from %s",
2113                       line, pgmname);
2114
2115           linep = end;
2116         }
2117
2118       /* Extract default value, if present.  Default to empty if
2119          not.  */
2120       if (linep)
2121         {
2122           char *end;
2123
2124           end = strchr (linep, ':');
2125           if (end)
2126             *(end++) = '\0';
2127
2128           if (flags & GC_OPT_FLAG_DEFAULT)
2129             default_value = linep;
2130
2131           linep = end;
2132         }
2133
2134       /* Look up the option in the component and install the
2135          configuration data.  */
2136       option = find_option (component, line, backend);
2137       if (option)
2138         {
2139           if (option->active)
2140             gc_error (1, errno, "option %s returned twice from %s",
2141                       line, pgmname);
2142           option->active = 1;
2143
2144           option->flags |= flags;
2145           if (default_value && *default_value)
2146             option->default_value = xstrdup (default_value);
2147         }
2148     }
2149   if (length < 0 || es_ferror (outfp))
2150     gc_error (1, errno, "error reading from %s", pgmname);
2151   if (es_fclose (outfp))
2152     gc_error (1, errno, "error closing %s", pgmname);
2153
2154   err = gnupg_wait_process (pgmname, pid, 1, &exitcode);
2155   if (err)
2156     gc_error (1, 0, "running %s failed (exitcode=%d): %s",
2157               pgmname, exitcode, gpg_strerror (err));
2158   gnupg_release_process (pid);
2159
2160
2161   /* At this point, we can parse the configuration file.  */
2162   config_filename = get_config_filename (component, backend);
2163
2164   config = es_fopen (config_filename, "r");
2165   if (!config)
2166     gc_error (0, errno, "warning: can not open config file %s",
2167               config_filename);
2168   else
2169     {
2170       while ((length = es_read_line (config, &line, &line_len, NULL)) > 0)
2171         {
2172           char *name;
2173           char *value;
2174           gc_option_t *option;
2175
2176           name = line;
2177           while (*name == ' ' || *name == '\t')
2178             name++;
2179           if (!*name || *name == '#' || *name == '\r' || *name == '\n')
2180             continue;
2181
2182           value = name;
2183           while (*value && *value != ' ' && *value != '\t'
2184                  && *value != '#' && *value != '\r' && *value != '\n')
2185             value++;
2186           if (*value == ' ' || *value == '\t')
2187             {
2188               char *end;
2189
2190               *(value++) = '\0';
2191               while (*value == ' ' || *value == '\t')
2192                 value++;
2193
2194               end = value;
2195               while (*end && *end != '#' && *end != '\r' && *end != '\n')
2196                 end++;
2197               while (end > value && (end[-1] == ' ' || end[-1] == '\t'))
2198                 end--;
2199               *end = '\0';
2200             }
2201           else
2202             *value = '\0';
2203
2204           /* Look up the option in the component and install the
2205              configuration data.  */
2206           option = find_option (component, line, backend);
2207           if (option)
2208             {
2209               char *opt_value;
2210
2211               if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
2212                 {
2213                   if (*value)
2214                     gc_error (0, 0,
2215                               "warning: ignoring argument %s for option %s",
2216                               value, name);
2217                   opt_value = xstrdup ("1");
2218                 }
2219               else if (gc_arg_type[option->arg_type].fallback
2220                        == GC_ARG_TYPE_STRING)
2221                 opt_value = xasprintf ("\"%s", gc_percent_escape (value));
2222               else
2223                 {
2224                   /* FIXME: Verify that the number is sane.  */
2225                   opt_value = xstrdup (value);
2226                 }
2227
2228               /* Now enter the option into the table.  */
2229               if (!(option->flags & GC_OPT_FLAG_LIST))
2230                 {
2231                   if (option->value)
2232                     xfree (option->value);
2233                   option->value = opt_value;
2234                 }
2235               else
2236                 {
2237                   if (!option->value)
2238                     option->value = opt_value;
2239                   else
2240                     {
2241                       char *old = option->value;
2242                       option->value = xasprintf ("%s,%s", old, opt_value);
2243                       xfree (old);
2244                       xfree (opt_value);
2245                     }
2246                 }
2247             }
2248         }
2249
2250       if (length < 0 || es_ferror (config))
2251         gc_error (1, errno, "error reading from %s", config_filename);
2252       if (es_fclose (config))
2253         gc_error (1, errno, "error closing %s", config_filename);
2254     }
2255
2256   xfree (line);
2257 }
2258
2259
2260 /* Retrieve the options for the component COMPONENT from backend
2261    BACKEND, which we already know is of type file list.  */
2262 static void
2263 retrieve_options_from_file (gc_component_t component, gc_backend_t backend)
2264 {
2265   gc_option_t *list_option;
2266   gc_option_t *config_option;
2267   char *list_filename;
2268   FILE *list_file;
2269   char *line = NULL;
2270   size_t line_len = 0;
2271   ssize_t length;
2272   char *list = NULL;
2273
2274   list_option = find_option (component,
2275                              gc_backend[backend].option_name, GC_BACKEND_ANY);
2276   assert (list_option);
2277   assert (!list_option->active);
2278
2279   list_filename = get_config_filename (component, backend);
2280   list_file = fopen (list_filename, "r");
2281   if (!list_file)
2282     gc_error (0, errno, "warning: can not open list file %s", list_filename);
2283   else
2284     {
2285
2286       while ((length = read_line (list_file, &line, &line_len, NULL)) > 0)
2287         {
2288           char *start;
2289           char *end;
2290           char *new_list;
2291
2292           start = line;
2293           while (*start == ' ' || *start == '\t')
2294             start++;
2295           if (!*start || *start == '#' || *start == '\r' || *start == '\n')
2296             continue;
2297
2298           end = start;
2299           while (*end && *end != '#' && *end != '\r' && *end != '\n')
2300             end++;
2301           /* Walk back to skip trailing white spaces.  Looks evil, but
2302              works because of the conditions on START and END imposed
2303              at this point (END is at least START + 1, and START is
2304              not a whitespace character).  */
2305           while (*(end - 1) == ' ' || *(end - 1) == '\t')
2306             end--;
2307           *end = '\0';
2308           /* FIXME: Oh, no!  This is so lame!  Should use realloc and
2309              really append.  */
2310           if (list)
2311             {
2312               new_list = xasprintf ("%s,\"%s", list, gc_percent_escape (start));
2313               xfree (list);
2314               list = new_list;
2315             }
2316           else
2317             list = xasprintf ("\"%s", gc_percent_escape (start));
2318         }
2319       if (length < 0 || ferror (list_file))
2320         gc_error (1, errno, "can not read list file %s", list_filename);
2321     }
2322
2323   list_option->active = 1;
2324   list_option->value = list;
2325
2326   /* Fix up the read-only flag.  */
2327   config_option = find_option
2328     (component, gc_backend[backend].option_config_filename, GC_BACKEND_ANY);
2329   if (config_option->flags & GC_OPT_FLAG_NO_CHANGE)
2330     list_option->flags |= GC_OPT_FLAG_NO_CHANGE;
2331
2332   if (list_file && fclose (list_file))
2333     gc_error (1, errno, "error closing %s", list_filename);
2334   xfree (line);
2335 }
2336
2337
2338 /* Retrieve the currently active options and their defaults from all
2339    involved backends for this component.  Using -1 for component will
2340    retrieve all options from all components. */
2341 void
2342 gc_component_retrieve_options (int component)
2343 {
2344   int process_all = 0;
2345   int backend_seen[GC_BACKEND_NR];
2346   gc_backend_t backend;
2347   gc_option_t *option;
2348
2349   for (backend = 0; backend < GC_BACKEND_NR; backend++)
2350     backend_seen[backend] = 0;
2351
2352   if (component == -1)
2353     {
2354       process_all = 1;
2355       component = 0;
2356       assert (component < GC_COMPONENT_NR);
2357     }
2358
2359   do
2360     {
2361       if (component == GC_COMPONENT_PINENTRY)
2362         continue; /* Skip this dummy component.  */
2363
2364       option = gc_component[component].options;
2365
2366       while (option && option->name)
2367         {
2368           if (!(option->flags & GC_OPT_FLAG_GROUP))
2369             {
2370               backend = option->backend;
2371
2372               if (backend_seen[backend])
2373                 {
2374                   option++;
2375                   continue;
2376                 }
2377               backend_seen[backend] = 1;
2378
2379               assert (backend != GC_BACKEND_ANY);
2380
2381               if (gc_backend[backend].program)
2382                 retrieve_options_from_program (component, backend);
2383               else
2384                 retrieve_options_from_file (component, backend);
2385             }
2386           option++;
2387         }
2388     }
2389   while (process_all && ++component < GC_COMPONENT_NR);
2390
2391 }
2392
2393
2394 \f
2395 /* Perform a simple validity check based on the type.  Return in
2396  * NEW_VALUE_NR the value of the number in NEW_VALUE if OPTION is of
2397  * type GC_ARG_TYPE_NONE.  If VERBATIM is set the profile parsing mode
2398  * is used. */
2399 static void
2400 option_check_validity (gc_option_t *option, unsigned long flags,
2401                        char *new_value, unsigned long *new_value_nr,
2402                        int verbatim)
2403 {
2404   char *arg;
2405
2406   if (!option->active)
2407     gc_error (1, 0, "option %s not supported by backend %s",
2408               option->name, gc_backend[option->backend].name);
2409
2410   if (option->new_flags || option->new_value)
2411     gc_error (1, 0, "option %s already changed", option->name);
2412
2413   if (flags & GC_OPT_FLAG_DEFAULT)
2414     {
2415       if (*new_value)
2416         gc_error (1, 0, "argument %s provided for deleted option %s",
2417                   new_value, option->name);
2418
2419       return;
2420     }
2421
2422   /* GC_ARG_TYPE_NONE options have special list treatment.  */
2423   if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
2424     {
2425       char *tail;
2426
2427       gpg_err_set_errno (0);
2428       *new_value_nr = strtoul (new_value, &tail, 0);
2429
2430       if (errno)
2431         gc_error (1, errno, "invalid argument for option %s",
2432                   option->name);
2433       if (*tail)
2434         gc_error (1, 0, "garbage after argument for option %s",
2435                       option->name);
2436
2437       if (!(option->flags & GC_OPT_FLAG_LIST))
2438         {
2439           if (*new_value_nr != 1)
2440             gc_error (1, 0, "argument for non-list option %s of type 0 "
2441                       "(none) must be 1", option->name);
2442         }
2443       else
2444         {
2445           if (*new_value_nr == 0)
2446             gc_error (1, 0, "argument for option %s of type 0 (none) "
2447                       "must be positive", option->name);
2448         }
2449
2450       return;
2451     }
2452
2453   arg = new_value;
2454   do
2455     {
2456       if (*arg == '\0' || (*arg == ',' && !verbatim))
2457         {
2458           if (!(option->flags & GC_OPT_FLAG_ARG_OPT))
2459             gc_error (1, 0, "argument required for option %s", option->name);
2460
2461           if (*arg == ',' && !verbatim && !(option->flags & GC_OPT_FLAG_LIST))
2462             gc_error (1, 0, "list found for non-list option %s", option->name);
2463         }
2464       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_STRING)
2465         {
2466           if (*arg != '"' && !verbatim)
2467             gc_error (1, 0, "string argument for option %s must begin "
2468                       "with a quote (\") character", option->name);
2469
2470           /* FIXME: We do not allow empty string arguments for now, as
2471              we do not quote arguments in configuration files, and
2472              thus no argument is indistinguishable from the empty
2473              string.  */
2474           if (arg[1] == '\0' || (arg[1] == ',' && !verbatim))
2475             gc_error (1, 0, "empty string argument for option %s is "
2476                       "currently not allowed.  Please report this!",
2477                       option->name);
2478         }
2479       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
2480         {
2481           long res;
2482
2483           gpg_err_set_errno (0);
2484           res = strtol (arg, &arg, 0);
2485           (void) res;
2486
2487           if (errno)
2488             gc_error (1, errno, "invalid argument for option %s",
2489                       option->name);
2490
2491           if (*arg != '\0' && (*arg != ',' || verbatim))
2492             gc_error (1, 0, "garbage after argument for option %s",
2493                       option->name);
2494         }
2495       else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_UINT32)
2496         {
2497           unsigned long res;
2498
2499           gpg_err_set_errno (0);
2500           res = strtoul (arg, &arg, 0);
2501           (void) res;
2502
2503           if (errno)
2504             gc_error (1, errno, "invalid argument for option %s",
2505                       option->name);
2506
2507           if (*arg != '\0' && (*arg != ',' || verbatim))
2508             gc_error (1, 0, "garbage after argument for option %s",
2509                       option->name);
2510         }
2511       arg = verbatim? strchr (arg, ',') : NULL;
2512       if (arg)
2513         arg++;
2514     }
2515   while (arg && *arg);
2516 }
2517
2518
2519 #ifdef HAVE_W32_SYSTEM
2520 int
2521 copy_file (const char *src_name, const char *dst_name)
2522 {
2523 #define BUF_LEN 4096
2524   char buffer[BUF_LEN];
2525   int len;
2526   FILE *src;
2527   FILE *dst;
2528
2529   src = fopen (src_name, "r");
2530   if (src == NULL)
2531     return -1;
2532
2533   dst = fopen (dst_name, "w");
2534   if (dst == NULL)
2535     {
2536       int saved_err = errno;
2537       fclose (src);
2538       gpg_err_set_errno (saved_err);
2539       return -1;
2540     }
2541
2542   do
2543     {
2544       int written;
2545
2546       len = fread (buffer, 1, BUF_LEN, src);
2547       if (len == 0)
2548         break;
2549       written = fwrite (buffer, 1, len, dst);
2550       if (written != len)
2551         break;
2552     }
2553   while (!feof (src) && !ferror (src) && !ferror (dst));
2554
2555   if (ferror (src) || ferror (dst) || !feof (src))
2556     {
2557       int saved_errno = errno;
2558       fclose (src);
2559       fclose (dst);
2560       unlink (dst_name);
2561       gpg_err_set_errno (saved_errno);
2562       return -1;
2563     }
2564
2565   if (fclose (dst))
2566     gc_error (1, errno, "error closing %s", dst_name);
2567   if (fclose (src))
2568     gc_error (1, errno, "error closing %s", src_name);
2569
2570   return 0;
2571 }
2572 #endif /* HAVE_W32_SYSTEM */
2573
2574
2575 /* Create and verify the new configuration file for the specified
2576    backend and component.  Returns 0 on success and -1 on error.  */
2577 static int
2578 change_options_file (gc_component_t component, gc_backend_t backend,
2579                      char **src_filenamep, char **dest_filenamep,
2580                      char **orig_filenamep)
2581 {
2582   static const char marker[] = "###+++--- " GPGCONF_DISP_NAME " ---+++###";
2583   /* True if we are within the marker in the config file.  */
2584   int in_marker = 0;
2585   gc_option_t *option;
2586   char *line = NULL;
2587   size_t line_len;
2588   ssize_t length;
2589   int res;
2590   int fd;
2591   FILE *src_file = NULL;
2592   FILE *dest_file = NULL;
2593   char *src_filename;
2594   char *dest_filename;
2595   char *orig_filename;
2596   char *arg;
2597   char *cur_arg = NULL;
2598
2599   option = find_option (component,
2600                         gc_backend[backend].option_name, GC_BACKEND_ANY);
2601   assert (option);
2602   assert (option->active);
2603   assert (gc_arg_type[option->arg_type].fallback != GC_ARG_TYPE_NONE);
2604
2605   /* FIXME.  Throughout the function, do better error reporting.  */
2606   /* Note that get_config_filename() calls percent_deescape(), so we
2607      call this before processing the arguments.  */
2608   dest_filename = xstrdup (get_config_filename (component, backend));
2609   src_filename = xasprintf ("%s.%s.%i.new",
2610                             dest_filename, GPGCONF_NAME, (int)getpid ());
2611   orig_filename = xasprintf ("%s.%s.%i.bak",
2612                              dest_filename, GPGCONF_NAME, (int)getpid ());
2613
2614   arg = option->new_value;
2615   if (arg && arg[0] == '\0')
2616     arg = NULL;
2617   else if (arg)
2618     {
2619       char *end;
2620
2621       arg++;
2622       end = strchr (arg, ',');
2623       if (end)
2624         *end = '\0';
2625
2626       cur_arg = percent_deescape (arg);
2627       if (end)
2628         {
2629           *end = ',';
2630           arg = end + 1;
2631         }
2632       else
2633         arg = NULL;
2634     }
2635
2636 #ifdef HAVE_W32_SYSTEM
2637   res = copy_file (dest_filename, orig_filename);
2638 #else
2639   res = link (dest_filename, orig_filename);
2640 #endif
2641   if (res < 0 && errno != ENOENT)
2642     {
2643       xfree (dest_filename);
2644       xfree (src_filename);
2645       xfree (orig_filename);
2646       return -1;
2647     }
2648   if (res < 0)
2649     {
2650       xfree (orig_filename);
2651       orig_filename = NULL;
2652     }
2653
2654   /* We now initialize the return strings, so the caller can do the
2655      cleanup for us.  */
2656   *src_filenamep = src_filename;
2657   *dest_filenamep = dest_filename;
2658   *orig_filenamep = orig_filename;
2659
2660   /* Use open() so that we can use O_EXCL.  */
2661   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2662   if (fd < 0)
2663     return -1;
2664   src_file = fdopen (fd, "w");
2665   res = errno;
2666   if (!src_file)
2667     {
2668       gpg_err_set_errno (res);
2669       return -1;
2670     }
2671
2672   /* Only if ORIG_FILENAME is not NULL did the configuration file
2673      exist already.  In this case, we will copy its content into the
2674      new configuration file, changing it to our liking in the
2675      process.  */
2676   if (orig_filename)
2677     {
2678       dest_file = fopen (dest_filename, "r");
2679       if (!dest_file)
2680         goto change_file_one_err;
2681
2682       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2683         {
2684           int disable = 0;
2685           char *start;
2686
2687           if (!strncmp (marker, line, sizeof (marker) - 1))
2688             {
2689               if (!in_marker)
2690                 in_marker = 1;
2691               else
2692                 break;
2693             }
2694
2695           start = line;
2696           while (*start == ' ' || *start == '\t')
2697             start++;
2698           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2699             {
2700               char *end;
2701               char *endp;
2702               char saved_end;
2703
2704               endp = start;
2705               end = endp;
2706
2707               /* Search for the end of the line.  */
2708               while (*endp && *endp != '#' && *endp != '\r' && *endp != '\n')
2709                 {
2710                   endp++;
2711                   if (*endp && *endp != ' ' && *endp != '\t'
2712                       && *endp != '\r' && *endp != '\n' && *endp != '#')
2713                     end = endp + 1;
2714                 }
2715               saved_end = *end;
2716               *end = '\0';
2717
2718               if ((option->new_flags & GC_OPT_FLAG_DEFAULT)
2719                   || !cur_arg || strcmp (start, cur_arg))
2720                 disable = 1;
2721               else
2722                 {
2723                   /* Find next argument.  */
2724                   if (arg)
2725                     {
2726                       char *arg_end;
2727
2728                       arg++;
2729                       arg_end = strchr (arg, ',');
2730                       if (arg_end)
2731                         *arg_end = '\0';
2732
2733                       cur_arg = percent_deescape (arg);
2734                       if (arg_end)
2735                         {
2736                           *arg_end = ',';
2737                           arg = arg_end + 1;
2738                         }
2739                       else
2740                         arg = NULL;
2741                     }
2742                   else
2743                     cur_arg = NULL;
2744                 }
2745
2746               *end = saved_end;
2747             }
2748
2749           if (disable)
2750             {
2751               if (!in_marker)
2752                 {
2753                   fprintf (src_file,
2754                            "# %s disabled this option here at %s\n",
2755                            GPGCONF_DISP_NAME, asctimestamp (gnupg_get_time ()));
2756                   if (ferror (src_file))
2757                     goto change_file_one_err;
2758                   fprintf (src_file, "# %s", line);
2759                   if (ferror (src_file))
2760                     goto change_file_one_err;
2761                 }
2762             }
2763           else
2764             {
2765               fprintf (src_file, "%s", line);
2766               if (ferror (src_file))
2767                 goto change_file_one_err;
2768             }
2769         }
2770       if (length < 0 || ferror (dest_file))
2771         goto change_file_one_err;
2772     }
2773
2774   if (!in_marker)
2775     {
2776       /* There was no marker.  This is the first time we edit the
2777          file.  We add our own marker at the end of the file and
2778          proceed.  Note that we first write a newline, this guards us
2779          against files which lack the newline at the end of the last
2780          line, while it doesn't hurt us in all other cases.  */
2781       fprintf (src_file, "\n%s\n", marker);
2782       if (ferror (src_file))
2783         goto change_file_one_err;
2784     }
2785
2786   /* At this point, we have copied everything up to the end marker
2787      into the new file, except for the arguments we are going to add.
2788      Now, dump the new arguments and write the end marker, possibly
2789      followed by the rest of the original file.  */
2790   while (cur_arg)
2791     {
2792       fprintf (src_file, "%s\n", cur_arg);
2793
2794       /* Find next argument.  */
2795       if (arg)
2796         {
2797           char *end;
2798
2799           arg++;
2800           end = strchr (arg, ',');
2801           if (end)
2802             *end = '\0';
2803
2804           cur_arg = percent_deescape (arg);
2805           if (end)
2806             {
2807               *end = ',';
2808               arg = end + 1;
2809             }
2810           else
2811             arg = NULL;
2812         }
2813       else
2814         cur_arg = NULL;
2815     }
2816
2817   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
2818   if (ferror (src_file))
2819     goto change_file_one_err;
2820
2821   if (!in_marker)
2822     {
2823       fprintf (src_file, "# %s edited this configuration file.\n",
2824                GPGCONF_DISP_NAME);
2825       if (ferror (src_file))
2826         goto change_file_one_err;
2827       fprintf (src_file, "# It will disable options before this marked "
2828                "block, but it will\n");
2829       if (ferror (src_file))
2830         goto change_file_one_err;
2831       fprintf (src_file, "# never change anything below these lines.\n");
2832       if (ferror (src_file))
2833         goto change_file_one_err;
2834     }
2835   if (dest_file)
2836     {
2837       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2838         {
2839           fprintf (src_file, "%s", line);
2840           if (ferror (src_file))
2841             goto change_file_one_err;
2842         }
2843       if (length < 0 || ferror (dest_file))
2844         goto change_file_one_err;
2845     }
2846   xfree (line);
2847   line = NULL;
2848
2849   res = fclose (src_file);
2850   if (res)
2851     {
2852       res = errno;
2853       close (fd);
2854       if (dest_file)
2855         fclose (dest_file);
2856       gpg_err_set_errno (res);
2857       return -1;
2858     }
2859   close (fd);
2860   if (dest_file)
2861     {
2862       res = fclose (dest_file);
2863       if (res)
2864         return -1;
2865     }
2866   return 0;
2867
2868  change_file_one_err:
2869   xfree (line);
2870   res = errno;
2871   if (src_file)
2872     {
2873       fclose (src_file);
2874       close (fd);
2875     }
2876   if (dest_file)
2877     fclose (dest_file);
2878   gpg_err_set_errno (res);
2879   return -1;
2880 }
2881
2882
2883 /* Create and verify the new configuration file for the specified
2884  * backend and component.  Returns 0 on success and -1 on error.  If
2885  * VERBATIM is set the profile mode is used. */
2886 static int
2887 change_options_program (gc_component_t component, gc_backend_t backend,
2888                         char **src_filenamep, char **dest_filenamep,
2889                         char **orig_filenamep,
2890                         int verbatim)
2891 {
2892   static const char marker[] = "###+++--- " GPGCONF_DISP_NAME " ---+++###";
2893   /* True if we are within the marker in the config file.  */
2894   int in_marker = 0;
2895   gc_option_t *option;
2896   char *line = NULL;
2897   size_t line_len;
2898   ssize_t length;
2899   int res;
2900   int fd;
2901   FILE *src_file = NULL;
2902   FILE *dest_file = NULL;
2903   char *src_filename;
2904   char *dest_filename;
2905   char *orig_filename;
2906   /* Special hack for gpg, see below.  */
2907   int utf8strings_seen = 0;
2908
2909   /* FIXME.  Throughout the function, do better error reporting.  */
2910   dest_filename = xstrdup (get_config_filename (component, backend));
2911   src_filename = xasprintf ("%s.%s.%i.new",
2912                             dest_filename, GPGCONF_NAME, (int)getpid ());
2913   orig_filename = xasprintf ("%s.%s.%i.bak",
2914                              dest_filename, GPGCONF_NAME, (int)getpid ());
2915
2916 #ifdef HAVE_W32_SYSTEM
2917   res = copy_file (dest_filename, orig_filename);
2918 #else
2919   res = link (dest_filename, orig_filename);
2920 #endif
2921   if (res < 0 && errno != ENOENT)
2922     {
2923       xfree (dest_filename);
2924       xfree (src_filename);
2925       xfree (orig_filename);
2926       return -1;
2927     }
2928   if (res < 0)
2929     {
2930       xfree (orig_filename);
2931       orig_filename = NULL;
2932     }
2933
2934   /* We now initialize the return strings, so the caller can do the
2935      cleanup for us.  */
2936   *src_filenamep = src_filename;
2937   *dest_filenamep = dest_filename;
2938   *orig_filenamep = orig_filename;
2939
2940   /* Use open() so that we can use O_EXCL.  */
2941   fd = open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
2942   if (fd < 0)
2943     return -1;
2944   src_file = fdopen (fd, "w");
2945   res = errno;
2946   if (!src_file)
2947     {
2948       gpg_err_set_errno (res);
2949       return -1;
2950     }
2951
2952   /* Only if ORIG_FILENAME is not NULL did the configuration file
2953      exist already.  In this case, we will copy its content into the
2954      new configuration file, changing it to our liking in the
2955      process.  */
2956   if (orig_filename)
2957     {
2958       dest_file = fopen (dest_filename, "r");
2959       if (!dest_file)
2960         goto change_one_err;
2961
2962       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
2963         {
2964           int disable = 0;
2965           char *start;
2966
2967           if (!strncmp (marker, line, sizeof (marker) - 1))
2968             {
2969               if (!in_marker)
2970                 in_marker = 1;
2971               else
2972                 break;
2973             }
2974           else if (backend == GC_BACKEND_GPG && in_marker
2975                    && ! strcmp ("utf8-strings\n", line))
2976             {
2977               /* Strip duplicated entries.  */
2978               if (utf8strings_seen)
2979                 disable = 1;
2980               else
2981                 utf8strings_seen = 1;
2982             }
2983
2984           start = line;
2985           while (*start == ' ' || *start == '\t')
2986             start++;
2987           if (*start && *start != '\r' && *start != '\n' && *start != '#')
2988             {
2989               char *end;
2990               char saved_end;
2991
2992               end = start;
2993               while (*end && *end != ' ' && *end != '\t'
2994                      && *end != '\r' && *end != '\n' && *end != '#')
2995                 end++;
2996               saved_end = *end;
2997               *end = '\0';
2998
2999               option = find_option (component, start, backend);
3000               *end = saved_end;
3001               if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
3002                              || option->new_value))
3003                 disable = 1;
3004             }
3005           if (disable)
3006             {
3007               if (!in_marker)
3008                 {
3009                   fprintf (src_file,
3010                            "# %s disabled this option here at %s\n",
3011                            GPGCONF_DISP_NAME, asctimestamp (gnupg_get_time ()));
3012                   if (ferror (src_file))
3013                     goto change_one_err;
3014                   fprintf (src_file, "# %s", line);
3015                   if (ferror (src_file))
3016                     goto change_one_err;
3017                 }
3018             }
3019           else
3020             {
3021               fprintf (src_file, "%s", line);
3022               if (ferror (src_file))
3023                 goto change_one_err;
3024             }
3025         }
3026       if (length < 0 || ferror (dest_file))
3027         goto change_one_err;
3028     }
3029
3030   if (!in_marker)
3031     {
3032       /* There was no marker.  This is the first time we edit the
3033          file.  We add our own marker at the end of the file and
3034          proceed.  Note that we first write a newline, this guards us
3035          against files which lack the newline at the end of the last
3036          line, while it doesn't hurt us in all other cases.  */
3037       fprintf (src_file, "\n%s\n", marker);
3038       if (ferror (src_file))
3039         goto change_one_err;
3040     }
3041   /* At this point, we have copied everything up to the end marker
3042      into the new file, except for the options we are going to change.
3043      Now, dump the changed options (except for those we are going to
3044      revert to their default), and write the end marker, possibly
3045      followed by the rest of the original file.  */
3046
3047   /* We have to turn on UTF8 strings for GnuPG.  */
3048   if (backend == GC_BACKEND_GPG && ! utf8strings_seen)
3049     fprintf (src_file, "utf8-strings\n");
3050
3051   option = gc_component[component].options;
3052   while (option->name)
3053     {
3054       if (!(option->flags & GC_OPT_FLAG_GROUP)
3055           && option->backend == backend
3056           && option->new_value)
3057         {
3058           char *arg = option->new_value;
3059
3060           do
3061             {
3062               if (*arg == '\0' || *arg == ',')
3063                 {
3064                   fprintf (src_file, "%s\n", option->name);
3065                   if (ferror (src_file))
3066                     goto change_one_err;
3067                 }
3068               else if (gc_arg_type[option->arg_type].fallback
3069                        == GC_ARG_TYPE_NONE)
3070                 {
3071                   assert (*arg == '1');
3072                   fprintf (src_file, "%s\n", option->name);
3073                   if (ferror (src_file))
3074                     goto change_one_err;
3075
3076                   arg++;
3077                 }
3078               else if (gc_arg_type[option->arg_type].fallback
3079                        == GC_ARG_TYPE_STRING)
3080                 {
3081                   char *end;
3082
3083                   if (!verbatim)
3084                     {
3085                       log_assert (*arg == '"');
3086                       arg++;
3087
3088                       end = strchr (arg, ',');
3089                       if (end)
3090                         *end = '\0';
3091                     }
3092                   else
3093                     end = NULL;
3094
3095                   fprintf (src_file, "%s %s\n", option->name,
3096                            verbatim? arg : percent_deescape (arg));
3097                   if (ferror (src_file))
3098                     goto change_one_err;
3099
3100                   if (end)
3101                     *end = ',';
3102                   arg = end;
3103                 }
3104               else
3105                 {
3106                   char *end;
3107
3108                   end = strchr (arg, ',');
3109                   if (end)
3110                     *end = '\0';
3111
3112                   fprintf (src_file, "%s %s\n", option->name, arg);
3113                   if (ferror (src_file))
3114                     goto change_one_err;
3115
3116                   if (end)
3117                     *end = ',';
3118                   arg = end;
3119                 }
3120
3121               assert (arg == NULL || *arg == '\0' || *arg == ',');
3122               if (arg && *arg == ',')
3123                 arg++;
3124             }
3125           while (arg && *arg);
3126         }
3127       option++;
3128     }
3129
3130   fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
3131   if (ferror (src_file))
3132     goto change_one_err;
3133
3134   if (!in_marker)
3135     {
3136       fprintf (src_file, "# %s edited this configuration file.\n",
3137                GPGCONF_DISP_NAME);
3138       if (ferror (src_file))
3139         goto change_one_err;
3140       fprintf (src_file, "# It will disable options before this marked "
3141                "block, but it will\n");
3142       if (ferror (src_file))
3143         goto change_one_err;
3144       fprintf (src_file, "# never change anything below these lines.\n");
3145       if (ferror (src_file))
3146         goto change_one_err;
3147     }
3148   if (dest_file)
3149     {
3150       while ((length = read_line (dest_file, &line, &line_len, NULL)) > 0)
3151         {
3152           fprintf (src_file, "%s", line);
3153           if (ferror (src_file))
3154             goto change_one_err;
3155         }
3156       if (length < 0 || ferror (dest_file))
3157         goto change_one_err;
3158     }
3159   xfree (line);
3160   line = NULL;
3161
3162   res = fclose (src_file);
3163   if (res)
3164     {
3165       res = errno;
3166       close (fd);
3167       if (dest_file)
3168         fclose (dest_file);
3169       gpg_err_set_errno (res);
3170       return -1;
3171     }
3172   close (fd);
3173   if (dest_file)
3174     {
3175       res = fclose (dest_file);
3176       if (res)
3177         return -1;
3178     }
3179   return 0;
3180
3181  change_one_err:
3182   xfree (line);
3183   res = errno;
3184   if (src_file)
3185     {
3186       fclose (src_file);
3187       close (fd);
3188     }
3189   if (dest_file)
3190     fclose (dest_file);
3191   gpg_err_set_errno (res);
3192   return -1;
3193 }
3194
3195
3196 /* Common code for gc_component_change_options and
3197  * gc_process_gpgconf_conf.  If VERBATIM is set the profile parsing
3198  * mode is used.  */
3199 static void
3200 change_one_value (gc_option_t *option, int *runtime,
3201                   unsigned long flags, char *new_value, int verbatim)
3202 {
3203   unsigned long new_value_nr = 0;
3204
3205   option_check_validity (option, flags, new_value, &new_value_nr, verbatim);
3206
3207   if (option->flags & GC_OPT_FLAG_RUNTIME)
3208     runtime[option->backend] = 1;
3209
3210   option->new_flags = flags;
3211   if (!(flags & GC_OPT_FLAG_DEFAULT))
3212     {
3213       if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
3214           && (option->flags & GC_OPT_FLAG_LIST))
3215         {
3216           char *str;
3217
3218           /* We convert the number to a list of 1's for convenient
3219              list handling.  */
3220           assert (new_value_nr > 0);
3221           option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
3222           str = option->new_value;
3223           *(str++) = '1';
3224           while (--new_value_nr > 0)
3225             {
3226               *(str++) = ',';
3227               *(str++) = '1';
3228             }
3229           *(str++) = '\0';
3230         }
3231       else
3232         option->new_value = xstrdup (new_value);
3233     }
3234 }
3235
3236
3237 /* Read the modifications from IN and apply them.  If IN is NULL the
3238    modifications are expected to already have been set to the global
3239    table.  If VERBATIM is set the profile mode is used.  */
3240 void
3241 gc_component_change_options (int component, estream_t in, estream_t out,
3242                              int verbatim)
3243 {
3244   int err = 0;
3245   int runtime[GC_BACKEND_NR];
3246   char *src_filename[GC_BACKEND_NR];
3247   char *dest_filename[GC_BACKEND_NR];
3248   char *orig_filename[GC_BACKEND_NR];
3249   gc_backend_t backend;
3250   gc_option_t *option;
3251   char *line = NULL;
3252   size_t line_len = 0;
3253   ssize_t length;
3254
3255   if (component == GC_COMPONENT_PINENTRY)
3256     return; /* Dummy component for now.  */
3257
3258   for (backend = 0; backend < GC_BACKEND_NR; backend++)
3259     {
3260       runtime[backend] = 0;
3261       src_filename[backend] = NULL;
3262       dest_filename[backend] = NULL;
3263       orig_filename[backend] = NULL;
3264     }
3265
3266   if (in)
3267     {
3268       /* Read options from the file IN.  */
3269       while ((length = es_read_line (in, &line, &line_len, NULL)) > 0)
3270         {
3271           char *linep;
3272           unsigned long flags = 0;
3273           char *new_value = "";
3274
3275           /* Strip newline and carriage return, if present.  */
3276           while (length > 0
3277                  && (line[length - 1] == '\n' || line[length - 1] == '\r'))
3278             line[--length] = '\0';
3279
3280           linep = strchr (line, ':');
3281           if (linep)
3282             *(linep++) = '\0';
3283
3284           /* Extract additional flags.  Default to none.  */
3285           if (linep)
3286             {
3287               char *end;
3288               char *tail;
3289
3290               end = strchr (linep, ':');
3291               if (end)
3292                 *(end++) = '\0';
3293
3294               gpg_err_set_errno (0);
3295               flags = strtoul (linep, &tail, 0);
3296               if (errno)
3297                 gc_error (1, errno, "malformed flags in option %s", line);
3298               if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
3299                 gc_error (1, 0, "garbage after flags in option %s", line);
3300
3301               linep = end;
3302             }
3303
3304           /* Don't allow setting of the no change flag.  */
3305           flags &= ~GC_OPT_FLAG_NO_CHANGE;
3306
3307           /* Extract default value, if present.  Default to empty if not.  */
3308           if (linep)
3309             {
3310               char *end;
3311               end = strchr (linep, ':');
3312               if (end)
3313                 *(end++) = '\0';
3314               new_value = linep;
3315               linep = end;
3316             }
3317
3318           option = find_option (component, line, GC_BACKEND_ANY);
3319           if (!option)
3320             gc_error (1, 0, "unknown option %s", line);
3321
3322           if ((option->flags & GC_OPT_FLAG_NO_CHANGE))
3323             {
3324               gc_error (0, 0, "ignoring new value for option %s",
3325                         option->name);
3326               continue;
3327             }
3328
3329           change_one_value (option, runtime, flags, new_value, 0);
3330         }
3331       if (length < 0 || gpgrt_ferror (in))
3332         gc_error (1, errno, "error reading stream 'in'");
3333     }
3334
3335   /* Now that we have collected and locally verified the changes,
3336      write them out to new configuration files, verify them
3337      externally, and then commit them.  */
3338   option = gc_component[component].options;
3339   while (option && option->name)
3340     {
3341       /* Go on if we have already seen this backend, or if there is
3342          nothing to do.  */
3343       if (src_filename[option->backend]
3344           || !(option->new_flags || option->new_value))
3345         {
3346           option++;
3347           continue;
3348         }
3349
3350       if (gc_backend[option->backend].program)
3351         {
3352           err = change_options_program (component, option->backend,
3353                                         &src_filename[option->backend],
3354                                         &dest_filename[option->backend],
3355                                         &orig_filename[option->backend],
3356                                         verbatim);
3357           if (! err)
3358             {
3359               /* External verification.  */
3360               err = gc_component_check_options (component, out,
3361                                                 src_filename[option->backend]);
3362               if (err)
3363                 {
3364                   gc_error (0, 0,
3365                             _("External verification of component %s failed"),
3366                             gc_component[component].name);
3367                   gpg_err_set_errno (EINVAL);
3368                 }
3369             }
3370
3371         }
3372       else
3373         err = change_options_file (component, option->backend,
3374                                    &src_filename[option->backend],
3375                                    &dest_filename[option->backend],
3376                                    &orig_filename[option->backend]);
3377
3378       if (err)
3379         break;
3380
3381       option++;
3382     }
3383
3384   if (! err && ! opt.dry_run)
3385     {
3386       int i;
3387
3388       for (i = 0; i < GC_BACKEND_NR; i++)
3389         {
3390           if (src_filename[i])
3391             {
3392               /* FIXME: Make a verification here.  */
3393
3394               assert (dest_filename[i]);
3395
3396               if (orig_filename[i])
3397                 {
3398 #ifdef HAVE_W32_SYSTEM
3399                   /* There is no atomic update on W32.  */
3400                   err = unlink (dest_filename[i]);
3401 #endif /* HAVE_W32_SYSTEM */
3402                   if (!err)
3403                     err = rename (src_filename[i], dest_filename[i]);
3404                 }
3405               else
3406                 {
3407 #ifdef HAVE_W32_SYSTEM
3408                   /* We skip the unlink if we expect the file not to
3409                      be there.  */
3410                   err = rename (src_filename[i], dest_filename[i]);
3411 #else /* HAVE_W32_SYSTEM */
3412                   /* This is a bit safer than rename() because we
3413                      expect DEST_FILENAME not to be there.  If it
3414                      happens to be there, this will fail.  */
3415                   err = link (src_filename[i], dest_filename[i]);
3416                   if (!err)
3417                     err = unlink (src_filename[i]);
3418 #endif /* !HAVE_W32_SYSTEM */
3419                 }
3420               if (err)
3421                 break;
3422               xfree (src_filename[i]);
3423               src_filename[i] = NULL;
3424             }
3425         }
3426     }
3427
3428   if (err || opt.dry_run)
3429     {
3430       int i;
3431       int saved_errno = errno;
3432
3433       /* An error occurred or a dry-run is requested.  */
3434       for (i = 0; i < GC_BACKEND_NR; i++)
3435         {
3436           if (src_filename[i])
3437             {
3438               /* The change was not yet committed.  */
3439               unlink (src_filename[i]);
3440               if (orig_filename[i])
3441                 unlink (orig_filename[i]);
3442             }
3443           else
3444             {
3445               /* The changes were already committed.  FIXME: This is a
3446                  tad dangerous, as we don't know if we don't overwrite
3447                  a version of the file that is even newer than the one
3448                  we just installed.  */
3449               if (orig_filename[i])
3450                 {
3451 #ifdef HAVE_W32_SYSTEM
3452                   /* There is no atomic update on W32.  */
3453                   unlink (dest_filename[i]);
3454 #endif /* HAVE_W32_SYSTEM */
3455                   rename (orig_filename[i], dest_filename[i]);
3456                 }
3457               else
3458                 unlink (dest_filename[i]);
3459             }
3460         }
3461       if (err)
3462         gc_error (1, saved_errno, "could not commit changes");
3463
3464       /* Fall-through for dry run.  */
3465       goto leave;
3466     }
3467
3468   /* If it all worked, notify the daemons of the changes.  */
3469   if (opt.runtime)
3470     for (backend = 0; backend < GC_BACKEND_NR; backend++)
3471       {
3472         if (runtime[backend] && gc_backend[backend].runtime_change)
3473           (*gc_backend[backend].runtime_change) (0);
3474       }
3475
3476   /* Move the per-process backup file into its place.  */
3477   for (backend = 0; backend < GC_BACKEND_NR; backend++)
3478     if (orig_filename[backend])
3479       {
3480         char *backup_filename;
3481
3482         assert (dest_filename[backend]);
3483
3484         backup_filename = xasprintf ("%s.%s.bak",
3485                                      dest_filename[backend], GPGCONF_NAME);
3486
3487 #ifdef HAVE_W32_SYSTEM
3488         /* There is no atomic update on W32.  */
3489         unlink (backup_filename);
3490 #endif /* HAVE_W32_SYSTEM */
3491         rename (orig_filename[backend], backup_filename);
3492         xfree (backup_filename);
3493       }
3494
3495  leave:
3496   xfree (line);
3497   for (backend = 0; backend < GC_BACKEND_NR; backend++)
3498     {
3499       xfree (src_filename[backend]);
3500       xfree (dest_filename[backend]);
3501       xfree (orig_filename[backend]);
3502     }
3503 }
3504
3505
3506 /* Check whether USER matches the current user of one of its group.
3507    This function may change USER.  Returns true is there is a
3508    match.  */
3509 static int
3510 key_matches_user_or_group (char *user)
3511 {
3512   char *group;
3513
3514   if (*user == '*' && user[1] == 0)
3515     return 1; /* A single asterisk matches all users.  */
3516
3517   group = strchr (user, ':');
3518   if (group)
3519     *group++ = 0;
3520
3521 #ifdef HAVE_W32_SYSTEM
3522   /* Under Windows we don't support groups. */
3523   if (group && *group)
3524     gc_error (0, 0, _("Note that group specifications are ignored\n"));
3525 #ifndef HAVE_W32CE_SYSTEM
3526   if (*user)
3527     {
3528       static char *my_name;
3529
3530       if (!my_name)
3531         {
3532           char tmp[1];
3533           DWORD size = 1;
3534
3535           GetUserNameA (tmp, &size);
3536           my_name = xmalloc (size);
3537           if (!GetUserNameA (my_name, &size))
3538             gc_error (1,0, "error getting current user name: %s",
3539                       w32_strerror (-1));
3540         }
3541
3542       if (!strcmp (user, my_name))
3543         return 1; /* Found.  */
3544     }
3545 #endif /*HAVE_W32CE_SYSTEM*/
3546 #else /*!HAVE_W32_SYSTEM*/
3547   /* First check whether the user matches.  */
3548   if (*user)
3549     {
3550       static char *my_name;
3551
3552       if (!my_name)
3553         {
3554           struct passwd *pw = getpwuid ( getuid () );
3555           if (!pw)
3556             gc_error (1, errno, "getpwuid failed for current user");
3557           my_name = xstrdup (pw->pw_name);
3558         }
3559       if (!strcmp (user, my_name))
3560         return 1; /* Found.  */
3561     }
3562
3563   /* If that failed, check whether a group matches.  */
3564   if (group && *group)
3565     {
3566       static char *my_group;
3567       static char **my_supgroups;
3568       int n;
3569
3570       if (!my_group)
3571         {
3572           struct group *gr = getgrgid ( getgid () );
3573           if (!gr)
3574             gc_error (1, errno, "getgrgid failed for current user");
3575           my_group = xstrdup (gr->gr_name);
3576         }
3577       if (!strcmp (group, my_group))
3578         return 1; /* Found.  */
3579
3580       if (!my_supgroups)
3581         {
3582           int ngids;
3583           gid_t *gids;
3584
3585           ngids = getgroups (0, NULL);
3586           gids  = xcalloc (ngids+1, sizeof *gids);
3587           ngids = getgroups (ngids, gids);
3588           if (ngids < 0)
3589             gc_error (1, errno, "getgroups failed for current user");
3590           my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
3591           for (n=0; n < ngids; n++)
3592             {
3593               struct group *gr = getgrgid ( gids[n] );
3594               if (!gr)
3595                 gc_error (1, errno, "getgrgid failed for supplementary group");
3596               my_supgroups[n] = xstrdup (gr->gr_name);
3597             }
3598           xfree (gids);
3599         }
3600
3601       for (n=0; my_supgroups[n]; n++)
3602         if (!strcmp (group, my_supgroups[n]))
3603           return 1; /* Found.  */
3604     }
3605 #endif /*!HAVE_W32_SYSTEM*/
3606   return 0; /* No match.  */
3607 }
3608
3609
3610
3611 /* Read and process the global configuration file for gpgconf.  This
3612    optional file is used to update our internal tables at runtime and
3613    may also be used to set new default values.  If FNAME is NULL the
3614    default name will be used.  With UPDATE set to true the internal
3615    tables are actually updated; if not set, only a syntax check is
3616    done.  If DEFAULTS is true the global options are written to the
3617    configuration files.  If LISTFP is set, no changes are done but the
3618    configuration file is printed to LISTFP in a colon separated format.
3619
3620    Returns 0 on success or if the config file is not present; -1 is
3621    returned on error. */
3622 int
3623 gc_process_gpgconf_conf (const char *fname_arg, int update, int defaults,
3624                          estream_t listfp)
3625 {
3626   int result = 0;
3627   char *line = NULL;
3628   size_t line_len = 0;
3629   ssize_t length;
3630   FILE *config;
3631   int lineno = 0;
3632   int in_rule = 0;
3633   int got_match = 0;
3634   int runtime[GC_BACKEND_NR];
3635   int backend_id, component_id;
3636   char *fname;
3637
3638   if (fname_arg)
3639     fname = xstrdup (fname_arg);
3640   else
3641     fname = make_filename (gnupg_sysconfdir (), GPGCONF_NAME EXTSEP_S "conf",
3642                            NULL);
3643
3644   for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3645     runtime[backend_id] = 0;
3646
3647   config = fopen (fname, "r");
3648   if (!config)
3649     {
3650       /* Do not print an error if the file is not available, except
3651          when running in syntax check mode.  */
3652       if (errno != ENOENT || !update)
3653         {
3654           gc_error (0, errno, "can not open global config file '%s'", fname);
3655           result = -1;
3656         }
3657       xfree (fname);
3658       return result;
3659     }
3660
3661   while ((length = read_line (config, &line, &line_len, NULL)) > 0)
3662     {
3663       char *key, *component, *option, *flags, *value;
3664       char *empty;
3665       gc_option_t *option_info = NULL;
3666       char *p;
3667       int is_continuation;
3668
3669       lineno++;
3670       key = line;
3671       while (*key == ' ' || *key == '\t')
3672         key++;
3673       if (!*key || *key == '#' || *key == '\r' || *key == '\n')
3674         continue;
3675
3676       is_continuation = (key != line);
3677
3678       /* Parse the key field.  */
3679       if (!is_continuation && got_match)
3680         break;  /* Finish after the first match.  */
3681       else if (!is_continuation)
3682         {
3683           in_rule = 0;
3684           for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
3685             ;
3686           if (!*p)
3687             {
3688               gc_error (0, 0, "missing rule at '%s', line %d", fname, lineno);
3689               result = -1;
3690               continue;
3691             }
3692           *p++ = 0;
3693           component = p;
3694         }
3695       else if (!in_rule)
3696         {
3697           gc_error (0, 0, "continuation but no rule at '%s', line %d",
3698                     fname, lineno);
3699           result = -1;
3700           continue;
3701         }
3702       else
3703         {
3704           component = key;
3705           key = NULL;
3706         }
3707
3708       in_rule = 1;
3709
3710       /* Parse the component.  */
3711       while (*component == ' ' || *component == '\t')
3712         component++;
3713       for (p=component; *p && !strchr (" \t\r\n", *p); p++)
3714         ;
3715       if (p == component)
3716         {
3717           gc_error (0, 0, "missing component at '%s', line %d",
3718                     fname, lineno);
3719           result = -1;
3720           continue;
3721         }
3722       empty = p;
3723       *p++ = 0;
3724       option = p;
3725       component_id = gc_component_find (component);
3726       if (component_id < 0)
3727         {
3728           gc_error (0, 0, "unknown component at '%s', line %d",
3729                     fname, lineno);
3730           result = -1;
3731         }
3732
3733       /* Parse the option name.  */
3734       while (*option == ' ' || *option == '\t')
3735         option++;
3736       for (p=option; *p && !strchr (" \t\r\n", *p); p++)
3737         ;
3738       if (p == option)
3739         {
3740           gc_error (0, 0, "missing option at '%s', line %d",
3741                     fname, lineno);
3742           result = -1;
3743           continue;
3744         }
3745       *p++ = 0;
3746       flags = p;
3747       if ( component_id != -1)
3748         {
3749           option_info = find_option (component_id, option, GC_BACKEND_ANY);
3750           if (!option_info)
3751             {
3752               gc_error (0, 0, "unknown option at '%s', line %d",
3753                         fname, lineno);
3754               result = -1;
3755             }
3756         }
3757
3758
3759       /* Parse the optional flags.  */
3760       while (*flags == ' ' || *flags == '\t')
3761         flags++;
3762       if (*flags == '[')
3763         {
3764           flags++;
3765           p = strchr (flags, ']');
3766           if (!p)
3767             {
3768               gc_error (0, 0, "syntax error in rule at '%s', line %d",
3769                         fname, lineno);
3770               result = -1;
3771               continue;
3772             }
3773           *p++ = 0;
3774           value = p;
3775         }
3776       else  /* No flags given.  */
3777         {
3778           value = flags;
3779           flags = NULL;
3780         }
3781
3782       /* Parse the optional value.  */
3783       while (*value == ' ' || *value == '\t')
3784        value++;
3785       for (p=value; *p && !strchr ("\r\n", *p); p++)
3786         ;
3787       if (p == value)
3788         value = empty; /* No value given; let it point to an empty string.  */
3789       else
3790         {
3791           /* Strip trailing white space.  */
3792           *p = 0;
3793           for (p--; p > value && (*p == ' ' || *p == '\t'); p--)
3794             *p = 0;
3795         }
3796
3797       /* Check flag combinations.  */
3798       if (!flags)
3799         ;
3800       else if (!strcmp (flags, "default"))
3801         {
3802           if (*value)
3803             {
3804               gc_error (0, 0, "flag \"default\" may not be combined "
3805                         "with a value at '%s', line %d",
3806                         fname, lineno);
3807               result = -1;
3808             }
3809         }
3810       else if (!strcmp (flags, "change"))
3811         ;
3812       else if (!strcmp (flags, "no-change"))
3813         ;
3814       else
3815         {
3816           gc_error (0, 0, "unknown flag at '%s', line %d",
3817                     fname, lineno);
3818           result = -1;
3819         }
3820
3821       /* In list mode we print out all records.  */
3822       if (listfp && !result)
3823         {
3824           /* If this is a new ruleset, print a key record.  */
3825           if (!is_continuation)
3826             {
3827               char *group = strchr (key, ':');
3828               if (group)
3829                 {
3830                   *group++ = 0;
3831                   if ((p = strchr (group, ':')))
3832                     *p = 0; /* We better strip any extra stuff. */
3833                 }
3834
3835               es_fprintf (listfp, "k:%s:", gc_percent_escape (key));
3836               es_fprintf (listfp, "%s\n", group? gc_percent_escape (group):"");
3837             }
3838
3839           /* All other lines are rule records.  */
3840           es_fprintf (listfp, "r:::%s:%s:%s:",
3841                       gc_component[component_id].name,
3842                       option_info->name? option_info->name : "",
3843                       flags? flags : "");
3844           if (value != empty)
3845             es_fprintf (listfp, "\"%s", gc_percent_escape (value));
3846
3847           es_putc ('\n', listfp);
3848         }
3849
3850       /* Check whether the key matches but do this only if we are not
3851          running in syntax check mode. */
3852       if ( update
3853            && !result && !listfp
3854            && (got_match || (key && key_matches_user_or_group (key))) )
3855         {
3856           int newflags = 0;
3857
3858           got_match = 1;
3859
3860           /* Apply the flags from gpgconf.conf.  */
3861           if (!flags)
3862             ;
3863           else if (!strcmp (flags, "default"))
3864             newflags |= GC_OPT_FLAG_DEFAULT;
3865           else if (!strcmp (flags, "no-change"))
3866             option_info->flags |= GC_OPT_FLAG_NO_CHANGE;
3867           else if (!strcmp (flags, "change"))
3868             option_info->flags &= ~GC_OPT_FLAG_NO_CHANGE;
3869
3870           if (defaults)
3871             {
3872               /* Here we explicitly allow updating the value again.  */
3873               if (newflags)
3874                 {
3875                   option_info->new_flags = 0;
3876                 }
3877               if (*value)
3878                 {
3879                   xfree (option_info->new_value);
3880                   option_info->new_value = NULL;
3881                 }
3882               change_one_value (option_info, runtime, newflags, value, 0);
3883             }
3884         }
3885     }
3886
3887   if (length < 0 || ferror (config))
3888     {
3889       gc_error (0, errno, "error reading from '%s'", fname);
3890       result = -1;
3891     }
3892   if (fclose (config))
3893     gc_error (0, errno, "error closing '%s'", fname);
3894
3895   xfree (line);
3896
3897   /* If it all worked, process the options. */
3898   if (!result && update && defaults && !listfp)
3899     {
3900       /* We need to switch off the runtime update, so that we can do
3901          it later all at once. */
3902       int save_opt_runtime = opt.runtime;
3903       opt.runtime = 0;
3904
3905       for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
3906         {
3907           gc_component_change_options (component_id, NULL, NULL, 0);
3908         }
3909       opt.runtime = save_opt_runtime;
3910
3911       if (opt.runtime)
3912         {
3913           for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3914             if (runtime[backend_id] && gc_backend[backend_id].runtime_change)
3915               (*gc_backend[backend_id].runtime_change) (0);
3916         }
3917     }
3918
3919   xfree (fname);
3920   return result;
3921 }
3922
3923
3924 /*
3925  * Apply the profile FNAME to all known configure files.
3926  */
3927 gpg_error_t
3928 gc_apply_profile (const char *fname)
3929 {
3930   gpg_error_t err;
3931   char *fname_buffer = NULL;
3932   char *line = NULL;
3933   size_t line_len = 0;
3934   ssize_t length;
3935   estream_t fp;
3936   int lineno = 0;
3937   int runtime[GC_BACKEND_NR];
3938   int backend_id;
3939   int component_id = -1;
3940   int skip_section = 0;
3941   int error_count = 0;
3942   int newflags;
3943
3944   if (!fname)
3945     fname = "-";
3946
3947   for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
3948     runtime[backend_id] = 0;
3949
3950
3951   if (!(!strcmp (fname, "-")
3952         || strchr (fname, '/')
3953 #ifdef HAVE_W32_SYSTEM
3954         || strchr (fname, '\\')
3955 #endif
3956         || strchr (fname, '.')))
3957     {
3958       /* FNAME looks like a standard profile name.  Check whether one
3959        * is installed and use that instead of the given file name.  */
3960       fname_buffer = xstrconcat (gnupg_datadir (), DIRSEP_S,
3961                                  fname, ".prf", NULL);
3962       if (!access (fname_buffer, F_OK))
3963         fname = fname_buffer;
3964     }
3965
3966   fp = !strcmp (fname, "-")? es_stdin : es_fopen (fname, "r");
3967   if (!fp)
3968     {
3969       err = gpg_error_from_syserror ();
3970       log_error ("can't open '%s': %s\n", fname, gpg_strerror (err));
3971       return err;
3972     }
3973
3974   if (opt.verbose)
3975     log_info ("applying profile '%s'\n", fname);
3976
3977   err = 0;
3978   while ((length = es_read_line (fp, &line, &line_len, NULL)) > 0)
3979     {
3980       char *name, *flags, *value;
3981       gc_option_t *option_info = NULL;
3982       char *p;
3983
3984       lineno++;
3985       name = line;
3986       while (*name == ' ' || *name == '\t')
3987         name++;
3988       if (!*name || *name == '#' || *name == '\r' || *name == '\n')
3989         continue;
3990       trim_trailing_spaces (name);
3991
3992       /* Check whether this is a new section.  */
3993       if (*name == '[')
3994         {
3995           name++;
3996           skip_section = 0;
3997           /* New section: Get the name of the component.  */
3998           p = strchr (name, ']');
3999           if (!p)
4000             {
4001               error_count++;
4002               log_info ("%s:%d:%d: error: syntax error in section tag\n",
4003                         fname, lineno, (int)(name - line));
4004               skip_section = 1;
4005               continue;
4006             }
4007           *p++ = 0;
4008           if (*p)
4009             log_info ("%s:%d:%d: warning: garbage after section tag\n",
4010                       fname, lineno, (int)(p - line));
4011
4012           trim_spaces (name);
4013           component_id = gc_component_find (name);
4014           if (component_id < 0)
4015             {
4016               log_info ("%s:%d:%d: warning: skipping unknown section '%s'\n",
4017                         fname, lineno, (int)(name - line), name );
4018               skip_section = 1;
4019             }
4020           continue;
4021         }
4022
4023       if (skip_section)
4024         continue;
4025       if (component_id < 0)
4026         {
4027           error_count++;
4028           log_info ("%s:%d:%d: error: not in a valid section\n",
4029                     fname, lineno, (int)(name - line));
4030           skip_section = 1;
4031           continue;
4032         }
4033
4034       /* Parse the option name.  */
4035       for (p = name; *p && !spacep (p); p++)
4036         ;
4037       *p++ = 0;
4038       value = p;
4039
4040       option_info = find_option (component_id, name, GC_BACKEND_ANY);
4041       if (!option_info)
4042         {
4043           error_count++;
4044           log_info ("%s:%d:%d: error: unknown option '%s' in section '%s'\n",
4045                     fname, lineno, (int)(name - line),
4046                     name, gc_component[component_id].name);
4047           continue;
4048         }
4049
4050       /* Parse the optional flags. */
4051       trim_spaces (value);
4052       flags = value;
4053       if (*flags == '[')
4054         {
4055           flags++;
4056           p = strchr (flags, ']');
4057           if (!p)
4058             {
4059               log_info ("%s:%d:%d: warning: invalid flag specification\n",
4060                         fname, lineno, (int)(p - line));
4061               continue;
4062             }
4063           *p++ = 0;
4064           value = p;
4065           trim_spaces (value);
4066         }
4067       else /* No flags given.  */
4068         flags = NULL;
4069
4070       /* Set required defaults.  */
4071       if (gc_arg_type[option_info->arg_type].fallback == GC_ARG_TYPE_NONE
4072           && !*value)
4073         value = "1";
4074
4075       /* Check and save this option.  */
4076       newflags = 0;
4077       if (flags && !strcmp (flags, "default"))
4078         newflags |= GC_OPT_FLAG_DEFAULT;
4079
4080       if (newflags)
4081         option_info->new_flags = 0;
4082       if (*value)
4083         {
4084           xfree (option_info->new_value);
4085           option_info->new_value = NULL;
4086         }
4087       change_one_value (option_info, runtime, newflags, value, 1);
4088     }
4089
4090   if (length < 0 || es_ferror (fp))
4091     {
4092       err = gpg_error_from_syserror ();
4093       error_count++;
4094       log_error (_("%s:%u: read error: %s\n"),
4095                  fname, lineno, gpg_strerror (err));
4096     }
4097   if (es_fclose (fp))
4098     log_error (_("error closing '%s'\n"), fname);
4099   if (error_count)
4100     log_error (_("error parsing '%s'\n"), fname);
4101
4102   xfree (line);
4103
4104   /* If it all worked, process the options. */
4105   if (!err)
4106     {
4107       /* We need to switch off the runtime update, so that we can do
4108          it later all at once. */
4109       int save_opt_runtime = opt.runtime;
4110       opt.runtime = 0;
4111
4112       for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
4113         {
4114           gc_component_change_options (component_id, NULL, NULL, 1);
4115         }
4116       opt.runtime = save_opt_runtime;
4117
4118       if (opt.runtime)
4119         {
4120           for (backend_id = 0; backend_id < GC_BACKEND_NR; backend_id++)
4121             if (runtime[backend_id] && gc_backend[backend_id].runtime_change)
4122               (*gc_backend[backend_id].runtime_change) (0);
4123         }
4124     }
4125
4126   xfree (fname_buffer);
4127   return err;
4128 }