libvirt/src/driver.c
Martin Kletzander 8e527dd653 virGetConnectGeneric: Only delegate existing identities
Inside virt-qemu-run, just like in virsh for example, there is no
identity set in the current thread, so we should not try to set it,
otherwise things like connecting to other drivers might fail and on
top of that there is no error set so the user can't even see what's
wrong.

Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=2000075

Signed-off-by: Martin Kletzander <mkletzan@redhat.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
2022-11-15 11:04:33 +01:00

384 lines
11 KiB
C

/*
* driver.c: Helpers for loading drivers
*
* Copyright (C) 2006-2011 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*/
#include <config.h>
#include <unistd.h>
#include "driver.h"
#include "viralloc.h"
#include "virfile.h"
#include "virlog.h"
#include "virmodule.h"
#include "virobject.h"
#include "virstring.h"
#include "virthread.h"
#include "virutil.h"
#include "viridentity.h"
#include "datatypes.h"
#include "configmake.h"
#include "virtypedparam.h"
VIR_LOG_INIT("driver");
#define VIR_FROM_THIS VIR_FROM_NONE
/* XXX re-implement this for other OS, or use libtools helper lib ? */
#define DEFAULT_DRIVER_DIR LIBDIR "/libvirt/connection-driver"
int
virDriverLoadModule(const char *name,
const char *regfunc,
bool required)
{
g_autofree char *modfile = NULL;
VIR_DEBUG("Module load %s", name);
if (!(modfile = virFileFindResourceFull(name,
"libvirt_driver_",
VIR_FILE_MODULE_EXT,
abs_top_builddir "/src",
DEFAULT_DRIVER_DIR,
"LIBVIRT_DRIVER_DIR")))
return -1;
return virModuleLoad(modfile, regfunc, required);
}
/* XXX unload modules, but we can't until we can unregister libvirt drivers */
/**
* virDriverShouldAutostart:
* @dir: driver's run state directory (usually /var/run/libvirt/$driver)
* @autostart: whether driver should initiate autostart
*
* Automatic starting of libvirt's objects (e.g. domains, networks, storage
* pools, etc.) doesn't play nice with using '--timeout' on daemon's command
* line because the objects are attempted to autostart on every start of
* corresponding driver/daemon. To resolve this problem, a file is created in
* driver's private directory (which doesn't survive host's reboot) and thus
* autostart is attempted only once.
*/
int
virDriverShouldAutostart(const char *dir,
bool *autostart)
{
g_autofree char *path = NULL;
*autostart = false;
path = g_strdup_printf("%s/autostarted", dir);
if (virFileExists(path)) {
VIR_DEBUG("Autostart file %s exists, skipping autostart", path);
return 0;
}
VIR_DEBUG("Autostart file %s does not exist, do autostart", path);
*autostart = true;
if (virFileTouch(path, 0600) < 0)
return -1;
return 0;
}
virThreadLocal connectInterface;
virThreadLocal connectNetwork;
virThreadLocal connectNWFilter;
virThreadLocal connectNodeDev;
virThreadLocal connectSecret;
virThreadLocal connectStorage;
static int
virConnectCacheOnceInit(void)
{
if (virThreadLocalInit(&connectInterface, NULL) < 0 ||
virThreadLocalInit(&connectNetwork, NULL) < 0 ||
virThreadLocalInit(&connectNWFilter, NULL) < 0 ||
virThreadLocalInit(&connectNodeDev, NULL) < 0 ||
virThreadLocalInit(&connectSecret, NULL) < 0 ||
virThreadLocalInit(&connectStorage, NULL) < 0) {
virReportSystemError(errno, "%s",
_("Unable to initialize thread local variable"));
return -1;
}
return 0;
}
VIR_ONCE_GLOBAL_INIT(virConnectCache);
static virConnectPtr
virGetConnectGeneric(virThreadLocal *threadPtr, const char *name)
{
virConnectPtr conn;
virErrorPtr orig_err;
if (virConnectCacheInitialize() < 0)
return NULL;
conn = virThreadLocalGet(threadPtr);
if (conn) {
VIR_DEBUG("Return cached %s connection %p", name, conn);
virObjectRef(conn);
} else {
g_autofree char *uri = NULL;
const char *uriPath = geteuid() == 0 ? "/system" : "/session";
uri = g_strdup_printf("%s://%s", name, uriPath);
conn = virConnectOpen(uri);
VIR_DEBUG("Opened new %s connection %p", name, conn);
if (!conn)
return NULL;
if (conn->driver->connectSetIdentity != NULL) {
g_autoptr(virIdentity) ident = NULL;
VIR_DEBUG("Attempting to delegate current identity");
ident = virIdentityGetCurrent();
if (ident) {
g_autoptr(virTypedParamList) tmp = virIdentityGetParameters(ident);
if (virConnectSetIdentity(conn, tmp->par, tmp->npar, 0) < 0)
goto error;
}
}
}
return conn;
error:
virErrorPreserveLast(&orig_err);
virConnectClose(conn);
virErrorRestore(&orig_err);
return NULL;
}
virConnectPtr virGetConnectInterface(void)
{
return virGetConnectGeneric(&connectInterface, "interface");
}
virConnectPtr virGetConnectNetwork(void)
{
return virGetConnectGeneric(&connectNetwork, "network");
}
virConnectPtr virGetConnectNWFilter(void)
{
return virGetConnectGeneric(&connectNWFilter, "nwfilter");
}
virConnectPtr virGetConnectNodeDev(void)
{
return virGetConnectGeneric(&connectNodeDev, "nodedev");
}
virConnectPtr virGetConnectSecret(void)
{
return virGetConnectGeneric(&connectSecret, "secret");
}
virConnectPtr virGetConnectStorage(void)
{
return virGetConnectGeneric(&connectStorage, "storage");
}
int
virSetConnectInterface(virConnectPtr conn)
{
if (virConnectCacheInitialize() < 0)
return -1;
VIR_DEBUG("Override interface connection with %p", conn);
return virThreadLocalSet(&connectInterface, conn);
}
int
virSetConnectNetwork(virConnectPtr conn)
{
if (virConnectCacheInitialize() < 0)
return -1;
VIR_DEBUG("Override network connection with %p", conn);
return virThreadLocalSet(&connectNetwork, conn);
}
int
virSetConnectNWFilter(virConnectPtr conn)
{
if (virConnectCacheInitialize() < 0)
return -1;
VIR_DEBUG("Override nwfilter connection with %p", conn);
return virThreadLocalSet(&connectNWFilter, conn);
}
int
virSetConnectNodeDev(virConnectPtr conn)
{
if (virConnectCacheInitialize() < 0)
return -1;
VIR_DEBUG("Override nodedev connection with %p", conn);
return virThreadLocalSet(&connectNodeDev, conn);
}
int
virSetConnectSecret(virConnectPtr conn)
{
if (virConnectCacheInitialize() < 0)
return -1;
VIR_DEBUG("Override secret connection with %p", conn);
return virThreadLocalSet(&connectSecret, conn);
}
int
virSetConnectStorage(virConnectPtr conn)
{
if (virConnectCacheInitialize() < 0)
return -1;
VIR_DEBUG("Override storage connection with %p", conn);
return virThreadLocalSet(&connectStorage, conn);
}
bool
virConnectValidateURIPath(const char *uriPath,
const char *entityName,
bool privileged)
{
if (privileged) {
/* TODO: qemu and vbox drivers allow '/session'
* connections as root. This is not ideal, but changing
* these drivers to refuse privileged '/session'
* connections, like everyone else is already doing, can
* break existing applications. Until we decide what to do,
* for now we can handle them as exception in this validate
* function.
*/
bool compatSessionRoot = (STREQ(entityName, "qemu") ||
STREQ(entityName, "vbox")) &&
STREQ(uriPath, "/session");
if (STRNEQ(uriPath, "/system") && !compatSessionRoot) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected %s URI path '%s', try "
"%s:///system"),
entityName, uriPath, entityName);
return false;
}
} else {
if (STRNEQ(uriPath, "/session")) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected %s URI path '%s', try "
"%s:///session"),
entityName, uriPath, entityName);
return false;
}
}
return true;
}
/**
* virDriverFeatureIsGlobal:
* @feat: a VIR_DRV_FEATURE
* @supported: If a feature is globally handled
*
* Certain driver feature flags are really not for individual drivers to decide
* whether they implement them or not, but are rather global based on e.g.
* whether the RPC protocol supports it.
*
* This function returns 'true' and fills @supported if a feature is a global
* feature and the individual driver implementations don't decide whether
* they support it or not.
*/
bool
virDriverFeatureIsGlobal(virDrvFeature feat,
int *supported)
{
switch (feat) {
/* This is a special case where the generated remote driver dispatcher
* function intercepts this specific flag and returns '1'. Thus any local
* implementation must return 0, so that the return value properly reflects
* whether we are going through the remote driver */
case VIR_DRV_FEATURE_REMOTE:
/* keepalive is handled at RPC level, driver implementations must always
* return 0, to signal that direct/embedded use doesn't use keepalive */
case VIR_DRV_FEATURE_PROGRAM_KEEPALIVE:
/* Support for close callbacks and remote event filtering are both features
* of the RPC protocol and thus normal drivers must not signal support
* for them. */
case VIR_DRV_FEATURE_REMOTE_CLOSE_CALLBACK:
case VIR_DRV_FEATURE_REMOTE_EVENT_CALLBACK:
*supported = 0;
return true;
/* Limitation of string support in typed parameters was an RPC limitation.
* At this point everything supports them and thus also drivers need to
* always advertise this feature */
case VIR_DRV_FEATURE_TYPED_PARAM_STRING:
/* Feature flag exposes that the accidental switching of order of arguments
* in the public API trampoline virNetworkUpdate is known. Updated clients
* thus use the correct ordering with an updated server. All drivers must
* signal support for this feature. */
case VIR_DRV_FEATURE_NETWORK_UPDATE_HAS_CORRECT_ORDER:
/* The remote driver intercepts and always reports the feature since it was
* introduced. This means that all driver implementations should advertise
* it too as it works natively without RPC. Always enabling this will also
* prevent regressions when a driver is used in embedded mode */
case VIR_DRV_FEATURE_FD_PASSING:
*supported = 1;
return true;
case VIR_DRV_FEATURE_MIGRATION_V2:
case VIR_DRV_FEATURE_MIGRATION_V3:
case VIR_DRV_FEATURE_MIGRATION_P2P:
case VIR_DRV_FEATURE_MIGRATE_CHANGE_PROTECTION:
case VIR_DRV_FEATURE_XML_MIGRATABLE:
case VIR_DRV_FEATURE_MIGRATION_OFFLINE:
case VIR_DRV_FEATURE_MIGRATION_PARAMS:
case VIR_DRV_FEATURE_MIGRATION_DIRECT:
case VIR_DRV_FEATURE_MIGRATION_V1:
default:
return false;
}
}