mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-08-27 19:11:16 +00:00
For now this serves just as an annotation because readline and also the bash completion script insist on completing local paths when an empty list is returned. This will serve for future reference once we'll be able to properly refuse to suggest anything. The completer is used for fields such as names for new objects, description strings, password strings etc, URIs and hostnames which we can't feasibly autocomplete. Signed-off-by: Peter Krempa <pkrempa@redhat.com> Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
879 lines
22 KiB
C
879 lines
22 KiB
C
/*
|
|
* virsh-secret.c: Commands to manage secret
|
|
*
|
|
* Copyright (C) 2005, 2007-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/>.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include "virsh-secret.h"
|
|
#include "virsh-util.h"
|
|
|
|
#include "internal.h"
|
|
#include "virbuffer.h"
|
|
#include "viralloc.h"
|
|
#include "virfile.h"
|
|
#include "virutil.h"
|
|
#include "virsecret.h"
|
|
#include "virtime.h"
|
|
#include "vsh-table.h"
|
|
#include "virenum.h"
|
|
#include "virsecureerase.h"
|
|
|
|
static virSecretPtr
|
|
virshCommandOptSecret(vshControl *ctl, const vshCmd *cmd, const char **name)
|
|
{
|
|
virSecretPtr secret = NULL;
|
|
const char *n = NULL;
|
|
const char *optname = "secret";
|
|
virshControl *priv = ctl->privData;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0)
|
|
return NULL;
|
|
|
|
vshDebug(ctl, VSH_ERR_DEBUG,
|
|
"%s: found option <%s>: %s\n", cmd->def->name, optname, n);
|
|
|
|
if (name != NULL)
|
|
*name = n;
|
|
|
|
secret = virSecretLookupByUUIDString(priv->conn, n);
|
|
|
|
if (secret == NULL)
|
|
vshError(ctl, _("failed to get secret '%s'"), n);
|
|
|
|
return secret;
|
|
}
|
|
|
|
/*
|
|
* "secret-define" command
|
|
*/
|
|
static const vshCmdInfo info_secret_define[] = {
|
|
{.name = "help",
|
|
.data = N_("define or modify a secret from an XML file")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Define or modify a secret.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_secret_define[] = {
|
|
VIRSH_COMMON_OPT_FILE(N_("file containing secret attributes in XML")),
|
|
{.name = "validate",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("validate the XML against the schema")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSecretDefine(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
const char *from = NULL;
|
|
g_autofree char *buffer = NULL;
|
|
virSecretPtr res;
|
|
char uuid[VIR_UUID_STRING_BUFLEN];
|
|
bool ret = false;
|
|
unsigned int flags = 0;
|
|
virshControl *priv = ctl->privData;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
|
|
return false;
|
|
|
|
if (vshCommandOptBool(cmd, "validate"))
|
|
flags |= VIR_SECRET_DEFINE_VALIDATE;
|
|
|
|
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
|
|
return false;
|
|
|
|
if (!(res = virSecretDefineXML(priv->conn, buffer, flags))) {
|
|
vshError(ctl, _("Failed to set attributes from %s"), from);
|
|
goto cleanup;
|
|
}
|
|
|
|
if (virSecretGetUUIDString(res, &(uuid[0])) < 0) {
|
|
vshError(ctl, "%s", _("Failed to get UUID of created secret"));
|
|
goto cleanup;
|
|
}
|
|
|
|
vshPrintExtra(ctl, _("Secret %s created\n"), uuid);
|
|
ret = true;
|
|
|
|
cleanup:
|
|
virshSecretFree(res);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* "secret-dumpxml" command
|
|
*/
|
|
static const vshCmdInfo info_secret_dumpxml[] = {
|
|
{.name = "help",
|
|
.data = N_("secret attributes in XML")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Output attributes of a secret as an XML dump to stdout.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_secret_dumpxml[] = {
|
|
{.name = "secret",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("secret UUID"),
|
|
.completer = virshSecretUUIDCompleter,
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSecretDumpXML(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
virSecretPtr secret;
|
|
bool ret = false;
|
|
g_autofree char *xml = NULL;
|
|
|
|
secret = virshCommandOptSecret(ctl, cmd, NULL);
|
|
if (secret == NULL)
|
|
return false;
|
|
|
|
xml = virSecretGetXMLDesc(secret, 0);
|
|
if (xml == NULL)
|
|
goto cleanup;
|
|
vshPrint(ctl, "%s", xml);
|
|
ret = true;
|
|
|
|
cleanup:
|
|
virshSecretFree(secret);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* "secret-set-value" command
|
|
*/
|
|
static const vshCmdInfo info_secret_set_value[] = {
|
|
{.name = "help",
|
|
.data = N_("set a secret value")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Set a secret value.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_secret_set_value[] = {
|
|
{.name = "secret",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("secret UUID"),
|
|
.completer = virshSecretUUIDCompleter,
|
|
},
|
|
{.name = "file",
|
|
.type = VSH_OT_STRING,
|
|
.flags = VSH_OFLAG_REQ_OPT,
|
|
.completer = virshCompletePathLocalExisting,
|
|
.help = N_("read secret from file"),
|
|
},
|
|
{.name = "plain",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("read the secret from file without converting from base64")
|
|
},
|
|
{.name = "interactive",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("read the secret from the terminal")
|
|
},
|
|
{.name = "base64",
|
|
.type = VSH_OT_STRING,
|
|
.completer = virshCompleteEmpty,
|
|
.help = N_("base64-encoded secret value")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSecretSetValue(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshSecret) secret = NULL;
|
|
const char *base64 = NULL;
|
|
const char *filename = NULL;
|
|
g_autofree char *secret_val = NULL;
|
|
size_t secret_len = 0;
|
|
bool plain = vshCommandOptBool(cmd, "plain");
|
|
bool interactive = vshCommandOptBool(cmd, "interactive");
|
|
int res;
|
|
|
|
VSH_EXCLUSIVE_OPTIONS("file", "base64");
|
|
VSH_EXCLUSIVE_OPTIONS("plain", "base64");
|
|
VSH_EXCLUSIVE_OPTIONS("interactive", "base64");
|
|
VSH_EXCLUSIVE_OPTIONS("interactive", "plain");
|
|
VSH_EXCLUSIVE_OPTIONS("interactive", "file");
|
|
|
|
if (!(secret = virshCommandOptSecret(ctl, cmd, NULL)))
|
|
return false;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "base64", &base64) < 0)
|
|
return false;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "file", &filename) < 0)
|
|
return false;
|
|
|
|
if (base64) {
|
|
/* warn users that the --base64 option passed from command line is wrong */
|
|
vshError(ctl, _("Passing secret value as command-line argument is insecure!"));
|
|
secret_val = g_strdup(base64);
|
|
secret_len = strlen(secret_val);
|
|
} else if (filename) {
|
|
ssize_t read_ret;
|
|
if ((read_ret = virFileReadAll(filename, 1024, &secret_val)) < 0) {
|
|
vshSaveLibvirtError();
|
|
return false;
|
|
}
|
|
|
|
secret_len = read_ret;
|
|
} else if (interactive) {
|
|
vshPrint(ctl, "%s", _("Enter new value for secret:"));
|
|
fflush(stdout);
|
|
|
|
if (!(secret_val = virGetPassword())) {
|
|
vshError(ctl, "%s", _("Failed to read secret"));
|
|
return false;
|
|
}
|
|
secret_len = strlen(secret_val);
|
|
plain = true;
|
|
} else {
|
|
vshError(ctl, _("Input secret value is missing"));
|
|
return false;
|
|
}
|
|
|
|
if (!plain) {
|
|
g_autofree char *tmp = g_steal_pointer(&secret_val);
|
|
size_t tmp_len = secret_len;
|
|
|
|
secret_val = (char *) g_base64_decode(tmp, &secret_len);
|
|
virSecureErase(tmp, tmp_len);
|
|
}
|
|
|
|
res = virSecretSetValue(secret, (unsigned char *) secret_val, secret_len, 0);
|
|
virSecureErase(secret_val, secret_len);
|
|
|
|
if (res != 0) {
|
|
vshError(ctl, "%s", _("Failed to set secret value"));
|
|
return false;
|
|
}
|
|
vshPrintExtra(ctl, "%s", _("Secret value set\n"));
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "secret-get-value" command
|
|
*/
|
|
static const vshCmdInfo info_secret_get_value[] = {
|
|
{.name = "help",
|
|
.data = N_("Output a secret value")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Output a secret value to stdout.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_secret_get_value[] = {
|
|
{.name = "secret",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("secret UUID"),
|
|
.completer = virshSecretUUIDCompleter,
|
|
},
|
|
{.name = "plain",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("get value without converting to base64")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSecretGetValue(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshSecret) secret = NULL;
|
|
g_autofree unsigned char *value = NULL;
|
|
size_t value_size;
|
|
bool plain = vshCommandOptBool(cmd, "plain");
|
|
|
|
if (!(secret = virshCommandOptSecret(ctl, cmd, NULL)))
|
|
return false;
|
|
|
|
if (!(value = virSecretGetValue(secret, &value_size, 0)))
|
|
return false;
|
|
|
|
if (plain) {
|
|
if (fwrite(value, 1, value_size, stdout) != value_size) {
|
|
virSecureErase(value, value_size);
|
|
vshError(ctl, "failed to write secret");
|
|
return false;
|
|
}
|
|
} else {
|
|
g_autofree char *base64 = g_base64_encode(value, value_size);
|
|
|
|
vshPrint(ctl, "%s", base64);
|
|
virSecureEraseString(base64);
|
|
}
|
|
|
|
virSecureErase(value, value_size);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "secret-undefine" command
|
|
*/
|
|
static const vshCmdInfo info_secret_undefine[] = {
|
|
{.name = "help",
|
|
.data = N_("undefine a secret")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Undefine a secret.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_secret_undefine[] = {
|
|
{.name = "secret",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("secret UUID"),
|
|
.completer = virshSecretUUIDCompleter,
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSecretUndefine(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
virSecretPtr secret;
|
|
bool ret = false;
|
|
const char *uuid;
|
|
|
|
secret = virshCommandOptSecret(ctl, cmd, &uuid);
|
|
if (secret == NULL)
|
|
return false;
|
|
|
|
if (virSecretUndefine(secret) < 0) {
|
|
vshError(ctl, _("Failed to delete secret %s"), uuid);
|
|
goto cleanup;
|
|
}
|
|
vshPrintExtra(ctl, _("Secret %s deleted\n"), uuid);
|
|
ret = true;
|
|
|
|
cleanup:
|
|
virshSecretFree(secret);
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
virshSecretSorter(const void *a, const void *b)
|
|
{
|
|
virSecretPtr *sa = (virSecretPtr *) a;
|
|
virSecretPtr *sb = (virSecretPtr *) b;
|
|
char uuid_sa[VIR_UUID_STRING_BUFLEN];
|
|
char uuid_sb[VIR_UUID_STRING_BUFLEN];
|
|
|
|
if (*sa && !*sb)
|
|
return -1;
|
|
|
|
if (!*sa)
|
|
return *sb != NULL;
|
|
|
|
virSecretGetUUIDString(*sa, uuid_sa);
|
|
virSecretGetUUIDString(*sb, uuid_sb);
|
|
|
|
return vshStrcasecmp(uuid_sa, uuid_sb);
|
|
}
|
|
|
|
struct virshSecretList {
|
|
virSecretPtr *secrets;
|
|
size_t nsecrets;
|
|
};
|
|
|
|
static void
|
|
virshSecretListFree(struct virshSecretList *list)
|
|
{
|
|
size_t i;
|
|
|
|
if (list && list->secrets) {
|
|
for (i = 0; i < list->nsecrets; i++)
|
|
virshSecretFree(list->secrets[i]);
|
|
|
|
g_free(list->secrets);
|
|
}
|
|
g_free(list);
|
|
}
|
|
|
|
static struct virshSecretList *
|
|
virshSecretListCollect(vshControl *ctl,
|
|
unsigned int flags)
|
|
{
|
|
struct virshSecretList *list = g_new0(struct virshSecretList, 1);
|
|
size_t i;
|
|
int ret;
|
|
virSecretPtr secret;
|
|
bool success = false;
|
|
size_t deleted = 0;
|
|
int nsecrets = 0;
|
|
char **uuids = NULL;
|
|
virshControl *priv = ctl->privData;
|
|
|
|
/* try the list with flags support (0.10.2 and later) */
|
|
if ((ret = virConnectListAllSecrets(priv->conn,
|
|
&list->secrets,
|
|
flags)) >= 0) {
|
|
list->nsecrets = ret;
|
|
goto finished;
|
|
}
|
|
|
|
/* check if the command is actually supported */
|
|
if (last_error && last_error->code == VIR_ERR_NO_SUPPORT)
|
|
goto fallback;
|
|
|
|
/* there was an error during the call */
|
|
vshError(ctl, "%s", _("Failed to list node secrets"));
|
|
goto cleanup;
|
|
|
|
|
|
fallback:
|
|
/* fall back to old method (0.10.1 and older) */
|
|
vshResetLibvirtError();
|
|
|
|
if (flags) {
|
|
vshError(ctl, "%s", _("Filtering is not supported by this libvirt"));
|
|
goto cleanup;
|
|
}
|
|
|
|
nsecrets = virConnectNumOfSecrets(priv->conn);
|
|
if (nsecrets < 0) {
|
|
vshError(ctl, "%s", _("Failed to count secrets"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (nsecrets == 0)
|
|
return list;
|
|
|
|
uuids = g_new0(char *, nsecrets);
|
|
|
|
nsecrets = virConnectListSecrets(priv->conn, uuids, nsecrets);
|
|
if (nsecrets < 0) {
|
|
vshError(ctl, "%s", _("Failed to list secrets"));
|
|
goto cleanup;
|
|
}
|
|
|
|
list->secrets = g_new0(virSecretPtr, nsecrets);
|
|
list->nsecrets = 0;
|
|
|
|
/* get the secrets */
|
|
for (i = 0; i < nsecrets; i++) {
|
|
if (!(secret = virSecretLookupByUUIDString(priv->conn, uuids[i])))
|
|
continue;
|
|
list->secrets[list->nsecrets++] = secret;
|
|
}
|
|
|
|
/* truncate secrets that weren't found */
|
|
deleted = nsecrets - list->nsecrets;
|
|
|
|
finished:
|
|
/* sort the list */
|
|
if (list->secrets && list->nsecrets)
|
|
qsort(list->secrets, list->nsecrets,
|
|
sizeof(*list->secrets), virshSecretSorter);
|
|
|
|
/* truncate the list for not found secret objects */
|
|
if (deleted)
|
|
VIR_SHRINK_N(list->secrets, list->nsecrets, deleted);
|
|
|
|
success = true;
|
|
|
|
cleanup:
|
|
if (nsecrets > 0) {
|
|
for (i = 0; i < nsecrets; i++)
|
|
VIR_FREE(uuids[i]);
|
|
VIR_FREE(uuids);
|
|
}
|
|
|
|
if (!success) {
|
|
virshSecretListFree(list);
|
|
list = NULL;
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
/*
|
|
* "secret-list" command
|
|
*/
|
|
static const vshCmdInfo info_secret_list[] = {
|
|
{.name = "help",
|
|
.data = N_("list secrets")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Returns a list of secrets")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_secret_list[] = {
|
|
{.name = "ephemeral",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list ephemeral secrets")
|
|
},
|
|
{.name = "no-ephemeral",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list non-ephemeral secrets")
|
|
},
|
|
{.name = "private",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list private secrets")
|
|
},
|
|
{.name = "no-private",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list non-private secrets")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSecretList(vshControl *ctl, const vshCmd *cmd G_GNUC_UNUSED)
|
|
{
|
|
size_t i;
|
|
struct virshSecretList *list = NULL;
|
|
bool ret = false;
|
|
unsigned int flags = 0;
|
|
g_autoptr(vshTable) table = NULL;
|
|
|
|
if (vshCommandOptBool(cmd, "ephemeral"))
|
|
flags |= VIR_CONNECT_LIST_SECRETS_EPHEMERAL;
|
|
|
|
if (vshCommandOptBool(cmd, "no-ephemeral"))
|
|
flags |= VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL;
|
|
|
|
if (vshCommandOptBool(cmd, "private"))
|
|
flags |= VIR_CONNECT_LIST_SECRETS_PRIVATE;
|
|
|
|
if (vshCommandOptBool(cmd, "no-private"))
|
|
flags |= VIR_CONNECT_LIST_SECRETS_NO_PRIVATE;
|
|
|
|
if (!(list = virshSecretListCollect(ctl, flags)))
|
|
return false;
|
|
|
|
table = vshTableNew(_("UUID"), _("Usage"), NULL);
|
|
if (!table)
|
|
goto cleanup;
|
|
|
|
for (i = 0; i < list->nsecrets; i++) {
|
|
virSecretPtr sec = list->secrets[i];
|
|
int usageType = virSecretGetUsageType(sec);
|
|
const char *usageStr = virSecretUsageTypeToString(usageType);
|
|
char uuid[VIR_UUID_STRING_BUFLEN];
|
|
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
|
|
g_autofree char *usage = NULL;
|
|
|
|
if (virSecretGetUUIDString(sec, uuid) < 0) {
|
|
vshError(ctl, "%s", _("Failed to get uuid of secret"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (usageType) {
|
|
virBufferStrcat(&buf, usageStr, " ",
|
|
virSecretGetUsageID(sec), NULL);
|
|
usage = virBufferContentAndReset(&buf);
|
|
if (!usage)
|
|
goto cleanup;
|
|
|
|
if (vshTableRowAppend(table, uuid, usage, NULL) < 0)
|
|
goto cleanup;
|
|
} else {
|
|
if (vshTableRowAppend(table, uuid, _("Unused"), NULL) < 0)
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
vshTablePrintToStdout(table, ctl);
|
|
|
|
ret = true;
|
|
|
|
cleanup:
|
|
virshSecretListFree(list);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* "Secret-event" command
|
|
*/
|
|
VIR_ENUM_DECL(virshSecretEvent);
|
|
VIR_ENUM_IMPL(virshSecretEvent,
|
|
VIR_SECRET_EVENT_LAST,
|
|
N_("Defined"),
|
|
N_("Undefined"));
|
|
|
|
static const char *
|
|
virshSecretEventToString(int event)
|
|
{
|
|
const char *str = virshSecretEventTypeToString(event);
|
|
return str ? _(str) : _("unknown");
|
|
}
|
|
|
|
struct virshSecretEventData {
|
|
vshControl *ctl;
|
|
bool loop;
|
|
bool timestamp;
|
|
int count;
|
|
virshSecretEventCallback *cb;
|
|
};
|
|
typedef struct virshSecretEventData virshSecretEventData;
|
|
|
|
static void
|
|
vshEventLifecyclePrint(virConnectPtr conn G_GNUC_UNUSED,
|
|
virSecretPtr secret,
|
|
int event,
|
|
int detail G_GNUC_UNUSED,
|
|
void *opaque)
|
|
{
|
|
virshSecretEventData *data = opaque;
|
|
char uuid[VIR_UUID_STRING_BUFLEN];
|
|
|
|
if (!data->loop && data->count)
|
|
return;
|
|
|
|
virSecretGetUUIDString(secret, uuid);
|
|
if (data->timestamp) {
|
|
char timestamp[VIR_TIME_STRING_BUFLEN];
|
|
|
|
if (virTimeStringNowRaw(timestamp) < 0)
|
|
timestamp[0] = '\0';
|
|
|
|
vshPrint(data->ctl, _("%s: event 'lifecycle' for secret %s: %s\n"),
|
|
timestamp, uuid, virshSecretEventToString(event));
|
|
} else {
|
|
vshPrint(data->ctl, _("event 'lifecycle' for secret %s: %s\n"),
|
|
uuid, virshSecretEventToString(event));
|
|
}
|
|
|
|
data->count++;
|
|
if (!data->loop)
|
|
vshEventDone(data->ctl);
|
|
}
|
|
|
|
static void
|
|
vshEventGenericPrint(virConnectPtr conn G_GNUC_UNUSED,
|
|
virSecretPtr secret,
|
|
void *opaque)
|
|
{
|
|
virshSecretEventData *data = opaque;
|
|
char uuid[VIR_UUID_STRING_BUFLEN];
|
|
|
|
if (!data->loop && data->count)
|
|
return;
|
|
|
|
virSecretGetUUIDString(secret, uuid);
|
|
|
|
if (data->timestamp) {
|
|
char timestamp[VIR_TIME_STRING_BUFLEN];
|
|
|
|
if (virTimeStringNowRaw(timestamp) < 0)
|
|
timestamp[0] = '\0';
|
|
|
|
vshPrint(data->ctl, _("%s: event '%s' for secret %s\n"),
|
|
timestamp,
|
|
data->cb->name,
|
|
uuid);
|
|
} else {
|
|
vshPrint(data->ctl, _("event '%s' for secret %s\n"),
|
|
data->cb->name,
|
|
uuid);
|
|
}
|
|
|
|
data->count++;
|
|
if (!data->loop)
|
|
vshEventDone(data->ctl);
|
|
}
|
|
|
|
virshSecretEventCallback virshSecretEventCallbacks[] = {
|
|
{ "lifecycle",
|
|
VIR_SECRET_EVENT_CALLBACK(vshEventLifecyclePrint), },
|
|
{ "value-changed", vshEventGenericPrint, },
|
|
};
|
|
G_STATIC_ASSERT(VIR_SECRET_EVENT_ID_LAST == G_N_ELEMENTS(virshSecretEventCallbacks));
|
|
|
|
static const vshCmdInfo info_secret_event[] = {
|
|
{.name = "help",
|
|
.data = N_("Secret Events")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("List event types, or wait for secret events to occur")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_secret_event[] = {
|
|
{.name = "secret",
|
|
.type = VSH_OT_STRING,
|
|
.help = N_("filter by secret name or uuid"),
|
|
.completer = virshSecretUUIDCompleter,
|
|
},
|
|
{.name = "event",
|
|
.type = VSH_OT_STRING,
|
|
.completer = virshSecretEventNameCompleter,
|
|
.help = N_("which event type to wait for")
|
|
},
|
|
{.name = "loop",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("loop until timeout or interrupt, rather than one-shot")
|
|
},
|
|
{.name = "timeout",
|
|
.type = VSH_OT_INT,
|
|
.help = N_("timeout seconds")
|
|
},
|
|
{.name = "list",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list valid event types")
|
|
},
|
|
{.name = "timestamp",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("show timestamp for each printed event")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSecretEvent(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
virSecretPtr secret = NULL;
|
|
bool ret = false;
|
|
int eventId = -1;
|
|
int timeout = 0;
|
|
virshSecretEventData data;
|
|
const char *eventName = NULL;
|
|
int event;
|
|
virshControl *priv = ctl->privData;
|
|
|
|
if (vshCommandOptBool(cmd, "list")) {
|
|
size_t i;
|
|
|
|
for (i = 0; i < VIR_SECRET_EVENT_ID_LAST; i++)
|
|
vshPrint(ctl, "%s\n", virshSecretEventCallbacks[i].name);
|
|
return true;
|
|
}
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "event", &eventName) < 0)
|
|
return false;
|
|
if (!eventName) {
|
|
vshError(ctl, "%s", _("either --list or --event <type> is required"));
|
|
return false;
|
|
}
|
|
for (event = 0; event < VIR_SECRET_EVENT_ID_LAST; event++)
|
|
if (STREQ(eventName, virshSecretEventCallbacks[event].name))
|
|
break;
|
|
if (event == VIR_SECRET_EVENT_ID_LAST) {
|
|
vshError(ctl, _("unknown event type %s"), eventName);
|
|
return false;
|
|
}
|
|
|
|
data.ctl = ctl;
|
|
data.loop = vshCommandOptBool(cmd, "loop");
|
|
data.timestamp = vshCommandOptBool(cmd, "timestamp");
|
|
data.count = 0;
|
|
data.cb = &virshSecretEventCallbacks[event];
|
|
if (vshCommandOptTimeoutToMs(ctl, cmd, &timeout) < 0)
|
|
return false;
|
|
|
|
if (vshCommandOptBool(cmd, "secret"))
|
|
secret = virshCommandOptSecret(ctl, cmd, NULL);
|
|
if (vshEventStart(ctl, timeout) < 0)
|
|
goto cleanup;
|
|
|
|
if ((eventId = virConnectSecretEventRegisterAny(priv->conn, secret, event,
|
|
data.cb->cb,
|
|
&data, NULL)) < 0)
|
|
goto cleanup;
|
|
switch (vshEventWait(ctl)) {
|
|
case VSH_EVENT_INTERRUPT:
|
|
vshPrint(ctl, "%s", _("event loop interrupted\n"));
|
|
break;
|
|
case VSH_EVENT_TIMEOUT:
|
|
vshPrint(ctl, "%s", _("event loop timed out\n"));
|
|
break;
|
|
case VSH_EVENT_DONE:
|
|
break;
|
|
default:
|
|
goto cleanup;
|
|
}
|
|
vshPrint(ctl, _("events received: %d\n"), data.count);
|
|
if (data.count)
|
|
ret = true;
|
|
|
|
cleanup:
|
|
vshEventCleanup(ctl);
|
|
if (eventId >= 0 &&
|
|
virConnectSecretEventDeregisterAny(priv->conn, eventId) < 0)
|
|
ret = false;
|
|
virshSecretFree(secret);
|
|
return ret;
|
|
}
|
|
|
|
const vshCmdDef secretCmds[] = {
|
|
{.name = "secret-define",
|
|
.handler = cmdSecretDefine,
|
|
.opts = opts_secret_define,
|
|
.info = info_secret_define,
|
|
.flags = 0
|
|
},
|
|
{.name = "secret-dumpxml",
|
|
.handler = cmdSecretDumpXML,
|
|
.opts = opts_secret_dumpxml,
|
|
.info = info_secret_dumpxml,
|
|
.flags = 0
|
|
},
|
|
{.name = "secret-event",
|
|
.handler = cmdSecretEvent,
|
|
.opts = opts_secret_event,
|
|
.info = info_secret_event,
|
|
.flags = 0
|
|
},
|
|
{.name = "secret-get-value",
|
|
.handler = cmdSecretGetValue,
|
|
.opts = opts_secret_get_value,
|
|
.info = info_secret_get_value,
|
|
.flags = 0
|
|
},
|
|
{.name = "secret-list",
|
|
.handler = cmdSecretList,
|
|
.opts = opts_secret_list,
|
|
.info = info_secret_list,
|
|
.flags = 0
|
|
},
|
|
{.name = "secret-set-value",
|
|
.handler = cmdSecretSetValue,
|
|
.opts = opts_secret_set_value,
|
|
.info = info_secret_set_value,
|
|
.flags = 0
|
|
},
|
|
{.name = "secret-undefine",
|
|
.handler = cmdSecretUndefine,
|
|
.opts = opts_secret_undefine,
|
|
.info = info_secret_undefine,
|
|
.flags = 0
|
|
},
|
|
{.name = NULL}
|
|
};
|