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

intnodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames){    virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData;    virNodeDeviceObjPtr obj;    virNodeDevCapsDefPtr caps;    int ncaps = 0;    int ret = -1;    nodeDeviceLock(driver);    obj = virNodeDeviceFindByName(&driver->devs, dev->name);    nodeDeviceUnlock(driver);    if (!obj) {        virReportError(VIR_ERR_NO_NODE_DEVICE,                       _("no node device with matching name '%s'"),                       dev->name);        goto cleanup;    }    for (caps = obj->def->caps; caps && ncaps < maxnames; caps = caps->next) {        names[ncaps] = strdup(virNodeDevCapTypeToString(caps->type));        if (names[ncaps++] == NULL) {            virReportOOMError();            goto cleanup;        }    }    ret = ncaps;cleanup:    if (obj)        virNodeDeviceObjUnlock(obj);    if (ret == -1) {        --ncaps;        while (--ncaps >= 0)            VIR_FREE(names[ncaps]);    }    return ret;}

virNetServerProgramPtr virNetServerProgramNew(unsigned program,                                              unsigned version,                                              virNetServerProgramProcPtr procs,                                              size_t nprocs){    virNetServerProgramPtr prog;    if (VIR_ALLOC(prog) < 0) {        virReportOOMError();        return NULL;    }    prog->refs = 1;    prog->program = program;    prog->version = version;    prog->procs = procs;    prog->nprocs = nprocs;    VIR_DEBUG("prog=%p refs=%d", prog, prog->refs);    return prog;}

static intxenInotifyXenCacheLookup(virConnectPtr conn,                         const char *filename,                         char **name, unsigned char *uuid) {    xenUnifiedPrivatePtr priv = conn->privateData;    xenXMConfCachePtr entry;    if (!(entry = virHashLookup(priv->configCache, filename))) {        VIR_DEBUG("No config found for %s", filename);        return -1;    }    *name = strdup(entry->def->name);    memcpy(uuid, entry->def->uuid, VIR_UUID_BUFLEN);    if (!*name) {        VIR_DEBUG("Error getting dom from def");        virReportOOMError();        return -1;    }    return 0;}

static intdaemonUnixSocketPaths(struct daemonConfig *config,                      bool privileged,                      char **sockfile,                      char **rosockfile){    if (config->unix_sock_dir) {        if (virAsprintf(sockfile, "%s/libvirt-sock", config->unix_sock_dir) < 0)            goto no_memory;        if (privileged &&            virAsprintf(rosockfile, "%s/libvirt-sock-ro", config->unix_sock_dir) < 0)            goto no_memory;    } else {        if (privileged) {            if (!(*sockfile = strdup(LOCALSTATEDIR "/run/libvirt/libvirt-sock")))                goto no_memory;            if (!(*rosockfile = strdup(LOCALSTATEDIR "/run/libvirt/libvirt-sock-ro")))                goto no_memory;        } else {            char *userdir = NULL;            if (!(userdir = virGetUserDirectory(geteuid())))                goto error;            if (virAsprintf(sockfile, "@%s/.libvirt/libvirt-sock", userdir) < 0) {                VIR_FREE(userdir);                goto no_memory;            }            VIR_FREE(userdir);        }    }    return 0;no_memory:    virReportOOMError();error:    return -1;}

static intqcowXGetBackingStore(char **res,                     const unsigned char *buf,                     size_t buf_size){    unsigned long long offset;    unsigned long size;    *res = NULL;    if (buf_size < 4+4+8+4)        return BACKING_STORE_INVALID;    offset = (((unsigned long long)buf[4+4] << 56)              | ((unsigned long long)buf[4+4+1] << 48)              | ((unsigned long long)buf[4+4+2] << 40)              | ((unsigned long long)buf[4+4+3] << 32)              | ((unsigned long long)buf[4+4+4] << 24)              | ((unsigned long long)buf[4+4+5] << 16)              | ((unsigned long long)buf[4+4+6] << 8)              | buf[4+4+7]); /* QCowHeader.backing_file_offset */    if (offset > buf_size)        return BACKING_STORE_INVALID;    size = ((buf[4+4+8] << 24)            | (buf[4+4+8+1] << 16)            | (buf[4+4+8+2] << 8)            | buf[4+4+8+3]); /* QCowHeader.backing_file_size */    if (size == 0)        return BACKING_STORE_OK;    if (offset + size > buf_size || offset + size < offset)        return BACKING_STORE_INVALID;    if (size + 1 == 0)        return BACKING_STORE_INVALID;    if (VIR_ALLOC_N(*res, size + 1) < 0) {        virReportOOMError();        return BACKING_STORE_ERROR;    }    memcpy(*res, buf + offset, size);    (*res)[size] = '/0';    return BACKING_STORE_OK;}

virNetClientProgramPtr virNetClientProgramNew(unsigned program,                                              unsigned version,                                              virNetClientProgramEventPtr events,                                              size_t nevents,                                              void *eventOpaque){    virNetClientProgramPtr prog;    if (VIR_ALLOC(prog) < 0) {        virReportOOMError();        return NULL;    }    prog->refs = 1;    prog->program = program;    prog->version = version;    prog->events = events;    prog->nevents = nevents;    prog->eventOpaque = eventOpaque;    return prog;}

/* * Linux maintains cpu bit map under cpu/online. For example, if * cpuid=5's flag is not set and max cpu is 7, the map file shows * 0-4,6-7. This function parses it and returns cpumap. */static virBitmapPtrlinuxParseCPUmap(int max_cpuid, const char *path){    virBitmapPtr map = NULL;    char *str = NULL;    if (virFileReadAll(path, 5 * VIR_DOMAIN_CPUMASK_LEN, &str) < 0) {        virReportOOMError();        goto error;    }    if (virBitmapParse(str, 0, &map, max_cpuid) < 0)        goto error;    VIR_FREE(str);    return map;error:    VIR_FREE(str);    virBitmapFree(map);    return NULL;}

static intvirInterfaceDefParseBondItfs(virInterfaceDefPtr def,                             xmlXPathContextPtr ctxt) {    xmlNodePtr *interfaces = NULL;    xmlNodePtr bond = ctxt->node;    virInterfaceDefPtr itf;    int nbItf, i;    int ret = 0;    nbItf = virXPathNodeSet("./interface", ctxt, &interfaces);    if (nbItf <= 0) {        virInterfaceReportError(VIR_ERR_XML_ERROR,                                "%s", _("bond has no interfaces"));        ret = -1;        goto error;    }    if (VIR_ALLOC_N(def->data.bond.itf, nbItf) < 0) {        virReportOOMError();        ret = -1;        goto error;    }    def->data.bond.nbItf = nbItf;    for (i = 0; i < nbItf;i++) {        ctxt->node = interfaces[i];        itf = virInterfaceDefParseXML(ctxt, VIR_INTERFACE_TYPE_BOND);        if (itf == NULL) {            ret = -1;            def->data.bond.nbItf = i;            goto error;        }        def->data.bond.itf[i] = itf;    }error:    VIR_FREE(interfaces);    ctxt->node = bond;    return(ret);}

static intppcVendorLoad(xmlXPathContextPtr ctxt,              struct ppc_map *map){    struct ppc_vendor *vendor = NULL;    if (VIR_ALLOC(vendor) < 0) {        virReportOOMError();        return -1;    }    vendor->name = virXPathString("string(@name)", ctxt);    if (!vendor->name) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       "%s", _("Missing CPU vendor name"));        goto ignore;    }    if (ppcVendorFind(map, vendor->name)) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("CPU vendor %s already defined"), vendor->name);        goto ignore;    }    if (!map->vendors) {        map->vendors = vendor;    } else {        vendor->next = map->vendors;        map->vendors = vendor;    }cleanup:    return 0;ignore:    ppcVendorFree(vendor);    goto cleanup;}

static int lxcProcGetattr(const char *path, struct stat *stbuf){    int res;    char *mempath = NULL;    struct stat sb;    memset(stbuf, 0, sizeof(struct stat));    if (virAsprintf(&mempath, "/proc/%s", path) < 0) {        virReportOOMError();        return -errno;    }    res = 0;    if (STREQ(path, "/")) {        stbuf->st_mode = S_IFDIR | 0755;        stbuf->st_nlink = 2;    } else if (STREQ(path, fuse_meminfo_path)) {        if (stat(mempath, &sb) < 0) {            res = -errno;            goto cleanup;        }        stbuf->st_mode = sb.st_mode;        stbuf->st_nlink = 1;        stbuf->st_blksize = sb.st_blksize;        stbuf->st_blocks = sb.st_blocks;        stbuf->st_size = sb.st_size;        stbuf->st_atime = sb.st_atime;        stbuf->st_ctime = sb.st_ctime;        stbuf->st_mtime = sb.st_mtime;    } else        res = -ENOENT;cleanup:    VIR_FREE(mempath);    return res;}

int virNetMessageDecodeNumFDs(virNetMessagePtr msg){    XDR xdr;    unsigned int numFDs;    int ret = -1;    size_t i;    xdrmem_create(&xdr, msg->buffer + msg->bufferOffset,                  msg->bufferLength - msg->bufferOffset, XDR_DECODE);    if (!xdr_u_int(&xdr, &numFDs)) {        virReportError(VIR_ERR_RPC, "%s", _("Unable to decode number of FDs"));        goto cleanup;    }    msg->bufferOffset += xdr_getpos(&xdr);    if (numFDs > VIR_NET_MESSAGE_NUM_FDS_MAX) {        virReportError(VIR_ERR_RPC,                       _("Received too many FDs %d, expected %d maximum"),                       numFDs, VIR_NET_MESSAGE_NUM_FDS_MAX);        goto cleanup;    }    msg->nfds = numFDs;    if (VIR_ALLOC_N(msg->fds, msg->nfds) < 0) {        virReportOOMError();        goto cleanup;    }    for (i = 0 ; i < msg->nfds ; i++)        msg->fds[i] = -1;    VIR_DEBUG("Got %zu FDs from peer", msg->nfds);    ret = 0;cleanup:    xdr_destroy(&xdr);    return ret;}

/* Create a private tty using the private devpts at PTMX, returning * the master in *TTYMASTER and the name of the slave, _from the * perspective of the guest after remounting file systems_, in * *TTYNAME.  Heavily borrowed from glibc, but doesn't require that * devpts == "/dev/pts" */static intlxcCreateTty(char *ptmx, int *ttymaster, char **ttyName){    int ret = -1;    int ptyno;    int unlock = 0;    if ((*ttymaster = open(ptmx, O_RDWR|O_NOCTTY|O_NONBLOCK)) < 0)        goto cleanup;    if (ioctl(*ttymaster, TIOCSPTLCK, &unlock) < 0)        goto cleanup;    if (ioctl(*ttymaster, TIOCGPTN, &ptyno) < 0)        goto cleanup;    /* If mount() succeeded at honoring newinstance, then the kernel     * was new enough to also honor the mode=0620,gid=5 options, which     * guarantee that the new pty already has correct permissions; so     * while glibc has to fstat(), fchmod(), and fchown() for older     * kernels, we can skip those steps.  ptyno shouldn't currently be     * anything other than 0, but let's play it safe.  */    if (virAsprintf(ttyName, "/dev/pts/%d", ptyno) < 0) {        virReportOOMError();        errno = ENOMEM;        goto cleanup;    }    ret = 0;cleanup:    if (ret != 0) {        VIR_FORCE_CLOSE(*ttymaster);        VIR_FREE(*ttyName);    }    return ret;}

virKeepAlivePtrvirKeepAliveNew(int interval,                unsigned int count,                void *client,                virKeepAliveSendFunc sendCB,                virKeepAliveDeadFunc deadCB,                virKeepAliveFreeFunc freeCB){    virKeepAlivePtr ka;    VIR_DEBUG("client=%p, interval=%d, count=%u", client, interval, count);    if (VIR_ALLOC(ka) < 0) {        virReportOOMError();        return NULL;    }    if (virMutexInit(&ka->lock) < 0) {        VIR_FREE(ka);        return NULL;    }    ka->refs = 1;    ka->interval = interval;    ka->count = count;    ka->countToDeath = count;    ka->timer = -1;    ka->client = client;    ka->sendCB = sendCB;    ka->deadCB = deadCB;    ka->freeCB = freeCB;    PROBE(RPC_KEEPALIVE_NEW,          "ka=%p client=%p refs=%d",          ka, ka->client, ka->refs);    return ka;}

int virNetDevVPortProfileMerge3(virNetDevVPortProfilePtr *result,                                virNetDevVPortProfilePtr fromInterface,                                virNetDevVPortProfilePtr fromNetwork,                                virNetDevVPortProfilePtr fromPortgroup){    int ret = -1;    *result = NULL;    if ((!fromInterface || (fromInterface->virtPortType == VIR_NETDEV_VPORT_PROFILE_NONE)) &&        (!fromNetwork   || (fromNetwork->virtPortType   == VIR_NETDEV_VPORT_PROFILE_NONE)) &&        (!fromPortgroup || (fromPortgroup->virtPortType == VIR_NETDEV_VPORT_PROFILE_NONE))) {        return 0;    }    /* at least one of the source profiles is non-empty */    if (VIR_ALLOC(*result) < 0) {        virReportOOMError();        return ret;    }    /* start with the interface's profile. There are no pointers in a     * virtualPortProfile, so a shallow copy is sufficient.     */    if (fromInterface)        **result = *fromInterface;    if (virNetDevVPortProfileMerge(*result, fromNetwork) < 0)        goto error;    if (virNetDevVPortProfileMerge(*result, fromPortgroup) < 0)        goto error;    ret = 0;error:    if (ret < 0)        VIR_FREE(*result);    return ret;}

static virNetworkObjPtrparallelsAddRoutedNetwork(parallelsConnPtr privconn){    virNetworkObjPtr net;    virNetworkDefPtr def;    if (VIR_ALLOC(def) < 0)        goto no_memory;    def->forward.type = VIR_NETWORK_FORWARD_ROUTE;    if (!(def->name = strdup(PARALLELS_ROUTED_NETWORK_NAME)))        goto no_memory;    if (virUUIDParse(PARALLELS_ROUTED_NETWORK_UUID, def->uuid) < 0) {        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",                       _("Can't parse UUID"));        goto cleanup;    }    def->uuid_specified = 1;    if (!(net = virNetworkAssignDef(&privconn->networks, def, false))) {        virNetworkDefFree(def);        goto cleanup;    }    net->active = 1;    net->persistent = 1;    net->autostart = 1;    virNetworkObjUnlock(net);    return net;no_memory:    virReportOOMError();cleanup:    virNetworkDefFree(def);    return NULL;}

static char *openvzGetOSType(virDomainPtr dom){    struct  openvz_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    char *ret = NULL;    openvzDriverLock(driver);    vm = virDomainFindByUUID(&driver->domains, dom->uuid);    openvzDriverUnlock(driver);    if (!vm) {        openvzError(VIR_ERR_NO_DOMAIN, NULL);        goto cleanup;    }    if (!(ret = strdup(vm->def->os.type)))        virReportOOMError();cleanup:    if (vm)        virDomainObjUnlock(vm);    return ret;}

char *qparam_get_query (const struct qparam_set *ps){    virBuffer buf = VIR_BUFFER_INITIALIZER;    int i, amp = 0;    for (i = 0; i < ps->n; ++i) {        if (!ps->p[i].ignore) {            if (amp) virBufferAddChar (&buf, '&');            virBufferStrcat (&buf, ps->p[i].name, "=", NULL);            virBufferURIEncodeString (&buf, ps->p[i].value);            amp = 1;        }    }    if (virBufferError(&buf)) {        virBufferFreeAndReset(&buf);        virReportOOMError();        return NULL;    }    return virBufferContentAndReset(&buf);}

virCPUDefPtrvirCPUDefCopy(const virCPUDefPtr cpu){    virCPUDefPtr copy;    unsigned int i;    if (!cpu)        return NULL;    if (VIR_ALLOC(copy) < 0        || (cpu->arch && !(copy->arch = strdup(cpu->arch)))        || (cpu->model && !(copy->model = strdup(cpu->model)))        || (cpu->vendor && !(copy->vendor = strdup(cpu->vendor)))        || VIR_ALLOC_N(copy->features, cpu->nfeatures) < 0)        goto no_memory;    copy->nfeatures_max = cpu->nfeatures;    copy->type = cpu->type;    copy->match = cpu->match;    copy->sockets = cpu->sockets;    copy->cores = cpu->cores;    copy->threads = cpu->threads;    copy->nfeatures = cpu->nfeatures;    for (i = 0; i < copy->nfeatures; i++) {        copy->features[i].policy = cpu->features[i].policy;        if (!(copy->features[i].name = strdup(cpu->features[i].name)))            goto no_memory;    }    return copy;no_memory:    virReportOOMError();    virCPUDefFree(copy);    return NULL;}

static int parallelsDiskDescParseNode(xmlDocPtr xml,                                      xmlNodePtr root,                                      virStorageVolDefPtr def){    xmlXPathContextPtr ctxt = NULL;    int ret = -1;    if (STRNEQ((const char *)root->name, "Parallels_disk_image")) {        virReportError(VIR_ERR_XML_ERROR,                       "%s", _("unknown root element for storage pool"));        goto cleanup;    }    ctxt = xmlXPathNewContext(xml);    if (ctxt == NULL) {        virReportOOMError();        goto cleanup;    }    ctxt->node = root;    if (virXPathULongLong("string(./Disk_Parameters/Disk_size)",                          ctxt, &def->target.capacity) < 0) {        virReportError(VIR_ERR_XML_ERROR,                       "%s", _("failed to get disk size from "                               "the disk descriptor xml"));        goto cleanup;    }    def->target.capacity <<= 9;    def->target.allocation = def->target.capacity;    ret = 0; cleanup:    xmlXPathFreeContext(ctxt);    return ret;}

static int lxcContainerMountNewFS(virDomainDefPtr vmDef){    int i;    /* Pull in rest of container's mounts */    for (i = 0 ; i < vmDef->nfss ; i++) {        char *src;        if (STREQ(vmDef->fss[i]->dst, "/"))            continue;        // XXX fix        if (vmDef->fss[i]->type != VIR_DOMAIN_FS_TYPE_MOUNT)            continue;        if (virAsprintf(&src, "/.oldroot/%s", vmDef->fss[i]->src) < 0) {            virReportOOMError();            return -1;        }        if (virFileMakePath(vmDef->fss[i]->dst) != 0) {            virReportSystemError(errno,                                 _("Failed to create %s"),                                 vmDef->fss[i]->dst);            VIR_FREE(src);            return -1;        }        if (mount(src, vmDef->fss[i]->dst, NULL, MS_BIND, NULL) < 0) {            virReportSystemError(errno,                                 _("Failed to mount %s at %s"),                                 src, vmDef->fss[i]->dst);            VIR_FREE(src);            return -1;        }        VIR_FREE(src);    }    return 0;}

static int parallelsAddDiskVolume(virStoragePoolObjPtr pool,                                  virDomainObjPtr dom,                                  const char *diskName,                                  const char *diskPath,                                  const char *diskDescPath){    virStorageVolDefPtr def = NULL;    if (VIR_ALLOC(def))        goto error;    if (virAsprintf(&def->name, "%s-%s", dom->def->name, diskName) < 0)        goto error;    def->type = VIR_STORAGE_VOL_FILE;    if (parallelsDiskDescParse(diskDescPath, def) < 0)        goto error;    if (!(def->target.path = realpath(diskPath, NULL)))        goto no_memory;    if (VIR_STRDUP(def->key, def->target.path) < 0)        goto error;    if (VIR_REALLOC_N(pool->volumes.objs, pool->volumes.count + 1) < 0)        goto error;    pool->volumes.objs[pool->volumes.count++] = def;    return 0;no_memory:    virReportOOMError();error:    virStorageVolDefFree(def);    return -1;}

static intparallelsFindVolumes(virStoragePoolObjPtr pool){    DIR *dir;    struct dirent *ent;    char *path = NULL;    int ret = -1;    if (!(dir = opendir(pool->def->target.path))) {        virReportSystemError(errno,                             _("cannot open path '%s'"),                             pool->def->target.path);        return -1;    }    while ((ent = readdir(dir)) != NULL) {        if (!virFileHasSuffix(ent->d_name, ".xml"))            continue;        if (!(path = virFileBuildPath(pool->def->target.path,                                      ent->d_name, NULL))) {            virReportOOMError();            goto cleanup;        }        if (!parallelsStorageVolDefineXML(pool, NULL, path, false))            goto cleanup;        VIR_FREE(path);    }    ret = 0;cleanup:    VIR_FREE(path);    closedir(dir);    return ret;}

/** * Create a full filename with path to the lock file based on * name/path of corresponding device * * @dev path of the character device * * Returns a modified name that the caller has to free, or NULL * on error. */static char *virChrdevLockFilePath(const char *dev){    char *path = NULL;    char *sanitizedPath = NULL;    char *devCopy;    char *filename;    char *p;    if (!(devCopy = strdup(dev))) {        virReportOOMError();        goto cleanup;    }    /* skip the leading "/dev/" */    filename = STRSKIP(devCopy, "/dev");    if (!filename)        filename = devCopy;    /* substitute path forward slashes for underscores */    p = filename;    while (*p) {        if (*p == '/')            *p = '_';        ++p;    }    if (virAsprintf(&path, "%s/LCK..%s", VIR_CHRDEV_LOCK_FILE_PATH, filename) < 0)        goto cleanup;    sanitizedPath = virFileSanitizePath(path);cleanup:    VIR_FREE(path);    VIR_FREE(devCopy);    return sanitizedPath;}

/* Parse config values of the form barrier:limit into barrier and limit */static intopenvzParseBarrierLimit(const char* value,                        unsigned long long *barrier,                        unsigned long long *limit){    char *token;    char *saveptr = NULL;    char *str = strdup(value);    if (str == NULL) {        virReportOOMError();        goto error;    }    token = strtok_r(str, ":", &saveptr);    if (token == NULL) {        goto error;    } else {        if (barrier != NULL) {            if (virStrToLong_ull(token, NULL, 10, barrier))                goto error;        }    }    token = strtok_r(NULL, ":", &saveptr);    if (token == NULL) {        goto error;    } else {        if (limit != NULL) {            if (virStrToLong_ull(token, NULL, 10, limit))                goto error;        }    }    return 0;error:    VIR_FREE(str);    return -1;}

static char *virSysinfoParseDelimited(const char *base, const char *name, char **value,                         char delim1, char delim2){    const char *start;    char *end;    if (delim1 != delim2 &&        (start = strstr(base, name)) &&        (start = strchr(start, delim1))) {        start += 1;        end = strchrnul(start, delim2);        virSkipSpaces(&start);        if (!((*value) = strndup(start, end - start))) {            virReportOOMError();            goto error;        }        virTrimSpaces(*value, NULL);        return end;    }error:    return NULL;}

static char *vmwareGetOSType(virDomainPtr dom){    struct vmware_driver *driver = dom->conn->privateData;    virDomainObjPtr vm;    char *ret = NULL;    vmwareDriverLock(driver);    vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);    vmwareDriverUnlock(driver);    if (!vm) {        virReportError(VIR_ERR_NO_DOMAIN, NULL);        goto cleanup;    }    if (!(ret = strdup(vm->def->os.type)))        virReportOOMError();  cleanup:    if (vm)        virObjectUnlock(vm);    return ret;}

static virStorageSourcePtrtestStorageFileGetMetadata(const char *path,                           int format,                           uid_t uid, gid_t gid,                           bool allow_probe){    virStorageSourcePtr ret = NULL;    if (VIR_ALLOC(ret) < 0)        return NULL;    ret->type = VIR_STORAGE_TYPE_FILE;    ret->format = format;    if (VIR_STRDUP(ret->relPath, path) < 0)        goto error;    if (!(ret->relDir = mdir_name(path))) {        virReportOOMError();        goto error;    }    if (!(ret->path = canonicalize_file_name(path))) {        virReportError(VIR_ERR_INTERNAL_ERROR, "failed to resolve '%s'", path);        goto error;    }    if (virStorageFileGetMetadata(ret, uid, gid, allow_probe) < 0)        goto error;    return ret; error:    virStorageSourceFree(ret);    return NULL;}

static int virFDStreamOpenInternal(virStreamPtr st,                                   int fd,                                   virCommandPtr cmd,                                   int errfd,                                   unsigned long long length){    struct virFDStreamData *fdst;    VIR_DEBUG("st=%p fd=%d cmd=%p errfd=%d length=%llu",              st, fd, cmd, errfd, length);    if ((st->flags & VIR_STREAM_NONBLOCK) &&        virSetNonBlock(fd) < 0)        return -1;    if (VIR_ALLOC(fdst) < 0) {        virReportOOMError();        return -1;    }    fdst->fd = fd;    fdst->cmd = cmd;    fdst->errfd = errfd;    fdst->length = length;    if (virMutexInit(&fdst->lock) < 0) {        VIR_FREE(fdst);        streamsReportError(VIR_ERR_INTERNAL_ERROR, "%s",                           _("Unable to initialize mutex"));        return -1;    }    st->driver = &virFDStreamDrv;    st->privateData = fdst;    return 0;}

static virDomainEventPtrvirDomainEventTrayChangeNew(int id, const char *name,                            unsigned char *uuid,                            const char *devAlias,                            int reason){    virDomainEventPtr ev =        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_TRAY_CHANGE,                                  id, name, uuid);    if (ev) {        if (!(ev->data.trayChange.devAlias = strdup(devAlias)))            goto error;        ev->data.trayChange.reason = reason;    }    return ev;error:    virReportOOMError();    virDomainEventFree(ev);    return NULL;}

static int virNetServerAddClient(virNetServerPtr srv,                                 virNetServerClientPtr client){    virObjectLock(srv);    if (srv->nclients >= srv->nclients_max) {        virReportError(VIR_ERR_RPC,                       _("Too many active clients (%zu), dropping connection from %s"),                       srv->nclients_max, virNetServerClientRemoteAddrString(client));        goto error;    }    if (virNetServerClientInit(client) < 0)        goto error;    if (VIR_EXPAND_N(srv->clients, srv->nclients, 1) < 0) {        virReportOOMError();        goto error;    }    srv->clients[srv->nclients-1] = client;    virObjectRef(client);    virNetServerClientSetDispatcher(client,                                    virNetServerDispatchNewMessage,                                    srv);    virNetServerClientInitKeepAlive(client, srv->keepaliveInterval,                                    srv->keepaliveCount);    virObjectUnlock(srv);    return 0;error:    virObjectUnlock(srv);    return -1;}