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

char *virSystemdMakeMachineName(const char *name,                                const char *drivername,                                bool privileged){    char *machinename = NULL;    char *username = NULL;    virBuffer buf = VIR_BUFFER_INITIALIZER;    if (privileged) {        virBufferAsprintf(&buf, "%s-", drivername);    } else {        if (!(username = virGetUserName(geteuid())))            goto cleanup;        virBufferAsprintf(&buf, "%s-%s-", username, drivername);    }    virSystemdEscapeName(&buf, name, false);    machinename = virBufferContentAndReset(&buf); cleanup:    VIR_FREE(username);    return machinename;}

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

intvirQEMUBuildCommandLineJSONArrayBitmap(const char *key,                                       virJSONValuePtr array,                                       virBufferPtr buf){    ssize_t pos = -1;    ssize_t end;    virBitmapPtr bitmap = NULL;    if (virJSONValueGetArrayAsBitmap(array, &bitmap) < 0)        return -1;    while ((pos = virBitmapNextSetBit(bitmap, pos)) > -1) {        if ((end = virBitmapNextClearBit(bitmap, pos)) < 0)            end = virBitmapLastSetBit(bitmap) + 1;        if (end - 1 > pos) {            virBufferAsprintf(buf, "%s=%zd-%zd,", key, pos, end - 1);            pos = end;        } else {            virBufferAsprintf(buf, "%s=%zd,", key, pos);        }    }    virBitmapFree(bitmap);    return 0;}

static dnsmasqHostsfile *hostsfileNew(const char *name,             const char *config_dir){    dnsmasqHostsfile *hostsfile;    virBuffer buf = VIR_BUFFER_INITIALIZER;    if (VIR_ALLOC(hostsfile) < 0)        return NULL;    hostsfile->hosts = NULL;    hostsfile->nhosts = 0;    virBufferAsprintf(&buf, "%s", config_dir);    virBufferEscapeString(&buf, "/%s", name);    virBufferAsprintf(&buf, ".%s", DNSMASQ_HOSTSFILE_SUFFIX);    if (virBufferCheckError(&buf) < 0)                goto error;    if (!(hostsfile->path = virBufferContentAndReset(&buf)))        goto error;    return hostsfile; error:    virBufferFreeAndReset(&buf);    hostsfileFree(hostsfile);    return NULL;}

static inttestQEMUSchemaValidateBuiltin(virJSONValuePtr obj,                              virJSONValuePtr root,                              virBufferPtr debug){    const char *t = virJSONValueObjectGetString(root, "json-type");    const char *s = NULL;    bool b = false;    int ret = -1;    if (STREQ_NULLABLE(t, "value")) {        s = "{any}";        ret = 0;        goto cleanup;    }    switch (virJSONValueGetType(obj)) {    case VIR_JSON_TYPE_STRING:        if (STRNEQ_NULLABLE(t, "string"))            goto cleanup;        s = virJSONValueGetString(obj);        break;    case VIR_JSON_TYPE_NUMBER:        if (STRNEQ_NULLABLE(t, "int") &&            STRNEQ_NULLABLE(t, "number"))            goto cleanup;        s = "{number}";        break;    case VIR_JSON_TYPE_BOOLEAN:        if (STRNEQ_NULLABLE(t, "boolean"))            goto cleanup;        virJSONValueGetBoolean(obj, &b);        if (b)            s = "true";        else            s = "false";        break;    case VIR_JSON_TYPE_NULL:        if (STRNEQ_NULLABLE(t, "null"))            goto cleanup;        break;    case VIR_JSON_TYPE_OBJECT:    case VIR_JSON_TYPE_ARRAY:        goto cleanup;    }    ret = 0; cleanup:    if (ret == 0)        virBufferAsprintf(debug, "'%s': OK", s);    else        virBufferAsprintf(debug, "ERROR: expected type '%s', actual type %d",                          t, virJSONValueGetType(obj));    return ret;}

static int udevGenerateDeviceName(struct udev_device *device,                                  virNodeDeviceDefPtr def,                                  const char *s){    int ret = 0, i = 0;    virBuffer buf = VIR_BUFFER_INITIALIZER;    virBufferAsprintf(&buf, "%s_%s",                      udev_device_get_subsystem(device),                      udev_device_get_sysname(device));    if (s != NULL) {        virBufferAsprintf(&buf, "_%s", s);    }    if (virBufferError(&buf)) {        virBufferFreeAndReset(&buf);        VIR_ERROR(_("Buffer error when generating device name for device "                    "with sysname '%s'"), udev_device_get_sysname(device));        ret = -1;    }    def->name = virBufferContentAndReset(&buf);    for (i = 0; i < strlen(def->name) ; i++) {        if (!(c_isalnum(*(def->name + i)))) {            *(def->name + i) = '_';        }    }    return ret;}

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

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

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 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");}

intvirNetDevVPortProfileFormat(virNetDevVPortProfilePtr virtPort,                            virBufferPtr buf){    char uuidstr[VIR_UUID_STRING_BUFLEN];    if (!virtPort || virtPort->virtPortType == VIR_NETDEV_VPORT_PROFILE_NONE)        return 0;    virBufferAsprintf(buf, "<virtualport type='%s'>/n",                      virNetDevVPortTypeToString(virtPort->virtPortType));    switch (virtPort->virtPortType) {    case VIR_NETDEV_VPORT_PROFILE_8021QBG:        virUUIDFormat(virtPort->u.virtPort8021Qbg.instanceID,                      uuidstr);        virBufferAsprintf(buf,                          "  <parameters managerid='%d' typeid='%d' "                          "typeidversion='%d' instanceid='%s'/>/n",                          virtPort->u.virtPort8021Qbg.managerID,                          virtPort->u.virtPort8021Qbg.typeID,                          virtPort->u.virtPort8021Qbg.typeIDVersion,                          uuidstr);        break;    case VIR_NETDEV_VPORT_PROFILE_8021QBH:        virBufferAsprintf(buf,                          "  <parameters profileid='%s'/>/n",                          virtPort->u.virtPort8021Qbh.profileID);        break;    case VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH:        virUUIDFormat(virtPort->u.openvswitch.interfaceID,                      uuidstr);        if (virtPort->u.openvswitch.profileID[0] == '/0') {            virBufferAsprintf(buf, "  <parameters interfaceid='%s'/>/n",                              uuidstr);        } else {            virBufferAsprintf(buf, "  <parameters interfaceid='%s' "                              "profileid='%s'/>/n", uuidstr,                              virtPort->u.openvswitch.profileID);        }        break;    default:        virReportError(VIR_ERR_XML_ERROR,                       _("unexpected virtualport type %d"), virtPort->virtPortType);        return -1;    }    virBufferAddLit(buf, "</virtualport>/n");    return 0;}

char *virDomainCapsFormat(virDomainCapsPtr const caps){    virBuffer buf = VIR_BUFFER_INITIALIZER;    const char *virttype_str = virDomainVirtTypeToString(caps->virttype);    const char *arch_str = virArchToString(caps->arch);    virBufferAddLit(&buf, "<domainCapabilities>/n");    virBufferAdjustIndent(&buf, 2);    virBufferEscapeString(&buf, "<path>%s</path>/n", caps->path);    virBufferAsprintf(&buf, "<domain>%s</domain>/n", virttype_str);    if (caps->machine)        virBufferAsprintf(&buf, "<machine>%s</machine>/n", caps->machine);    virBufferAsprintf(&buf, "<arch>%s</arch>/n", arch_str);    if (caps->maxvcpus)        virBufferAsprintf(&buf, "<vcpu max='%d'/>/n", caps->maxvcpus);    FORMAT_SINGLE("iothreads", caps->iothreads);    virDomainCapsOSFormat(&buf, &caps->os);    virDomainCapsCPUFormat(&buf, &caps->cpu);    virBufferAddLit(&buf, "<devices>/n");    virBufferAdjustIndent(&buf, 2);    virDomainCapsDeviceDiskFormat(&buf, &caps->disk);    virDomainCapsDeviceGraphicsFormat(&buf, &caps->graphics);    virDomainCapsDeviceVideoFormat(&buf, &caps->video);    virDomainCapsDeviceHostdevFormat(&buf, &caps->hostdev);    virBufferAdjustIndent(&buf, -2);    virBufferAddLit(&buf, "</devices>/n");    virBufferAddLit(&buf, "<features>/n");    virBufferAdjustIndent(&buf, 2);    virDomainCapsFeatureGICFormat(&buf, &caps->gic);    FORMAT_SINGLE("vmcoreinfo", caps->vmcoreinfo);    FORMAT_SINGLE("genid", caps->genid);    virDomainCapsFeatureSEVFormat(&buf, caps->sev);    virBufferAdjustIndent(&buf, -2);    virBufferAddLit(&buf, "</features>/n");    virBufferAdjustIndent(&buf, -2);    virBufferAddLit(&buf, "</domainCapabilities>/n");    virBufferCheckError(&buf);    return virBufferContentAndReset(&buf);}

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 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");}

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

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

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

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 intvirInterfaceStartmodeDefFormat(virBufferPtr buf,                               enum virInterfaceStartMode startmode,                               int level) {    const char *mode;    switch (startmode) {        case VIR_INTERFACE_START_UNSPECIFIED:            return 0;        case VIR_INTERFACE_START_NONE:            mode = "none";            break;        case VIR_INTERFACE_START_ONBOOT:            mode = "onboot";            break;        case VIR_INTERFACE_START_HOTPLUG:            mode = "hotplug";            break;        default:            virInterfaceReportError(VIR_ERR_INTERNAL_ERROR,                        "%s", _("virInterfaceDefFormat unknown startmode"));            return -1;    }    virBufferAsprintf(buf, "%*s  <start mode='%s'/>/n", level*2, "", mode);    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;}

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");    }}

/* converts bitmap to string of the form '1,2...' */char *mapDomainPinVcpu(unsigned char *cpumap, int maplen){    virBuffer buf = VIR_BUFFER_INITIALIZER;    size_t len;    char *ret = NULL;    size_t i, j;    for (i = 0; i < maplen; i++) {        for (j = 0; j < 8; j++) {            if (cpumap[i] & (1 << j)) {                virBufferAsprintf(&buf, "%zu,", (8*i)+j);            }        }    }    if (virBufferError(&buf)) {        virReportOOMError();        virBufferFreeAndReset(&buf);        return NULL;    }    ret = virBufferContentAndReset(&buf);    len = strlen(ret);    if (len > 0 && ret[len - 1] == ',')        ret[len - 1] = 0;    return ret;}

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

/** * virBitmapFormat: * @bitmap: the bitmap * * This function is the counterpart of virBitmapParse. This function creates * a human-readable string representing the bits in bitmap. * * See virBitmapParse for the format of @str. * * Returns the string on success or NULL otherwise. Caller should call * VIR_FREE to free the string. */char *virBitmapFormat(virBitmapPtr bitmap){    virBuffer buf = VIR_BUFFER_INITIALIZER;    bool first = true;    int start, cur, prev;    if (!bitmap)        return NULL;    cur = virBitmapNextSetBit(bitmap, -1);    if (cur < 0) {        char *ret;        ignore_value(VIR_STRDUP(ret, ""));        return ret;    }    start = prev = cur;    while (prev >= 0) {        cur = virBitmapNextSetBit(bitmap, prev);        if (cur == prev + 1) {            prev = cur;            continue;        }        /* cur < 0 or cur > prev + 1 */        if (!first)            virBufferAddLit(&buf, ",");        else            first = false;        if (prev == start)            virBufferAsprintf(&buf, "%d", start);        else            virBufferAsprintf(&buf, "%d-%d", start, prev);        start = prev = cur;    }    if (virBufferError(&buf)) {        virBufferFreeAndReset(&buf);        return NULL;    }    return virBufferContentAndReset(&buf);}

/** * 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_LONG:        case VIR_CONF_ULONG:            virBufferAsprintf(buf, "%ld", 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 voidvirDomainCapsFeatureSEVFormat(virBufferPtr buf,                              virSEVCapabilityPtr const sev){    if (!sev) {        virBufferAddLit(buf, "<sev supported='no'/>/n");    } else {        virBufferAddLit(buf, "<sev supported='yes'>/n");        virBufferAdjustIndent(buf, 2);        virBufferAsprintf(buf, "<cbitpos>%d</cbitpos>/n", sev->cbitpos);        virBufferAsprintf(buf, "<reducedPhysBits>%d</reducedPhysBits>/n",                          sev->reduced_phys_bits);        virBufferAdjustIndent(buf, -2);        virBufferAddLit(buf, "</sev>/n");    }    return;}

static int virLXCDomainObjPrivateXMLFormat(virBufferPtr buf, void *data){    virLXCDomainObjPrivatePtr priv = data;    virBufferAsprintf(buf, "  <init pid='%llu'/>/n",                      (unsigned long long)priv->initpid);    return 0;}