自学教程：C++ virBufferAddLit函数代码示例

static intvirDomainCapsEnumFormat(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 voidqemuMigrationCookieNetworkXMLFormat(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. */intvirNetDevBandwidthFormat(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 voidvirDomainSnapshotDiskDefFormat(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 voidvirDomainSnapshotDiskDefFormat(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 virDomainPtrhypervDomainLookupByUUID(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 inthypervConnectNumOfDefinedDomains(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 virDomainPtrhypervDomainLookupByName(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 intvirInterfaceBridgeDefFormat(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 voidvirSysinfoBaseBoardFormat(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 voidvirSysinfoSystemFormat(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 voidvirSysinfoSystemFormat(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 virDomainPtrhypervDomainLookupByID(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 inthypervListDefinedDomains(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 voidvirSysinfoMemoryFormat(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 voidvirSysinfoProcessorFormat(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");    }}

intvirDomainNumatuneFormatXML(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;}

intvirCPUDefFormatBufFull(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 intvirNetDevBandwidthRateFormat(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. */intvirSysinfoFormat(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;}

intvirNetDevVlanFormat(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 intcpuTestGuestData(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;}

intvirStorageEncryptionFormat(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;}

intvirStorageEncryptionFormat(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 intvirConfSaveValue(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 voidvirSysinfoBIOSFormat(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 intvirConfSaveEntry(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;}