/** * virStringListRemove: * @strings: a NULL-terminated array of strings * @item: string to remove * * Remove every occurrence of @item in list of @strings. */ void virStringListRemove(char ***strings, const char *item) { size_t r, w = 0; if (!strings || !*strings) return; for (r = 0; (*strings)[r]; r++) { if (STREQ((*strings)[r], item)) { VIR_FREE((*strings)[r]); continue; } if (r != w) (*strings)[w] = (*strings)[r]; w++; } if (w == 0) { VIR_FREE(*strings); } else { (*strings)[w] = NULL; ignore_value(VIR_REALLOC_N(*strings, w + 1)); } }
void virNodeDeviceObjRemove(virNodeDeviceObjListPtr devs, const virNodeDeviceObjPtr dev) { unsigned int i; virNodeDeviceObjUnlock(dev); for (i = 0; i < devs->count; i++) { virNodeDeviceObjLock(dev); if (devs->objs[i] == dev) { virNodeDeviceObjUnlock(dev); virNodeDeviceObjFree(devs->objs[i]); if (i < (devs->count - 1)) memmove(devs->objs + i, devs->objs + i + 1, sizeof(*(devs->objs)) * (devs->count - (i + 1))); if (VIR_REALLOC_N(devs->objs, devs->count - 1) < 0) { ; /* Failure to reduce memory allocation isn't fatal */ } devs->count--; break; } virNodeDeviceObjUnlock(dev); } }
int virCondWait(virCondPtr c, virMutexPtr m) { HANDLE event = virThreadLocalGet(&virCondEvent); if (!event) { event = CreateEvent(0, FALSE, FALSE, NULL); if (!event) { return -1; } virThreadLocalSet(&virCondEvent, event); } virMutexLock(&c->lock); if (VIR_REALLOC_N(c->waiters, c->nwaiters + 1) < 0) { virMutexUnlock(&c->lock); return -1; } c->waiters[c->nwaiters] = event; c->nwaiters++; virMutexUnlock(&c->lock); virMutexUnlock(m); if (WaitForSingleObject(event, INFINITE) == WAIT_FAILED) { virMutexLock(m); errno = EINVAL; return -1; } virMutexLock(m); return 0; }
static int virJSONParserHandleStartArray(void *ctx) { virJSONParserPtr parser = ctx; virJSONValuePtr value = virJSONValueNewArray(); VIR_DEBUG("parser=%p", parser); if (!value) return 0; if (virJSONParserInsertValue(parser, value) < 0) { virJSONValueFree(value); return 0; } if (VIR_REALLOC_N(parser->state, parser->nstate + 1) < 0) return 0; parser->state[parser->nstate].value = value; parser->state[parser->nstate].key = NULL; parser->nstate++; return 1; }
/** * virConfReadFile: * @filename: the path to the configuration file. * @flags: combination of virConfFlag(s) * * Reads a configuration file. * * Returns a handle to lookup settings or NULL if it failed to * read or parse the file, use virConfFree() to free the data. */ virConfPtr virConfReadFile(const char *filename, unsigned int flags) { char *content; int len; virConfPtr conf = NULL; VIR_DEBUG("filename=%s", NULLSTR(filename)); if (filename == NULL) { virConfError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__); return NULL; } if ((len = virFileReadAll(filename, MAX_CONFIG_FILE_SIZE, &content)) < 0) return NULL; if (len && len < MAX_CONFIG_FILE_SIZE && content[len - 1] != '\n') { VIR_DEBUG("appending newline to busted config file %s", filename); if (VIR_REALLOC_N(content, len + 2) < 0) goto cleanup; content[len++] = '\n'; content[len] = '\0'; } conf = virConfParse(filename, content, len, flags); cleanup: VIR_FREE(content); return conf; }
int virJSONValueObjectAppend(virJSONValuePtr object, const char *key, virJSONValuePtr value) { char *newkey; if (object->type != VIR_JSON_TYPE_OBJECT) return -1; if (virJSONValueObjectHasKey(object, key)) return -1; if (!(newkey = strdup(key))) return -1; if (VIR_REALLOC_N(object->data.object.pairs, object->data.object.npairs + 1) < 0) { VIR_FREE(newkey); return -1; } object->data.object.pairs[object->data.object.npairs].key = newkey; object->data.object.pairs[object->data.object.npairs].value = value; object->data.object.npairs++; return 0; }
static int hostsfileAdd(dnsmasqHostsfile *hostsfile, const char *mac, virSocketAddr *ip, const char *name) { char *ipstr = NULL; if (VIR_REALLOC_N(hostsfile->hosts, hostsfile->nhosts + 1) < 0) goto alloc_error; if (!(ipstr = virSocketAddrFormat(ip))) return -1; if (name) { if (virAsprintf(&hostsfile->hosts[hostsfile->nhosts].host, "%s,%s,%s", mac, ipstr, name) < 0) { goto alloc_error; } } else { if (virAsprintf(&hostsfile->hosts[hostsfile->nhosts].host, "%s,%s", mac, ipstr) < 0) { goto alloc_error; } } VIR_FREE(ipstr); hostsfile->nhosts++; return 0; alloc_error: virReportOOMError(); VIR_FREE(ipstr); return -1; }
virInterfaceObjPtr virInterfaceAssignDef(virInterfaceObjListPtr interfaces, virInterfaceDefPtr def) { virInterfaceObjPtr iface; if ((iface = virInterfaceFindByName(interfaces, def->name))) { virInterfaceDefFree(iface->def); iface->def = def; return iface; } if (VIR_ALLOC(iface) < 0) return NULL; if (virMutexInit(&iface->lock) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("cannot initialize mutex")); VIR_FREE(iface); return NULL; } virInterfaceObjLock(iface); iface->def = def; if (VIR_REALLOC_N(interfaces->objs, interfaces->count + 1) < 0) { VIR_FREE(iface); return NULL; } interfaces->objs[interfaces->count] = iface; interfaces->count++; return iface; }
static int lxcSetupLoopDevices(virDomainDefPtr def, size_t *nloopDevs, int **loopDevs) { size_t i; int ret = -1; for (i = 0 ; i < def->nfss ; i++) { int fd; if (def->fss[i]->type != VIR_DOMAIN_FS_TYPE_FILE) continue; fd = lxcSetupLoopDevice(def->fss[i]); if (fd < 0) goto cleanup; VIR_DEBUG("Saving loop fd %d", fd); if (VIR_REALLOC_N(*loopDevs, *nloopDevs+1) < 0) { VIR_FORCE_CLOSE(fd); virReportOOMError(); goto cleanup; } (*loopDevs)[(*nloopDevs)++] = fd; } VIR_DEBUG("Setup all loop devices"); ret = 0; cleanup: return ret; }
static int virObjectEventCallbackListPurgeMarked(virObjectEventCallbackListPtr cbList) { int old_count = cbList->count; int n; for (n = 0; n < cbList->count; n++) { if (cbList->callbacks[n]->deleted) { virFreeCallback freecb = cbList->callbacks[n]->freecb; if (freecb) (*freecb)(cbList->callbacks[n]->opaque); virObjectUnref(cbList->callbacks[n]->conn); VIR_FREE(cbList->callbacks[n]); if (n < (cbList->count - 1)) memmove(cbList->callbacks + n, cbList->callbacks + n + 1, sizeof(*(cbList->callbacks)) * (cbList->count - (n + 1))); cbList->count--; n--; } } if (cbList->count < old_count && VIR_REALLOC_N(cbList->callbacks, cbList->count) < 0) { ; /* Failure to reduce memory allocation isn't fatal */ } return 0; }
static void virConsoleEventOnStdout(int watch ATTRIBUTE_UNUSED, int fd, int events, void *opaque) { virConsolePtr con = opaque; virObjectLock(con); /* we got late event after console was shutdown */ if (!con->st) goto cleanup; if (events & VIR_EVENT_HANDLE_WRITABLE && con->streamToTerminal.offset) { ssize_t done; size_t avail; done = write(fd, con->streamToTerminal.data, con->streamToTerminal.offset); if (done < 0) { if (errno != EAGAIN) { virReportSystemError(errno, "%s", _("cannot write to stdout")); virConsoleShutdown(con); } goto cleanup; } memmove(con->streamToTerminal.data, con->streamToTerminal.data + done, con->streamToTerminal.offset - done); con->streamToTerminal.offset -= done; avail = con->streamToTerminal.length - con->streamToTerminal.offset; if (avail > 1024) { ignore_value(VIR_REALLOC_N(con->streamToTerminal.data, con->streamToTerminal.offset + 1024)); con->streamToTerminal.length = con->streamToTerminal.offset + 1024; } } if (!con->streamToTerminal.offset) virEventUpdateHandle(con->stdoutWatch, 0); if (events & VIR_EVENT_HANDLE_ERROR) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("IO error stdout")); virConsoleShutdown(con); goto cleanup; } if (events & VIR_EVENT_HANDLE_HANGUP) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("EOF on stdout")); virConsoleShutdown(con); goto cleanup; } cleanup: virObjectUnlock(con); }
int virNetMessageEncodePayload(virNetMessagePtr msg, xdrproc_t filter, void *data) { XDR xdr; unsigned int msglen; /* Serialise payload of the message. This assumes that * virNetMessageEncodeHeader has already been run, so * just appends to that data */ xdrmem_create(&xdr, msg->buffer + msg->bufferOffset, msg->bufferLength - msg->bufferOffset, XDR_ENCODE); /* Try to encode the payload. If the buffer is too small increase it. */ while (!(*filter)(&xdr, data, 0)) { unsigned int newlen = msg->bufferLength - VIR_NET_MESSAGE_LEN_MAX; newlen *= 2; if (newlen > VIR_NET_MESSAGE_MAX) { virReportError(VIR_ERR_RPC, "%s", _("Unable to encode message payload")); goto error; } xdr_destroy(&xdr); msg->bufferLength = newlen + VIR_NET_MESSAGE_LEN_MAX; if (VIR_REALLOC_N(msg->buffer, msg->bufferLength) < 0) goto error; xdrmem_create(&xdr, msg->buffer + msg->bufferOffset, msg->bufferLength - msg->bufferOffset, XDR_ENCODE); VIR_DEBUG("Increased message buffer length = %zu", msg->bufferLength); } /* Get the length stored in buffer. */ msg->bufferOffset += xdr_getpos(&xdr); xdr_destroy(&xdr); /* Re-encode the length word. */ VIR_DEBUG("Encode length as %zu", msg->bufferOffset); xdrmem_create(&xdr, msg->buffer, VIR_NET_MESSAGE_HEADER_XDR_LEN, XDR_ENCODE); msglen = msg->bufferOffset; if (!xdr_u_int(&xdr, &msglen)) { virReportError(VIR_ERR_RPC, "%s", _("Unable to encode message length")); goto error; } xdr_destroy(&xdr); msg->bufferLength = msg->bufferOffset; msg->bufferOffset = 0; return 0; error: xdr_destroy(&xdr); return -1; }
/** * virNWFilterRuleInstAddData: * @res : pointer to virNWFilterRuleInst object collecting the instantiation * data of a single firewall rule. * @data : the opaque data that the driver wants to add * * Add instantiation data to a firewall rule. An instantiated firewall * rule may hold multiple data structure representing its instantiation * data. This may for example be the case if a rule has been defined * for bidirectional traffic and data needs to be added to the incoming * and outgoing chains. * * Returns 0 in case of success, -1 in case of an error. */ int virNWFilterRuleInstAddData(virNWFilterRuleInstPtr res, void *data) { if (VIR_REALLOC_N(res->data, res->ndata+1) < 0) return -1; res->data[res->ndata++] = data; return 0; }
static void virConsoleEventOnStdin(int watch ATTRIBUTE_UNUSED, int fd ATTRIBUTE_UNUSED, int events, void *opaque) { virConsolePtr con = opaque; if (events & VIR_EVENT_HANDLE_READABLE) { size_t avail = con->terminalToStream.length - con->terminalToStream.offset; int got; if (avail < 1024) { if (VIR_REALLOC_N(con->terminalToStream.data, con->terminalToStream.length + 1024) < 0) { virReportOOMError(); virConsoleShutdown(con); return; } con->terminalToStream.length += 1024; avail += 1024; } got = read(fd, con->terminalToStream.data + con->terminalToStream.offset, avail); if (got < 0) { if (errno != EAGAIN) { virConsoleShutdown(con); } return; } if (got == 0) { virConsoleShutdown(con); return; } if (con->terminalToStream.data[con->terminalToStream.offset] == con->escapeChar) { virConsoleShutdown(con); return; } con->terminalToStream.offset += got; if (con->terminalToStream.offset) virStreamEventUpdateCallback(con->st, VIR_STREAM_EVENT_READABLE | VIR_STREAM_EVENT_WRITABLE); } if (events & VIR_EVENT_HANDLE_ERROR || events & VIR_EVENT_HANDLE_HANGUP) { virConsoleShutdown(con); } }
static int virStorageBackendMpathNewVol(virStoragePoolObjPtr pool, const int devnum, const char *dev) { virStorageVolDefPtr vol; int ret = -1; if (VIR_ALLOC(vol) < 0) { virReportOOMError(); goto cleanup; } vol->type = VIR_STORAGE_VOL_BLOCK; if (virAsprintf(&(vol->name), "dm-%u", devnum) < 0) { virReportOOMError(); goto cleanup; } if (virAsprintf(&vol->target.path, "/dev/%s", dev) < 0) { virReportOOMError(); goto cleanup; } if (virStorageBackendMpathUpdateVolTargetInfo(&vol->target, &vol->allocation, &vol->capacity) < 0) { goto cleanup; } /* XXX should use logical unit's UUID instead */ vol->key = strdup(vol->target.path); if (vol->key == NULL) { virReportOOMError(); goto cleanup; } if (VIR_REALLOC_N(pool->volumes.objs, pool->volumes.count + 1) < 0) { virReportOOMError(); goto cleanup; } pool->volumes.objs[pool->volumes.count++] = vol; pool->def->capacity += vol->capacity; pool->def->allocation += vol->allocation; ret = 0; cleanup: if (ret != 0) virStorageVolDefFree(vol); return ret; }
/* Note: There are many additional dhcp-host specifications * supported by dnsmasq. There are only the basic ones. */ static int hostsfileAdd(dnsmasqHostsfile *hostsfile, const char *mac, virSocketAddr *ip, const char *name, const char *id, bool ipv6) { char *ipstr = NULL; if (VIR_REALLOC_N(hostsfile->hosts, hostsfile->nhosts + 1) < 0) goto alloc_error; if (!(ipstr = virSocketAddrFormat(ip))) return -1; /* the first test determines if it is a dhcpv6 host */ if (ipv6) { if (name && id) { if (virAsprintf(&hostsfile->hosts[hostsfile->nhosts].host, "id:%s,%s,[%s]", id, name, ipstr) < 0) goto alloc_error; } else if (name && !id) { if (virAsprintf(&hostsfile->hosts[hostsfile->nhosts].host, "%s,[%s]", name, ipstr) < 0) goto alloc_error; } else if (!name && id) { if (virAsprintf(&hostsfile->hosts[hostsfile->nhosts].host, "id:%s,[%s]", id, ipstr) < 0) goto alloc_error; } } else if (name && mac) { if (virAsprintf(&hostsfile->hosts[hostsfile->nhosts].host, "%s,%s,%s", mac, ipstr, name) < 0) goto alloc_error; } else if (name && !mac){ if (virAsprintf(&hostsfile->hosts[hostsfile->nhosts].host, "%s,%s", name, ipstr) < 0) goto alloc_error; } else { if (virAsprintf(&hostsfile->hosts[hostsfile->nhosts].host, "%s,%s", mac, ipstr) < 0) goto alloc_error; } VIR_FREE(ipstr); hostsfile->nhosts++; return 0; alloc_error: virReportOOMError(); VIR_FREE(ipstr); return -1; }
/** * virNWFilterRuleInstAddData: * @res : pointer to virNWFilterRuleInst object collecting the instantiation * data of a single firewall rule. * @data : the opaque data that the driver wants to add * * Add instantiation data to a firewall rule. An instantiated firewall * rule may hold multiple data structure representing its instantiation * data. This may for example be the case if a rule has been defined * for bidirectional traffic and data needs to be added to the incoming * and outgoing chains. * * Returns 0 in case of success, -1 in case of an error. */ int virNWFilterRuleInstAddData(virNWFilterRuleInstPtr res, void *data) { if (VIR_REALLOC_N(res->data, res->ndata+1) < 0) { virReportOOMError(); return -1; } res->data[res->ndata++] = data; return 0; }
/* Ensure there is space to store at least one more parameter * at the end of the set. */ static int grow_qparam_set (struct qparam_set *ps) { if (ps->n >= ps->alloc) { if (VIR_REALLOC_N(ps->p, ps->alloc * 2) < 0) { virReportOOMError(); return -1; } ps->alloc *= 2; } return 0; }
int virNetMessageEncodePayloadRaw(virNetMessagePtr msg, const char *data, size_t len) { XDR xdr; unsigned int msglen; /* If the message buffer is too small for the payload increase it accordingly. */ if ((msg->bufferLength - msg->bufferOffset) < len) { if ((msg->bufferOffset + len) > (VIR_NET_MESSAGE_MAX + VIR_NET_MESSAGE_LEN_MAX)) { virReportError(VIR_ERR_RPC, _("Stream data too long to send " "(%zu bytes needed, %zu bytes available)"), len, VIR_NET_MESSAGE_MAX + VIR_NET_MESSAGE_LEN_MAX - msg->bufferOffset); return -1; } msg->bufferLength = msg->bufferOffset + len; if (VIR_REALLOC_N(msg->buffer, msg->bufferLength) < 0) return -1; VIR_DEBUG("Increased message buffer length = %zu", msg->bufferLength); } memcpy(msg->buffer + msg->bufferOffset, data, len); msg->bufferOffset += len; /* Re-encode the length word. */ VIR_DEBUG("Encode length as %zu", msg->bufferOffset); xdrmem_create(&xdr, msg->buffer, VIR_NET_MESSAGE_HEADER_XDR_LEN, XDR_ENCODE); msglen = msg->bufferOffset; if (!xdr_u_int(&xdr, &msglen)) { virReportError(VIR_ERR_RPC, "%s", _("Unable to encode message length")); goto error; } xdr_destroy(&xdr); msg->bufferLength = msg->bufferOffset; msg->bufferOffset = 0; return 0; error: xdr_destroy(&xdr); return -1; }
static int lxcContainerUnmountOldFS(void) { struct mntent mntent; char **mounts = NULL; int nmounts = 0; FILE *procmnt; int i; char mntbuf[1024]; if (!(procmnt = setmntent("/proc/mounts", "r"))) { virReportSystemError(errno, "%s", _("Failed to read /proc/mounts")); return -1; } while (getmntent_r(procmnt, &mntent, mntbuf, sizeof(mntbuf)) != NULL) { VIR_DEBUG("Got %s", mntent.mnt_dir); if (!STRPREFIX(mntent.mnt_dir, "/.oldroot")) continue; if (VIR_REALLOC_N(mounts, nmounts+1) < 0) { endmntent(procmnt); virReportOOMError(); return -1; } if (!(mounts[nmounts++] = strdup(mntent.mnt_dir))) { endmntent(procmnt); virReportOOMError(); return -1; } } endmntent(procmnt); if (mounts) qsort(mounts, nmounts, sizeof(mounts[0]), lxcContainerChildMountSort); for (i = 0 ; i < nmounts ; i++) { VIR_DEBUG("Umount %s", mounts[i]); if (umount(mounts[i]) < 0) { virReportSystemError(errno, _("Failed to unmount '%s'"), mounts[i]); return -1; } VIR_FREE(mounts[i]); } VIR_FREE(mounts); return 0; }
int virJSONValueArrayAppend(virJSONValuePtr array, virJSONValuePtr value) { if (array->type != VIR_JSON_TYPE_ARRAY) return -1; if (VIR_REALLOC_N(array->data.array.values, array->data.array.nvalues + 1) < 0) return -1; array->data.array.values[array->data.array.nvalues] = value; array->data.array.nvalues++; return 0; }
static int virStorageBackendLogicalFindPoolSourcesFunc(char **const groups, void *data) { virStoragePoolSourceListPtr sourceList = data; char *pvname = NULL; char *vgname = NULL; size_t i; virStoragePoolSourceDevicePtr dev; virStoragePoolSource *thisSource; if (VIR_STRDUP(pvname, groups[0]) < 0 || VIR_STRDUP(vgname, groups[1]) < 0) goto error; thisSource = NULL; for (i = 0; i < sourceList->nsources; i++) { if (STREQ(sourceList->sources[i].name, vgname)) { thisSource = &sourceList->sources[i]; break; } } if (thisSource == NULL) { if (!(thisSource = virStoragePoolSourceListNewSource(sourceList))) goto error; thisSource->name = vgname; } else VIR_FREE(vgname); if (VIR_REALLOC_N(thisSource->devices, thisSource->ndevice + 1) != 0) goto error; dev = &thisSource->devices[thisSource->ndevice]; thisSource->ndevice++; thisSource->format = VIR_STORAGE_POOL_LOGICAL_LVM2; memset(dev, 0, sizeof(*dev)); dev->path = pvname; return 0; error: VIR_FREE(pvname); VIR_FREE(vgname); return -1; }
/* * @msg: the outgoing message, whose header to encode * * Encodes the length word and header of the message, setting the * message offset ready to encode the payload. Leaves space * for the length field later. Upon return bufferLength will * refer to the total available space for message, while * bufferOffset will refer to current space used by header * * returns 0 if successfully encoded, -1 upon fatal error */ int virNetMessageEncodeHeader(virNetMessagePtr msg) { XDR xdr; int ret = -1; unsigned int len = 0; msg->bufferLength = VIR_NET_MESSAGE_MAX + VIR_NET_MESSAGE_LEN_MAX; if (VIR_REALLOC_N(msg->buffer, msg->bufferLength) < 0) { virReportOOMError(); return ret; } msg->bufferOffset = 0; /* Format the header. */ xdrmem_create(&xdr, msg->buffer, msg->bufferLength, XDR_ENCODE); /* The real value is filled in shortly */ if (!xdr_u_int(&xdr, &len)) { virReportError(VIR_ERR_RPC, "%s", _("Unable to encode message length")); goto cleanup; } if (!xdr_virNetMessageHeader(&xdr, &msg->header)) { virReportError(VIR_ERR_RPC, "%s", _("Unable to encode message header")); goto cleanup; } len = xdr_getpos(&xdr); xdr_setpos(&xdr, 0); /* Fill in current length - may be re-written later * if a payload is added */ if (!xdr_u_int(&xdr, &len)) { virReportError(VIR_ERR_RPC, "%s", _("Unable to re-encode message length")); goto cleanup; } msg->bufferOffset += len; ret = 0; cleanup: xdr_destroy(&xdr); return ret; }
int virNetMessageDecodeLength(virNetMessagePtr msg) { XDR xdr; unsigned int len; int ret = -1; xdrmem_create(&xdr, msg->buffer, msg->bufferLength, XDR_DECODE); if (!xdr_u_int(&xdr, &len)) { virReportError(VIR_ERR_RPC, "%s", _("Unable to decode message length")); goto cleanup; } msg->bufferOffset = xdr_getpos(&xdr); if (len < VIR_NET_MESSAGE_LEN_MAX) { virReportError(VIR_ERR_RPC, _("packet %d bytes received from server too small, want %d"), len, VIR_NET_MESSAGE_LEN_MAX); goto cleanup; } /* Length includes length word - adjust to real length to read. */ len -= VIR_NET_MESSAGE_LEN_MAX; if (len > VIR_NET_MESSAGE_MAX) { virReportError(VIR_ERR_RPC, _("packet %d bytes received from server too large, want %d"), len, VIR_NET_MESSAGE_MAX); goto cleanup; } /* Extend our declared buffer length and carry on reading the header + payload */ msg->bufferLength += len; if (VIR_REALLOC_N(msg->buffer, msg->bufferLength) < 0) { virReportOOMError(); goto cleanup; } VIR_DEBUG("Got length, now need %zu total (%u more)", msg->bufferLength, len); ret = 0; cleanup: xdr_destroy(&xdr); return ret; }
/* Note: There are many additional dhcp-host specifications * supported by dnsmasq. There are only the basic ones. */ static int hostsfileAdd(dnsmasqHostsfile *hostsfile, const char *mac, virSocketAddr *ip, const char *name, const char *id, const char *leasetime, bool ipv6) { int ret = -1; char *ipstr = NULL; virBuffer hostbuf = VIR_BUFFER_INITIALIZER; if (VIR_REALLOC_N(hostsfile->hosts, hostsfile->nhosts + 1) < 0) goto error; if (!(ipstr = virSocketAddrFormat(ip))) goto error; /* the first test determines if it is a dhcpv6 host */ if (ipv6) { if (name && id) virBufferAsprintf(&hostbuf, "id:%s,%s,[%s]", id, name, ipstr); else if (name && !id) virBufferAsprintf(&hostbuf, "%s,[%s]", name, ipstr); else if (!name && id) virBufferAsprintf(&hostbuf, "id:%s,[%s]", id, ipstr); } else if (name && mac) { virBufferAsprintf(&hostbuf, "%s,%s,%s", mac, ipstr, name); } else if (name && !mac) { virBufferAsprintf(&hostbuf, "%s,%s", name, ipstr); } else { virBufferAsprintf(&hostbuf, "%s,%s", mac, ipstr); } /* The leasetime string already includes comma if there's any value at all */ virBufferAsprintf(&hostbuf, "%s", leasetime); if (!(hostsfile->hosts[hostsfile->nhosts].host = virBufferContentAndReset (&hostbuf))) goto error; hostsfile->nhosts++; ret = 0; error: virBufferFreeAndReset(&hostbuf); VIR_FREE(ipstr); return ret; }
/* allocate a flexible array and fill values(key,val) */ int allocStringMap(xen_string_string_map **strings, char *key, char *val) { int sz = ((*strings) == NULL) ? 0 : (*strings)->size; sz++; if (VIR_REALLOC_N(*strings, sizeof(xen_string_string_map) + sizeof(xen_string_string_map_contents) * sz) < 0) return -1; (*strings)->size = sz; if (VIR_STRDUP((*strings)->contents[sz-1].key, key) < 0 || VIR_STRDUP((*strings)->contents[sz-1].val, val) < 0) goto error; return 0; error: xen_string_string_map_free(*strings); return -1; }
/* * Called when the monitor has incoming data to read * Call this function while holding the monitor lock. * * Returns -1 on error, or number of bytes read */ static int qemuAgentIORead(qemuAgentPtr mon) { size_t avail = mon->bufferLength - mon->bufferOffset; int ret = 0; if (avail < 1024) { if (VIR_REALLOC_N(mon->buffer, mon->bufferLength + 1024) < 0) { virReportOOMError(); return -1; } mon->bufferLength += 1024; avail += 1024; } /* Read as much as we can get into our buffer, until we block on EAGAIN, or hit EOF */ while (avail > 1) { int got; got = read(mon->fd, mon->buffer + mon->bufferOffset, avail - 1); if (got < 0) { if (errno == EAGAIN) break; virReportSystemError(errno, "%s", _("Unable to read from monitor")); ret = -1; break; } if (got == 0) break; ret += got; avail -= got; mon->bufferOffset += got; mon->buffer[mon->bufferOffset] = '\0'; } #if DEBUG_IO VIR_DEBUG("Now read %zu bytes of data", mon->bufferOffset); #endif return ret; }
int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool, virStorageVolDefPtr privvol) { int ret = -1; char *xml_path = NULL; size_t i; privpool->def->allocation -= privvol->allocation; privpool->def->available = (privpool->def->capacity - privpool->def->allocation); for (i = 0; i < privpool->volumes.count; i++) { if (privpool->volumes.objs[i] == privvol) { xml_path = parallelsAddFileExt(privvol->target.path, ".xml"); if (!xml_path) goto cleanup; if (unlink(xml_path)) { virReportError(VIR_ERR_OPERATION_FAILED, _("Can't remove file '%s'"), xml_path); goto cleanup; } virStorageVolDefFree(privvol); if (i < (privpool->volumes.count - 1)) memmove(privpool->volumes.objs + i, privpool->volumes.objs + i + 1, sizeof(*(privpool->volumes.objs)) * (privpool->volumes.count - (i + 1))); if (VIR_REALLOC_N(privpool->volumes.objs, privpool->volumes.count - 1) < 0) { ; /* Failure to reduce memory allocation isn't fatal */ } privpool->volumes.count--; break; } } ret = 0; cleanup: VIR_FREE(xml_path); return ret; }
static int virStorageBackendDiskMakeFreeExtent(virStoragePoolObjPtr pool, char **const groups) { virStoragePoolSourceDevicePtr dev = &pool->def->source.devices[0]; if (VIR_REALLOC_N(dev->freeExtents, dev->nfreeExtent + 1) < 0) return -1; memset(dev->freeExtents + dev->nfreeExtent, 0, sizeof(dev->freeExtents[0])); /* set type of free area */ if (STREQ(groups[1], "logical")) { dev->freeExtents[dev->nfreeExtent].type = VIR_STORAGE_FREE_LOGICAL; } else { dev->freeExtents[dev->nfreeExtent].type = VIR_STORAGE_FREE_NORMAL; } if (virStrToLong_ull(groups[3], NULL, 10, &dev->freeExtents[dev->nfreeExtent].start) < 0) return -1; /* Don't bother to re-alloc freeExtents - it'll be free'd shortly */ if (virStrToLong_ull(groups[4], NULL, 10, &dev->freeExtents[dev->nfreeExtent].end) < 0) return -1; /* Don't bother to re-alloc freeExtents - it'll be free'd shortly */ /* first block reported as free, even if it is not */ if (dev->freeExtents[dev->nfreeExtent].start == 0) { dev->freeExtents[dev->nfreeExtent].start = SECTOR_SIZE; } pool->def->available += (dev->freeExtents[dev->nfreeExtent].end - dev->freeExtents[dev->nfreeExtent].start); if (dev->freeExtents[dev->nfreeExtent].end > pool->def->capacity) pool->def->capacity = dev->freeExtents[dev->nfreeExtent].end; dev->nfreeExtent++; return 0; }
int virSCSIDeviceListAdd(virSCSIDeviceListPtr list, virSCSIDevicePtr dev) { if (virSCSIDeviceListFind(list, dev)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Device %s already exists"), dev->name); return -1; } if (VIR_REALLOC_N(list->devs, list->count + 1) < 0) return -1; list->devs[list->count++] = dev; return 0; }