mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-08-28 19:41:16 +00:00
Expose a public API to retrieve some identity and connection information about a client connected to the specified server on daemon. The identity info retrieved is mostly connection transport dependent, i.e. there won't be any socket address returned for a local (UNIX socket) connection, while on the other hand, when connected through TLS or unencrypted TCP, obviously no UNIX process identification will be present in the returned data. All supported values that can be returned in typed params are exposed and documented in include/libvirt/libvirt-admin.h Signed-off-by: Erik Skultety <eskultet@redhat.com>
299 lines
9.1 KiB
C
299 lines
9.1 KiB
C
/*
|
|
* admin.c: handlers for admin RPC method calls
|
|
*
|
|
* Copyright (C) 2014-2016 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/>.
|
|
*
|
|
* Author: Martin Kletzander <mkletzan@redhat.com>
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include "internal.h"
|
|
#include "libvirtd.h"
|
|
#include "libvirt_internal.h"
|
|
|
|
#include "admin_protocol.h"
|
|
#include "admin.h"
|
|
#include "admin_server.h"
|
|
#include "datatypes.h"
|
|
#include "viralloc.h"
|
|
#include "virerror.h"
|
|
#include "virlog.h"
|
|
#include "virnetdaemon.h"
|
|
#include "virnetserver.h"
|
|
#include "virstring.h"
|
|
#include "virthreadjob.h"
|
|
#include "virtypedparam.h"
|
|
|
|
#define VIR_FROM_THIS VIR_FROM_ADMIN
|
|
|
|
VIR_LOG_INIT("daemon.admin");
|
|
|
|
|
|
void
|
|
remoteAdmClientFreeFunc(void *data)
|
|
{
|
|
struct daemonAdmClientPrivate *priv = data;
|
|
|
|
virMutexDestroy(&priv->lock);
|
|
virObjectUnref(priv->dmn);
|
|
VIR_FREE(priv);
|
|
}
|
|
|
|
void *
|
|
remoteAdmClientInitHook(virNetServerClientPtr client ATTRIBUTE_UNUSED,
|
|
void *opaque)
|
|
{
|
|
struct daemonAdmClientPrivate *priv;
|
|
|
|
if (VIR_ALLOC(priv) < 0)
|
|
return NULL;
|
|
|
|
if (virMutexInit(&priv->lock) < 0) {
|
|
VIR_FREE(priv);
|
|
virReportSystemError(errno, "%s", _("unable to init mutex"));
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* We don't necessarily need to ref this object right now as there
|
|
* must be one ref being held throughout the life of the daemon,
|
|
* but let's just be safe for future.
|
|
*/
|
|
priv->dmn = virObjectRef(opaque);
|
|
|
|
return priv;
|
|
}
|
|
|
|
/* Helpers */
|
|
|
|
static virNetServerPtr
|
|
get_nonnull_server(virNetDaemonPtr dmn, admin_nonnull_server srv)
|
|
{
|
|
return virNetDaemonGetServer(dmn, srv.name);
|
|
}
|
|
|
|
static void
|
|
make_nonnull_server(admin_nonnull_server *srv_dst,
|
|
virNetServerPtr srv_src)
|
|
{
|
|
ignore_value(VIR_STRDUP_QUIET(srv_dst->name, virNetServerGetName(srv_src)));
|
|
}
|
|
|
|
static void
|
|
make_nonnull_client(admin_nonnull_client *clt_dst,
|
|
virNetServerClientPtr clt_src)
|
|
{
|
|
clt_dst->id = virNetServerClientGetID(clt_src);
|
|
clt_dst->timestamp = virNetServerClientGetTimestamp(clt_src);
|
|
clt_dst->transport = virNetServerClientGetTransport(clt_src);
|
|
}
|
|
|
|
/* Functions */
|
|
static int
|
|
adminDispatchConnectOpen(virNetServerPtr server ATTRIBUTE_UNUSED,
|
|
virNetServerClientPtr client,
|
|
virNetMessagePtr msg ATTRIBUTE_UNUSED,
|
|
virNetMessageErrorPtr rerr,
|
|
struct admin_connect_open_args *args)
|
|
{
|
|
unsigned int flags;
|
|
struct daemonAdmClientPrivate *priv =
|
|
virNetServerClientGetPrivateData(client);
|
|
int ret = -1;
|
|
|
|
VIR_DEBUG("priv=%p dmn=%p", priv, priv->dmn);
|
|
virMutexLock(&priv->lock);
|
|
|
|
flags = args->flags;
|
|
virCheckFlagsGoto(0, cleanup);
|
|
|
|
ret = 0;
|
|
cleanup:
|
|
if (ret < 0)
|
|
virNetMessageSaveError(rerr);
|
|
virMutexUnlock(&priv->lock);
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
adminDispatchConnectClose(virNetServerPtr server ATTRIBUTE_UNUSED,
|
|
virNetServerClientPtr client,
|
|
virNetMessagePtr msg ATTRIBUTE_UNUSED,
|
|
virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED)
|
|
{
|
|
virNetServerClientDelayedClose(client);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
adminConnectGetLibVersion(virNetDaemonPtr dmn ATTRIBUTE_UNUSED,
|
|
unsigned long long *libVer)
|
|
{
|
|
if (libVer)
|
|
*libVer = LIBVIR_VERSION_NUMBER;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
adminDispatchServerGetThreadpoolParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
|
|
virNetServerClientPtr client,
|
|
virNetMessagePtr msg ATTRIBUTE_UNUSED,
|
|
virNetMessageErrorPtr rerr,
|
|
struct admin_server_get_threadpool_parameters_args *args,
|
|
struct admin_server_get_threadpool_parameters_ret *ret)
|
|
{
|
|
int rv = -1;
|
|
virNetServerPtr srv = NULL;
|
|
virTypedParameterPtr params = NULL;
|
|
int nparams = 0;
|
|
struct daemonAdmClientPrivate *priv =
|
|
virNetServerClientGetPrivateData(client);
|
|
|
|
if (!(srv = virNetDaemonGetServer(priv->dmn, args->srv.name)))
|
|
goto cleanup;
|
|
|
|
if (adminServerGetThreadPoolParameters(srv, ¶ms, &nparams,
|
|
args->flags) < 0)
|
|
goto cleanup;
|
|
|
|
if (nparams > ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX) {
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
_("Number of threadpool parameters %d exceeds max "
|
|
"allowed limit: %d"), nparams,
|
|
ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX);
|
|
goto cleanup;
|
|
}
|
|
|
|
if (virTypedParamsSerialize(params, nparams,
|
|
(virTypedParameterRemotePtr *) &ret->params.params_val,
|
|
&ret->params.params_len, 0) < 0)
|
|
goto cleanup;
|
|
|
|
rv = 0;
|
|
cleanup:
|
|
if (rv < 0)
|
|
virNetMessageSaveError(rerr);
|
|
|
|
virTypedParamsFree(params, nparams);
|
|
virObjectUnref(srv);
|
|
return rv;
|
|
}
|
|
|
|
static int
|
|
adminDispatchServerSetThreadpoolParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
|
|
virNetServerClientPtr client,
|
|
virNetMessagePtr msg ATTRIBUTE_UNUSED,
|
|
virNetMessageErrorPtr rerr,
|
|
struct admin_server_set_threadpool_parameters_args *args)
|
|
{
|
|
int rv = -1;
|
|
virNetServerPtr srv = NULL;
|
|
virTypedParameterPtr params = NULL;
|
|
int nparams = 0;
|
|
struct daemonAdmClientPrivate *priv =
|
|
virNetServerClientGetPrivateData(client);
|
|
|
|
if (!(srv = virNetDaemonGetServer(priv->dmn, args->srv.name))) {
|
|
virReportError(VIR_ERR_NO_SERVER,
|
|
_("no server with matching name '%s' found"),
|
|
args->srv.name);
|
|
goto cleanup;
|
|
}
|
|
|
|
if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
|
|
args->params.params_len,
|
|
ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX,
|
|
¶ms,
|
|
&nparams) < 0)
|
|
goto cleanup;
|
|
|
|
|
|
if (adminServerSetThreadPoolParameters(srv, params,
|
|
nparams, args->flags) < 0)
|
|
goto cleanup;
|
|
|
|
rv = 0;
|
|
cleanup:
|
|
if (rv < 0)
|
|
virNetMessageSaveError(rerr);
|
|
|
|
virTypedParamsFree(params, nparams);
|
|
virObjectUnref(srv);
|
|
return rv;
|
|
}
|
|
|
|
static int
|
|
adminDispatchClientGetInfo(virNetServerPtr server ATTRIBUTE_UNUSED,
|
|
virNetServerClientPtr client,
|
|
virNetMessagePtr msg ATTRIBUTE_UNUSED,
|
|
virNetMessageErrorPtr rerr,
|
|
struct admin_client_get_info_args *args,
|
|
struct admin_client_get_info_ret *ret)
|
|
{
|
|
int rv = -1;
|
|
virNetServerPtr srv = NULL;
|
|
virNetServerClientPtr clnt = NULL;
|
|
virTypedParameterPtr params = NULL;
|
|
int nparams = 0;
|
|
struct daemonAdmClientPrivate *priv =
|
|
virNetServerClientGetPrivateData(client);
|
|
|
|
if (!(srv = virNetDaemonGetServer(priv->dmn, args->clnt.srv.name))) {
|
|
virReportError(VIR_ERR_NO_SERVER,
|
|
_("no server with matching name '%s' found"),
|
|
args->clnt.srv.name);
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!(clnt = virNetServerGetClient(srv, args->clnt.id))) {
|
|
virReportError(VIR_ERR_NO_CLIENT,
|
|
_("no client with matching id '%lu' found"),
|
|
args->clnt.id);
|
|
goto cleanup;
|
|
}
|
|
|
|
if (adminClientGetInfo(clnt, ¶ms, &nparams, args->flags) < 0)
|
|
goto cleanup;
|
|
|
|
if (nparams > ADMIN_CLIENT_INFO_PARAMETERS_MAX) {
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
_("Number of client info parameters %d exceeds max "
|
|
"allowed limit: %d"), nparams,
|
|
ADMIN_CLIENT_INFO_PARAMETERS_MAX);
|
|
goto cleanup;
|
|
}
|
|
|
|
if (virTypedParamsSerialize(params, nparams,
|
|
(virTypedParameterRemotePtr *) &ret->params.params_val,
|
|
&ret->params.params_len,
|
|
VIR_TYPED_PARAM_STRING_OKAY) < 0)
|
|
goto cleanup;
|
|
|
|
rv = 0;
|
|
|
|
cleanup:
|
|
if (rv < 0)
|
|
virNetMessageSaveError(rerr);
|
|
|
|
virTypedParamsFree(params, nparams);
|
|
virObjectUnref(clnt);
|
|
virObjectUnref(srv);
|
|
return rv;
|
|
}
|
|
#include "admin_dispatch.h"
|