mirror of
git://git.gnupg.org/gnupg.git
synced 2024-09-07 12:56:21 +02:00
![Ingo Klöcker](/assets/img/avatar_default.png)
* common/i18n.c (i18n_init): Use gnupg_localedir() instead of LOCALEDIR. (i18n_localegettext): Ditto. * tools/gpgconf-comp.c (my_dgettext): Ditto. -- On Unix, gnupg_localedir() returns the locale directory relative to the root directory of the gnupg installation if specified in the gpgconf.ctl. Otherwise, it returns the built-in LOCALEDIR. GnuPG-bug-id: 5999
3585 lines
105 KiB
C
3585 lines
105 KiB
C
/* gpgconf-comp.c - Configuration utility for GnuPG.
|
||
* Copyright (C) 2004, 2007-2011 Free Software Foundation, Inc.
|
||
* Copyright (C) 2016 Werner Koch
|
||
* Copyright (C) 2020, 2021 g10 Code GmbH
|
||
*
|
||
* This file is part of GnuPG.
|
||
*
|
||
* GnuPG is free software; you can redistribute it and/or modify it
|
||
* under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation; either version 3 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* GnuPG is distributed in the hope that it will be useful, but
|
||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with GnuPG; if not, see <https://www.gnu.org/licenses/>.
|
||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||
*/
|
||
|
||
#if HAVE_CONFIG_H
|
||
#include <config.h>
|
||
#endif
|
||
#include <stdlib.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <fcntl.h>
|
||
#include <unistd.h>
|
||
#include <sys/types.h>
|
||
#include <errno.h>
|
||
#include <time.h>
|
||
#include <stdarg.h>
|
||
#ifdef HAVE_SIGNAL_H
|
||
# include <signal.h>
|
||
#endif
|
||
#include <ctype.h>
|
||
#ifdef HAVE_W32_SYSTEM
|
||
# define WIN32_LEAN_AND_MEAN 1
|
||
# include <windows.h>
|
||
#else
|
||
# include <pwd.h>
|
||
# include <grp.h>
|
||
#endif
|
||
|
||
#include "../common/util.h"
|
||
#include "../common/i18n.h"
|
||
#include "../common/exechelp.h"
|
||
#include "../common/sysutils.h"
|
||
#include "../common/status.h"
|
||
|
||
#include "../common/gc-opt-flags.h"
|
||
#include "gpgconf.h"
|
||
|
||
|
||
|
||
|
||
#if (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
|
||
void gc_error (int status, int errnum, const char *fmt, ...) \
|
||
__attribute__ ((format (printf, 3, 4)));
|
||
#endif
|
||
|
||
/* Output a diagnostic message. If ERRNUM is not 0, then the output
|
||
is followed by a colon, a white space, and the error string for the
|
||
error number ERRNUM. In any case the output is finished by a
|
||
newline. The message is prepended by the program name, a colon,
|
||
and a whitespace. The output may be further formatted or
|
||
redirected by the jnlib logging facility. */
|
||
void
|
||
gc_error (int status, int errnum, const char *fmt, ...)
|
||
{
|
||
va_list arg_ptr;
|
||
|
||
va_start (arg_ptr, fmt);
|
||
log_logv (GPGRT_LOGLVL_ERROR, fmt, arg_ptr);
|
||
va_end (arg_ptr);
|
||
|
||
if (errnum)
|
||
log_printf (": %s\n", strerror (errnum));
|
||
else
|
||
log_printf ("\n");
|
||
|
||
if (status)
|
||
{
|
||
log_printf (NULL);
|
||
log_printf ("fatal error (exit status %i)\n", status);
|
||
gpgconf_failure (gpg_error_from_errno (errnum));
|
||
}
|
||
}
|
||
|
||
|
||
/* Forward declaration. */
|
||
static void gpg_agent_runtime_change (int killflag);
|
||
static void scdaemon_runtime_change (int killflag);
|
||
#ifdef BUILD_WITH_TPM2D
|
||
static void tpm2daemon_runtime_change (int killflag);
|
||
#endif
|
||
static void dirmngr_runtime_change (int killflag);
|
||
static void keyboxd_runtime_change (int killflag);
|
||
|
||
|
||
|
||
/* STRING_ARRAY is a malloced array with malloced strings. It is used
|
||
* a space to store strings so that other objects may point to these
|
||
* strings. It shall never be shrinked or any items changes.
|
||
* STRING_ARRAY itself may be reallocated to increase the size of the
|
||
* table. STRING_ARRAY_USED is the number of items currently used,
|
||
* STRING_ARRAY_SIZE is the number of calloced slots. */
|
||
static char **string_array;
|
||
static size_t string_array_used;
|
||
static size_t string_array_size;
|
||
|
||
|
||
|
||
/* Option configuration. */
|
||
|
||
/* An option might take an argument, or not. Argument types can be
|
||
basic or complex. Basic types are generic and easy to validate.
|
||
Complex types provide more specific information about the intended
|
||
use, but can be difficult to validate. If you add to this enum,
|
||
don't forget to update GC_ARG_TYPE below. YOU MUST NOT CHANGE THE
|
||
NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE EXTERNAL
|
||
INTERFACE. */
|
||
typedef enum
|
||
{
|
||
/* Basic argument types. */
|
||
|
||
/* No argument. */
|
||
GC_ARG_TYPE_NONE = 0,
|
||
|
||
/* A String argument. */
|
||
GC_ARG_TYPE_STRING = 1,
|
||
|
||
/* A signed integer argument. */
|
||
GC_ARG_TYPE_INT32 = 2,
|
||
|
||
/* An unsigned integer argument. */
|
||
GC_ARG_TYPE_UINT32 = 3,
|
||
|
||
/* ADD NEW BASIC TYPE ENTRIES HERE. */
|
||
|
||
/* Complex argument types. */
|
||
|
||
/* A complete filename. */
|
||
GC_ARG_TYPE_FILENAME = 32,
|
||
|
||
/* An LDAP server in the format
|
||
HOSTNAME:PORT:USERNAME:PASSWORD:BASE_DN. */
|
||
GC_ARG_TYPE_LDAP_SERVER = 33,
|
||
|
||
/* A 40 character fingerprint. */
|
||
GC_ARG_TYPE_KEY_FPR = 34,
|
||
|
||
/* A user ID or key ID or fingerprint for a certificate. */
|
||
GC_ARG_TYPE_PUB_KEY = 35,
|
||
|
||
/* A user ID or key ID or fingerprint for a certificate with a key. */
|
||
GC_ARG_TYPE_SEC_KEY = 36,
|
||
|
||
/* A alias list made up of a key, an equal sign and a space
|
||
separated list of values. */
|
||
GC_ARG_TYPE_ALIAS_LIST = 37,
|
||
|
||
/* ADD NEW COMPLEX TYPE ENTRIES HERE. */
|
||
|
||
/* The number of the above entries. */
|
||
GC_ARG_TYPE_NR
|
||
} gc_arg_type_t;
|
||
|
||
|
||
/* For every argument, we record some information about it in the
|
||
following struct. */
|
||
static const struct
|
||
{
|
||
/* For every argument type exists a basic argument type that can be
|
||
used as a fallback for input and validation purposes. */
|
||
gc_arg_type_t fallback;
|
||
|
||
/* Human-readable name of the type. */
|
||
const char *name;
|
||
} gc_arg_type[GC_ARG_TYPE_NR] =
|
||
{
|
||
/* The basic argument types have their own types as fallback. */
|
||
{ GC_ARG_TYPE_NONE, "none" },
|
||
{ GC_ARG_TYPE_STRING, "string" },
|
||
{ GC_ARG_TYPE_INT32, "int32" },
|
||
{ GC_ARG_TYPE_UINT32, "uint32" },
|
||
|
||
/* Reserved basic type entries for future extension. */
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
{ GC_ARG_TYPE_NR, NULL }, { GC_ARG_TYPE_NR, NULL },
|
||
|
||
/* The complex argument types have a basic type as fallback. */
|
||
{ GC_ARG_TYPE_STRING, "filename" },
|
||
{ GC_ARG_TYPE_STRING, "ldap server" },
|
||
{ GC_ARG_TYPE_STRING, "key fpr" },
|
||
{ GC_ARG_TYPE_STRING, "pub key" },
|
||
{ GC_ARG_TYPE_STRING, "sec key" },
|
||
{ GC_ARG_TYPE_STRING, "alias list" },
|
||
};
|
||
|
||
|
||
/* Every option has an associated expert level, than can be used to
|
||
hide advanced and expert options from beginners. If you add to
|
||
this list, don't forget to update GC_LEVEL below. YOU MUST NOT
|
||
CHANGE THE NUMBERS OF THE EXISTING ENTRIES, AS THEY ARE PART OF THE
|
||
EXTERNAL INTERFACE. */
|
||
typedef enum
|
||
{
|
||
/* The basic options should always be displayed. */
|
||
GC_LEVEL_BASIC,
|
||
|
||
/* The advanced options may be hidden from beginners. */
|
||
GC_LEVEL_ADVANCED,
|
||
|
||
/* The expert options should only be displayed to experts. */
|
||
GC_LEVEL_EXPERT,
|
||
|
||
/* The invisible options should normally never be displayed. */
|
||
GC_LEVEL_INVISIBLE,
|
||
|
||
/* The internal options are never exported, they mark options that
|
||
are recorded for internal use only. */
|
||
GC_LEVEL_INTERNAL,
|
||
|
||
/* ADD NEW ENTRIES HERE. */
|
||
|
||
/* The number of the above entries. */
|
||
GC_LEVEL_NR
|
||
} gc_expert_level_t;
|
||
|
||
/* A description for each expert level. */
|
||
static const struct
|
||
{
|
||
const char *name;
|
||
} gc_level[] =
|
||
{
|
||
{ "basic" },
|
||
{ "advanced" },
|
||
{ "expert" },
|
||
{ "invisible" },
|
||
{ "internal" }
|
||
};
|
||
|
||
|
||
/* Option flags. The flags which are used by the components are defined
|
||
by gc-opt-flags.h, included above.
|
||
|
||
YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING FLAGS, AS THEY ARE
|
||
PART OF THE EXTERNAL INTERFACE. */
|
||
|
||
/* Some entries in the emitted option list are not options, but mark
|
||
the beginning of a new group of options. These entries have the
|
||
GROUP flag set. Note that this is internally also known as a
|
||
header line. */
|
||
#define GC_OPT_FLAG_GROUP (1UL << 0)
|
||
/* The ARG_OPT flag for an option indicates that the argument is
|
||
optional. This is never set for GC_ARG_TYPE_NONE options. */
|
||
#define GC_OPT_FLAG_ARG_OPT (1UL << 1)
|
||
/* The LIST flag for an option indicates that the option can occur
|
||
several times. A comma separated list of arguments is used as the
|
||
argument value. */
|
||
#define GC_OPT_FLAG_LIST (1UL << 2)
|
||
/* The RUNTIME flag for an option indicates that the option can be
|
||
changed at runtime. */
|
||
#define GC_OPT_FLAG_RUNTIME (1UL << 3)
|
||
|
||
|
||
/* A human-readable description for each flag. */
|
||
static const struct
|
||
{
|
||
const char *name;
|
||
} gc_flag[] =
|
||
{
|
||
{ "group" },
|
||
{ "optional arg" },
|
||
{ "list" },
|
||
{ "runtime" },
|
||
{ "default" },
|
||
{ "default desc" },
|
||
{ "no arg desc" },
|
||
{ "no change" }
|
||
};
|
||
|
||
|
||
|
||
/* Each option we want to support in gpgconf has the needed
|
||
* information in a static list per componenet. This struct describes
|
||
* the info for a single option. */
|
||
struct known_option_s
|
||
{
|
||
/* If this is NULL, then this is a terminator in an array of unknown
|
||
* length. Otherwise it is the name of the option described by this
|
||
* entry. The name must not contain a colon. */
|
||
const char *name;
|
||
|
||
/* The option flags. */
|
||
unsigned long flags;
|
||
|
||
/* The expert level. */
|
||
gc_expert_level_t level;
|
||
|
||
/* The complex type of the option argument; the default of 0 is used
|
||
* for a standard type as returned by --dump-option-table. */
|
||
gc_arg_type_t arg_type;
|
||
};
|
||
typedef struct known_option_s known_option_t;
|
||
|
||
|
||
/* The known options of the GC_COMPONENT_GPG_AGENT component. */
|
||
static known_option_t known_options_gpg_agent[] =
|
||
{
|
||
{ "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "quiet", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "disable-scdaemon", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "enable-ssh-support", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "ssh-fingerprint-digest", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
{ "enable-putty-support", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "enable-extended-key-format", GC_OPT_FLAG_RUNTIME, GC_LEVEL_INVISIBLE },
|
||
{ "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED},
|
||
{ "log-file", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
|
||
/**/ GC_ARG_TYPE_FILENAME },
|
||
{ "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
|
||
{ "default-cache-ttl", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "default-cache-ttl-ssh", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED },
|
||
{ "max-cache-ttl", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
{ "max-cache-ttl-ssh", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
{ "ignore-cache-for-signing", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "allow-emacs-pinentry", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED },
|
||
{ "grab", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
{ "no-allow-external-cache", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "no-allow-mark-trusted", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED },
|
||
{ "no-allow-loopback-pinentry", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
|
||
{ "enforce-passphrase-constraints", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
{ "min-passphrase-len", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED },
|
||
{ "min-passphrase-nonalpha", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
{ "check-passphrase-pattern", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT,
|
||
/**/ GC_ARG_TYPE_FILENAME },
|
||
{ "check-sym-passphrase-pattern", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT,
|
||
/**/ GC_ARG_TYPE_FILENAME },
|
||
{ "max-passphrase-days", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
{ "enable-passphrase-history", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
{ "pinentry-timeout", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED },
|
||
|
||
{ NULL }
|
||
};
|
||
|
||
|
||
/* The known options of the GC_COMPONENT_SCDAEMON component. */
|
||
static known_option_t known_options_scdaemon[] =
|
||
{
|
||
{ "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "reader-port", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "ctapi-driver", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED },
|
||
{ "pcsc-driver", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED },
|
||
{ "disable-ccid", GC_OPT_FLAG_RUNTIME, GC_LEVEL_EXPERT },
|
||
{ "disable-pinpad", GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "enable-pinpad-varlen", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "card-timeout", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "application-priority", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED },
|
||
{ "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED},
|
||
{ "log-file", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
|
||
GC_ARG_TYPE_FILENAME },
|
||
{ "deny-admin", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
|
||
{ NULL }
|
||
};
|
||
|
||
#ifdef BUILD_WITH_TPM2D
|
||
/* The known options of the GC_COMPONENT_TPM2DAEMON component. */
|
||
static known_option_t known_options_tpm2daemon[] =
|
||
{
|
||
{ "verbose", GC_OPT_FLAG_LIST|GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "debug-level", GC_OPT_FLAG_ARG_OPT|GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED},
|
||
{ "log-file", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED,
|
||
GC_ARG_TYPE_FILENAME },
|
||
{ "deny-admin", GC_OPT_FLAG_RUNTIME, GC_LEVEL_BASIC },
|
||
{ "parent", GC_OPT_FLAG_RUNTIME, GC_LEVEL_ADVANCED },
|
||
|
||
{ NULL }
|
||
};
|
||
#endif
|
||
|
||
|
||
/* The known options of the GC_COMPONENT_GPG component. */
|
||
static known_option_t known_options_gpg[] =
|
||
{
|
||
{ "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC },
|
||
{ "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "group", GC_OPT_FLAG_LIST, GC_LEVEL_ADVANCED,
|
||
GC_ARG_TYPE_ALIAS_LIST},
|
||
{ "compliance", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT },
|
||
{ "default-new-key-algo", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "trust-model", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED },
|
||
{ "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
|
||
GC_ARG_TYPE_FILENAME },
|
||
{ "auto-key-locate", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "auto-key-import", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "auto-key-retrieve", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT },
|
||
{ "include-key-block", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "disable-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT },
|
||
{ "max-cert-depth", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "completes-needed", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "marginals-needed", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
|
||
/* The next items are pseudo options which we read via --gpgconf-list.
|
||
* The meta information is taken from the table below. */
|
||
{ "default_pubkey_algo", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "compliance_de_vs", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "use_keyboxd", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
|
||
{ NULL }
|
||
};
|
||
static const char *known_pseudo_options_gpg[] =
|
||
{/* v-- ARGPARSE_TYPE_STRING */
|
||
"default_pubkey_algo:0:2:@:",
|
||
/* A basic compliance check for gpg. We use gpg here but the
|
||
* result is valid for all components.
|
||
* v-- ARGPARSE_TYPE_INT */
|
||
"compliance_de_vs:0:1:@:",
|
||
/* True is use_keyboxd is enabled. That option can be set in
|
||
* common.conf but is not direcly supported by gpgconf. Thus we
|
||
* only allow to read it out.
|
||
* v-- ARGPARSE_TYPE_INT */
|
||
"use_keyboxd:0:1:@:",
|
||
NULL
|
||
};
|
||
|
||
|
||
/* The known options of the GC_COMPONENT_GPGSM component. */
|
||
static known_option_t known_options_gpgsm[] =
|
||
{
|
||
{ "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC },
|
||
{ "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "default-key", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "encrypt-to", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "disable-dirmngr", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT },
|
||
{ "p12-charset", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "keyserver", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC,
|
||
GC_ARG_TYPE_LDAP_SERVER },
|
||
{ "compliance", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT },
|
||
{ "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED },
|
||
{ "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
|
||
GC_ARG_TYPE_FILENAME },
|
||
{ "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "disable-crl-checks", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "enable-crl-checks", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "enable-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "include-certs", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT },
|
||
{ "disable-policy-checks", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "auto-issuer-key-retrieve", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "cipher-algo", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "disable-trusted-cert-crl-check", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT },
|
||
|
||
/* Pseudo option follows. See also table below. */
|
||
{ "default_pubkey_algo", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
|
||
{ NULL }
|
||
};
|
||
static const char *known_pseudo_options_gpgsm[] =
|
||
{/* v-- ARGPARSE_TYPE_STRING */
|
||
"default_pubkey_algo:0:2:@:",
|
||
NULL
|
||
};
|
||
|
||
|
||
/* The known options of the GC_COMPONENT_DIRMNGR component. */
|
||
static known_option_t known_options_dirmngr[] =
|
||
{
|
||
{ "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC },
|
||
{ "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "no-greeting", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "resolver-timeout", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "nameserver", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "debug-level", GC_OPT_FLAG_ARG_OPT, GC_LEVEL_ADVANCED },
|
||
{ "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
|
||
GC_ARG_TYPE_FILENAME },
|
||
{ "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
{ "batch", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "force", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "use-tor", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "keyserver", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "disable-http", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "ignore-http-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "honor-http-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "disable-ldap", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "ignore-ldap-dp", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "only-ldap-proxy", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "add-servers", GC_OPT_FLAG_NONE, GC_LEVEL_EXPERT },
|
||
{ "ldaptimeout", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "max-replies", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "allow-ocsp", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "ocsp-responder", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "ocsp-signer", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
{ "allow-version-check", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "ignore-ocsp-service-url", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED },
|
||
|
||
|
||
{ NULL }
|
||
};
|
||
|
||
/* The known options of the GC_COMPONENT_KEYBOXD component. */
|
||
static known_option_t known_options_keyboxd[] =
|
||
{
|
||
{ "verbose", GC_OPT_FLAG_LIST, GC_LEVEL_BASIC },
|
||
{ "quiet", GC_OPT_FLAG_NONE, GC_LEVEL_BASIC },
|
||
{ "log-file", GC_OPT_FLAG_NONE, GC_LEVEL_ADVANCED,
|
||
GC_ARG_TYPE_FILENAME },
|
||
{ "faked-system-time", GC_OPT_FLAG_NONE, GC_LEVEL_INVISIBLE },
|
||
|
||
{ NULL }
|
||
};
|
||
|
||
|
||
/* The known options of the GC_COMPONENT_PINENTRY component. */
|
||
static known_option_t known_options_pinentry[] =
|
||
{
|
||
{ NULL }
|
||
};
|
||
|
||
|
||
|
||
/* Our main option info object. We copy all required information from the
|
||
* gpgrt_opt_t items but convert the flags value to bit flags. */
|
||
struct gc_option_s
|
||
{
|
||
const char *name; /* The same as gpgrt_opt_t.long_opt. */
|
||
const char *desc; /* The same as gpgrt_opt_t.description. */
|
||
|
||
unsigned int is_header:1; /* This is a header item. */
|
||
unsigned int is_list:1; /* This is a list style option. */
|
||
unsigned int opt_arg:1; /* The option's argument is optional. */
|
||
unsigned int runtime:1; /* The option is runtime changeable. */
|
||
|
||
unsigned int gpgconf_list:1; /* Mentioned by --gpgconf-list. */
|
||
|
||
unsigned int has_default:1; /* The option has a default value. */
|
||
unsigned int def_in_desc:1; /* The default is in the descrition. */
|
||
unsigned int no_arg_desc:1; /* The argument has a default ???. */
|
||
unsigned int no_change:1; /* User shall not change the option. */
|
||
|
||
unsigned int attr_ignore:1; /* The ARGPARSE_ATTR_IGNORE. */
|
||
unsigned int attr_force:1; /* The ARGPARSE_ATTR_FORCE. */
|
||
|
||
/* The expert level - copied from known_options. */
|
||
gc_expert_level_t level;
|
||
|
||
/* The complex type - copied from known_options. */
|
||
gc_arg_type_t arg_type;
|
||
|
||
/* The default value for this option. This is NULL if the option is
|
||
not present in the component, the empty string if no default is
|
||
available, and otherwise a quoted string. This is currently
|
||
malloced.*/
|
||
char *default_value;
|
||
|
||
/* The current value of this option. */
|
||
char *value;
|
||
|
||
/* The new flags for this option. The only defined flag is actually
|
||
GC_OPT_FLAG_DEFAULT, and it means that the option should be
|
||
deleted. In this case, NEW_VALUE is NULL. */
|
||
unsigned long new_flags;
|
||
|
||
/* The new value of this option. */
|
||
char *new_value;
|
||
};
|
||
typedef struct gc_option_s gc_option_t;
|
||
|
||
|
||
|
||
/* The information associated with each component. */
|
||
static struct
|
||
{
|
||
/* The name of the component. Some components don't have an
|
||
* associated program, but are implemented directly by GPGConf. In
|
||
* this case, PROGRAM is NULL. */
|
||
char *program;
|
||
|
||
/* The displayed name of this component. Must not contain a colon
|
||
* (':') character. */
|
||
const char *name;
|
||
|
||
/* The gettext domain for the description DESC. If this is NULL,
|
||
then the description is not translated. */
|
||
const char *desc_domain;
|
||
|
||
/* The description of this component. */
|
||
const char *desc;
|
||
|
||
/* The module name (GNUPG_MODULE_NAME_foo) as defined by
|
||
* ../common/util.h. This value is used to get the actual installed
|
||
* path of the program. 0 is used if no program for the component
|
||
* is available. */
|
||
char module_name;
|
||
|
||
/* The name for the configuration filename of this component. */
|
||
const char *option_config_filename;
|
||
|
||
/* The static table of known options for this component. */
|
||
known_option_t *known_options;
|
||
|
||
/* The static table of known pseudo options for this component or NULL. */
|
||
const char **known_pseudo_options;
|
||
|
||
/* The runtime change callback. If KILLFLAG is true the component
|
||
is killed and not just reloaded. */
|
||
void (*runtime_change) (int killflag);
|
||
|
||
/* The table of known options as read from the component including
|
||
* header lines and such. This is suitable to be passed to
|
||
* gpgrt_argparser. Will be filled in by
|
||
* retrieve_options_from_program. */
|
||
gpgrt_opt_t *opt_table;
|
||
|
||
/* The full table including data from OPT_TABLE. The end of the
|
||
* table is marked by NULL entry for NAME. Will be filled in by
|
||
* retrieve_options_from_program. */
|
||
gc_option_t *options;
|
||
|
||
} gc_component[GC_COMPONENT_NR] =
|
||
{
|
||
/* Note: The order of the items must match the order given in the
|
||
* gc_component_id_t enumeration. The order is often used by
|
||
* frontends to display the backend options thus do not change the
|
||
* order without considering the user experience. */
|
||
{ NULL }, /* DUMMY for GC_COMPONENT_ANY */
|
||
|
||
{ GPG_NAME, GPG_DISP_NAME, "gnupg", N_("OpenPGP"),
|
||
GNUPG_MODULE_NAME_GPG, GPG_NAME ".conf",
|
||
known_options_gpg, known_pseudo_options_gpg },
|
||
|
||
{ GPGSM_NAME, GPGSM_DISP_NAME, "gnupg", N_("S/MIME"),
|
||
GNUPG_MODULE_NAME_GPGSM, GPGSM_NAME ".conf",
|
||
known_options_gpgsm, known_pseudo_options_gpgsm },
|
||
|
||
{ KEYBOXD_NAME, KEYBOXD_DISP_NAME, "gnupg", N_("Public Keys"),
|
||
GNUPG_MODULE_NAME_KEYBOXD, KEYBOXD_NAME ".conf",
|
||
known_options_keyboxd, NULL, keyboxd_runtime_change },
|
||
|
||
{ GPG_AGENT_NAME, GPG_AGENT_DISP_NAME, "gnupg", N_("Private Keys"),
|
||
GNUPG_MODULE_NAME_AGENT, GPG_AGENT_NAME ".conf",
|
||
known_options_gpg_agent, NULL, gpg_agent_runtime_change },
|
||
|
||
{ SCDAEMON_NAME, SCDAEMON_DISP_NAME, "gnupg", N_("Smartcards"),
|
||
GNUPG_MODULE_NAME_SCDAEMON, SCDAEMON_NAME ".conf",
|
||
known_options_scdaemon, NULL, scdaemon_runtime_change},
|
||
|
||
#ifdef BUILD_WITH_TPM2D
|
||
{ TPM2DAEMON_NAME, TPM2DAEMON_DISP_NAME, "gnupg", N_("TPM"),
|
||
GNUPG_MODULE_NAME_TPM2DAEMON, TPM2DAEMON_NAME ".conf",
|
||
known_options_tpm2daemon, NULL, tpm2daemon_runtime_change},
|
||
#endif
|
||
|
||
{ DIRMNGR_NAME, DIRMNGR_DISP_NAME, "gnupg", N_("Network"),
|
||
GNUPG_MODULE_NAME_DIRMNGR, DIRMNGR_NAME ".conf",
|
||
known_options_dirmngr, NULL, dirmngr_runtime_change },
|
||
|
||
{ "pinentry", "Pinentry", "gnupg", N_("Passphrase Entry"),
|
||
GNUPG_MODULE_NAME_PINENTRY, NULL,
|
||
known_options_pinentry }
|
||
};
|
||
|
||
|
||
|
||
/* Structure used to collect error output of the component programs. */
|
||
struct error_line_s;
|
||
typedef struct error_line_s *error_line_t;
|
||
struct error_line_s
|
||
{
|
||
error_line_t next; /* Link to next item. */
|
||
const char *fname; /* Name of the config file (points into BUFFER). */
|
||
unsigned int lineno; /* Line number of the config file. */
|
||
const char *errtext; /* Text of the error message (points into BUFFER). */
|
||
char buffer[1]; /* Helper buffer. */
|
||
};
|
||
|
||
|
||
|
||
|
||
/* Initialization and finalization. */
|
||
|
||
static void
|
||
gc_option_free (gc_option_t *o)
|
||
{
|
||
if (o == NULL || o->name == NULL)
|
||
return;
|
||
|
||
xfree (o->value);
|
||
gc_option_free (o + 1);
|
||
}
|
||
|
||
static void
|
||
gc_components_free (void)
|
||
{
|
||
int i;
|
||
for (i = 0; i < DIM (gc_component); i++)
|
||
gc_option_free (gc_component[i].options);
|
||
}
|
||
|
||
void
|
||
gc_components_init (void)
|
||
{
|
||
atexit (gc_components_free);
|
||
}
|
||
|
||
|
||
|
||
/* Engine specific support. */
|
||
static void
|
||
gpg_agent_runtime_change (int killflag)
|
||
{
|
||
gpg_error_t err = 0;
|
||
const char *pgmname;
|
||
const char *argv[5];
|
||
pid_t pid = (pid_t)(-1);
|
||
int i = 0;
|
||
int cmdidx;
|
||
|
||
pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
|
||
if (!gnupg_default_homedir_p ())
|
||
{
|
||
argv[i++] = "--homedir";
|
||
argv[i++] = gnupg_homedir ();
|
||
}
|
||
argv[i++] = "--no-autostart";
|
||
cmdidx = i;
|
||
argv[i++] = killflag? "KILLAGENT" : "RELOADAGENT";
|
||
argv[i] = NULL;
|
||
log_assert (i < DIM(argv));
|
||
|
||
if (!err)
|
||
err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
|
||
if (!err)
|
||
err = gnupg_wait_process (pgmname, pid, 1, NULL);
|
||
if (err)
|
||
gc_error (0, 0, "error running '%s %s': %s",
|
||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||
gnupg_release_process (pid);
|
||
}
|
||
|
||
|
||
static void
|
||
scdaemon_runtime_change (int killflag)
|
||
{
|
||
gpg_error_t err = 0;
|
||
const char *pgmname;
|
||
const char *argv[9];
|
||
pid_t pid = (pid_t)(-1);
|
||
int i = 0;
|
||
int cmdidx;
|
||
|
||
(void)killflag; /* For scdaemon kill and reload are synonyms. */
|
||
|
||
/* We use "GETINFO app_running" to see whether the agent is already
|
||
running and kill it only in this case. This avoids an explicit
|
||
starting of the agent in case it is not yet running. There is
|
||
obviously a race condition but that should not harm too much. */
|
||
|
||
pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
|
||
if (!gnupg_default_homedir_p ())
|
||
{
|
||
argv[i++] = "--homedir";
|
||
argv[i++] = gnupg_homedir ();
|
||
}
|
||
argv[i++] = "-s";
|
||
argv[i++] = "--no-autostart";
|
||
argv[i++] = "GETINFO scd_running";
|
||
argv[i++] = "/if ${! $?}";
|
||
cmdidx = i;
|
||
argv[i++] = "scd killscd";
|
||
argv[i++] = "/end";
|
||
argv[i] = NULL;
|
||
log_assert (i < DIM(argv));
|
||
|
||
if (!err)
|
||
err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
|
||
if (!err)
|
||
err = gnupg_wait_process (pgmname, pid, 1, NULL);
|
||
if (err)
|
||
gc_error (0, 0, "error running '%s %s': %s",
|
||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||
gnupg_release_process (pid);
|
||
}
|
||
|
||
|
||
#ifdef BUILD_WITH_TPM2D
|
||
static void
|
||
tpm2daemon_runtime_change (int killflag)
|
||
{
|
||
gpg_error_t err = 0;
|
||
const char *pgmname;
|
||
const char *argv[9];
|
||
pid_t pid = (pid_t)(-1);
|
||
int i = 0;
|
||
int cmdidx;
|
||
|
||
(void)killflag; /* For scdaemon kill and reload are synonyms. */
|
||
|
||
/* We use "GETINFO app_running" to see whether the agent is already
|
||
running and kill it only in this case. This avoids an explicit
|
||
starting of the agent in case it is not yet running. There is
|
||
obviously a race condition but that should not harm too much. */
|
||
|
||
pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
|
||
if (!gnupg_default_homedir_p ())
|
||
{
|
||
argv[i++] = "--homedir";
|
||
argv[i++] = gnupg_homedir ();
|
||
}
|
||
argv[i++] = "-s";
|
||
argv[i++] = "--no-autostart";
|
||
argv[i++] = "GETINFO tpm2d_running";
|
||
argv[i++] = "/if ${! $?}";
|
||
cmdidx = i;
|
||
argv[i++] = "scd killtpm2cd";
|
||
argv[i++] = "/end";
|
||
argv[i] = NULL;
|
||
log_assert (i < DIM(argv));
|
||
|
||
if (!err)
|
||
err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
|
||
if (!err)
|
||
err = gnupg_wait_process (pgmname, pid, 1, NULL);
|
||
if (err)
|
||
gc_error (0, 0, "error running '%s %s': %s",
|
||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||
gnupg_release_process (pid);
|
||
}
|
||
#endif
|
||
|
||
|
||
static void
|
||
dirmngr_runtime_change (int killflag)
|
||
{
|
||
gpg_error_t err = 0;
|
||
const char *pgmname;
|
||
const char *argv[6];
|
||
pid_t pid = (pid_t)(-1);
|
||
int i = 0;
|
||
int cmdidx;
|
||
|
||
pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
|
||
if (!gnupg_default_homedir_p ())
|
||
{
|
||
argv[i++] = "--homedir";
|
||
argv[i++] = gnupg_homedir ();
|
||
}
|
||
argv[i++] = "--no-autostart";
|
||
argv[i++] = "--dirmngr";
|
||
cmdidx = i;
|
||
argv[i++] = killflag? "KILLDIRMNGR" : "RELOADDIRMNGR";
|
||
argv[i] = NULL;
|
||
log_assert (i < DIM(argv));
|
||
|
||
if (!err)
|
||
err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
|
||
if (!err)
|
||
err = gnupg_wait_process (pgmname, pid, 1, NULL);
|
||
if (err)
|
||
gc_error (0, 0, "error running '%s %s': %s",
|
||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||
gnupg_release_process (pid);
|
||
}
|
||
|
||
|
||
static void
|
||
keyboxd_runtime_change (int killflag)
|
||
{
|
||
gpg_error_t err = 0;
|
||
const char *pgmname;
|
||
const char *argv[6];
|
||
pid_t pid = (pid_t)(-1);
|
||
int i = 0;
|
||
int cmdidx;
|
||
|
||
pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
|
||
argv[i++] = "--no-autostart";
|
||
argv[i++] = "--keyboxd";
|
||
cmdidx = i;
|
||
argv[i++] = killflag? "KILLKEYBOXD" : "RELOADKEYBOXD";
|
||
if (!gnupg_default_homedir_p ())
|
||
{
|
||
argv[i++] = "--homedir";
|
||
argv[i++] = gnupg_homedir ();
|
||
}
|
||
argv[i] = NULL;
|
||
log_assert (i < DIM(argv));
|
||
|
||
if (!err)
|
||
err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
|
||
if (!err)
|
||
err = gnupg_wait_process (pgmname, pid, 1, NULL);
|
||
if (err)
|
||
gc_error (0, 0, "error running '%s %s': %s",
|
||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||
gnupg_release_process (pid);
|
||
}
|
||
|
||
|
||
/* Launch the gpg-agent or the dirmngr if not already running. */
|
||
gpg_error_t
|
||
gc_component_launch (int component)
|
||
{
|
||
gpg_error_t err;
|
||
const char *pgmname;
|
||
const char *argv[6];
|
||
int i;
|
||
pid_t pid;
|
||
|
||
if (component < 0)
|
||
{
|
||
err = gc_component_launch (GC_COMPONENT_GPG_AGENT);
|
||
if (!err)
|
||
err = gc_component_launch (GC_COMPONENT_KEYBOXD);
|
||
if (!err)
|
||
err = gc_component_launch (GC_COMPONENT_DIRMNGR);
|
||
return err;
|
||
}
|
||
|
||
if (!(component == GC_COMPONENT_GPG_AGENT
|
||
|| component == GC_COMPONENT_KEYBOXD
|
||
|| component == GC_COMPONENT_DIRMNGR))
|
||
{
|
||
log_error ("%s\n", _("Component not suitable for launching"));
|
||
gpgconf_failure (0);
|
||
}
|
||
|
||
if (gc_component_check_options (component, NULL, NULL))
|
||
{
|
||
log_error (_("Configuration file of component %s is broken\n"),
|
||
gc_component[component].name);
|
||
if (!opt.quiet)
|
||
log_info (_("Note: Use the command \"%s%s\" to get details.\n"),
|
||
gc_component[component].program
|
||
? gc_component[component].program
|
||
: gc_component[component].name,
|
||
" --gpgconf-test");
|
||
gpgconf_failure (0);
|
||
}
|
||
|
||
pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CONNECT_AGENT);
|
||
i = 0;
|
||
if (!gnupg_default_homedir_p ())
|
||
{
|
||
argv[i++] = "--homedir";
|
||
argv[i++] = gnupg_homedir ();
|
||
}
|
||
if (component == GC_COMPONENT_DIRMNGR)
|
||
argv[i++] = "--dirmngr";
|
||
else if (component == GC_COMPONENT_KEYBOXD)
|
||
argv[i++] = "--keyboxd";
|
||
argv[i++] = "NOP";
|
||
argv[i] = NULL;
|
||
log_assert (i < DIM(argv));
|
||
|
||
err = gnupg_spawn_process_fd (pgmname, argv, -1, -1, -1, &pid);
|
||
if (!err)
|
||
err = gnupg_wait_process (pgmname, pid, 1, NULL);
|
||
if (err)
|
||
gc_error (0, 0, "error running '%s%s%s': %s",
|
||
pgmname,
|
||
component == GC_COMPONENT_DIRMNGR? " --dirmngr"
|
||
: component == GC_COMPONENT_KEYBOXD? " --keyboxd":"",
|
||
" NOP",
|
||
gpg_strerror (err));
|
||
gnupg_release_process (pid);
|
||
return err;
|
||
}
|
||
|
||
|
||
static void
|
||
do_runtime_change (int component, int killflag)
|
||
{
|
||
int runtime[GC_COMPONENT_NR] = { 0 };
|
||
|
||
if (component < 0)
|
||
{
|
||
for (component = 0; component < GC_COMPONENT_NR; component++)
|
||
runtime [component] = 1;
|
||
}
|
||
else
|
||
{
|
||
log_assert (component >= 0 && component < GC_COMPONENT_NR);
|
||
runtime [component] = 1;
|
||
}
|
||
|
||
/* Do the restart for the selected components. */
|
||
for (component = GC_COMPONENT_NR-1; component >= 0; component--)
|
||
{
|
||
if (runtime[component] && gc_component[component].runtime_change)
|
||
(*gc_component[component].runtime_change) (killflag);
|
||
}
|
||
}
|
||
|
||
|
||
/* Unconditionally restart COMPONENT. */
|
||
void
|
||
gc_component_kill (int component)
|
||
{
|
||
do_runtime_change (component, 1);
|
||
}
|
||
|
||
|
||
/* Unconditionally reload COMPONENT or all components if COMPONENT is -1. */
|
||
void
|
||
gc_component_reload (int component)
|
||
{
|
||
do_runtime_change (component, 0);
|
||
}
|
||
|
||
|
||
|
||
/* More or less Robust version of dgettext. It has the side effect of
|
||
switching the codeset to utf-8 because this is what we want to
|
||
output. In theory it is possible to keep the original code set and
|
||
switch back for regular diagnostic output (redefine "_(" for that)
|
||
but given the nature of this tool, being something invoked from
|
||
other programs, it does not make much sense. */
|
||
static const char *
|
||
my_dgettext (const char *domain, const char *msgid)
|
||
{
|
||
if (!msgid || !*msgid)
|
||
return msgid; /* Shortcut form "" which has the PO files meta data. */
|
||
|
||
#ifdef USE_SIMPLE_GETTEXT
|
||
if (domain)
|
||
{
|
||
static int switched_codeset;
|
||
char *text;
|
||
|
||
if (!switched_codeset)
|
||
{
|
||
switched_codeset = 1;
|
||
gettext_use_utf8 (1);
|
||
}
|
||
|
||
if (!strcmp (domain, "gnupg"))
|
||
domain = PACKAGE_GT;
|
||
|
||
/* FIXME: we have no dgettext, thus we can't switch. */
|
||
|
||
text = (char*)gettext (msgid);
|
||
return text ? text : msgid;
|
||
}
|
||
else
|
||
return msgid;
|
||
#elif defined(ENABLE_NLS)
|
||
if (domain)
|
||
{
|
||
static int switched_codeset;
|
||
char *text;
|
||
|
||
if (!switched_codeset)
|
||
{
|
||
switched_codeset = 1;
|
||
bind_textdomain_codeset (PACKAGE_GT, "utf-8");
|
||
|
||
bindtextdomain (DIRMNGR_NAME, gnupg_localedir ());
|
||
bind_textdomain_codeset (DIRMNGR_NAME, "utf-8");
|
||
|
||
}
|
||
|
||
/* Note: This is a hack to actually use the gnupg2 domain as
|
||
long we are in a transition phase where gnupg 1.x and 1.9 may
|
||
coexist. */
|
||
if (!strcmp (domain, "gnupg"))
|
||
domain = PACKAGE_GT;
|
||
|
||
text = dgettext (domain, msgid);
|
||
return text ? text : msgid;
|
||
}
|
||
else
|
||
return msgid;
|
||
#else
|
||
(void)domain;
|
||
return msgid;
|
||
#endif
|
||
}
|
||
|
||
|
||
/* Percent-Escape special characters. The string is valid until the
|
||
next invocation of the function. */
|
||
char *
|
||
gc_percent_escape (const char *src)
|
||
{
|
||
static char *esc_str;
|
||
static int esc_str_len;
|
||
int new_len = 3 * strlen (src) + 1;
|
||
char *dst;
|
||
|
||
if (esc_str_len < new_len)
|
||
{
|
||
char *new_esc_str = xrealloc (esc_str, new_len);
|
||
esc_str = new_esc_str;
|
||
esc_str_len = new_len;
|
||
}
|
||
|
||
dst = esc_str;
|
||
while (*src)
|
||
{
|
||
if (*src == '%')
|
||
{
|
||
*(dst++) = '%';
|
||
*(dst++) = '2';
|
||
*(dst++) = '5';
|
||
}
|
||
else if (*src == ':')
|
||
{
|
||
/* The colon is used as field separator. */
|
||
*(dst++) = '%';
|
||
*(dst++) = '3';
|
||
*(dst++) = 'a';
|
||
}
|
||
else if (*src == ',')
|
||
{
|
||
/* The comma is used as list separator. */
|
||
*(dst++) = '%';
|
||
*(dst++) = '2';
|
||
*(dst++) = 'c';
|
||
}
|
||
else if (*src == '\n')
|
||
{
|
||
/* The newline is problematic in a line-based format. */
|
||
*(dst++) = '%';
|
||
*(dst++) = '0';
|
||
*(dst++) = 'a';
|
||
}
|
||
else
|
||
*(dst++) = *(src);
|
||
src++;
|
||
}
|
||
*dst = '\0';
|
||
return esc_str;
|
||
}
|
||
|
||
|
||
|
||
/* Percent-Deescape special characters. The string is valid until the
|
||
next invocation of the function. */
|
||
static char *
|
||
percent_deescape (const char *src)
|
||
{
|
||
static char *str;
|
||
static int str_len;
|
||
int new_len = 3 * strlen (src) + 1;
|
||
char *dst;
|
||
|
||
if (str_len < new_len)
|
||
{
|
||
char *new_str = xrealloc (str, new_len);
|
||
str = new_str;
|
||
str_len = new_len;
|
||
}
|
||
|
||
dst = str;
|
||
while (*src)
|
||
{
|
||
if (*src == '%')
|
||
{
|
||
int val = hextobyte (src + 1);
|
||
|
||
if (val < 0)
|
||
gc_error (1, 0, "malformed end of string %s", src);
|
||
|
||
*(dst++) = (char) val;
|
||
src += 3;
|
||
}
|
||
else
|
||
*(dst++) = *(src++);
|
||
}
|
||
*dst = '\0';
|
||
return str;
|
||
}
|
||
|
||
|
||
/* List all components that are available. */
|
||
void
|
||
gc_component_list_components (estream_t out)
|
||
{
|
||
gc_component_id_t component;
|
||
const char *desc;
|
||
const char *pgmname;
|
||
|
||
for (component = 0; component < GC_COMPONENT_NR; component++)
|
||
{
|
||
if (!gc_component[component].program)
|
||
continue;
|
||
if (gc_component[component].module_name)
|
||
pgmname = gnupg_module_name (gc_component[component].module_name);
|
||
else
|
||
pgmname = "";
|
||
|
||
desc = gc_component[component].desc;
|
||
desc = my_dgettext (gc_component[component].desc_domain, desc);
|
||
es_fprintf (out, "%s:%s:",
|
||
gc_component[component].program, gc_percent_escape (desc));
|
||
es_fprintf (out, "%s\n", gc_percent_escape (pgmname));
|
||
}
|
||
}
|
||
|
||
|
||
|
||
static int
|
||
all_digits_p (const char *p, size_t len)
|
||
{
|
||
if (!len)
|
||
return 0; /* No. */
|
||
for (; len; len--, p++)
|
||
if (!isascii (*p) || !isdigit (*p))
|
||
return 0; /* No. */
|
||
return 1; /* Yes. */
|
||
}
|
||
|
||
|
||
/* Collect all error lines from stream FP. Only lines prefixed with
|
||
TAG are considered. Returns a list of error line items (which may
|
||
be empty). There is no error return. */
|
||
static error_line_t
|
||
collect_error_output (estream_t fp, const char *tag)
|
||
{
|
||
char buffer[1024];
|
||
char *p, *p2, *p3;
|
||
int c, cont_line;
|
||
unsigned int pos;
|
||
error_line_t eitem, errlines, *errlines_tail;
|
||
size_t taglen = strlen (tag);
|
||
|
||
errlines = NULL;
|
||
errlines_tail = &errlines;
|
||
pos = 0;
|
||
cont_line = 0;
|
||
while ((c=es_getc (fp)) != EOF)
|
||
{
|
||
buffer[pos++] = c;
|
||
if (pos >= sizeof buffer - 5 || c == '\n')
|
||
{
|
||
buffer[pos - (c == '\n')] = 0;
|
||
if (cont_line)
|
||
; /*Ignore continuations of previous line. */
|
||
else if (!strncmp (buffer, tag, taglen) && buffer[taglen] == ':')
|
||
{
|
||
/* "gpgsm: foo:4: bla" */
|
||
/* Yep, we are interested in this line. */
|
||
p = buffer + taglen + 1;
|
||
while (*p == ' ' || *p == '\t')
|
||
p++;
|
||
trim_trailing_spaces (p); /* Get rid of extra CRs. */
|
||
if (!*p)
|
||
; /* Empty lines are ignored. */
|
||
else if ( (p2 = strchr (p, ':')) && (p3 = strchr (p2+1, ':'))
|
||
&& all_digits_p (p2+1, p3 - (p2+1)))
|
||
{
|
||
/* Line in standard compiler format. */
|
||
p3++;
|
||
while (*p3 == ' ' || *p3 == '\t')
|
||
p3++;
|
||
eitem = xmalloc (sizeof *eitem + strlen (p));
|
||
eitem->next = NULL;
|
||
strcpy (eitem->buffer, p);
|
||
eitem->fname = eitem->buffer;
|
||
eitem->buffer[p2-p] = 0;
|
||
eitem->errtext = eitem->buffer + (p3 - p);
|
||
/* (we already checked that there are only ascii
|
||
digits followed by a colon) */
|
||
eitem->lineno = 0;
|
||
for (p2++; isdigit (*p2); p2++)
|
||
eitem->lineno = eitem->lineno*10 + (*p2 - '0');
|
||
*errlines_tail = eitem;
|
||
errlines_tail = &eitem->next;
|
||
}
|
||
else
|
||
{
|
||
/* Other error output. */
|
||
eitem = xmalloc (sizeof *eitem + strlen (p));
|
||
eitem->next = NULL;
|
||
strcpy (eitem->buffer, p);
|
||
eitem->fname = NULL;
|
||
eitem->errtext = eitem->buffer;
|
||
eitem->lineno = 0;
|
||
*errlines_tail = eitem;
|
||
errlines_tail = &eitem->next;
|
||
}
|
||
}
|
||
pos = 0;
|
||
/* If this was not a complete line mark that we are in a
|
||
continuation. */
|
||
cont_line = (c != '\n');
|
||
}
|
||
}
|
||
|
||
/* We ignore error lines not terminated by a LF. */
|
||
return errlines;
|
||
}
|
||
|
||
|
||
/* Check the options of a single component. If CONF_FILE is NULL the
|
||
* standard config file is used. If OUT is not NULL the output is
|
||
* written to that stream. Returns 0 if everything is OK. */
|
||
int
|
||
gc_component_check_options (int component, estream_t out, const char *conf_file)
|
||
{
|
||
gpg_error_t err;
|
||
unsigned int result;
|
||
const char *pgmname;
|
||
const char *argv[6];
|
||
int i;
|
||
pid_t pid;
|
||
int exitcode;
|
||
estream_t errfp;
|
||
error_line_t errlines;
|
||
|
||
log_assert (component >= 0 && component < GC_COMPONENT_NR);
|
||
|
||
if (!gc_component[component].program)
|
||
return 0;
|
||
if (!gc_component[component].module_name)
|
||
return 0;
|
||
|
||
pgmname = gnupg_module_name (gc_component[component].module_name);
|
||
i = 0;
|
||
if (!gnupg_default_homedir_p ()
|
||
&& component != GC_COMPONENT_PINENTRY)
|
||
{
|
||
argv[i++] = "--homedir";
|
||
argv[i++] = gnupg_homedir ();
|
||
}
|
||
if (conf_file)
|
||
{
|
||
argv[i++] = "--options";
|
||
argv[i++] = conf_file;
|
||
}
|
||
if (component == GC_COMPONENT_PINENTRY)
|
||
argv[i++] = "--version";
|
||
else
|
||
argv[i++] = "--gpgconf-test";
|
||
argv[i] = NULL;
|
||
log_assert (i < DIM(argv));
|
||
|
||
result = 0;
|
||
errlines = NULL;
|
||
err = gnupg_spawn_process (pgmname, argv, NULL, NULL, 0,
|
||
NULL, NULL, &errfp, &pid);
|
||
if (err)
|
||
result |= 1; /* Program could not be run. */
|
||
else
|
||
{
|
||
errlines = collect_error_output (errfp,
|
||
gc_component[component].name);
|
||
if (gnupg_wait_process (pgmname, pid, 1, &exitcode))
|
||
{
|
||
if (exitcode == -1)
|
||
result |= 1; /* Program could not be run or it
|
||
terminated abnormally. */
|
||
result |= 2; /* Program returned an error. */
|
||
}
|
||
gnupg_release_process (pid);
|
||
es_fclose (errfp);
|
||
}
|
||
|
||
/* If the program could not be run, we can't tell whether
|
||
the config file is good. */
|
||
if (result & 1)
|
||
result |= 2;
|
||
|
||
if (out)
|
||
{
|
||
const char *desc;
|
||
error_line_t errptr;
|
||
|
||
desc = gc_component[component].desc;
|
||
desc = my_dgettext (gc_component[component].desc_domain, desc);
|
||
es_fprintf (out, "%s:%s:",
|
||
gc_component[component].program, gc_percent_escape (desc));
|
||
es_fputs (gc_percent_escape (pgmname), out);
|
||
es_fprintf (out, ":%d:%d:", !(result & 1), !(result & 2));
|
||
for (errptr = errlines; errptr; errptr = errptr->next)
|
||
{
|
||
if (errptr != errlines)
|
||
es_fputs ("\n:::::", out); /* Continuation line. */
|
||
if (errptr->fname)
|
||
es_fputs (gc_percent_escape (errptr->fname), out);
|
||
es_putc (':', out);
|
||
if (errptr->fname)
|
||
es_fprintf (out, "%u", errptr->lineno);
|
||
es_putc (':', out);
|
||
es_fputs (gc_percent_escape (errptr->errtext), out);
|
||
es_putc (':', out);
|
||
}
|
||
es_putc ('\n', out);
|
||
}
|
||
|
||
while (errlines)
|
||
{
|
||
error_line_t tmp = errlines->next;
|
||
xfree (errlines);
|
||
errlines = tmp;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
|
||
/* Check all components that are available. */
|
||
void
|
||
gc_check_programs (estream_t out)
|
||
{
|
||
gc_component_id_t component;
|
||
|
||
for (component = 0; component < GC_COMPONENT_NR; component++)
|
||
gc_component_check_options (component, out, NULL);
|
||
}
|
||
|
||
|
||
|
||
/* Find the component with the name NAME. Returns -1 if not
|
||
found. */
|
||
int
|
||
gc_component_find (const char *name)
|
||
{
|
||
gc_component_id_t idx;
|
||
|
||
for (idx = 0; idx < GC_COMPONENT_NR; idx++)
|
||
{
|
||
if (gc_component[idx].program
|
||
&& !strcmp (name, gc_component[idx].program))
|
||
return idx;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
|
||
/* List the option OPTION. */
|
||
static void
|
||
list_one_option (gc_component_id_t component,
|
||
const gc_option_t *option, estream_t out)
|
||
{
|
||
const char *desc = NULL;
|
||
char *arg_name = NULL;
|
||
unsigned long flags;
|
||
const char *desc_domain = gc_component[component].desc_domain;
|
||
|
||
if (option->desc)
|
||
{
|
||
desc = my_dgettext (desc_domain, option->desc);
|
||
|
||
if (*desc == '|')
|
||
{
|
||
const char *arg_tail = strchr (&desc[1], '|');
|
||
|
||
if (arg_tail)
|
||
{
|
||
int arg_len = arg_tail - &desc[1];
|
||
arg_name = xmalloc (arg_len + 1);
|
||
memcpy (arg_name, &desc[1], arg_len);
|
||
arg_name[arg_len] = '\0';
|
||
desc = arg_tail + 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* YOU MUST NOT REORDER THE FIELDS IN THIS OUTPUT, AS THEIR ORDER IS
|
||
PART OF THE EXTERNAL INTERFACE. YOU MUST NOT REMOVE ANY
|
||
FIELDS. */
|
||
|
||
/* The name field. */
|
||
es_fprintf (out, "%s", option->name);
|
||
|
||
/* The flags field. */
|
||
flags = 0;
|
||
if (option->is_header) flags |= GC_OPT_FLAG_GROUP;
|
||
if (option->is_list) flags |= GC_OPT_FLAG_LIST;
|
||
if (option->runtime) flags |= GC_OPT_FLAG_RUNTIME;
|
||
if (option->has_default) flags |= GC_OPT_FLAG_DEFAULT;
|
||
if (option->def_in_desc) flags |= GC_OPT_FLAG_DEF_DESC;
|
||
if (option->no_arg_desc) flags |= GC_OPT_FLAG_NO_ARG_DESC;
|
||
if (option->no_change) flags |= GC_OPT_FLAG_NO_CHANGE;
|
||
es_fprintf (out, ":%lu", flags);
|
||
if (opt.verbose)
|
||
{
|
||
es_putc (' ', out);
|
||
|
||
if (!flags)
|
||
es_fprintf (out, "none");
|
||
else
|
||
{
|
||
unsigned long flag = 0;
|
||
unsigned long first = 1;
|
||
|
||
while (flags)
|
||
{
|
||
if (flags & 1)
|
||
{
|
||
if (first)
|
||
first = 0;
|
||
else
|
||
es_putc (',', out);
|
||
es_fprintf (out, "%s", gc_flag[flag].name);
|
||
}
|
||
flags >>= 1;
|
||
flag++;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* The level field. */
|
||
es_fprintf (out, ":%u", option->level);
|
||
if (opt.verbose)
|
||
es_fprintf (out, " %s", gc_level[option->level].name);
|
||
|
||
/* The description field. */
|
||
es_fprintf (out, ":%s", desc ? gc_percent_escape (desc) : "");
|
||
|
||
/* The type field. */
|
||
es_fprintf (out, ":%u", option->arg_type);
|
||
if (opt.verbose)
|
||
es_fprintf (out, " %s", gc_arg_type[option->arg_type].name);
|
||
|
||
/* The alternate type field. */
|
||
es_fprintf (out, ":%u", gc_arg_type[option->arg_type].fallback);
|
||
if (opt.verbose)
|
||
es_fprintf (out, " %s",
|
||
gc_arg_type[gc_arg_type[option->arg_type].fallback].name);
|
||
|
||
/* The argument name field. */
|
||
es_fprintf (out, ":%s", arg_name ? gc_percent_escape (arg_name) : "");
|
||
xfree (arg_name);
|
||
|
||
/* The default value field. */
|
||
es_fprintf (out, ":%s", option->default_value ? option->default_value : "");
|
||
|
||
/* The default argument field. This was never used and is thus empty. */
|
||
es_fprintf (out, ":");
|
||
|
||
/* The value field. */
|
||
if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
|
||
&& option->is_list && option->value)
|
||
{
|
||
/* The special format "1,1,1,1,...,1" is converted to a number
|
||
here. */
|
||
es_fprintf (out, ":%u", (unsigned int)((strlen (option->value) + 1) / 2));
|
||
}
|
||
else
|
||
es_fprintf (out, ":%s", option->value ? option->value : "");
|
||
|
||
/* ADD NEW FIELDS HERE. */
|
||
|
||
es_putc ('\n', out);
|
||
}
|
||
|
||
|
||
/* List all options of the component COMPONENT. */
|
||
void
|
||
gc_component_list_options (int component, estream_t out)
|
||
{
|
||
const gc_option_t *option = gc_component[component].options;
|
||
|
||
for ( ; option && option->name; option++)
|
||
{
|
||
/* Do not output unknown or internal options. */
|
||
if (!option->is_header
|
||
&& option->level == GC_LEVEL_INTERNAL)
|
||
continue;
|
||
|
||
if (option->is_header)
|
||
{
|
||
const gc_option_t *group_option = option + 1;
|
||
gc_expert_level_t level = GC_LEVEL_NR;
|
||
|
||
/* The manual states that the group level is always the
|
||
minimum of the levels of all contained options. Due to
|
||
different active options, and because it is hard to
|
||
maintain manually, we calculate it here. The value in
|
||
the global static table is ignored. */
|
||
|
||
for ( ; group_option->name; group_option++)
|
||
{
|
||
if (group_option->is_header)
|
||
break;
|
||
if (group_option->level < level)
|
||
level = group_option->level;
|
||
}
|
||
|
||
/* Check if group is empty. */
|
||
if (level != GC_LEVEL_NR)
|
||
{
|
||
gc_option_t opt_copy;
|
||
|
||
/* Fix up the group level. */
|
||
opt_copy = *option;
|
||
opt_copy.level = level;
|
||
list_one_option (component, &opt_copy, out);
|
||
}
|
||
}
|
||
else
|
||
list_one_option (component, option, out);
|
||
}
|
||
}
|
||
|
||
|
||
/* Return true if the option NAME is known and that we want it as
|
||
* gpgconf managed option. */
|
||
static known_option_t *
|
||
is_known_option (gc_component_id_t component, const char *name)
|
||
{
|
||
known_option_t *option = gc_component[component].known_options;
|
||
if (option)
|
||
{
|
||
for (; option->name; option++)
|
||
if (!strcmp (option->name, name))
|
||
break;
|
||
}
|
||
return (option && option->name)? option : NULL;
|
||
}
|
||
|
||
|
||
/* Find the option NAME in component COMPONENT. Returns pointer to
|
||
* the option descriptor or NULL if not found. */
|
||
static gc_option_t *
|
||
find_option (gc_component_id_t component, const char *name)
|
||
{
|
||
gc_option_t *option = gc_component[component].options;
|
||
|
||
if (option)
|
||
{
|
||
for (; option->name; option++)
|
||
{
|
||
if (!option->is_header
|
||
&& !strcmp (option->name, name))
|
||
return option;
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
|
||
|
||
|
||
struct read_line_wrapper_parm_s
|
||
{
|
||
const char *pgmname;
|
||
estream_t fp;
|
||
char *line;
|
||
size_t line_len;
|
||
const char **extra_lines;
|
||
int extra_lines_idx;
|
||
char *extra_line_buffer;
|
||
};
|
||
|
||
|
||
/* Helper for retrieve_options_from_program. */
|
||
static ssize_t
|
||
read_line_wrapper (struct read_line_wrapper_parm_s *parm)
|
||
{
|
||
ssize_t length;
|
||
const char *extra_line;
|
||
|
||
if (parm->fp)
|
||
{
|
||
length = es_read_line (parm->fp, &parm->line, &parm->line_len, NULL);
|
||
if (length > 0)
|
||
return length;
|
||
if (length < 0 || es_ferror (parm->fp))
|
||
gc_error (1, errno, "error reading from %s", parm->pgmname);
|
||
if (es_fclose (parm->fp))
|
||
gc_error (1, errno, "error closing %s", parm->pgmname);
|
||
/* EOF seen. */
|
||
parm->fp = NULL;
|
||
}
|
||
/* Return the made up lines. */
|
||
if (!parm->extra_lines
|
||
|| !(extra_line = parm->extra_lines[parm->extra_lines_idx]))
|
||
return -1; /* This is really the EOF. */
|
||
parm->extra_lines_idx++;
|
||
xfree (parm->extra_line_buffer);
|
||
parm->extra_line_buffer = xstrdup (extra_line);
|
||
return strlen (parm->extra_line_buffer);
|
||
}
|
||
|
||
/* Retrieve the options for the component COMPONENT. With
|
||
* ONLY_INSTALLED set components which are not installed are silently
|
||
* ignored. */
|
||
static void
|
||
retrieve_options_from_program (gc_component_id_t component, int only_installed)
|
||
{
|
||
gpg_error_t err;
|
||
const char *pgmname;
|
||
const char *argv[2];
|
||
estream_t outfp;
|
||
int exitcode;
|
||
pid_t pid;
|
||
known_option_t *known_option;
|
||
gc_option_t *option;
|
||
char *line = NULL;
|
||
size_t line_len;
|
||
ssize_t length;
|
||
const char *config_name;
|
||
gpgrt_argparse_t pargs;
|
||
int dummy_argc;
|
||
char *twopartconfig_name = NULL;
|
||
gpgrt_opt_t *opt_table = NULL; /* A malloced option table. */
|
||
size_t opt_table_used = 0; /* Its current length. */
|
||
size_t opt_table_size = 0; /* Its allocated length. */
|
||
gc_option_t *opt_info = NULL; /* A malloced options table. */
|
||
size_t opt_info_used = 0; /* Its current length. */
|
||
size_t opt_info_size = 0; /* Its allocated length. */
|
||
int i;
|
||
struct read_line_wrapper_parm_s read_line_parm;
|
||
int pseudo_count;
|
||
|
||
pgmname = (gc_component[component].module_name
|
||
? gnupg_module_name (gc_component[component].module_name)
|
||
: gc_component[component].program );
|
||
|
||
if (only_installed && gnupg_access (pgmname, X_OK))
|
||
{
|
||
return; /* The component is not installed. */
|
||
}
|
||
|
||
|
||
/* First we need to read the option table from the program. */
|
||
argv[0] = "--dump-option-table";
|
||
argv[1] = NULL;
|
||
err = gnupg_spawn_process (pgmname, argv, NULL, NULL, 0,
|
||
NULL, &outfp, NULL, &pid);
|
||
if (err)
|
||
{
|
||
gc_error (1, 0, "could not gather option table from '%s': %s",
|
||
pgmname, gpg_strerror (err));
|
||
}
|
||
|
||
read_line_parm.pgmname = pgmname;
|
||
read_line_parm.fp = outfp;
|
||
read_line_parm.line = line;
|
||
read_line_parm.line_len = line_len = 0;
|
||
read_line_parm.extra_line_buffer = NULL;
|
||
read_line_parm.extra_lines = gc_component[component].known_pseudo_options;
|
||
read_line_parm.extra_lines_idx = 0;
|
||
pseudo_count = 0;
|
||
while ((length = read_line_wrapper (&read_line_parm)) > 0)
|
||
{
|
||
const char *fields[4];
|
||
const char *optname, *optdesc;
|
||
unsigned int optflags;
|
||
int short_opt;
|
||
gc_arg_type_t arg_type;
|
||
int pseudo = 0;
|
||
|
||
|
||
if (read_line_parm.extra_line_buffer)
|
||
{
|
||
line = read_line_parm.extra_line_buffer;
|
||
pseudo = 1;
|
||
pseudo_count++;
|
||
}
|
||
else
|
||
line = read_line_parm.line;
|
||
|
||
/* Strip newline and carriage return, if present. */
|
||
while (length > 0
|
||
&& (line[length - 1] == '\n' || line[length - 1] == '\r'))
|
||
line[--length] = '\0';
|
||
|
||
if (split_fields_colon (line, fields, DIM (fields)) < 4)
|
||
{
|
||
gc_error (0,0, "WARNING: invalid line in option table of '%s'\n",
|
||
pgmname);
|
||
continue;
|
||
}
|
||
|
||
optname = fields[0];
|
||
short_opt = atoi (fields[1]);
|
||
if (short_opt < 1 && !pseudo)
|
||
{
|
||
gc_error (0,0, "WARNING: bad short option in option table of '%s'\n",
|
||
pgmname);
|
||
continue;
|
||
}
|
||
|
||
optflags = strtoul (fields[2], NULL, 10);
|
||
if ((optflags & ARGPARSE_OPT_HEADER))
|
||
known_option = NULL; /* We want all header-only options. */
|
||
else if ((known_option = is_known_option (component, optname)))
|
||
; /* Yes we want this one. */
|
||
else
|
||
continue; /* No need to store this option description. */
|
||
|
||
/* The +1 here is to make sure that we will have a zero item at
|
||
* the end of the table. */
|
||
if (opt_table_used + 1 >= opt_table_size)
|
||
{
|
||
/* Note that this also does the initial allocation. */
|
||
opt_table_size += 128;
|
||
opt_table = xreallocarray (opt_table,
|
||
opt_table_used,
|
||
opt_table_size,
|
||
sizeof *opt_table);
|
||
}
|
||
/* The +1 here is to make sure that we will have a zero item at
|
||
* the end of the table. */
|
||
if (opt_info_used + 1 >= opt_info_size)
|
||
{
|
||
/* Note that this also does the initial allocation. */
|
||
opt_info_size += 128;
|
||
opt_info = xreallocarray (opt_info,
|
||
opt_info_used,
|
||
opt_info_size,
|
||
sizeof *opt_info);
|
||
}
|
||
/* The +1 here accounts for the two items we are going to add to
|
||
* the global string table. */
|
||
if (string_array_used + 1 >= string_array_size)
|
||
{
|
||
string_array_size += 256;
|
||
string_array = xreallocarray (string_array,
|
||
string_array_used,
|
||
string_array_size,
|
||
sizeof *string_array);
|
||
}
|
||
optname = string_array[string_array_used++] = xstrdup (fields[0]);
|
||
optdesc = string_array[string_array_used++] = xstrdup (fields[3]);
|
||
|
||
/* Create an option table which can then be supplied to
|
||
* gpgrt_parser. Unfortunately there is no private pointer in
|
||
* the public option table struct so that we can't add extra
|
||
* data we need here. Thus we need to build up another table
|
||
* for such info and for ease of use we also copy the tehre the
|
||
* data from the option table. It is not possible to use the
|
||
* known_option_s for this because that one does not carry
|
||
* header lines and it might also be problematic to use such
|
||
* static tables for caching options and default values. */
|
||
if (!pseudo)
|
||
{
|
||
opt_table[opt_table_used].long_opt = optname;
|
||
opt_table[opt_table_used].short_opt = short_opt;
|
||
opt_table[opt_table_used].description = optdesc;
|
||
opt_table[opt_table_used].flags = optflags;
|
||
opt_table_used++;
|
||
}
|
||
|
||
/* Note that as per argparser specs the opt_table uses "@" to
|
||
* specifify an empty description. In the DESC script of
|
||
* options (opt_info_t) we want to have a real empty string. */
|
||
opt_info[opt_info_used].name = optname;
|
||
if (*optdesc == '@' && !optdesc[1])
|
||
opt_info[opt_info_used].desc = optdesc+1;
|
||
else
|
||
opt_info[opt_info_used].desc = optdesc;
|
||
|
||
/* Unfortunately we need to remap the types. */
|
||
switch ((optflags & ARGPARSE_TYPE_MASK))
|
||
{
|
||
case ARGPARSE_TYPE_INT: arg_type = GC_ARG_TYPE_INT32; break;
|
||
case ARGPARSE_TYPE_LONG: arg_type = GC_ARG_TYPE_INT32; break;
|
||
case ARGPARSE_TYPE_ULONG: arg_type = GC_ARG_TYPE_UINT32; break;
|
||
case ARGPARSE_TYPE_STRING: arg_type = GC_ARG_TYPE_STRING; break;
|
||
default: arg_type = GC_ARG_TYPE_NONE; break;
|
||
}
|
||
opt_info[opt_info_used].arg_type = arg_type;
|
||
if (pseudo) /* Pseudo options are always no_change. */
|
||
opt_info[opt_info_used].no_change = 1;
|
||
|
||
|
||
if ((optflags & ARGPARSE_OPT_HEADER))
|
||
opt_info[opt_info_used].is_header = 1;
|
||
if (known_option)
|
||
{
|
||
if ((known_option->flags & GC_OPT_FLAG_LIST))
|
||
opt_info[opt_info_used].is_list = 1;
|
||
/* FIXME: The next can also be taken from opt_table->flags.
|
||
* We need to check the code whether both specifications match. */
|
||
if ((known_option->flags & GC_OPT_FLAG_ARG_OPT))
|
||
opt_info[opt_info_used].opt_arg = 1;
|
||
|
||
if ((known_option->flags & GC_OPT_FLAG_RUNTIME))
|
||
opt_info[opt_info_used].runtime = 1;
|
||
|
||
opt_info[opt_info_used].level = known_option->level;
|
||
/* Override the received argtype by a complex type. */
|
||
if (known_option->arg_type)
|
||
opt_info[opt_info_used].arg_type = known_option->arg_type;
|
||
}
|
||
opt_info_used++;
|
||
}
|
||
xfree (read_line_parm.extra_line_buffer);
|
||
line = read_line_parm.line;
|
||
line_len = read_line_parm.line_len;
|
||
log_assert (opt_table_used + pseudo_count == opt_info_used);
|
||
|
||
|
||
err = gnupg_wait_process (pgmname, pid, 1, &exitcode);
|
||
if (err)
|
||
gc_error (1, 0, "running %s failed (exitcode=%d): %s",
|
||
pgmname, exitcode, gpg_strerror (err));
|
||
gnupg_release_process (pid);
|
||
|
||
/* Make the gpgrt option table and the internal option table available. */
|
||
gc_component[component].opt_table = opt_table;
|
||
gc_component[component].options = opt_info;
|
||
|
||
|
||
/* Now read the default options. */
|
||
argv[0] = "--gpgconf-list";
|
||
argv[1] = NULL;
|
||
err = gnupg_spawn_process (pgmname, argv, NULL, NULL, 0,
|
||
NULL, &outfp, NULL, &pid);
|
||
if (err)
|
||
{
|
||
gc_error (1, 0, "could not gather active options from '%s': %s",
|
||
pgmname, gpg_strerror (err));
|
||
}
|
||
|
||
while ((length = es_read_line (outfp, &line, &line_len, NULL)) > 0)
|
||
{
|
||
char *linep;
|
||
unsigned long flags = 0;
|
||
char *default_value = NULL;
|
||
|
||
/* Strip newline and carriage return, if present. */
|
||
while (length > 0
|
||
&& (line[length - 1] == '\n' || line[length - 1] == '\r'))
|
||
line[--length] = '\0';
|
||
|
||
linep = strchr (line, ':');
|
||
if (linep)
|
||
*(linep++) = '\0';
|
||
|
||
/* Extract additional flags. Default to none. */
|
||
if (linep)
|
||
{
|
||
char *end;
|
||
char *tail;
|
||
|
||
end = strchr (linep, ':');
|
||
if (end)
|
||
*(end++) = '\0';
|
||
|
||
gpg_err_set_errno (0);
|
||
flags = strtoul (linep, &tail, 0);
|
||
if (errno)
|
||
gc_error (1, errno, "malformed flags in option %s from %s",
|
||
line, pgmname);
|
||
if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
|
||
gc_error (1, 0, "garbage after flags in option %s from %s",
|
||
line, pgmname);
|
||
|
||
linep = end;
|
||
}
|
||
|
||
/* Extract default value, if present. Default to empty if
|
||
not. */
|
||
if (linep)
|
||
{
|
||
char *end;
|
||
|
||
end = strchr (linep, ':');
|
||
if (end)
|
||
*(end++) = '\0';
|
||
|
||
if ((flags & GC_OPT_FLAG_DEFAULT))
|
||
default_value = linep;
|
||
|
||
linep = end;
|
||
}
|
||
|
||
/* Look up the option in the component and install the
|
||
configuration data. */
|
||
option = find_option (component, line);
|
||
if (option)
|
||
{
|
||
if (option->gpgconf_list)
|
||
gc_error (1, errno,
|
||
"option %s returned twice from \"%s --gpgconf-list\"",
|
||
line, pgmname);
|
||
option->gpgconf_list = 1;
|
||
|
||
if ((flags & GC_OPT_FLAG_DEFAULT))
|
||
option->has_default = 1;
|
||
if ((flags & GC_OPT_FLAG_DEF_DESC))
|
||
option->def_in_desc = 1;
|
||
if ((flags & GC_OPT_FLAG_NO_ARG_DESC))
|
||
option->no_arg_desc = 1;
|
||
if ((flags & GC_OPT_FLAG_NO_CHANGE))
|
||
option->no_change = 1;
|
||
|
||
if (default_value && *default_value)
|
||
option->default_value = xstrdup (default_value);
|
||
}
|
||
}
|
||
if (length < 0 || es_ferror (outfp))
|
||
gc_error (1, errno, "error reading from %s", pgmname);
|
||
if (es_fclose (outfp))
|
||
gc_error (1, errno, "error closing %s", pgmname);
|
||
|
||
err = gnupg_wait_process (pgmname, pid, 1, &exitcode);
|
||
if (err)
|
||
gc_error (1, 0, "running %s failed (exitcode=%d): %s",
|
||
pgmname, exitcode, gpg_strerror (err));
|
||
gnupg_release_process (pid);
|
||
|
||
|
||
/* At this point, we can parse the configuration file. */
|
||
config_name = gc_component[component].option_config_filename;
|
||
if (!config_name)
|
||
gc_error (1, 0, "name of config file for %s is not known\n", pgmname);
|
||
|
||
if (!gnupg_default_homedir_p ())
|
||
{
|
||
/* This is not the default homedir. We need to take an absolute
|
||
* config name for the user config file; gpgrt_argparser
|
||
* fortunately supports this. */
|
||
char *tmp = make_filename (gnupg_homedir (), config_name, NULL);
|
||
twopartconfig_name = xstrconcat (config_name, PATHSEP_S, tmp, NULL);
|
||
xfree (tmp);
|
||
config_name = twopartconfig_name;
|
||
}
|
||
|
||
memset (&pargs, 0, sizeof pargs);
|
||
dummy_argc = 0;
|
||
pargs.argc = &dummy_argc;
|
||
pargs.flags = (ARGPARSE_FLAG_KEEP
|
||
| ARGPARSE_FLAG_SYS
|
||
| ARGPARSE_FLAG_USER
|
||
| ARGPARSE_FLAG_WITHATTR);
|
||
if (opt.verbose)
|
||
pargs.flags |= ARGPARSE_FLAG_VERBOSE;
|
||
|
||
while (gpgrt_argparser (&pargs, opt_table, config_name))
|
||
{
|
||
char *opt_value;
|
||
|
||
if (pargs.r_type & ARGPARSE_OPT_IGNORE)
|
||
{
|
||
/* log_debug ("ignored\n"); */
|
||
continue;
|
||
}
|
||
if (pargs.r_opt == ARGPARSE_CONFFILE)
|
||
{
|
||
/* log_debug ("current conffile='%s'\n", */
|
||
/* pargs.r_type? pargs.r.ret_str: "[cmdline]"); */
|
||
continue;
|
||
}
|
||
|
||
/* We only have the short option. Search in the option table
|
||
* for the long option name. */
|
||
for (i=0; opt_table[i].short_opt; i++)
|
||
if (opt_table[i].short_opt == pargs.r_opt)
|
||
break;
|
||
if (!opt_table[i].short_opt || !opt_table[i].long_opt)
|
||
continue; /* No or only a short option - ignore. */
|
||
|
||
/* Look up the option from the config file in our list of
|
||
* supported options. */
|
||
option= find_option (component, opt_table[i].long_opt);
|
||
if (!option)
|
||
continue; /* We don't want to handle this option. */
|
||
|
||
option->attr_ignore = !!(pargs.r_type & ARGPARSE_ATTR_IGNORE);
|
||
option->attr_force = !!(pargs.r_type & ARGPARSE_ATTR_FORCE);
|
||
|
||
switch ((pargs.r_type & ARGPARSE_TYPE_MASK))
|
||
{
|
||
case ARGPARSE_TYPE_INT:
|
||
opt_value = xasprintf ("%d", pargs.r.ret_int);
|
||
break;
|
||
case ARGPARSE_TYPE_LONG:
|
||
opt_value = xasprintf ("%ld", pargs.r.ret_long);
|
||
break;
|
||
case ARGPARSE_TYPE_ULONG:
|
||
opt_value = xasprintf ("%lu", pargs.r.ret_ulong);
|
||
break;
|
||
case ARGPARSE_TYPE_STRING:
|
||
opt_value = xasprintf ("\"%s", gc_percent_escape (pargs.r.ret_str));
|
||
break;
|
||
default: /* ARGPARSE_TYPE_NONE or any unknown type. */
|
||
opt_value = xstrdup ("1"); /* Make sure we have some value. */
|
||
break;
|
||
}
|
||
|
||
/* Now enter the value read from the config file into the table. */
|
||
if (!option->is_list)
|
||
{
|
||
xfree (option->value);
|
||
option->value = opt_value;
|
||
}
|
||
else if (!option->value) /* LIST but first item. */
|
||
option->value = opt_value;
|
||
else
|
||
{
|
||
char *old = option->value;
|
||
option->value = xstrconcat (old, ",", opt_value, NULL);
|
||
xfree (old);
|
||
xfree (opt_value);
|
||
}
|
||
}
|
||
|
||
xfree (line);
|
||
xfree (twopartconfig_name);
|
||
}
|
||
|
||
|
||
|
||
/* Retrieve the currently active options and their defaults for this
|
||
component. Using -1 for component will retrieve all options from
|
||
all installed components. */
|
||
void
|
||
gc_component_retrieve_options (int component)
|
||
{
|
||
int process_all = 0;
|
||
|
||
if (component == -1)
|
||
{
|
||
process_all = 1;
|
||
component = 0;
|
||
}
|
||
|
||
do
|
||
{
|
||
if (component == GC_COMPONENT_PINENTRY)
|
||
continue; /* Skip this dummy component. */
|
||
|
||
if (gc_component[component].program)
|
||
retrieve_options_from_program (component, process_all);
|
||
}
|
||
while (process_all && ++component < GC_COMPONENT_NR);
|
||
|
||
}
|
||
|
||
|
||
|
||
/* Perform a simple validity check based on the type. Return in
|
||
* NEW_VALUE_NR the value of the number in NEW_VALUE if OPTION is of
|
||
* type GC_ARG_TYPE_NONE. If VERBATIM is set the profile parsing mode
|
||
* is used. */
|
||
static void
|
||
option_check_validity (gc_component_id_t component,
|
||
gc_option_t *option, unsigned long flags,
|
||
char *new_value, unsigned long *new_value_nr,
|
||
int verbatim)
|
||
{
|
||
char *arg;
|
||
|
||
(void)component;
|
||
|
||
if (option->new_flags || option->new_value)
|
||
gc_error (1, 0, "option %s already changed", option->name);
|
||
|
||
if (flags & GC_OPT_FLAG_DEFAULT)
|
||
{
|
||
if (*new_value)
|
||
gc_error (1, 0, "argument %s provided for deleted option %s",
|
||
new_value, option->name);
|
||
|
||
return;
|
||
}
|
||
|
||
/* GC_ARG_TYPE_NONE options have special list treatment. */
|
||
if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE)
|
||
{
|
||
char *tail;
|
||
|
||
gpg_err_set_errno (0);
|
||
*new_value_nr = strtoul (new_value, &tail, 0);
|
||
|
||
if (errno)
|
||
gc_error (1, errno, "invalid argument for option %s",
|
||
option->name);
|
||
if (*tail)
|
||
gc_error (1, 0, "garbage after argument for option %s",
|
||
option->name);
|
||
|
||
if (!option->is_list)
|
||
{
|
||
if (*new_value_nr != 1)
|
||
gc_error (1, 0, "argument for non-list option %s of type 0 "
|
||
"(none) must be 1", option->name);
|
||
}
|
||
else
|
||
{
|
||
if (*new_value_nr == 0)
|
||
gc_error (1, 0, "argument for option %s of type 0 (none) "
|
||
"must be positive", option->name);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
arg = new_value;
|
||
do
|
||
{
|
||
if (*arg == '\0' || (*arg == ',' && !verbatim))
|
||
{
|
||
if (!option->opt_arg)
|
||
gc_error (1, 0, "argument required for option %s", option->name);
|
||
|
||
if (*arg == ',' && !verbatim && !option->is_list)
|
||
gc_error (1, 0, "list found for non-list option %s", option->name);
|
||
}
|
||
else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_STRING)
|
||
{
|
||
if (*arg != '"' && !verbatim)
|
||
gc_error (1, 0, "string argument for option %s must begin "
|
||
"with a quote (\") character", option->name);
|
||
|
||
/* FIXME: We do not allow empty string arguments for now, as
|
||
we do not quote arguments in configuration files, and
|
||
thus no argument is indistinguishable from the empty
|
||
string. */
|
||
if (arg[1] == '\0' || (arg[1] == ',' && !verbatim))
|
||
gc_error (1, 0, "empty string argument for option %s is "
|
||
"currently not allowed. Please report this!",
|
||
option->name);
|
||
}
|
||
else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_INT32)
|
||
{
|
||
long res;
|
||
|
||
gpg_err_set_errno (0);
|
||
res = strtol (arg, &arg, 0);
|
||
(void) res;
|
||
|
||
if (errno)
|
||
gc_error (1, errno, "invalid argument for option %s",
|
||
option->name);
|
||
|
||
if (*arg != '\0' && (*arg != ',' || verbatim))
|
||
gc_error (1, 0, "garbage after argument for option %s",
|
||
option->name);
|
||
}
|
||
else if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_UINT32)
|
||
{
|
||
unsigned long res;
|
||
|
||
gpg_err_set_errno (0);
|
||
res = strtoul (arg, &arg, 0);
|
||
(void) res;
|
||
|
||
if (errno)
|
||
gc_error (1, errno, "invalid argument for option %s",
|
||
option->name);
|
||
|
||
if (*arg != '\0' && (*arg != ',' || verbatim))
|
||
gc_error (1, 0, "garbage after argument for option %s",
|
||
option->name);
|
||
}
|
||
arg = verbatim? strchr (arg, ',') : NULL;
|
||
if (arg)
|
||
arg++;
|
||
}
|
||
while (arg && *arg);
|
||
}
|
||
|
||
#ifdef HAVE_W32_SYSTEM
|
||
int
|
||
copy_file (const char *src_name, const char *dst_name)
|
||
{
|
||
#define BUF_LEN 4096
|
||
char buffer[BUF_LEN];
|
||
int len;
|
||
gpgrt_stream_t src;
|
||
gpgrt_stream_t dst;
|
||
|
||
src = gpgrt_fopen (src_name, "r");
|
||
if (src == NULL)
|
||
return -1;
|
||
|
||
dst = gpgrt_fopen (dst_name, "w");
|
||
if (dst == NULL)
|
||
{
|
||
int saved_err = errno;
|
||
gpgrt_fclose (src);
|
||
gpg_err_set_errno (saved_err);
|
||
return -1;
|
||
}
|
||
|
||
do
|
||
{
|
||
int written;
|
||
|
||
len = gpgrt_fread (buffer, 1, BUF_LEN, src);
|
||
if (len == 0)
|
||
break;
|
||
written = gpgrt_fwrite (buffer, 1, len, dst);
|
||
if (written != len)
|
||
break;
|
||
}
|
||
while (! gpgrt_feof (src) && ! gpgrt_ferror (src) && ! gpgrt_ferror (dst));
|
||
|
||
if (gpgrt_ferror (src) || gpgrt_ferror (dst) || ! gpgrt_feof (src))
|
||
{
|
||
int saved_errno = errno;
|
||
gpgrt_fclose (src);
|
||
gpgrt_fclose (dst);
|
||
unlink (dst_name);
|
||
gpg_err_set_errno (saved_errno);
|
||
return -1;
|
||
}
|
||
|
||
if (gpgrt_fclose (dst))
|
||
gc_error (1, errno, "error closing %s", dst_name);
|
||
if (gpgrt_fclose (src))
|
||
gc_error (1, errno, "error closing %s", src_name);
|
||
|
||
return 0;
|
||
}
|
||
#endif /* HAVE_W32_SYSTEM */
|
||
|
||
|
||
/* Create and verify the new configuration file for the specified
|
||
* component. Returns 0 on success and -1 on error. If
|
||
* VERBATIM is set the profile mode is used. This function may store
|
||
* pointers to malloced strings in SRC_FILENAMEP, DEST_FILENAMEP, and
|
||
* ORIG_FILENAMEP. Those must be freed by the caller. The strings
|
||
* refer to three versions of the configuration file:
|
||
*
|
||
* SRC_FILENAME: The updated configuration is written to this file.
|
||
* DEST_FILENAME: Name of the configuration file read by the
|
||
* component.
|
||
* ORIG_FILENAME: A backup of the previous configuration file.
|
||
*
|
||
* To apply the configuration change, rename SRC_FILENAME to
|
||
* DEST_FILENAME. To revert to the previous configuration, rename
|
||
* ORIG_FILENAME to DEST_FILENAME. */
|
||
static int
|
||
change_options_program (gc_component_id_t component,
|
||
char **src_filenamep, char **dest_filenamep,
|
||
char **orig_filenamep,
|
||
int verbatim)
|
||
{
|
||
static const char marker[] = "###+++--- " GPGCONF_DISP_NAME " ---+++###";
|
||
/* True if we are within the marker in the config file. */
|
||
int in_marker = 0;
|
||
gc_option_t *option;
|
||
char *line = NULL;
|
||
size_t line_len;
|
||
ssize_t length;
|
||
int res;
|
||
int fd;
|
||
gpgrt_stream_t src_file = NULL;
|
||
gpgrt_stream_t dest_file = NULL;
|
||
char *src_filename;
|
||
char *dest_filename;
|
||
char *orig_filename;
|
||
/* Special hack for gpg, see below. */
|
||
int utf8strings_seen = 0;
|
||
|
||
|
||
/* FIXME. Throughout the function, do better error reporting. */
|
||
if (!gc_component[component].option_config_filename)
|
||
gc_error (1, 0, "name of config file for %s is not known\n",
|
||
gc_component[component].name);
|
||
|
||
dest_filename = make_absfilename
|
||
(gnupg_homedir (), gc_component[component].option_config_filename, NULL);
|
||
src_filename = xasprintf ("%s.%s.%i.new",
|
||
dest_filename, GPGCONF_NAME, (int)getpid ());
|
||
orig_filename = xasprintf ("%s.%s.%i.bak",
|
||
dest_filename, GPGCONF_NAME, (int)getpid ());
|
||
|
||
#ifdef HAVE_W32_SYSTEM
|
||
res = copy_file (dest_filename, orig_filename);
|
||
#else
|
||
res = link (dest_filename, orig_filename);
|
||
#endif
|
||
if (res < 0 && errno != ENOENT)
|
||
{
|
||
xfree (dest_filename);
|
||
xfree (src_filename);
|
||
xfree (orig_filename);
|
||
return -1;
|
||
}
|
||
if (res < 0)
|
||
{
|
||
xfree (orig_filename);
|
||
orig_filename = NULL;
|
||
}
|
||
|
||
/* We now initialize the return strings, so the caller can do the
|
||
cleanup for us. */
|
||
*src_filenamep = src_filename;
|
||
*dest_filenamep = dest_filename;
|
||
*orig_filenamep = orig_filename;
|
||
|
||
/* Use open() so that we can use O_EXCL.
|
||
* FIXME: gpgrt has an x flag for quite some time now - use that. */
|
||
fd = gnupg_open (src_filename, O_CREAT | O_EXCL | O_WRONLY, 0644);
|
||
if (fd < 0)
|
||
return -1;
|
||
src_file = gpgrt_fdopen (fd, "w");
|
||
res = errno;
|
||
if (!src_file)
|
||
{
|
||
gpg_err_set_errno (res);
|
||
return -1;
|
||
}
|
||
|
||
/* Only if ORIG_FILENAME is not NULL did the configuration file
|
||
exist already. In this case, we will copy its content into the
|
||
new configuration file, changing it to our liking in the
|
||
process. */
|
||
if (orig_filename)
|
||
{
|
||
dest_file = gpgrt_fopen (dest_filename, "r");
|
||
if (!dest_file)
|
||
goto change_one_err;
|
||
|
||
while ((length = gpgrt_read_line (dest_file, &line, &line_len, NULL)) > 0)
|
||
{
|
||
int disable = 0;
|
||
char *start;
|
||
|
||
if (!strncmp (marker, line, sizeof (marker) - 1))
|
||
{
|
||
if (!in_marker)
|
||
in_marker = 1;
|
||
else
|
||
break;
|
||
}
|
||
else if (component == GC_COMPONENT_GPG && in_marker
|
||
&& ! strcmp ("utf8-strings\n", line))
|
||
{
|
||
/* Strip duplicated entries. */
|
||
if (utf8strings_seen)
|
||
disable = 1;
|
||
else
|
||
utf8strings_seen = 1;
|
||
}
|
||
|
||
start = line;
|
||
while (*start == ' ' || *start == '\t')
|
||
start++;
|
||
if (*start && *start != '\r' && *start != '\n' && *start != '#')
|
||
{
|
||
char *end;
|
||
char saved_end;
|
||
|
||
end = start;
|
||
while (*end && *end != ' ' && *end != '\t'
|
||
&& *end != '\r' && *end != '\n' && *end != '#')
|
||
end++;
|
||
saved_end = *end;
|
||
*end = '\0';
|
||
|
||
option = find_option (component, start);
|
||
*end = saved_end;
|
||
if (option && ((option->new_flags & GC_OPT_FLAG_DEFAULT)
|
||
|| option->new_value))
|
||
disable = 1;
|
||
}
|
||
if (disable)
|
||
{
|
||
if (!in_marker)
|
||
{
|
||
gpgrt_fprintf (src_file,
|
||
"# %s disabled this option here at %s\n",
|
||
GPGCONF_DISP_NAME, asctimestamp (gnupg_get_time ()));
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
gpgrt_fprintf (src_file, "# %s", line);
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
gpgrt_fprintf (src_file, "%s", line);
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
}
|
||
}
|
||
if (length < 0 || gpgrt_ferror (dest_file))
|
||
goto change_one_err;
|
||
}
|
||
|
||
if (!in_marker)
|
||
{
|
||
/* There was no marker. This is the first time we edit the
|
||
file. We add our own marker at the end of the file and
|
||
proceed. Note that we first write a newline, this guards us
|
||
against files which lack the newline at the end of the last
|
||
line, while it doesn't hurt us in all other cases. */
|
||
gpgrt_fprintf (src_file, "\n%s\n", marker);
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
}
|
||
/* At this point, we have copied everything up to the end marker
|
||
into the new file, except for the options we are going to change.
|
||
Now, dump the changed options (except for those we are going to
|
||
revert to their default), and write the end marker, possibly
|
||
followed by the rest of the original file. */
|
||
|
||
/* We have to turn on UTF8 strings for GnuPG. */
|
||
if (component == GC_COMPONENT_GPG && ! utf8strings_seen)
|
||
gpgrt_fprintf (src_file, "utf8-strings\n");
|
||
|
||
option = gc_component[component].options;
|
||
for ( ; option->name; option++)
|
||
{
|
||
if (!option->is_header && option->new_value)
|
||
{
|
||
char *arg = option->new_value;
|
||
|
||
do
|
||
{
|
||
if (*arg == '\0' || *arg == ',')
|
||
{
|
||
gpgrt_fprintf (src_file, "%s\n", option->name);
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
}
|
||
else if (gc_arg_type[option->arg_type].fallback
|
||
== GC_ARG_TYPE_NONE)
|
||
{
|
||
log_assert (*arg == '1');
|
||
gpgrt_fprintf (src_file, "%s\n", option->name);
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
|
||
arg++;
|
||
}
|
||
else if (gc_arg_type[option->arg_type].fallback
|
||
== GC_ARG_TYPE_STRING)
|
||
{
|
||
char *end;
|
||
|
||
if (!verbatim)
|
||
{
|
||
log_assert (*arg == '"');
|
||
arg++;
|
||
|
||
end = strchr (arg, ',');
|
||
if (end)
|
||
*end = '\0';
|
||
}
|
||
else
|
||
end = NULL;
|
||
|
||
gpgrt_fprintf (src_file, "%s %s\n", option->name,
|
||
verbatim? arg : percent_deescape (arg));
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
|
||
if (end)
|
||
*end = ',';
|
||
arg = end;
|
||
}
|
||
else
|
||
{
|
||
char *end;
|
||
|
||
end = strchr (arg, ',');
|
||
if (end)
|
||
*end = '\0';
|
||
|
||
gpgrt_fprintf (src_file, "%s %s\n", option->name, arg);
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
|
||
if (end)
|
||
*end = ',';
|
||
arg = end;
|
||
}
|
||
|
||
log_assert (arg == NULL || *arg == '\0' || *arg == ',');
|
||
if (arg && *arg == ',')
|
||
arg++;
|
||
}
|
||
while (arg && *arg);
|
||
}
|
||
}
|
||
|
||
gpgrt_fprintf (src_file, "%s %s\n", marker, asctimestamp (gnupg_get_time ()));
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
|
||
if (!in_marker)
|
||
{
|
||
gpgrt_fprintf (src_file, "# %s edited this configuration file.\n",
|
||
GPGCONF_DISP_NAME);
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
gpgrt_fprintf (src_file, "# It will disable options before this marked "
|
||
"block, but it will\n");
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
gpgrt_fprintf (src_file, "# never change anything below these lines.\n");
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
}
|
||
if (dest_file)
|
||
{
|
||
while ((length = gpgrt_read_line (dest_file, &line, &line_len, NULL)) > 0)
|
||
{
|
||
gpgrt_fprintf (src_file, "%s", line);
|
||
if (gpgrt_ferror (src_file))
|
||
goto change_one_err;
|
||
}
|
||
if (length < 0 || gpgrt_ferror (dest_file))
|
||
goto change_one_err;
|
||
}
|
||
xfree (line);
|
||
line = NULL;
|
||
|
||
res = gpgrt_fclose (src_file);
|
||
if (res)
|
||
{
|
||
res = errno;
|
||
close (fd);
|
||
if (dest_file)
|
||
gpgrt_fclose (dest_file);
|
||
gpg_err_set_errno (res);
|
||
return -1;
|
||
}
|
||
close (fd);
|
||
if (dest_file)
|
||
{
|
||
res = gpgrt_fclose (dest_file);
|
||
if (res)
|
||
return -1;
|
||
}
|
||
return 0;
|
||
|
||
change_one_err:
|
||
xfree (line);
|
||
res = errno;
|
||
if (src_file)
|
||
{
|
||
gpgrt_fclose (src_file);
|
||
close (fd);
|
||
}
|
||
if (dest_file)
|
||
gpgrt_fclose (dest_file);
|
||
gpg_err_set_errno (res);
|
||
return -1;
|
||
}
|
||
|
||
|
||
/* Common code for gc_component_change_options and
|
||
* gc_process_gpgconf_conf. If VERBATIM is set the profile parsing
|
||
* mode is used. */
|
||
static void
|
||
change_one_value (gc_component_id_t component,
|
||
gc_option_t *option, int *r_runtime,
|
||
unsigned long flags, char *new_value, int verbatim)
|
||
{
|
||
unsigned long new_value_nr = 0;
|
||
|
||
option_check_validity (component, option,
|
||
flags, new_value, &new_value_nr, verbatim);
|
||
|
||
if (option->runtime)
|
||
*r_runtime = 1;
|
||
|
||
option->new_flags = flags;
|
||
if (!(flags & GC_OPT_FLAG_DEFAULT))
|
||
{
|
||
if (gc_arg_type[option->arg_type].fallback == GC_ARG_TYPE_NONE
|
||
&& option->is_list)
|
||
{
|
||
char *str;
|
||
|
||
/* We convert the number to a list of 1's for convenient
|
||
list handling. */
|
||
log_assert (new_value_nr > 0);
|
||
option->new_value = xmalloc ((2 * (new_value_nr - 1) + 1) + 1);
|
||
str = option->new_value;
|
||
*(str++) = '1';
|
||
while (--new_value_nr > 0)
|
||
{
|
||
*(str++) = ',';
|
||
*(str++) = '1';
|
||
}
|
||
*(str++) = '\0';
|
||
}
|
||
else
|
||
option->new_value = xstrdup (new_value);
|
||
}
|
||
}
|
||
|
||
|
||
/* Read the modifications from IN and apply them. If IN is NULL the
|
||
modifications are expected to already have been set to the global
|
||
table. If VERBATIM is set the profile mode is used. */
|
||
void
|
||
gc_component_change_options (int component, estream_t in, estream_t out,
|
||
int verbatim)
|
||
{
|
||
int err = 0;
|
||
int block = 0;
|
||
int runtime = 0;
|
||
char *src_filename = NULL;
|
||
char *dest_filename = NULL;
|
||
char *orig_filename = NULL;
|
||
gc_option_t *option;
|
||
char *line = NULL;
|
||
size_t line_len = 0;
|
||
ssize_t length;
|
||
|
||
if (component == GC_COMPONENT_PINENTRY)
|
||
return; /* Dummy component for now. */
|
||
|
||
if (in)
|
||
{
|
||
/* Read options from the file IN. */
|
||
while ((length = es_read_line (in, &line, &line_len, NULL)) > 0)
|
||
{
|
||
char *linep;
|
||
unsigned long flags = 0;
|
||
char *new_value = "";
|
||
|
||
/* Strip newline and carriage return, if present. */
|
||
while (length > 0
|
||
&& (line[length - 1] == '\n' || line[length - 1] == '\r'))
|
||
line[--length] = '\0';
|
||
|
||
linep = strchr (line, ':');
|
||
if (linep)
|
||
*(linep++) = '\0';
|
||
|
||
/* Extract additional flags. Default to none. */
|
||
if (linep)
|
||
{
|
||
char *end;
|
||
char *tail;
|
||
|
||
end = strchr (linep, ':');
|
||
if (end)
|
||
*(end++) = '\0';
|
||
|
||
gpg_err_set_errno (0);
|
||
flags = strtoul (linep, &tail, 0);
|
||
if (errno)
|
||
gc_error (1, errno, "malformed flags in option %s", line);
|
||
if (!(*tail == '\0' || *tail == ':' || *tail == ' '))
|
||
gc_error (1, 0, "garbage after flags in option %s", line);
|
||
|
||
linep = end;
|
||
}
|
||
|
||
/* Don't allow setting of the no change flag. */
|
||
flags &= ~GC_OPT_FLAG_NO_CHANGE;
|
||
|
||
/* Extract default value, if present. Default to empty if not. */
|
||
if (linep)
|
||
{
|
||
char *end;
|
||
end = strchr (linep, ':');
|
||
if (end)
|
||
*(end++) = '\0';
|
||
new_value = linep;
|
||
linep = end;
|
||
}
|
||
|
||
option = find_option (component, line);
|
||
if (!option)
|
||
gc_error (1, 0, "unknown option %s", line);
|
||
|
||
if (option->no_change)
|
||
{
|
||
gc_error (0, 0, "ignoring new value for option %s",
|
||
option->name);
|
||
continue;
|
||
}
|
||
|
||
change_one_value (component, option, &runtime, flags, new_value, 0);
|
||
}
|
||
if (length < 0 || gpgrt_ferror (in))
|
||
gc_error (1, errno, "error reading stream 'in'");
|
||
}
|
||
|
||
/* Now that we have collected and locally verified the changes,
|
||
write them out to new configuration files, verify them
|
||
externally, and then commit them. */
|
||
option = gc_component[component].options;
|
||
while (option && option->name)
|
||
{
|
||
/* Go on if there is nothing to do. */
|
||
if (src_filename || !(option->new_flags || option->new_value))
|
||
{
|
||
option++;
|
||
continue;
|
||
}
|
||
|
||
if (gc_component[component].program)
|
||
{
|
||
err = change_options_program (component,
|
||
&src_filename,
|
||
&dest_filename,
|
||
&orig_filename,
|
||
verbatim);
|
||
if (! err)
|
||
{
|
||
/* External verification. */
|
||
err = gc_component_check_options (component, out, src_filename);
|
||
if (err)
|
||
{
|
||
gc_error (0, 0,
|
||
_("External verification of component %s failed"),
|
||
gc_component[component].name);
|
||
gpg_err_set_errno (EINVAL);
|
||
}
|
||
}
|
||
|
||
}
|
||
if (err)
|
||
break;
|
||
|
||
option++;
|
||
}
|
||
|
||
/* We are trying to atomically commit all changes. Unfortunately,
|
||
we cannot rely on gnupg_rename_file to manage the signals for us,
|
||
doing so would require us to pass NULL as BLOCK to any subsequent
|
||
call to it. Instead, we just manage the signal handling
|
||
manually. */
|
||
block = 1;
|
||
gnupg_block_all_signals ();
|
||
|
||
if (!err && !opt.dry_run)
|
||
{
|
||
if (src_filename)
|
||
{
|
||
/* FIXME: Make a verification here. */
|
||
|
||
log_assert (dest_filename);
|
||
|
||
if (orig_filename)
|
||
err = gnupg_rename_file (src_filename, dest_filename, NULL);
|
||
else
|
||
{
|
||
#ifdef HAVE_W32_SYSTEM
|
||
/* We skip the unlink if we expect the file not to be
|
||
* there. */
|
||
err = gnupg_rename_file (src_filename, dest_filename, NULL);
|
||
#else /* HAVE_W32_SYSTEM */
|
||
/* This is a bit safer than rename() because we expect
|
||
* DEST_FILENAME not to be there. If it happens to be
|
||
* there, this will fail. */
|
||
err = link (src_filename, dest_filename);
|
||
if (!err)
|
||
err = unlink (src_filename);
|
||
#endif /* !HAVE_W32_SYSTEM */
|
||
}
|
||
if (!err)
|
||
{
|
||
xfree (src_filename);
|
||
src_filename = NULL;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (err || opt.dry_run)
|
||
{
|
||
int saved_errno = errno;
|
||
|
||
/* An error occurred or a dry-run is requested. */
|
||
if (src_filename)
|
||
{
|
||
/* The change was not yet committed. */
|
||
unlink (src_filename);
|
||
if (orig_filename)
|
||
unlink (orig_filename);
|
||
}
|
||
else
|
||
{
|
||
/* The changes were already committed. FIXME: This is a tad
|
||
dangerous, as we don't know if we don't overwrite a
|
||
version of the file that is even newer than the one we
|
||
just installed. */
|
||
if (orig_filename)
|
||
gnupg_rename_file (orig_filename, dest_filename, NULL);
|
||
else
|
||
unlink (dest_filename);
|
||
}
|
||
if (err)
|
||
gc_error (1, saved_errno, "could not commit changes");
|
||
|
||
/* Fall-through for dry run. */
|
||
goto leave;
|
||
}
|
||
|
||
/* If it all worked, notify the daemons of the changes. */
|
||
if (opt.runtime)
|
||
do_runtime_change (component, 0);
|
||
|
||
|
||
/* Move the per-process backup file into its place. */
|
||
if (orig_filename)
|
||
{
|
||
char *backup_filename;
|
||
|
||
log_assert (dest_filename);
|
||
|
||
backup_filename = xasprintf ("%s.%s.bak",
|
||
dest_filename, GPGCONF_NAME);
|
||
gnupg_rename_file (orig_filename, backup_filename, NULL);
|
||
xfree (backup_filename);
|
||
}
|
||
|
||
leave:
|
||
if (block)
|
||
gnupg_unblock_all_signals ();
|
||
xfree (line);
|
||
xfree (src_filename);
|
||
xfree (dest_filename);
|
||
xfree (orig_filename);
|
||
}
|
||
|
||
|
||
/* Check whether USER matches the current user or one of its group.
|
||
This function may change USER. Returns true is there is a
|
||
match. */
|
||
static int
|
||
key_matches_user_or_group (char *user)
|
||
{
|
||
char *group;
|
||
|
||
if (*user == '*' && user[1] == 0)
|
||
return 1; /* A single asterisk matches all users. */
|
||
|
||
group = strchr (user, ':');
|
||
if (group)
|
||
*group++ = 0;
|
||
|
||
#ifdef HAVE_W32_SYSTEM
|
||
/* Under Windows we don't support groups. */
|
||
if (group && *group)
|
||
gc_error (0, 0, _("Note that group specifications are ignored\n"));
|
||
#ifndef HAVE_W32CE_SYSTEM
|
||
if (*user)
|
||
{
|
||
static char *my_name;
|
||
|
||
if (!my_name)
|
||
{
|
||
char tmp[1];
|
||
DWORD size = 1;
|
||
|
||
GetUserNameA (tmp, &size);
|
||
my_name = xmalloc (size);
|
||
if (!GetUserNameA (my_name, &size))
|
||
gc_error (1,0, "error getting current user name: %s",
|
||
w32_strerror (-1));
|
||
}
|
||
|
||
if (!strcmp (user, my_name))
|
||
return 1; /* Found. */
|
||
}
|
||
#endif /*HAVE_W32CE_SYSTEM*/
|
||
#else /*!HAVE_W32_SYSTEM*/
|
||
/* First check whether the user matches. */
|
||
if (*user)
|
||
{
|
||
static char *my_name;
|
||
|
||
if (!my_name)
|
||
{
|
||
struct passwd *pw = getpwuid ( getuid () );
|
||
if (!pw)
|
||
gc_error (1, errno, "getpwuid failed for current user");
|
||
my_name = xstrdup (pw->pw_name);
|
||
}
|
||
if (!strcmp (user, my_name))
|
||
return 1; /* Found. */
|
||
}
|
||
|
||
/* If that failed, check whether a group matches. */
|
||
if (group && *group)
|
||
{
|
||
static char *my_group;
|
||
static char **my_supgroups;
|
||
int n;
|
||
|
||
if (!my_group)
|
||
{
|
||
struct group *gr = getgrgid ( getgid () );
|
||
if (!gr)
|
||
gc_error (1, errno, "getgrgid failed for current user");
|
||
my_group = xstrdup (gr->gr_name);
|
||
}
|
||
if (!strcmp (group, my_group))
|
||
return 1; /* Found. */
|
||
|
||
if (!my_supgroups)
|
||
{
|
||
int ngids;
|
||
gid_t *gids;
|
||
|
||
ngids = getgroups (0, NULL);
|
||
gids = xcalloc (ngids+1, sizeof *gids);
|
||
ngids = getgroups (ngids, gids);
|
||
if (ngids < 0)
|
||
gc_error (1, errno, "getgroups failed for current user");
|
||
my_supgroups = xcalloc (ngids+1, sizeof *my_supgroups);
|
||
for (n=0; n < ngids; n++)
|
||
{
|
||
struct group *gr = getgrgid ( gids[n] );
|
||
if (!gr)
|
||
gc_error (1, errno, "getgrgid failed for supplementary group");
|
||
my_supgroups[n] = xstrdup (gr->gr_name);
|
||
}
|
||
xfree (gids);
|
||
}
|
||
|
||
for (n=0; my_supgroups[n]; n++)
|
||
if (!strcmp (group, my_supgroups[n]))
|
||
return 1; /* Found. */
|
||
}
|
||
#endif /*!HAVE_W32_SYSTEM*/
|
||
return 0; /* No match. */
|
||
}
|
||
|
||
|
||
|
||
/* Read and process the global configuration file for gpgconf. This
|
||
optional file is used to update our internal tables at runtime and
|
||
may also be used to set new default values. If FNAME is NULL the
|
||
default name will be used. With UPDATE set to true the internal
|
||
tables are actually updated; if not set, only a syntax check is
|
||
done. If DEFAULTS is true the global options are written to the
|
||
configuration files. If LISTFP is set, no changes are done but the
|
||
configuration file is printed to LISTFP in a colon separated format.
|
||
|
||
Returns 0 on success or if the config file is not present; -1 is
|
||
returned on error. */
|
||
int
|
||
gc_process_gpgconf_conf (const char *fname_arg, int update, int defaults,
|
||
estream_t listfp)
|
||
{
|
||
int result = 0;
|
||
char *line = NULL;
|
||
size_t line_len = 0;
|
||
ssize_t length;
|
||
gpgrt_stream_t config;
|
||
int lineno = 0;
|
||
int in_rule = 0;
|
||
int got_match = 0;
|
||
int runtime[GC_COMPONENT_NR] = { 0 };
|
||
int component_id;
|
||
char *fname;
|
||
|
||
if (fname_arg)
|
||
fname = xstrdup (fname_arg);
|
||
else
|
||
fname = make_filename (gnupg_sysconfdir (), GPGCONF_NAME EXTSEP_S "conf",
|
||
NULL);
|
||
|
||
config = gpgrt_fopen (fname, "r");
|
||
if (!config)
|
||
{
|
||
/* Do not print an error if the file is not available, except
|
||
when running in syntax check mode. */
|
||
if (errno != ENOENT || !update)
|
||
{
|
||
gc_error (0, errno, "can't open global config file '%s'", fname);
|
||
result = -1;
|
||
}
|
||
xfree (fname);
|
||
return result;
|
||
}
|
||
|
||
while ((length = gpgrt_read_line (config, &line, &line_len, NULL)) > 0)
|
||
{
|
||
char *key, *compname, *option, *flags, *value;
|
||
char *empty;
|
||
gc_option_t *option_info = NULL;
|
||
char *p;
|
||
int is_continuation;
|
||
|
||
lineno++;
|
||
key = line;
|
||
while (*key == ' ' || *key == '\t')
|
||
key++;
|
||
if (!*key || *key == '#' || *key == '\r' || *key == '\n')
|
||
continue;
|
||
|
||
is_continuation = (key != line);
|
||
|
||
/* Parse the key field. */
|
||
if (!is_continuation && got_match)
|
||
break; /* Finish after the first match. */
|
||
else if (!is_continuation)
|
||
{
|
||
in_rule = 0;
|
||
for (p=key+1; *p && !strchr (" \t\r\n", *p); p++)
|
||
;
|
||
if (!*p)
|
||
{
|
||
gc_error (0, 0, "missing rule at '%s', line %d", fname, lineno);
|
||
result = -1;
|
||
gpgconf_write_status (STATUS_WARNING,
|
||
"gpgconf.conf %d file '%s' line %d "
|
||
"missing rule",
|
||
GPG_ERR_SYNTAX, fname, lineno);
|
||
continue;
|
||
}
|
||
*p++ = 0;
|
||
compname = p;
|
||
}
|
||
else if (!in_rule)
|
||
{
|
||
gc_error (0, 0, "continuation but no rule at '%s', line %d",
|
||
fname, lineno);
|
||
result = -1;
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
compname = key;
|
||
key = NULL;
|
||
}
|
||
|
||
in_rule = 1;
|
||
|
||
/* Parse the component. */
|
||
while (*compname == ' ' || *compname == '\t')
|
||
compname++;
|
||
for (p=compname; *p && !strchr (" \t\r\n", *p); p++)
|
||
;
|
||
if (p == compname)
|
||
{
|
||
gc_error (0, 0, "missing component at '%s', line %d",
|
||
fname, lineno);
|
||
gpgconf_write_status (STATUS_WARNING,
|
||
"gpgconf.conf %d file '%s' line %d "
|
||
" missing component",
|
||
GPG_ERR_NO_NAME, fname, lineno);
|
||
result = -1;
|
||
continue;
|
||
}
|
||
empty = p;
|
||
*p++ = 0;
|
||
option = p;
|
||
component_id = gc_component_find (compname);
|
||
if (component_id < 0)
|
||
{
|
||
gc_error (0, 0, "unknown component at '%s', line %d",
|
||
fname, lineno);
|
||
gpgconf_write_status (STATUS_WARNING,
|
||
"gpgconf.conf %d file '%s' line %d "
|
||
"unknown component",
|
||
GPG_ERR_UNKNOWN_NAME, fname, lineno);
|
||
result = -1;
|
||
}
|
||
|
||
/* Parse the option name. */
|
||
while (*option == ' ' || *option == '\t')
|
||
option++;
|
||
for (p=option; *p && !strchr (" \t\r\n", *p); p++)
|
||
;
|
||
if (p == option)
|
||
{
|
||
gc_error (0, 0, "missing option at '%s', line %d",
|
||
fname, lineno);
|
||
gpgconf_write_status (STATUS_WARNING,
|
||
"gpgconf.conf %d file '%s' line %d "
|
||
"missing option",
|
||
GPG_ERR_INV_NAME, fname, lineno);
|
||
result = -1;
|
||
continue;
|
||
}
|
||
*p++ = 0;
|
||
flags = p;
|
||
if ( component_id != -1)
|
||
{
|
||
/* We need to make sure that we got the option list for the
|
||
* component. */
|
||
if (!gc_component[component_id].options)
|
||
gc_component_retrieve_options (component_id);
|
||
option_info = find_option (component_id, option);
|
||
if (!option_info)
|
||
{
|
||
gc_error (0, 0, "unknown option '%s' at '%s', line %d",
|
||
option, fname, lineno);
|
||
gpgconf_write_status (STATUS_WARNING,
|
||
"gpgconf.conf %d file '%s' line %d "
|
||
"unknown option",
|
||
GPG_ERR_UNKNOWN_OPTION, fname, lineno);
|
||
result = -1;
|
||
}
|
||
}
|
||
|
||
|
||
/* Parse the optional flags. */
|
||
while (*flags == ' ' || *flags == '\t')
|
||
flags++;
|
||
if (*flags == '[')
|
||
{
|
||
flags++;
|
||
p = strchr (flags, ']');
|
||
if (!p)
|
||
{
|
||
gc_error (0, 0, "syntax error in rule at '%s', line %d",
|
||
fname, lineno);
|
||
gpgconf_write_status (STATUS_WARNING,
|
||
"gpgconf.conf %d file '%s' line %d "
|
||
"syntax error in rule",
|
||
GPG_ERR_SYNTAX, fname, lineno);
|
||
result = -1;
|
||
continue;
|
||
}
|
||
*p++ = 0;
|
||
value = p;
|
||
}
|
||
else /* No flags given. */
|
||
{
|
||
value = flags;
|
||
flags = NULL;
|
||
}
|
||
|
||
/* Parse the optional value. */
|
||
while (*value == ' ' || *value == '\t')
|
||
value++;
|
||
for (p=value; *p && !strchr ("\r\n", *p); p++)
|
||
;
|
||
if (p == value)
|
||
value = empty; /* No value given; let it point to an empty string. */
|
||
else
|
||
{
|
||
/* Strip trailing white space. */
|
||
*p = 0;
|
||
for (p--; p > value && (*p == ' ' || *p == '\t'); p--)
|
||
*p = 0;
|
||
}
|
||
|
||
/* Check flag combinations. */
|
||
if (!flags)
|
||
;
|
||
else if (!strcmp (flags, "default"))
|
||
{
|
||
if (*value)
|
||
{
|
||
gc_error (0, 0, "flag \"default\" may not be combined "
|
||
"with a value at '%s', line %d",
|
||
fname, lineno);
|
||
result = -1;
|
||
}
|
||
}
|
||
else if (!strcmp (flags, "change"))
|
||
;
|
||
else if (!strcmp (flags, "no-change"))
|
||
;
|
||
else
|
||
{
|
||
gc_error (0, 0, "unknown flag at '%s', line %d",
|
||
fname, lineno);
|
||
result = -1;
|
||
}
|
||
|
||
/* In list mode we print out all records. */
|
||
if (listfp && !result)
|
||
{
|
||
/* If this is a new ruleset, print a key record. */
|
||
if (!is_continuation)
|
||
{
|
||
char *group = strchr (key, ':');
|
||
if (group)
|
||
{
|
||
*group++ = 0;
|
||
if ((p = strchr (group, ':')))
|
||
*p = 0; /* We better strip any extra stuff. */
|
||
}
|
||
|
||
es_fprintf (listfp, "k:%s:", gc_percent_escape (key));
|
||
es_fprintf (listfp, "%s\n", group? gc_percent_escape (group):"");
|
||
}
|
||
|
||
/* All other lines are rule records. */
|
||
es_fprintf (listfp, "r:::%s:%s:%s:",
|
||
gc_component[component_id].name,
|
||
option_info->name? option_info->name : "",
|
||
flags? flags : "");
|
||
if (value != empty)
|
||
es_fprintf (listfp, "\"%s", gc_percent_escape (value));
|
||
|
||
es_putc ('\n', listfp);
|
||
}
|
||
|
||
/* Check whether the key matches but do this only if we are not
|
||
running in syntax check mode. */
|
||
if ( update
|
||
&& !result && !listfp
|
||
&& (got_match || (key && key_matches_user_or_group (key))) )
|
||
{
|
||
int newflags = 0;
|
||
|
||
got_match = 1;
|
||
|
||
/* Apply the flags from gpgconf.conf. */
|
||
if (!flags)
|
||
;
|
||
else if (!strcmp (flags, "default"))
|
||
newflags |= GC_OPT_FLAG_DEFAULT;
|
||
else if (!strcmp (flags, "no-change"))
|
||
option_info->no_change = 1;
|
||
else if (!strcmp (flags, "change"))
|
||
option_info->no_change = 0;
|
||
|
||
if (defaults)
|
||
{
|
||
/* Here we explicitly allow updating the value again. */
|
||
if (newflags)
|
||
{
|
||
option_info->new_flags = 0;
|
||
}
|
||
if (*value)
|
||
{
|
||
xfree (option_info->new_value);
|
||
option_info->new_value = NULL;
|
||
}
|
||
change_one_value (component_id, option_info,
|
||
runtime, newflags, value, 0);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (length < 0 || gpgrt_ferror (config))
|
||
{
|
||
gc_error (0, errno, "error reading from '%s'", fname);
|
||
result = -1;
|
||
}
|
||
if (gpgrt_fclose (config))
|
||
gc_error (0, errno, "error closing '%s'", fname);
|
||
|
||
xfree (line);
|
||
|
||
/* If it all worked, process the options. */
|
||
if (!result && update && defaults && !listfp)
|
||
{
|
||
/* We need to switch off the runtime update, so that we can do
|
||
it later all at once. */
|
||
int save_opt_runtime = opt.runtime;
|
||
opt.runtime = 0;
|
||
|
||
for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
|
||
{
|
||
gc_component_change_options (component_id, NULL, NULL, 0);
|
||
}
|
||
opt.runtime = save_opt_runtime;
|
||
|
||
if (opt.runtime)
|
||
{
|
||
for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
|
||
if (runtime[component_id]
|
||
&& gc_component[component_id].runtime_change)
|
||
(*gc_component[component_id].runtime_change) (0);
|
||
}
|
||
}
|
||
|
||
xfree (fname);
|
||
return result;
|
||
}
|
||
|
||
|
||
/*
|
||
* Apply the profile FNAME to all known configure files.
|
||
*/
|
||
gpg_error_t
|
||
gc_apply_profile (const char *fname)
|
||
{
|
||
gpg_error_t err;
|
||
char *fname_buffer = NULL;
|
||
char *line = NULL;
|
||
size_t line_len = 0;
|
||
ssize_t length;
|
||
estream_t fp;
|
||
int lineno = 0;
|
||
int runtime[GC_COMPONENT_NR] = { 0 };
|
||
int component_id = -1;
|
||
int skip_section = 0;
|
||
int error_count = 0;
|
||
int newflags;
|
||
|
||
if (!fname)
|
||
fname = "-";
|
||
|
||
|
||
if (!(!strcmp (fname, "-")
|
||
|| strchr (fname, '/')
|
||
#ifdef HAVE_W32_SYSTEM
|
||
|| strchr (fname, '\\')
|
||
#endif
|
||
|| strchr (fname, '.')))
|
||
{
|
||
/* FNAME looks like a standard profile name. Check whether one
|
||
* is installed and use that instead of the given file name. */
|
||
fname_buffer = xstrconcat (gnupg_datadir (), DIRSEP_S,
|
||
fname, ".prf", NULL);
|
||
if (!gnupg_access (fname_buffer, F_OK))
|
||
fname = fname_buffer;
|
||
}
|
||
|
||
fp = !strcmp (fname, "-")? es_stdin : es_fopen (fname, "r");
|
||
if (!fp)
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
log_error ("can't open '%s': %s\n", fname, gpg_strerror (err));
|
||
return err;
|
||
}
|
||
|
||
if (opt.verbose)
|
||
log_info ("applying profile '%s'\n", fname);
|
||
|
||
err = 0;
|
||
while ((length = es_read_line (fp, &line, &line_len, NULL)) > 0)
|
||
{
|
||
char *name, *flags, *value;
|
||
gc_option_t *option_info = NULL;
|
||
char *p;
|
||
|
||
lineno++;
|
||
name = line;
|
||
while (*name == ' ' || *name == '\t')
|
||
name++;
|
||
if (!*name || *name == '#' || *name == '\r' || *name == '\n')
|
||
continue;
|
||
trim_trailing_spaces (name);
|
||
|
||
/* Check whether this is a new section. */
|
||
if (*name == '[')
|
||
{
|
||
name++;
|
||
skip_section = 0;
|
||
/* New section: Get the name of the component. */
|
||
p = strchr (name, ']');
|
||
if (!p)
|
||
{
|
||
error_count++;
|
||
log_info ("%s:%d:%d: error: syntax error in section tag\n",
|
||
fname, lineno, (int)(name - line));
|
||
skip_section = 1;
|
||
continue;
|
||
}
|
||
*p++ = 0;
|
||
if (*p)
|
||
log_info ("%s:%d:%d: warning: garbage after section tag\n",
|
||
fname, lineno, (int)(p - line));
|
||
|
||
trim_spaces (name);
|
||
component_id = gc_component_find (name);
|
||
if (component_id < 0)
|
||
{
|
||
log_info ("%s:%d:%d: warning: skipping unknown section '%s'\n",
|
||
fname, lineno, (int)(name - line), name );
|
||
skip_section = 1;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (skip_section)
|
||
continue;
|
||
if (component_id < 0)
|
||
{
|
||
error_count++;
|
||
log_info ("%s:%d:%d: error: not in a valid section\n",
|
||
fname, lineno, (int)(name - line));
|
||
skip_section = 1;
|
||
continue;
|
||
}
|
||
|
||
/* Parse the option name. */
|
||
for (p = name; *p && !spacep (p); p++)
|
||
;
|
||
*p++ = 0;
|
||
value = p;
|
||
|
||
option_info = find_option (component_id, name);
|
||
if (!option_info)
|
||
{
|
||
error_count++;
|
||
log_info ("%s:%d:%d: error: unknown option '%s' in section '%s'\n",
|
||
fname, lineno, (int)(name - line),
|
||
name, gc_component[component_id].name);
|
||
continue;
|
||
}
|
||
|
||
/* Parse the optional flags. */
|
||
trim_spaces (value);
|
||
flags = value;
|
||
if (*flags == '[')
|
||
{
|
||
flags++;
|
||
p = strchr (flags, ']');
|
||
if (!p)
|
||
{
|
||
log_info ("%s:%d:%d: warning: invalid flag specification\n",
|
||
fname, lineno, (int)(p - line));
|
||
continue;
|
||
}
|
||
*p++ = 0;
|
||
value = p;
|
||
trim_spaces (value);
|
||
}
|
||
else /* No flags given. */
|
||
flags = NULL;
|
||
|
||
/* Set required defaults. */
|
||
if (gc_arg_type[option_info->arg_type].fallback == GC_ARG_TYPE_NONE
|
||
&& !*value)
|
||
value = "1";
|
||
|
||
/* Check and save this option. */
|
||
newflags = 0;
|
||
if (flags && !strcmp (flags, "default"))
|
||
newflags |= GC_OPT_FLAG_DEFAULT;
|
||
|
||
if (newflags)
|
||
option_info->new_flags = 0;
|
||
if (*value)
|
||
{
|
||
xfree (option_info->new_value);
|
||
option_info->new_value = NULL;
|
||
}
|
||
change_one_value (component_id, option_info, runtime, newflags, value, 1);
|
||
}
|
||
|
||
if (length < 0 || es_ferror (fp))
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
error_count++;
|
||
log_error (_("%s:%u: read error: %s\n"),
|
||
fname, lineno, gpg_strerror (err));
|
||
}
|
||
if (es_fclose (fp))
|
||
log_error (_("error closing '%s'\n"), fname);
|
||
if (error_count)
|
||
log_error (_("error parsing '%s'\n"), fname);
|
||
|
||
xfree (line);
|
||
|
||
/* If it all worked, process the options. */
|
||
if (!err)
|
||
{
|
||
/* We need to switch off the runtime update, so that we can do
|
||
it later all at once. */
|
||
int save_opt_runtime = opt.runtime;
|
||
opt.runtime = 0;
|
||
|
||
for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
|
||
{
|
||
gc_component_change_options (component_id, NULL, NULL, 1);
|
||
}
|
||
opt.runtime = save_opt_runtime;
|
||
|
||
if (opt.runtime)
|
||
{
|
||
for (component_id = 0; component_id < GC_COMPONENT_NR; component_id++)
|
||
if (runtime[component_id]
|
||
&& gc_component[component_id].runtime_change)
|
||
(*gc_component[component_id].runtime_change) (0);
|
||
}
|
||
}
|
||
|
||
xfree (fname_buffer);
|
||
return err;
|
||
}
|