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

static intlibvirt_off(const char *vm_name, const char *src, uint32_t seqno, void *priv){	struct libvirt_info *info = (struct libvirt_info *)priv;	virDomainPtr vdp = NULL;	virDomainInfo vdi;	virDomainPtr (*virt_lookup_fn)(virConnectPtr, const char *);	int ret = -1;	int i;	dbg_printf(5, "ENTER %s %s %u/n", __FUNCTION__, vm_name, seqno);	VALIDATE(info);	if (is_uuid(vm_name))		virt_lookup_fn = virDomainLookupByUUIDString;	else		virt_lookup_fn = virDomainLookupByName;	for (i = 0 ; i < info->vp_count ; i++) {		vdp = virt_lookup_fn(info->vp[i], vm_name);		if (vdp)			break;	}	if (!vdp) {		dbg_printf(2, "[libvirt:OFF] Domain %s does not exist/n", vm_name);		return 1;	}	if (virDomainGetInfo(vdp, &vdi) == 0 && vdi.state == VIR_DOMAIN_SHUTOFF) {		dbg_printf(2, "[libvirt:OFF] Nothing to do - "			"domain %s is already off/n",			vm_name);		virDomainFree(vdp);		return 0;	}	syslog(LOG_NOTICE, "Destroying domain %s/n", vm_name);	dbg_printf(2, "[libvirt:OFF] Calling virDomainDestroy for %s/n", vm_name);	ret = virDomainDestroy(vdp);	virDomainFree(vdp);	if (ret < 0) {		syslog(LOG_NOTICE, "Failed to destroy domain %s: %d/n", vm_name, ret);		dbg_printf(2, "[libvirt:OFF] Failed to destroy domain: %s %d/n",			vm_name, ret);		return 1;	}	if (ret) {		syslog(LOG_NOTICE, "Domain %s still exists; fencing failed/n", vm_name);		dbg_printf(2, "[libvirt:OFF] Domain %s still exists; fencing failed/n",			vm_name);		return 1;	}	dbg_printf(2, "[libvirt:OFF] Success for %s/n", vm_name);	return 0;}

static intmymain(void){    int id = 0;    int ro = 0;    virConnectPtr conn;    virDomainPtr dom;    int status;    virCommandPtr cmd;    struct utsname ut;    /* Skip test if xend is not running.  Calling xend on a non-xen       kernel causes some versions of xend to issue a crash report, so       we first probe uname results.  */    uname(&ut);    if (strstr(ut.release, "xen") == NULL)        return EXIT_AM_SKIP;    cmd = virCommandNewArgList("/usr/sbin/xend", "status", NULL);    if (virCommandRun(cmd, &status) != 0 || status != 0) {        virCommandFree(cmd);        return EXIT_AM_SKIP;    }    virCommandFree(cmd);    virSetErrorFunc(NULL, errorHandler);    conn = virConnectOpen(NULL);    if (conn == NULL) {        ro = 1;        conn = virConnectOpenReadOnly(NULL);    }    if (conn == NULL) {        fprintf(stderr, "First virConnectOpen() failed/n");        return EXIT_FAILURE;    }    dom = virDomainLookupByID(conn, id);    if (dom == NULL) {        fprintf(stderr, "First lookup for domain %d failed/n", id);        return EXIT_FAILURE;    }    virDomainFree(dom);    virConnectClose(conn);    if (ro == 1)        conn = virConnectOpenReadOnly(NULL);    else        conn = virConnectOpen(NULL);    if (conn == NULL) {        fprintf(stderr, "Second virConnectOpen() failed/n");        return EXIT_FAILURE;    }    dom = virDomainLookupByID(conn, id);    if (dom == NULL) {        fprintf(stderr, "Second lookup for domain %d failed/n", id);        return EXIT_FAILURE;    }    virDomainFree(dom);    virConnectClose(conn);    return EXIT_SUCCESS;}

static intxenInotifyXendDomainsDirLookup(virConnectPtr conn, const char *filename,                               char **name, unsigned char *uuid) {    int i;    virDomainPtr dom;    const char *uuid_str;    unsigned char rawuuid[VIR_UUID_BUFLEN];    xenUnifiedPrivatePtr priv = conn->privateData;    /* xend is managing domains. we will get    * a filename in the manner:    * /var/lib/xend/domains/<uuid>/    */    uuid_str = filename + strlen(XEND_DOMAINS_DIR) + 1;    if (virUUIDParse(uuid_str, rawuuid) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("parsing uuid %s"), uuid_str);        return -1;    }    /* call directly into xend here, as driver may not yet       be set during open while we are building our       initial list of domains */    VIR_DEBUG("Looking for dom with uuid: %s", uuid_str);    /* XXX Should not have to go via a virDomainPtr obj instance */    if(!(dom = xenDaemonLookupByUUID(conn, rawuuid))) {        /* If we are here, the domain has gone away.           search for, and create a domain from the stored           list info */        for (i = 0 ; i < priv->configInfoList->count ; i++) {            if (!memcmp(rawuuid, priv->configInfoList->doms[i]->uuid, VIR_UUID_BUFLEN)) {                *name = strdup(priv->configInfoList->doms[i]->name);                if (!*name) {                    virReportOOMError();                    return -1;                }                memcpy(uuid, priv->configInfoList->doms[i]->uuid, VIR_UUID_BUFLEN);                VIR_DEBUG("Found dom on list");                return 0;            }        }        virReportError(VIR_ERR_INTERNAL_ERROR,                       "%s", _("finding dom on config list"));        return -1;    }    if (!(*name = strdup(dom->name))) {        virReportOOMError();        virDomainFree(dom);        return -1;    }    memcpy(uuid, dom->uuid, VIR_UUID_BUFLEN);    virDomainFree(dom);    /* succeeded too find domain by uuid */    return 0;}

static intregisterExisting(virConnectPtr vp, const char *path, int mode){	int *d_ids = NULL;	int d_count, x;	virDomainPtr dom;	virDomainInfo d_info;	errno = EINVAL;	if (!vp)		return -1;	d_count = virConnectNumOfDomains(vp);	if (d_count <= 0) {		if (d_count == 0) {			/* Successful, but no domains running */			errno = 0;			return 0;		}		goto out_fail;	}	d_ids = malloc(sizeof (int) * d_count);	if (!d_ids)		goto out_fail;	if (virConnectListDomains(vp, d_ids, d_count) < 0)		goto out_fail;	/* Ok, we have the domain IDs - let's get their names and states */	for (x = 0; x < d_count; x++) {		dom = virDomainLookupByID(vp, d_ids[x]);		if (!dom) {			/* XXX doom */			goto out_fail;		}		if (virDomainGetInfo(dom, &d_info) < 0) {			/* XXX no info for the domain?!! */			virDomainFree(dom);			goto out_fail;		}		if (d_info.state != VIR_DOMAIN_SHUTOFF &&		    d_info.state != VIR_DOMAIN_CRASHED)			domainStarted(dom, path, mode);		virDomainFree(dom);	}      out_fail:	free(d_ids);	return 0;}

timearg GetVirtInfo::GetCpuTime(QString VM_name){    virDomainPtr vm_ptr = virDomainLookupByName(conn, qPrintable(VM_name));    if(vm_ptr == NULL) {        printf("error finding domain/n");        virConnectClose(conn);        exit(1);    }    virDomainInfo info_s;    struct timeval real_time_s;    timearg return_arg;    if(virDomainGetInfo(vm_ptr, &info_s) != 0) {        printf("error get domain info/n");        virDomainFree(vm_ptr);        virConnectClose(conn);        exit(1);    }    if(gettimeofday(&real_time_s, NULL) == -1) {        printf("error get time of day/n");        virDomainFree(vm_ptr);        virConnectClose(conn);        exit(1);    }    return_arg.info = info_s;    return_arg.real_time = real_time_s;    virDomainFree(vm_ptr);    return return_arg;    /* sleep(1);     if(virDomainGetInfo(vm_ptr, &info_e) !=0) {         printf("error get domain info/n");         virDomainFree(vm_ptr);         virConnectClose(conn);         exit(1);     }     if(gettimeofday(&real_time_e, NULL) == -1) {         printf("error get time of day/n");         virDomainFree(vm_ptr);         virConnectClose(conn);         exit(1);     }     cpu_diff = (info_e.cpuTime - info_s.cpuTime) / 1000;     real_diff = 1000000 * (real_time_e.tv_sec - real_time_s.tv_sec) +(real_time_e.tv_usec - real_time_s.tv_usec);     virDomainFree(vm_ptr);     usage = cpu_diff / (float) (real_diff);     return usage*100;*/}

int main(int argc, char *argv[]){virConnectPtr conn;int i;int numDomains;int *activeDomains;virDomainPtr dom;conn = virConnectOpen("qemu:///system");if (conn == NULL) {fprintf(stderr, "Failed to open connection to qemu:///system/n");}numDomains = virConnectNumOfDomains(conn);activeDomains = malloc(sizeof(int) * numDomains);numDomains = virConnectListDomains(conn, activeDomains, numDomains);printf("Active domain IDs:/n");for (i = 0 ; i < numDomains ; i++) {printf(" %d/n", activeDomains[i]);}printf("Terminating Domain/n");free(activeDomains);int domainName = "sudip";dom = virDomainLookupByName(conn,domainName);virDomainDestroy(dom);virDomainFree(dom);printf("Domain sudip terminated successfully/n");if (conn != NULL)virConnectClose(conn);return 0;}

static int DeleteVirt(virConnectPtr vc, char *uri, Attributes a, Promise *pp){    virDomainPtr dom;    int ret = true;    dom = virDomainLookupByName(vc, pp->promiser);    if (dom)    {        if (virDomainDestroy(dom) == -1)        {            cfPS(cf_verbose, CF_FAIL, "", pp, a, " !! Failed to delete virtual domain /"%s/"/n", pp->promiser);            ret = false;        }        else        {            cfPS(cf_verbose, CF_CHG, "", pp, a, " -> Deleted virtual domain /"%s/"/n", pp->promiser);        }        virDomainFree(dom);    }    else    {        cfPS(cf_verbose, CF_NOP, "", pp, a, " -> No such virtual domain called /"%s/" - promise kept/n", pp->promiser);    }    return ret;}

static int DeleteVirt(EvalContext *ctx, virConnectPtr vc, Attributes a, Promise *pp){    virDomainPtr dom;    int ret = true;    dom = virDomainLookupByName(vc, pp->promiser);    if (dom)    {        if (virDomainDestroy(dom) == -1)        {            cfPS(ctx, OUTPUT_LEVEL_VERBOSE, PROMISE_RESULT_FAIL, "", pp, a, " !! Failed to delete virtual domain /"%s/"/n", pp->promiser);            ret = false;        }        else        {            cfPS(ctx, OUTPUT_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, "", pp, a, " -> Deleted virtual domain /"%s/"/n", pp->promiser);        }        virDomainFree(dom);    }    else    {        cfPS(ctx, OUTPUT_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, "", pp, a, " -> No such virtual domain called /"%s/" - promise kept/n", pp->promiser);    }    return ret;}

static int __domain_op_simple(char * name, int op){    if (g_conn == NULL)        return -1;    virDomainPtr domain;    domain = virDomainLookupByName(g_conn, name);    if (domain == NULL) {        logerror(_("%s: connect domain by name(%s) error. "                   "domain may not exist/n"),                   __func__, name);        return -1;    }    int ret;    if (op == __DOMAIN_OP_STOP)        ret = virDomainShutdown(domain);    else if (op == __DOMAIN_OP_STOP_FORCE)        ret = virDomainDestroy(domain);    else if (op == __DOMAIN_OP_REBOOT)        ret = virDomainReboot(domain, 0);    else        ret = -1;    virDomainFree(domain);    return ret;}

static void getDomainInfo(int id) {	virConnectPtr conn = NULL; /* the hypervisor connection */	virDomainPtr dom = NULL;   /* the domain being checked */	virDomainInfo info;        /* the information being fetched */	int ret;	/* NULL means connect to local Xen hypervisor */	conn = virConnectOpenReadOnly(NULL);	if (conn == NULL) {		fprintf(stderr, "Failed to connect to hypervisor/n");		goto error;	}	/* Find the domain of the given id */	dom = virDomainLookupByID(conn, id);	if (dom == NULL) {		fprintf(stderr, "Failed to find Domain %d/n", id);		goto error;	}	/* Get the information */	ret = virDomainGetInfo(dom, &info);	if (ret < 0) {		fprintf(stderr, "Failed to get information for Domain %d/n", id);		goto error;	}	printf("Domains %d: %d CPUs/n", id, info.nrVirtCpu);error:	if (dom != NULL)		virDomainFree(dom);	if (conn != NULL)		virConnectClose(conn);}

/** * @fn Domain::~Domain * @brief destroys the domain object * * If domain object references a valid domain in libvirt, * the corresponding memory will be freed. */Domain::~Domain(){    if (m_domain)    {        virDomainFree(m_domain);    }}

void SetDisksDataThread::run(){    if ( nullptr==ptr_ConnPtr || nullptr==*ptr_ConnPtr ) {        emit ptrIsNull();        return;    };    // NOTE: currConnName == domainName    virDomainPtr domain = virDomainLookupByName(                *ptr_ConnPtr, currConnName.toUtf8().data());    if ( nullptr!=domain ) {        char *xmlDesc = virDomainGetXMLDesc(domain, 0);        virDomainFree(domain);        if ( nullptr!=xmlDesc ) {            QDomDocument doc;            doc.setContent(QString(xmlDesc));            free(xmlDesc);            QDomElement _devices = doc                    .firstChildElement("domain")                    .firstChildElement("devices");            QDomElement _disk = _devices                    .firstChildElement("disk");            while ( !_disk.isNull() ) {                emit diskData(_disk);                _disk = _disk.nextSiblingElement("disk");            };        };    } else        sendConnErrors();}

static intlibvirt_status(const char *vm_name, void *priv){	struct libvirt_info *info = (struct libvirt_info *)priv;	virDomainPtr vdp;	virDomainInfo vdi;	int ret = 0;	dbg_printf(5, "%s %s/n", __FUNCTION__, vm_name);	VALIDATE(info);	if (is_uuid(vm_name)) {		vdp = virDomainLookupByUUIDString(info->vp,					    (const char *)vm_name);	} else {		vdp = virDomainLookupByName(info->vp, vm_name);	}	if (!vdp || ((virDomainGetInfo(vdp, &vdi) == 0) &&	     (vdi.state == VIR_DOMAIN_SHUTOFF))) {		ret = RESP_OFF;	}	if (vdp)		virDomainFree(vdp);	return ret;}

boolVirshType::ResumeFromSoftSuspend(void){	vmprintf(D_FULLDEBUG, "Inside VirshType::ResumeFromSoftSuspend/n");	if( (m_configfile.Length() == 0)) {		return false;	}	if( m_is_soft_suspended ) {		priv_state priv = set_root_priv();		virDomainPtr dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value());		set_priv(priv);		if(dom == NULL)		  {		    virErrorPtr err = virConnGetLastError(m_libvirt_connection);		    vmprintf(D_ALWAYS, "Error finding domain %s: %s/n", m_vm_name.Value(), (err ? err->message : "No reason found"));		    return false;		  }		priv = set_root_priv();		int result = virDomainResume(dom);		virDomainFree(dom);		set_priv(priv);		if( result != 0 ) {			// unpause failed.			vmprintf(D_ALWAYS, "Unpausing VM failed in "					"VirshType::ResumeFromSoftSuspend/n");			return false;		}		m_is_soft_suspended = false;	}	return true;}

static intfetch_domains(virConnectPtr conn){    int num_domains, ret = -1;    virDomainPtr *domains = NULL;    ssize_t i;    const int list_flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE;    DEBUG("Fetching list of running domains");    num_domains = virConnectListAllDomains(conn, &domains, list_flags);    DEBUG("num_domains=%d", num_domains);    if (num_domains < 0) {        ERROR("Unable to fetch list of running domains");        goto cleanup;    }    printf("Running domains:/n");    printf("----------------/n");    for (i = 0; i < num_domains; i++) {        virDomainPtr dom = domains[i];        const char *dom_name = virDomainGetName(dom);        printf("%s/n", dom_name);        virDomainFree(dom);    }    ret = 0; cleanup:    free(domains);    return ret;}

// read /var/lib/libvirt/dnsmasq/default.leases to get ip// domain must use DHCPstd::string VM_Controller::get_vm_ip_by_name(std::string domain_name){    LOG_INFO(domain_name);    Json::Value j;    virDomainPtr dom = virDomainLookupByName(_conn, domain_name.c_str());    if(dom == NULL){        Json::Value j;        j["status"] = "no such domain";        return j.toStyledString();    }            std::string mac = _get_vm_mac(dom);    LOG_INFO(mac);    virDomainFree(dom);    std::ifstream leases("/var/lib/libvirt/dnsmasq/default.leases");    while(!leases.eof()){        std::string line;        std::getline(leases, line);        DEBUG(line);        if(line == "")            break;        std::vector<std::string> v;        Tools::split(line, v, ' ');        if(v[1] == mac){            j["ip"] = v[2];            j["status"] = "ok";            return j.toStyledString();        }    }    leases.close();    j["status"] = "Could not find ip for the mac address";    return j.toStyledString();}

static PromiseResult DeleteVirt(EvalContext *ctx, virConnectPtr vc, Attributes a, const Promise *pp){    virDomainPtr dom;    dom = virDomainLookupByName(vc, pp->promiser);    PromiseResult result = PROMISE_RESULT_NOOP;    if (dom)    {        if (virDomainDestroy(dom) == -1)        {            cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Failed to delete virtual domain '%s'", pp->promiser);            result = PromiseResultUpdate(result, PROMISE_RESULT_FAIL);        }        else        {            cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, pp, a, "Deleted virtual domain '%s'", pp->promiser);            result = PromiseResultUpdate(result, PROMISE_RESULT_CHANGE);        }        virDomainFree(dom);    }    else    {        cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, pp, a, "No such virtual domain called '%s' - promise kept", pp->promiser);    }    return result;}

 //qDebug()<<URIs; foreach (QString uri, URIs) {     virConnect *connPtr =             virConnectOpenReadOnly(uri.toUtf8().data());     if ( Q_NULLPTR!=connPtr ) {         // don't work for VBox         // int num = virConnectNumOfDefinedDomains(connPtr);         virDomainPtr *domains;         int ret = virConnectListAllDomains(                     connPtr, &domains, 0);         if ( ret+1 ) {             for (int i = 0; i < ret; i++) {                  if ( virDomainFree(domains[i]) <0 )                      sendConnErrors();             };             if (domains) free(domains);         } else {             sendConnErrors();         };         virConnectClose(connPtr);         if ( ret ) {             emit localConnFound(uri);         };     } else {         sendConnErrors();     };     //msleep(333); };

static int dominfo_from_dom(const char *uri,                            const char *domain,                            struct domain **d){        virConnectPtr conn = NULL;        virDomainPtr dom = NULL;        int ret = 0;        conn = virConnectOpen(uri);        if (conn == NULL) {                printf("Unable to connect to libvirt/n");                goto out;        }        dom = virDomainLookupByName(conn, domain);        if (dom == NULL) {                printf("Unable to find domain `%s'/n", domain);                goto out;        }        ret = get_dominfo(dom, d); out:        virDomainFree(dom);        virConnectClose(conn);        return ret;}

static intmymain(void){    struct metadataTest test;    int ret = EXIT_SUCCESS;    if (!(test.conn = virConnectOpen("test:///default")))        return EXIT_FAILURE;    if (!(test.dom = virDomainLookupByName(test.conn, "test"))) {        virConnectClose(test.conn);        return EXIT_FAILURE;    }    virtTestQuiesceLibvirtErrors(false);    if (virtTestRun("Assign metadata ", testAssignMetadata, &test) < 0)        ret = EXIT_FAILURE;    if (virtTestRun("Rewrite Metadata ", testRewriteMetadata, &test) < 0)        ret = EXIT_FAILURE;    if (virtTestRun("Erase metadata ", testEraseMetadata, &test) < 0)        ret = EXIT_FAILURE;    virDomainFree(test.dom);    virConnectClose(test.conn);    return ret;}

int VM_Controller::get_image_config_fd_by_name(std::string vm_name){    virDomainPtr dom = virDomainLookupByName(_conn, vm_name.c_str());    if(dom == NULL){        return -1;    }    char *domain_xml = virDomainGetXMLDesc(dom, VIR_DOMAIN_XML_SECURE);    virDomainFree(dom);    std::string config_file = _make_tmp_config_file_name(vm_name);    int fd = open(config_file.c_str(), O_WRONLY|O_CREAT);    int filesize = strlen(domain_xml);    int write_count = 0;    while(write_count < filesize){        int once_write_count = write(fd, domain_xml, filesize);        if(once_write_count < 0){            LOG_ERROR("write error");            close(fd);            return -1;        }        write_count += once_write_count;    }    close(fd);    fd = open(config_file.c_str(), O_RDONLY);    return fd;}

static inline intwait_domain(const char *vm_name, virConnectPtr vp, int timeout){	int tries = 0;	int response = 1;	int ret;	virDomainPtr vdp;	virDomainInfo vdi;	int uuid_check;	uuid_check = is_uuid(vm_name);	if (uuid_check) {		vdp = virDomainLookupByUUIDString(vp, (const char *)vm_name);	} else {		vdp = virDomainLookupByName(vp, vm_name);	}	if (!vdp)		return 0;	/* Check domain liveliness.  If the domain is still here,	   we return failure, and the client must then retry */	/* XXX On the xen 3.0.4 API, we will be able to guarantee	   synchronous virDomainDestroy, so this check will not	   be necessary */	do {		if (++tries > timeout)			break;		sleep(1);		if (uuid_check) {			vdp = virDomainLookupByUUIDString(vp, (const char *)vm_name);		} else {			vdp = virDomainLookupByName(vp, vm_name);		}		if (!vdp) {			dbg_printf(2, "Domain no longer exists/n");			response = 0;			break;		}		memset(&vdi, 0, sizeof(vdi));		ret = virDomainGetInfo(vdp, &vdi);		virDomainFree(vdp);		if (ret < 0)			continue;		if (vdi.state == VIR_DOMAIN_SHUTOFF) {			dbg_printf(2, "Domain has been shut off/n");			response = 0;			break;		}		dbg_printf(4, "Domain still exists (state %d) after %d seconds/n",			vdi.state, tries);	} while (1);	return response;}

int libvirt_node_info_update(NodeInfo * ni){    if (g_conn == NULL || ni == NULL)        return -1;    int ret = -1;    int cpu_commit = 0;    unsigned int mem_commit = 0;    int *activeDomains = NULL;    __this_lock();    int numDomains = virConnectNumOfDomains(g_conn);    if (numDomains <= 0) {        ret = numDomains;        goto out;    }    activeDomains = malloc(sizeof(int) * numDomains);    if (activeDomains == NULL) {        logerror(_("error in %s(%d)/n"), __func__, __LINE__);        goto out;    }    numDomains = virConnectListDomains(g_conn, activeDomains, numDomains);    if (numDomains <= 0) {        ret = numDomains;        goto out;    }    for (int i = 0; i< numDomains; i++) {        /* skip id dom 0 */        if (activeDomains[i] == 0)            continue;        virDomainPtr d = virDomainLookupByID(g_conn, activeDomains[i]);	if (d == NULL) {            logerror(_("error in %s(%d)/n"), __func__, __LINE__);            goto out;        }        virDomainInfo di;	if (virDomainGetInfo(d, &di)) {            logerror(_("error in %s(%d)/n"), __func__, __LINE__);            goto out;        }        cpu_commit += di.nrVirtCpu;        mem_commit += di.maxMem;        virDomainFree(d);    }    ni->cpu_commit = cpu_commit;    ni->mem_commit = mem_commit;    ret = numDomains;out:    __this_unlock();    if (activeDomains)        free(activeDomains);    return ret;}

static intshowDomains(virConnectPtr conn){    int ret = 0, numNames, numInactiveDomains, numActiveDomains;    ssize_t i;    int flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE |                VIR_CONNECT_LIST_DOMAINS_INACTIVE;    virDomainPtr *nameList = NULL;    /* NB: The return from the virConnectNum*() APIs is only useful for     * the current call.  A domain could be started or stopped and any     * assumptions made purely on these return values could result in     * unexpected results */    numActiveDomains = virConnectNumOfDomains(conn);    if (numActiveDomains == -1) {        ret = 1;        printf("Failed to get number of active domains: %s/n",               virGetLastErrorMessage());        goto out;    }    numInactiveDomains = virConnectNumOfDefinedDomains(conn);    if (numInactiveDomains == -1) {        ret = 1;        printf("Failed to get number of inactive domains: %s/n",               virGetLastErrorMessage());        goto out;    }    printf("There are %d active and %d inactive domains/n",           numActiveDomains, numInactiveDomains);    /* Return a list of all active and inactive domains. Using this API     * instead of virConnectListDomains() and virConnectListDefinedDomains()     * is preferred since it "solves" an inherit race between separated API     * calls if domains are started or stopped between calls */    numNames = virConnectListAllDomains(conn,                                        &nameList,                                        flags);    if (numNames == -1) {        ret = 1;        printf("Failed to get a list of all domains: %s/n",               virGetLastErrorMessage());        goto out;    }    for (i = 0; i < numNames; i++) {        int active = virDomainIsActive(nameList[i]);        printf("  %8s (%s)/n",               virDomainGetName(nameList[i]),               (active == 1 ? "active" : "non-active"));        /* must free the returned named per the API documentation */        virDomainFree(nameList[i]);    }    free(nameList); out:    return ret;}

static void rebootVM(virDomainPtr dom){    int ret = virDomainReset(dom,0);    if (ret < 0)     {       virDomainFree(dom);    }}

SnapshotActionDialog::~SnapshotActionDialog(){    if ( nullptr!=domain ) virDomainFree(domain);    settings.beginGroup("SnapshotActionDialog");    settings.setValue("Geometry", saveGeometry());    settings.setValue("column0", snapshotTree->columnWidth(0));    settings.setValue("column1", snapshotTree->columnWidth(1));    settings.endGroup();    settings.sync();}

static intsuspend_and_resume(virConnectPtr conn,                   const char *dom_name,                   unsigned int seconds){    int ret = -1;    virDomainPtr dom;    virDomainInfo dom_info;    if (!(dom = virDomainLookupByName(conn, dom_name))) {        ERROR("Unable to find domain '%s'", dom_name);        goto cleanup;    }    if (virDomainGetInfo(dom, &dom_info) < 0) {        ERROR("Unable to get domain info");        goto cleanup;    }    DEBUG("Domain state %d", dom_info.state);    switch (dom_info.state) {    case VIR_DOMAIN_NOSTATE:    case VIR_DOMAIN_RUNNING:    case VIR_DOMAIN_BLOCKED:        /* In these states the domain can be suspended */        DEBUG("Suspending domain");        if (virDomainSuspend(dom) < 0) {            ERROR("Unable to suspend domain");            goto cleanup;        }        DEBUG("Domain suspended. Entering sleep for %u seconds.", seconds);        sleep(seconds);        DEBUG("Sleeping done. Resuming the domain.");        if (virDomainResume(dom) < 0) {            ERROR("Unable to resume domain");            goto cleanup;        }        break;    default:        /* In all other states domain can't be suspended */        ERROR("Domain is not in a state where it can be suspended: %d",              dom_info.state);        goto cleanup;    }    ret = 0; cleanup:    if (dom)        virDomainFree(dom);    return ret;}

static voidfree_domains (void){    if (domains) {        for (int i = 0; i < nr_domains; ++i)            virDomainFree (domains[i]);        sfree (domains);    }    domains = NULL;    nr_domains = 0;}