static int
virDomainCapsEnumFormat(virBufferPtr buf,
virDomainCapsEnumPtr capsEnum,
const char *capsEnumName,
virDomainCapsValToStr valToStr)
{
int ret = -1;
size_t i;
virBufferAsprintf(buf, "<enum name='%s'", capsEnumName);
if (!capsEnum->values) {
virBufferAddLit(buf, "/>\n");
ret = 0;
goto cleanup;
}
virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2);
for (i = 0; i < sizeof(capsEnum->values) * CHAR_BIT; i++) {
const char *val;
if (!(capsEnum->values & (1 << i)))
continue;
if ((val = (valToStr)(i)))
virBufferAsprintf(buf, "<value>%s</value>\n", val);
}
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</enum>\n");
ret = 0;
cleanup:
return ret;
}
static void
qemuMigrationCookieNetworkXMLFormat(virBufferPtr buf,
qemuMigrationCookieNetworkPtr optr)
{
size_t i;
bool empty = true;
for (i = 0; i < optr->nnets; i++) {
/* If optr->net[i].vporttype is not set, there is nothing to transfer */
if (optr->net[i].vporttype != VIR_NETDEV_VPORT_PROFILE_NONE) {
if (empty) {
virBufferAddLit(buf, "<network>\n");
virBufferAdjustIndent(buf, 2);
empty = false;
}
virBufferAsprintf(buf, "<interface index='%zu' vporttype='%s'",
i, virNetDevVPortTypeToString(optr->net[i].vporttype));
if (optr->net[i].portdata) {
virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2);
virBufferEscapeString(buf, "<portdata>%s</portdata>\n",
optr->net[i].portdata);
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</interface>\n");
} else {
virBufferAddLit(buf, "/>\n");
}
}
}
if (!empty) {
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</network>\n");
}
}
/**
* virNetDevBandwidthFormat:
* @def: Data source
* @buf: Buffer to print to
*
* Formats bandwidth and prepend each line with @indent.
* @buf may use auto-indentation.
*
* Returns 0 on success, else -1.
*/
int
virNetDevBandwidthFormat(virNetDevBandwidthPtr def, virBufferPtr buf)
{
int ret = -1;
if (!buf)
goto cleanup;
if (!def) {
ret = 0;
goto cleanup;
}
virBufferAddLit(buf, "<bandwidth>\n");
virBufferAdjustIndent(buf, 2);
if (virNetDevBandwidthRateFormat(def->in, buf, "inbound") < 0 ||
virNetDevBandwidthRateFormat(def->out, buf, "outbound") < 0)
goto cleanup;
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</bandwidth>\n");
ret = 0;
cleanup:
return ret;
}
static void
virDomainSnapshotDiskDefFormat(virBufferPtr buf,
virDomainSnapshotDiskDefPtr disk)
{
int type = disk->type;
if (!disk->name)
return;
virBufferEscapeString(buf, " <disk name='%s'", disk->name);
if (disk->snapshot > 0)
virBufferAsprintf(buf, " snapshot='%s'",
virDomainSnapshotLocationTypeToString(disk->snapshot));
if (type < 0)
type = VIR_DOMAIN_DISK_TYPE_FILE;
if (!disk->file && disk->format == 0) {
virBufferAddLit(buf, "/>\n");
return;
}
virBufferAddLit(buf, ">\n");
if (disk->format > 0)
virBufferEscapeString(buf, " <driver type='%s'/>\n",
virStorageFileFormatTypeToString(disk->format));
virDomainDiskSourceDefFormatInternal(buf,
type,
disk->file,
0, 0, 0, NULL, 0, NULL, NULL, 0);
virBufferAddLit(buf, " </disk>\n");
}
static void
virDomainSnapshotDiskDefFormat(virBufferPtr buf,
virDomainSnapshotDiskDefPtr disk)
{
int type = disk->src->type;
if (!disk->name)
return;
virBufferEscapeString(buf, "<disk name='%s'", disk->name);
if (disk->snapshot > 0)
virBufferAsprintf(buf, " snapshot='%s'",
virDomainSnapshotLocationTypeToString(disk->snapshot));
if (!disk->src->path && disk->src->format == 0) {
virBufferAddLit(buf, "/>\n");
return;
}
virBufferAsprintf(buf, " type='%s'>\n", virStorageTypeToString(type));
virBufferAdjustIndent(buf, 2);
if (disk->src->format > 0)
virBufferEscapeString(buf, "<driver type='%s'/>\n",
virStorageFileFormatTypeToString(disk->src->format));
virDomainDiskSourceFormat(buf, disk->src, 0, 0);
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</disk>\n");
}
static virDomainPtr
hypervDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
virDomainPtr domain = NULL;
hypervPrivate *priv = conn->privateData;
char uuid_string[VIR_UUID_STRING_BUFLEN];
virBuffer query = VIR_BUFFER_INITIALIZER;
Msvm_ComputerSystem *computerSystem = NULL;
virUUIDFormat(uuid, uuid_string);
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_SELECT);
virBufferAddLit(&query, "where ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_VIRTUAL);
virBufferAsprintf(&query, "and Name = \"%s\"", uuid_string);
if (hypervGetMsvmComputerSystemList(priv, &query, &computerSystem) < 0) {
goto cleanup;
}
if (computerSystem == NULL) {
virReportError(VIR_ERR_NO_DOMAIN,
_("No domain with UUID %s"), uuid_string);
goto cleanup;
}
hypervMsvmComputerSystemToDomain(conn, computerSystem, &domain);
cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return domain;
}
static int
hypervConnectNumOfDefinedDomains(virConnectPtr conn)
{
bool success = false;
hypervPrivate *priv = conn->privateData;
virBuffer query = VIR_BUFFER_INITIALIZER;
Msvm_ComputerSystem *computerSystemList = NULL;
Msvm_ComputerSystem *computerSystem = NULL;
int count = 0;
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_SELECT);
virBufferAddLit(&query, "where ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_VIRTUAL);
virBufferAddLit(&query, "and ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_INACTIVE);
if (hypervGetMsvmComputerSystemList(priv, &query,
&computerSystemList) < 0) {
goto cleanup;
}
for (computerSystem = computerSystemList; computerSystem != NULL;
computerSystem = computerSystem->next) {
++count;
}
success = true;
cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystemList);
return success ? count : -1;
}
static virDomainPtr
hypervDomainLookupByName(virConnectPtr conn, const char *name)
{
virDomainPtr domain = NULL;
hypervPrivate *priv = conn->privateData;
virBuffer query = VIR_BUFFER_INITIALIZER;
Msvm_ComputerSystem *computerSystem = NULL;
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_SELECT);
virBufferAddLit(&query, "where ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_VIRTUAL);
virBufferAsprintf(&query, "and ElementName = \"%s\"", name);
if (hypervGetMsvmComputerSystemList(priv, &query, &computerSystem) < 0) {
goto cleanup;
}
if (computerSystem == NULL) {
virReportError(VIR_ERR_NO_DOMAIN,
_("No domain with name %s"), name);
goto cleanup;
}
hypervMsvmComputerSystemToDomain(conn, computerSystem, &domain);
cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return domain;
}
static int
virInterfaceBridgeDefFormat(virBufferPtr buf,
const virInterfaceDef *def, int level)
{
size_t i;
int ret = 0;
virBufferAsprintf(buf, "%*s <bridge", level*2, "");
if (def->data.bridge.stp == 1)
virBufferAddLit(buf, " stp='on'");
else if (def->data.bridge.stp == 0)
virBufferAddLit(buf, " stp='off'");
if (def->data.bridge.delay != NULL)
virBufferAsprintf(buf, " delay='%s'", def->data.bridge.delay);
virBufferAddLit(buf, ">\n");
for (i = 0; i < def->data.bridge.nbItf; i++) {
if (virInterfaceDefDevFormat(buf,
def->data.bridge.itf[i], level+2) < 0)
ret = -1;
}
virBufferAsprintf(buf, "%*s </bridge>\n", level*2, "");
return ret;
}
static void
virSysinfoBaseBoardFormat(virBufferPtr buf,
virSysinfoBaseBoardDefPtr baseBoard,
size_t nbaseBoard)
{
virSysinfoBaseBoardDefPtr def;
size_t i;
for (i = 0; i < nbaseBoard; i++) {
def = baseBoard + i;
virBufferAddLit(buf, "<baseBoard>\n");
virBufferAdjustIndent(buf, 2);
virBufferEscapeString(buf, "<entry name='manufacturer'>%s</entry>\n",
def->manufacturer);
virBufferEscapeString(buf, "<entry name='product'>%s</entry>\n",
def->product);
virBufferEscapeString(buf, "<entry name='version'>%s</entry>\n",
def->version);
virBufferEscapeString(buf, "<entry name='serial'>%s</entry>\n",
def->serial);
virBufferEscapeString(buf, "<entry name='asset'>%s</entry>\n",
def->asset);
virBufferEscapeString(buf, "<entry name='location'>%s</entry>\n",
def->location);
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</baseBoard>\n");
}
}
static void
virSysinfoSystemFormat(virBufferPtr buf, virSysinfoSystemDefPtr def)
{
if (!def)
return;
virBufferAddLit(buf, "<system>\n");
virBufferAdjustIndent(buf, 2);
virBufferEscapeString(buf, "<entry name='manufacturer'>%s</entry>\n",
def->manufacturer);
virBufferEscapeString(buf, "<entry name='product'>%s</entry>\n",
def->product);
virBufferEscapeString(buf, "<entry name='version'>%s</entry>\n",
def->version);
virBufferEscapeString(buf, "<entry name='serial'>%s</entry>\n",
def->serial);
virBufferEscapeString(buf, "<entry name='uuid'>%s</entry>\n",
def->uuid);
virBufferEscapeString(buf, "<entry name='sku'>%s</entry>\n",
def->sku);
virBufferEscapeString(buf, "<entry name='family'>%s</entry>\n",
def->family);
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</system>\n");
}
static void
virSysinfoSystemFormat(virBufferPtr buf, virSysinfoDefPtr def)
{
if (!def->system_manufacturer && !def->system_product &&
!def->system_version && !def->system_serial &&
!def->system_uuid && !def->system_sku && !def->system_family)
return;
virBufferAddLit(buf, " <system>\n");
virBufferEscapeString(buf, " <entry name='manufacturer'>%s</entry>\n",
def->system_manufacturer);
virBufferEscapeString(buf, " <entry name='product'>%s</entry>\n",
def->system_product);
virBufferEscapeString(buf, " <entry name='version'>%s</entry>\n",
def->system_version);
virBufferEscapeString(buf, " <entry name='serial'>%s</entry>\n",
def->system_serial);
virBufferEscapeString(buf, " <entry name='uuid'>%s</entry>\n",
def->system_uuid);
virBufferEscapeString(buf, " <entry name='sku'>%s</entry>\n",
def->system_sku);
virBufferEscapeString(buf, " <entry name='family'>%s</entry>\n",
def->system_family);
virBufferAddLit(buf, " </system>\n");
}
static virDomainPtr
hypervDomainLookupByID(virConnectPtr conn, int id)
{
virDomainPtr domain = NULL;
hypervPrivate *priv = conn->privateData;
virBuffer query = VIR_BUFFER_INITIALIZER;
Msvm_ComputerSystem *computerSystem = NULL;
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_SELECT);
virBufferAddLit(&query, "where ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_VIRTUAL);
virBufferAsprintf(&query, "and ProcessID = %d", id);
if (hypervGetMsvmComputerSystemList(priv, &query, &computerSystem) < 0) {
goto cleanup;
}
if (computerSystem == NULL) {
HYPERV_ERROR(VIR_ERR_NO_DOMAIN, _("No domain with ID %d"), id);
goto cleanup;
}
hypervMsvmComputerSystemToDomain(conn, computerSystem, &domain);
cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return domain;
}
static int
hypervListDefinedDomains(virConnectPtr conn, char **const names, int maxnames)
{
bool success = false;
hypervPrivate *priv = conn->privateData;
virBuffer query = VIR_BUFFER_INITIALIZER;
Msvm_ComputerSystem *computerSystemList = NULL;
Msvm_ComputerSystem *computerSystem = NULL;
int count = 0;
int i;
if (maxnames == 0) {
return 0;
}
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_SELECT);
virBufferAddLit(&query, "where ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_VIRTUAL);
virBufferAddLit(&query, "and ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_INACTIVE);
if (hypervGetMsvmComputerSystemList(priv, &query,
&computerSystemList) < 0) {
goto cleanup;
}
for (computerSystem = computerSystemList; computerSystem != NULL;
computerSystem = computerSystem->next) {
names[count] = strdup(computerSystem->data->ElementName);
if (names[count] == NULL) {
virReportOOMError();
goto cleanup;
}
++count;
if (count >= maxnames) {
break;
}
}
success = true;
cleanup:
if (!success) {
for (i = 0; i < count; ++i) {
VIR_FREE(names[i]);
}
count = -1;
}
hypervFreeObject(priv, (hypervObject *)computerSystemList);
return count;
}
static void
virSysinfoMemoryFormat(virBufferPtr buf, virSysinfoDefPtr def)
{
size_t i;
virSysinfoMemoryDefPtr memory;
for (i = 0; i < def->nmemory; i++) {
memory = &def->memory[i];
if (!memory->memory_size &&
!memory->memory_form_factor &&
!memory->memory_locator &&
!memory->memory_bank_locator &&
!memory->memory_type &&
!memory->memory_type_detail &&
!memory->memory_speed &&
!memory->memory_manufacturer &&
!memory->memory_serial_number &&
!memory->memory_part_number)
continue;
virBufferAddLit(buf, "<memory_device>\n");
virBufferAdjustIndent(buf, 2);
virBufferEscapeString(buf, "<entry name='size'>%s</entry>\n",
memory->memory_size);
virBufferEscapeString(buf,
"<entry name='form_factor'>%s</entry>\n",
memory->memory_form_factor);
virBufferEscapeString(buf, "<entry name='locator'>%s</entry>\n",
memory->memory_locator);
virBufferEscapeString(buf,
"<entry name='bank_locator'>%s</entry>\n",
memory->memory_bank_locator);
virBufferEscapeString(buf, "<entry name='type'>%s</entry>\n",
memory->memory_type);
virBufferEscapeString(buf,
"<entry name='type_detail'>%s</entry>\n",
memory->memory_type_detail);
virBufferEscapeString(buf, "<entry name='speed'>%s</entry>\n",
memory->memory_speed);
virBufferEscapeString(buf,
"<entry name='manufacturer'>%s</entry>\n",
memory->memory_manufacturer);
virBufferEscapeString(buf,
"<entry name='serial_number'>%s</entry>\n",
memory->memory_serial_number);
virBufferEscapeString(buf,
"<entry name='part_number'>%s</entry>\n",
memory->memory_part_number);
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</memory_device>\n");
}
}
static void
virSysinfoProcessorFormat(virBufferPtr buf, virSysinfoDefPtr def)
{
int i;
virSysinfoProcessorDefPtr processor;
for (i = 0; i < def->nprocessor; i++) {
processor = &def->processor[i];
if (!processor->processor_socket_destination &&
!processor->processor_type &&
!processor->processor_family &&
!processor->processor_manufacturer &&
!processor->processor_signature &&
!processor->processor_version &&
!processor->processor_external_clock &&
!processor->processor_max_speed &&
!processor->processor_status &&
!processor->processor_serial_number &&
!processor->processor_part_number)
continue;
virBufferAddLit(buf, " <processor>\n");
virBufferAdjustIndent(buf, 4);
virBufferEscapeString(buf,
"<entry name='socket_destination'>%s</entry>\n",
processor->processor_socket_destination);
virBufferEscapeString(buf, "<entry name='type'>%s</entry>\n",
processor->processor_type);
virBufferEscapeString(buf, "<entry name='family'>%s</entry>\n",
processor->processor_family);
virBufferEscapeString(buf, "<entry name='manufacturer'>%s</entry>\n",
processor->processor_manufacturer);
virBufferEscapeString(buf, "<entry name='signature'>%s</entry>\n",
processor->processor_signature);
virBufferEscapeString(buf, "<entry name='version'>%s</entry>\n",
processor->processor_version);
virBufferEscapeString(buf, "<entry name='external_clock'>%s</entry>\n",
processor->processor_external_clock);
virBufferEscapeString(buf, "<entry name='max_speed'>%s</entry>\n",
processor->processor_max_speed);
virBufferEscapeString(buf, "<entry name='status'>%s</entry>\n",
processor->processor_status);
virBufferEscapeString(buf, "<entry name='serial_number'>%s</entry>\n",
processor->processor_serial_number);
virBufferEscapeString(buf, "<entry name='part_number'>%s</entry>\n",
processor->processor_part_number);
virBufferAdjustIndent(buf, -4);
virBufferAddLit(buf, " </processor>\n");
}
}
int
virDomainNumatuneFormatXML(virBufferPtr buf,
virDomainNumatunePtr numatune)
{
const char *tmp = NULL;
char *nodeset = NULL;
size_t i = 0;
if (!numatune)
return 0;
virBufferAddLit(buf, "<numatune>\n");
virBufferAdjustIndent(buf, 2);
if (numatune->memory.specified) {
tmp = virDomainNumatuneMemModeTypeToString(numatune->memory.mode);
virBufferAsprintf(buf, "<memory mode='%s' ", tmp);
if (numatune->memory.placement == VIR_DOMAIN_NUMATUNE_PLACEMENT_STATIC) {
if (!(nodeset = virBitmapFormat(numatune->memory.nodeset)))
return -1;
virBufferAsprintf(buf, "nodeset='%s'/>\n", nodeset);
VIR_FREE(nodeset);
} else if (numatune->memory.placement) {
tmp = virDomainNumatunePlacementTypeToString(numatune->memory.placement);
virBufferAsprintf(buf, "placement='%s'/>\n", tmp);
}
}
for (i = 0; i < numatune->nmem_nodes; i++) {
virDomainNumatuneNodePtr mem_node = &numatune->mem_nodes[i];
if (!mem_node->nodeset)
continue;
if (!(nodeset = virBitmapFormat(mem_node->nodeset)))
return -1;
virBufferAsprintf(buf,
"<memnode cellid='%zu' mode='%s' nodeset='%s'/>\n",
i,
virDomainNumatuneMemModeTypeToString(mem_node->mode),
nodeset);
VIR_FREE(nodeset);
}
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</numatune>\n");
return 0;
}
int
virCPUDefFormatBufFull(virBufferPtr buf,
virCPUDefPtr def,
unsigned int flags)
{
if (!def)
return 0;
virBufferAddLit(buf, "<cpu");
if (def->type == VIR_CPU_TYPE_GUEST) {
const char *tmp;
if (def->mode != VIR_CPU_MODE_CUSTOM || def->model) {
if (!(tmp = virCPUModeTypeToString(def->mode))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unexpected CPU mode %d"), def->mode);
return -1;
}
virBufferAsprintf(buf, " mode='%s'", tmp);
}
if (def->model &&
(def->mode == VIR_CPU_MODE_CUSTOM ||
(flags & VIR_DOMAIN_XML_UPDATE_CPU))) {
if (!(tmp = virCPUMatchTypeToString(def->match))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unexpected CPU match policy %d"),
def->match);
return -1;
}
virBufferAsprintf(buf, " match='%s'", tmp);
}
}
virBufferAddLit(buf, ">\n");
if (def->arch)
virBufferAsprintf(buf, " <arch>%s</arch>\n",
virArchToString(def->arch));
virBufferAdjustIndent(buf, 2);
if (virCPUDefFormatBuf(buf, def, flags) < 0)
return -1;
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</cpu>\n");
return 0;
}
static int
virNetDevBandwidthRateFormat(virNetDevBandwidthRatePtr def,
virBufferPtr buf,
const char *elem_name)
{
if (!buf || !elem_name)
return -1;
if (!def)
return 0;
if (def->average || def->floor) {
virBufferAsprintf(buf, "<%s", elem_name);
if (def->average)
virBufferAsprintf(buf, " average='%llu'", def->average);
if (def->peak)
virBufferAsprintf(buf, " peak='%llu'", def->peak);
if (def->floor)
virBufferAsprintf(buf, " floor='%llu'", def->floor);
if (def->burst)
virBufferAsprintf(buf, " burst='%llu'", def->burst);
virBufferAddLit(buf, "/>\n");
}
return 0;
}
/**
* virSysinfoFormat:
* @buf: buffer to append output to (may use auto-indentation)
* @def: structure to convert to xml string
*
* Returns 0 on success, -1 on failure after generating an error message.
*/
int
virSysinfoFormat(virBufferPtr buf, virSysinfoDefPtr def)
{
const char *type = virSysinfoTypeToString(def->type);
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected sysinfo type model %d"),
def->type);
virBufferFreeAndReset(buf);
return -1;
}
virBufferAsprintf(buf, "<sysinfo type='%s'>\n", type);
virSysinfoBIOSFormat(buf, def);
virSysinfoSystemFormat(buf, def);
virSysinfoProcessorFormat(buf, def);
virSysinfoMemoryFormat(buf, def);
virBufferAddLit(buf, "</sysinfo>\n");
if (virBufferError(buf)) {
virReportOOMError();
return -1;
}
return 0;
}
int
virNetDevVlanFormat(virNetDevVlanPtr def, virBufferPtr buf)
{
size_t i;
if (def->nTags == 0)
return 0;
if (!def->tag) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("missing vlan tag data"));
return -1;
}
virBufferAsprintf(buf, "<vlan%s>\n", def->trunk ? " trunk='yes'" : "");
for (i = 0; i < def->nTags; i++) {
if (def->nativeMode != VIR_NATIVE_VLAN_MODE_DEFAULT &&
def->nativeTag == def->tag[i]) {
/* check the nativeMode in case we get <tag id='0'/>*/
const char *mode = virNativeVlanModeTypeToString(def->nativeMode);
if (!mode) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Bad value for nativeMode"));
}
virBufferAsprintf(buf, " <tag id='%u' nativeMode='%s'/>\n",
def->tag[i], mode);
} else {
virBufferAsprintf(buf, " <tag id='%u'/>\n", def->tag[i]);
}
}
virBufferAddLit(buf, "</vlan>\n");
return 0;
}
char *virSystemdMakeScopeName(const char *name,
const char *drivername)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBufferAddLit(&buf, "machine-");
virSystemdEscapeName(&buf, drivername);
virBufferAddLit(&buf, "\\x2d");
virSystemdEscapeName(&buf, name);
virBufferAddLit(&buf, ".scope");
if (virBufferCheckError(&buf) < 0)
return NULL;
return virBufferContentAndReset(&buf);
}
static int
cpuTestGuestData(const void *arg)
{
const struct data *data = arg;
int ret = -1;
virCPUDefPtr host = NULL;
virCPUDefPtr cpu = NULL;
virCPUDefPtr guest = NULL;
union cpuData *guestData = NULL;
virCPUCompareResult cmpResult;
virBuffer buf = VIR_BUFFER_INITIALIZER;
char *result = NULL;
if (!(host = cpuTestLoadXML(data->arch, data->host)) ||
!(cpu = cpuTestLoadXML(data->arch, data->name)))
goto cleanup;
cmpResult = cpuGuestData(host, cpu, &guestData);
if (cmpResult == VIR_CPU_COMPARE_ERROR ||
cmpResult == VIR_CPU_COMPARE_INCOMPATIBLE)
goto cleanup;
if (VIR_ALLOC(guest) < 0 || !(guest->arch = strdup(host->arch)))
goto cleanup;
guest->type = VIR_CPU_TYPE_GUEST;
guest->match = VIR_CPU_MATCH_EXACT;
if (cpuDecode(guest, guestData, data->models,
data->nmodels, data->preferred) < 0) {
if (data->result < 0) {
virResetLastError();
ret = 0;
}
goto cleanup;
}
virBufferAsprintf(&buf, "%s+%s", data->host, data->name);
if (data->nmodels)
virBufferAsprintf(&buf, ",%s", data->modelsName);
if (data->preferred)
virBufferAsprintf(&buf, ",%s", data->preferred);
virBufferAddLit(&buf, "-result");
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
goto cleanup;
}
result = virBufferContentAndReset(&buf);
ret = cpuTestCompareXML(data->arch, guest, result);
cleanup:
VIR_FREE(result);
if (host)
cpuDataFree(host->arch, guestData);
virCPUDefFree(host);
virCPUDefFree(cpu);
virCPUDefFree(guest);
return ret;
}
int
virStorageEncryptionFormat(virBufferPtr buf,
virStorageEncryptionPtr enc)
{
const char *format;
size_t i;
if (!(format = virStorageEncryptionFormatTypeToString(enc->format))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("unexpected encryption format"));
return -1;
}
virBufferAsprintf(buf, "<encryption format='%s'>\n", format);
virBufferAdjustIndent(buf, 2);
for (i = 0; i < enc->nsecrets; i++) {
if (virStorageEncryptionSecretFormat(buf, enc->secrets[i]) < 0)
return -1;
}
if (enc->format == VIR_STORAGE_ENCRYPTION_FORMAT_LUKS &&
enc->encinfo.cipher_name)
virStorageEncryptionInfoDefFormat(buf, &enc->encinfo);
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</encryption>\n");
return 0;
}
char *
virSecretDefFormat(const virSecretDef *def)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const unsigned char *uuid;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virBufferAsprintf(&buf, "<secret ephemeral='%s' private='%s'>\n",
def->isephemeral ? "yes" : "no",
def->isprivate ? "yes" : "no");
uuid = def->uuid;
virUUIDFormat(uuid, uuidstr);
virBufferAdjustIndent(&buf, 2);
virBufferEscapeString(&buf, "<uuid>%s</uuid>\n", uuidstr);
if (def->description != NULL)
virBufferEscapeString(&buf, "<description>%s</description>\n",
def->description);
if (def->usage_type != VIR_SECRET_USAGE_TYPE_NONE &&
virSecretDefFormatUsage(&buf, def) < 0)
goto error;
virBufferAdjustIndent(&buf, -2);
virBufferAddLit(&buf, "</secret>\n");
if (virBufferCheckError(&buf) < 0)
goto error;
return virBufferContentAndReset(&buf);
error:
virBufferFreeAndReset(&buf);
return NULL;
}
static char *
hypervConnectGetHostname(virConnectPtr conn)
{
char *hostname = NULL;
hypervPrivate *priv = conn->privateData;
virBuffer query = VIR_BUFFER_INITIALIZER;
Win32_ComputerSystem *computerSystem = NULL;
virBufferAddLit(&query, WIN32_COMPUTERSYSTEM_WQL_SELECT);
if (hypervGetWin32ComputerSystemList(priv, &query, &computerSystem) < 0) {
goto cleanup;
}
if (computerSystem == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Could not lookup %s"),
"Win32_ComputerSystem");
goto cleanup;
}
ignore_value(VIR_STRDUP(hostname, computerSystem->data->DNSHostName));
cleanup:
hypervFreeObject(priv, (hypervObject *)computerSystem);
return hostname;
}
int
virStorageEncryptionFormat(virBufferPtr buf,
virStorageEncryptionPtr enc)
{
const char *format;
size_t i;
format = virStorageEncryptionFormatTypeToString(enc->format);
if (!format) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("unexpected encryption format"));
return -1;
}
virBufferAsprintf(buf, "<encryption format='%s'>\n", format);
virBufferAdjustIndent(buf, 2);
for (i = 0; i < enc->nsecrets; i++) {
if (virStorageEncryptionSecretFormat(buf, enc->secrets[i]) < 0)
return -1;
}
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</encryption>\n");
return 0;
}
/**
* virConfSaveValue:
* @buf: output buffer
* @val: a value
*
* Serialize the value to the buffer
*
* Returns 0 in case of success, -1 in case of error.
*/
static int
virConfSaveValue(virBufferPtr buf, virConfValuePtr val)
{
if (val == NULL)
return -1;
switch (val->type) {
case VIR_CONF_NONE:
return -1;
case VIR_CONF_LLONG:
virBufferAsprintf(buf, "%lld", val->l);
break;
case VIR_CONF_ULLONG:
virBufferAsprintf(buf, "%llu", val->l);
break;
case VIR_CONF_STRING:
if (strchr(val->str, '\n') != NULL) {
virBufferAsprintf(buf, "\"\"\"%s\"\"\"", val->str);
} else if (strchr(val->str, '"') == NULL) {
virBufferAsprintf(buf, "\"%s\"", val->str);
} else if (strchr(val->str, '\'') == NULL) {
virBufferAsprintf(buf, "'%s'", val->str);
} else {
virBufferAsprintf(buf, "\"\"\"%s\"\"\"", val->str);
}
break;
case VIR_CONF_LIST: {
virConfValuePtr cur;
cur = val->list;
virBufferAddLit(buf, "[ ");
if (cur != NULL) {
virConfSaveValue(buf, cur);
cur = cur->next;
while (cur != NULL) {
virBufferAddLit(buf, ", ");
virConfSaveValue(buf, cur);
cur = cur->next;
}
}
virBufferAddLit(buf, " ]");
break;
}
default:
return -1;
}
return 0;
}
static void
virSysinfoBIOSFormat(virBufferPtr buf, virSysinfoDefPtr def)
{
if (!def->bios_vendor && !def->bios_version &&
!def->bios_date && !def->bios_release)
return;
virBufferAddLit(buf, " <bios>\n");
virBufferEscapeString(buf, " <entry name='vendor'>%s</entry>\n",
def->bios_vendor);
virBufferEscapeString(buf, " <entry name='version'>%s</entry>\n",
def->bios_version);
virBufferEscapeString(buf, " <entry name='date'>%s</entry>\n",
def->bios_date);
virBufferEscapeString(buf, " <entry name='release'>%s</entry>\n",
def->bios_release);
virBufferAddLit(buf, " </bios>\n");
}
/**
* virConfSaveEntry:
* @buf: output buffer
* @cur: a conf entry
*
* Serialize the entry to the buffer
*
* Returns 0 in case of success, -1 in case of error.
*/
static int
virConfSaveEntry(virBufferPtr buf, virConfEntryPtr cur)
{
if (cur->name != NULL) {
virBufferAdd(buf, cur->name, -1);
virBufferAddLit(buf, " = ");
virConfSaveValue(buf, cur->value);
if (cur->comment != NULL) {
virBufferAddLit(buf, " #");
virBufferAdd(buf, cur->comment, -1);
}
} else if (cur->comment != NULL) {
virBufferAddLit(buf, "#");
virBufferAdd(buf, cur->comment, -1);
}
virBufferAddLit(buf, "\n");
return 0;
}
