static void
virCapabilitiesFreeGuestDomain(virCapsGuestDomainPtr dom)
{
- int i;
+ size_t i;
if (dom == NULL)
return;
static void
virCapabilitiesFreeGuest(virCapsGuestPtr guest)
{
- int i;
+ size_t i;
if (guest == NULL)
return;
void
virCapabilitiesFreeNUMAInfo(virCapsPtr caps)
{
- int i;
+ size_t i;
for (i = 0; i < caps->host.nnumaCell; i++)
virCapabilitiesFreeHostNUMACell(caps->host.numaCell[i]);
virCapabilitiesDispose(void *object)
{
virCapsPtr caps = object;
- int i;
+ size_t i;
for (i = 0; i < caps->nguests; i++)
virCapabilitiesFreeGuest(caps->guests[i]);
virCapabilitiesAllocMachines(const char *const *names, int nnames)
{
virCapsGuestMachinePtr *machines;
- int i;
+ size_t i;
if (VIR_ALLOC_N(machines, nnames) < 0)
return NULL;
virCapabilitiesFreeMachines(virCapsGuestMachinePtr *machines,
int nmachines)
{
- int i;
+ size_t i;
if (!machines)
return;
for (i = 0; i < nmachines && machines[i]; i++) {
virCapabilitiesSupportsGuestArch(virCapsPtr caps,
virArch arch)
{
- int i;
+ size_t i;
for (i = 0; i < caps->nguests; i++) {
if (caps->guests[i]->arch.id == arch)
return 1;
virCapabilitiesSupportsGuestOSType(virCapsPtr caps,
const char *ostype)
{
- int i;
+ size_t i;
for (i = 0; i < caps->nguests; i++) {
if (STREQ(caps->guests[i]->ostype, ostype))
return 1;
const char *ostype,
virArch arch)
{
- int i;
+ size_t i;
for (i = 0; i < caps->nguests; i++) {
if (STREQ(caps->guests[i]->ostype, ostype) &&
caps->guests[i]->arch.id == arch)
const char *ostype,
const char *domain)
{
- int i, j;
+ size_t i, j;
/* First try to find one matching host arch */
for (i = 0; i < caps->nguests; i++) {
virArch arch,
const char *domain)
{
- int i;
+ size_t i;
for (i = 0; i < caps->nguests; i++) {
virCapsGuestPtr guest = caps->guests[i];
- int j;
+ size_t j;
if (!STREQ(guest->ostype, ostype) ||
guest->arch.id != arch)
virArch arch,
const char *domain)
{
- int i, j;
+ size_t i, j;
for (i = 0; i < caps->nguests; i++) {
char *emulator;
if (STREQ(caps->guests[i]->ostype, ostype) &&
size_t ncells,
virCapsHostNUMACellPtr *cells)
{
- int i;
- int j;
+ size_t i;
+ size_t j;
char *siblings;
virBufferAddLit(xml, " <topology>\n");
virCapabilitiesFormatXML(virCapsPtr caps)
{
virBuffer xml = VIR_BUFFER_INITIALIZER;
- int i, j, k;
+ size_t i, j, k;
char host_uuid[VIR_UUID_STRING_BUFLEN];
virBufferAddLit(&xml, "<capabilities>\n\n");
void ATTRIBUTE_NONNULL(1)
virCPUDefFreeModel(virCPUDefPtr def)
{
- unsigned int i;
+ size_t i;
VIR_FREE(def->model);
VIR_FREE(def->vendor);
void
virCPUDefFree(virCPUDefPtr def)
{
- unsigned int i;
+ size_t i;
if (!def)
return;
const virCPUDefPtr src,
bool resetPolicy)
{
- unsigned int i;
+ size_t i;
if (VIR_STRDUP(dst->model, src->model) < 0 ||
VIR_STRDUP(dst->vendor, src->vendor) < 0 ||
virCPUDefCopy(const virCPUDefPtr cpu)
{
virCPUDefPtr copy;
- unsigned int i;
+ size_t i;
if (!cpu || VIR_ALLOC(copy) < 0)
return NULL;
virCPUDefPtr def;
xmlNodePtr *nodes = NULL;
int n;
- unsigned int i;
+ size_t i;
char *cpuMode;
char *fallback = NULL;
char *vendor_id = NULL;
for (i = 0; i < n; i++) {
char *name;
int policy; /* enum virDomainCPUFeaturePolicy */
- unsigned int j;
+ size_t j;
if (def->type == VIR_CPU_TYPE_GUEST) {
char *strpolicy;
virCPUDefPtr def,
unsigned int flags)
{
- unsigned int i;
+ size_t i;
bool formatModel;
bool formatFallback;
const char *name,
int policy)
{
- int i;
+ size_t i;
for (i = 0; i < def->nfeatures; i++) {
if (STREQ(name, def->features[i].name)) {
virCPUDefPtr dst)
{
bool identical = false;
- int i;
+ size_t i;
if (!src && !dst)
return true;
void
virDomainAuditStart(virDomainObjPtr vm, const char *reason, bool success)
{
- int i;
+ size_t i;
for (i = 0; i < vm->def->ndisks; i++) {
virDomainDiskDefPtr disk = vm->def->disks[i];
char uuidstr[VIR_UUID_STRING_BUFLEN];
char *vmname;
const char *virt;
- int i;
+ size_t i;
virUUIDFormat(vm->def->uuid, uuidstr);
if (!(vmname = virAuditEncode("vm", vm->def->name))) {
virBlkioDeviceWeightArrayClear(virBlkioDeviceWeightPtr deviceWeights,
int ndevices)
{
- int i;
+ size_t i;
for (i = 0; i < ndevices; i++)
VIR_FREE(deviceWeights[i].path);
void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def)
{
- int ii;
+ size_t i;
if (!def)
return;
break;
}
- for (ii = 0; ii < def->nListens; ii++)
- virDomainGraphicsListenDefClear(&def->listens[ii]);
+ for (i = 0; i < def->nListens; i++)
+ virDomainGraphicsListenDefClear(&def->listens[i]);
VIR_FREE(def->listens);
VIR_FREE(def);
void virDomainDiskDefFree(virDomainDiskDefPtr def)
{
- unsigned int i;
+ size_t i;
if (!def)
return;
virDomainDeviceInfoClear(&def->info);
- int i;
+ size_t i;
for (i = 0; i < def->ncodecs; i++)
virDomainSoundCodecDefFree(def->codecs[i]);
VIR_FREE(def->codecs);
if (def->offset == VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE)
VIR_FREE(def->data.timezone);
- int i;
+ size_t i;
for (i = 0; i < def->ntimers; i++)
VIR_FREE(def->timers[i]);
VIR_FREE(def->timers);
virDomainVcpuPinDefPtr *
virDomainVcpuPinDefCopy(virDomainVcpuPinDefPtr *src, int nvcpupin)
{
- int i = 0;
+ size_t i;
virDomainVcpuPinDefPtr *ret = NULL;
if (VIR_ALLOC_N(ret, nvcpupin) < 0)
error:
if (ret) {
- for (; i >= 0; --i) {
+ for (i = 0; i < nvcpupin; i++) {
if (ret[i]) {
virBitmapFree(ret[i]->cpumask);
VIR_FREE(ret[i]);
virDomainVcpuPinDefArrayFree(virDomainVcpuPinDefPtr *def,
int nvcpupin)
{
- int i;
+ size_t i;
if (!def || !nvcpupin)
return;
void virDomainDefFree(virDomainDefPtr def)
{
- unsigned int i;
+ size_t i;
if (!def)
return;
bool all,
void *opaque)
{
- int i;
+ size_t i;
virDomainDeviceDef device;
device.type = VIR_DOMAIN_DEVICE_DISK;
size_t nbitmaps = 0;
int ret = -1;
bool b;
- int i;
+ size_t i;
memset(max_idx, -1, sizeof(max_idx));
virDomainDefPostParseInternal(virDomainDefPtr def,
virCapsPtr caps ATTRIBUTE_UNUSED)
{
- int i;
+ size_t i;
/* verify init path for container based domains */
if (STREQ(def->os.type, "exe") && !def->os.init) {
unsigned int unit)
{
virDomainDiskDefPtr disk;
- int i;
+ size_t i;
for (i = 0; i < def->ndisks; i++) {
disk = def->disks[i];
unsigned int unit)
{
virDomainHostdevDefPtr hostdev;
- int i;
+ size_t i;
for (i = 0; i < def->nhostdevs; i++) {
hostdev = def->hostdevs[i];
unsigned int max_unit,
unsigned int controller)
{
- int i;
+ size_t i;
for (i = 0; i < max_unit; i++) {
if (!virDomainSCSIDriveAddressIsUsed(def, controller, i))
{
int next_unit = 0;
unsigned controller = 0;
- int i;
+ size_t i;
int ret;
if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI)
int controllerType)
{
int model = -1;
- int i;
+ size_t i;
for (i = 0; i < def->ncontrollers; i++) {
if (def->controllers[i]->type == controllerType &&
int bus,
char *dst)
{
- int i;
+ size_t i;
if (!dst)
return NULL;
virCapsPtr caps,
unsigned int flags)
{
- int i = 0, n;
+ size_t i = 0;
+ int n;
xmlNodePtr *list = NULL, saved_node;
virCapsHostPtr host = &caps->host;
{
virSecurityDeviceLabelDefPtr *seclabels;
size_t nseclabels = 0;
- int n, i, j;
+ int n;
+ size_t i, j;
xmlNodePtr *list = NULL;
virSecurityLabelDefPtr vmDef = NULL;
char *model, *relabel, *label;
}
if (ioeventfd) {
+ int val;
+
if (def->bus != VIR_DOMAIN_DISK_BUS_VIRTIO) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk ioeventfd mode supported "
goto error;
}
- int i;
- if ((i = virDomainIoEventFdTypeFromString(ioeventfd)) <= 0) {
+ if ((val = virDomainIoEventFdTypeFromString(ioeventfd)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown disk ioeventfd mode '%s'"),
ioeventfd);
goto error;
}
- def->ioeventfd=i;
+ def->ioeventfd = val;
}
if (event_idx) {
}
if (startupPolicy) {
- int i;
+ int val;
- if ((i = virDomainStartupPolicyTypeFromString(startupPolicy)) <= 0) {
+ if ((val = virDomainStartupPolicyTypeFromString(startupPolicy)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown startupPolicy value '%s'"),
startupPolicy);
startupPolicy);
goto error;
}
- def->startupPolicy = i;
+ def->startupPolicy = val;
}
def->src = source;
def->driver.virtio.txmode = m;
}
if (ioeventfd) {
- int i;
- if ((i = virDomainIoEventFdTypeFromString(ioeventfd)) <= 0) {
+ int val;
+ if ((val = virDomainIoEventFdTypeFromString(ioeventfd)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown interface ioeventfd mode '%s'"),
ioeventfd);
goto error;
}
- def->driver.virtio.ioeventfd = i;
+ def->driver.virtio.ioeventfd = val;
}
if (event_idx) {
int idx;
char *mode = NULL;
char *type = NULL;
virDomainSmartcardDefPtr def;
- int i;
+ size_t i;
if (VIR_ALLOC(def) < 0)
return NULL;
goto error;
if (nListens > 0) {
- int ii;
+ size_t i;
if (VIR_ALLOC_N(def->listens, nListens) < 0)
goto error;
- for (ii = 0; ii < nListens; ii++) {
- int ret = virDomainGraphicsListenDefParseXML(&def->listens[ii],
- listenNodes[ii],
+ for (i = 0; i < nListens; i++) {
+ int ret = virDomainGraphicsListenDefParseXML(&def->listens[i],
+ listenNodes[i],
flags);
if (ret < 0)
goto error;
* graphics. */
bool matched = false;
const char *found = NULL;
- int ii;
+ size_t i;
- for (ii = 0; ii < nListens; ii++) {
- if (virDomainGraphicsListenGetType(def, ii)
+ for (i = 0; i < nListens; i++) {
+ if (virDomainGraphicsListenGetType(def, i)
== VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS) {
- found = virDomainGraphicsListenGetAddress(def, ii);
+ found = virDomainGraphicsListenGetAddress(def, i);
if (STREQ_NULLABLE(found, listenAddr)) {
matched = true;
}
goto error;
if (ncodecs > 0) {
- int ii;
+ size_t i;
if (VIR_ALLOC_N(def->codecs, ncodecs) < 0) {
VIR_FREE(codecNodes);
goto error;
}
- for (ii = 0; ii < ncodecs; ii++) {
- virDomainSoundCodecDefPtr codec = virDomainSoundCodecDefParseXML(codecNodes[ii]);
+ for (i = 0; i < ncodecs; i++) {
+ virDomainSoundCodecDefPtr codec = virDomainSoundCodecDefParseXML(codecNodes[i]);
if (codec == NULL)
goto error;
virDomainHostdevDefPtr *found)
{
virDomainHostdevDefPtr local_found;
- int i;
+ size_t i;
if (!found)
found = &local_found;
bool allow_ambiguous)
{
virDomainDiskDefPtr vdisk;
- int i;
+ size_t i;
int candidate = -1;
/* We prefer the <target dev='name'/> name (it's shorter, required
const char *
virDomainDiskPathByName(virDomainDefPtr def, const char *name)
{
- int i = virDomainDiskIndexByName(def, name, true);
+ int idx = virDomainDiskIndexByName(def, name, true);
- return i < 0 ? NULL : def->disks[i]->src;
+ return idx < 0 ? NULL : def->disks[idx]->src;
}
int virDomainDiskInsert(virDomainDefPtr def,
void virDomainDiskInsertPreAlloced(virDomainDefPtr def,
virDomainDiskDefPtr disk)
{
- int i;
+ int idx;
/* Tenatively plan to insert disk at the end. */
int insertAt = -1;
* index greater than the new one, insert at
* that position
*/
- for (i = (def->ndisks - 1); i >= 0; i--) {
+ for (idx = (def->ndisks - 1); idx >= 0; idx--) {
/* If bus matches and current disk is after
* new disk, then new disk should go here */
- if (def->disks[i]->bus == disk->bus &&
- (virDiskNameToIndex(def->disks[i]->dst) >
+ if (def->disks[idx]->bus == disk->bus &&
+ (virDiskNameToIndex(def->disks[idx]->dst) >
virDiskNameToIndex(disk->dst))) {
- insertAt = i;
- } else if (def->disks[i]->bus == disk->bus &&
+ insertAt = idx;
+ } else if (def->disks[idx]->bus == disk->bus &&
insertAt == -1) {
/* Last disk with match bus is before the
* new disk, then put new disk just after
*/
- insertAt = i + 1;
+ insertAt = idx + 1;
}
}
virDomainDiskDefPtr
virDomainDiskRemoveByName(virDomainDefPtr def, const char *name)
{
- int i = virDomainDiskIndexByName(def, name, false);
- if (i < 0)
+ int idx = virDomainDiskIndexByName(def, name, false);
+ if (idx < 0)
return NULL;
- return virDomainDiskRemove(def, i);
+ return virDomainDiskRemove(def, idx);
}
/* Return true if VM has at least one disk involved in a current block
bool
virDomainHasDiskMirror(virDomainObjPtr vm)
{
- int i;
+ size_t i;
for (i = 0; i < vm->def->ndisks; i++)
if (vm->def->disks[i]->mirror)
return true;
int
virDomainNetFindIdx(virDomainDefPtr def, virDomainNetDefPtr net)
{
- int ii, matchidx = -1;
+ size_t i;
+ int matchidx = -1;
bool PCIAddrSpecified = virDomainDeviceAddressIsValid(&net->info,
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI);
- for (ii = 0; ii < def->nnets; ii++) {
- if (virMacAddrCmp(&def->nets[ii]->mac, &net->mac))
+ for (i = 0; i < def->nnets; i++) {
+ if (virMacAddrCmp(&def->nets[i]->mac, &net->mac))
continue;
if ((matchidx >= 0) && !PCIAddrSpecified) {
break;
}
if (PCIAddrSpecified) {
- if (virDevicePCIAddressEqual(&def->nets[ii]->info.addr.pci,
+ if (virDevicePCIAddressEqual(&def->nets[i]->info.addr.pci,
&net->info.addr.pci)) {
/* exit early if the pci address was specified and
* it matches, as this guarantees no duplicates.
*/
- matchidx = ii;
+ matchidx = i;
break;
}
} else {
/* no PCI address given, so there may be multiple matches */
- matchidx = ii;
+ matchidx = i;
}
}
return matchidx;
void virDomainControllerInsertPreAlloced(virDomainDefPtr def,
virDomainControllerDefPtr controller)
{
- int i;
+ int idx;
/* Tenatively plan to insert controller at the end. */
int insertAt = -1;
* index greater than the new one, insert at
* that position
*/
- for (i = (def->ncontrollers - 1); i >= 0; i--) {
+ for (idx = (def->ncontrollers - 1); idx >= 0; idx--) {
/* If bus matches and current controller is after
* new controller, then new controller should go here */
- if (def->controllers[i]->type == controller->type &&
- def->controllers[i]->idx > controller->idx) {
- insertAt = i;
- } else if (def->controllers[i]->type == controller->type &&
+ if (def->controllers[idx]->type == controller->type &&
+ def->controllers[idx]->idx > controller->idx) {
+ insertAt = idx;
+ } else if (def->controllers[idx]->type == controller->type &&
insertAt == -1) {
/* Last controller with match bus is before the
* new controller, then put new controller just after
*/
- insertAt = i + 1;
+ insertAt = idx + 1;
}
}
virDomainControllerFind(virDomainDefPtr def,
int type, int idx)
{
- int i;
+ size_t i;
for (i = 0; i < def->ncontrollers; i++) {
if ((def->controllers[i]->type == type) &&
virDomainLeaseDefPtr lease)
{
virDomainLeaseDefPtr vlease;
- int i;
+ size_t i;
for (i = 0; i < def->nleases; i++) {
vlease = def->leases[i];
virDomainLeaseRemove(virDomainDefPtr def,
virDomainLeaseDefPtr lease)
{
- int i = virDomainLeaseIndex(def, lease);
- if (i < 0)
+ int idx = virDomainLeaseIndex(def, lease);
+ if (idx < 0)
return NULL;
- return virDomainLeaseRemoveAt(def, i);
+ return virDomainLeaseRemoveAt(def, idx);
}
virDomainDefPtr def)
{
xmlNodePtr *nodes = NULL;
- int i, n;
+ size_t i;
+ int n;
char *tmp = NULL;
int ret = -1;
unsigned long deviceBoot, serialPorts;
virDomainLookupVcpuPin(virDomainDefPtr def,
int vcpuid)
{
- int i;
+ size_t i;
if (!def->cputune.vcpupin)
return NULL;
int idx,
int model)
{
- int i;
+ size_t i;
virDomainControllerDefPtr cont;
for (i = 0; i < def->ncontrollers; i++) {
virDomainDefMaybeAddHostdevSCSIcontroller(virDomainDefPtr def)
{
/* Look for any hostdev scsi dev */
- int i;
+ size_t i;
int maxController = -1;
virDomainHostdevDefPtr hostdev;
}
}
+ if (maxController == -1)
+ return 0;
+
for (i = 0; i <= maxController; i++) {
if (virDomainDefMaybeAddController(def, VIR_DOMAIN_CONTROLLER_TYPE_SCSI, i, -1) < 0)
return -1;
{
xmlNodePtr *nodes = NULL, node = NULL;
char *tmp = NULL;
- int i, n;
+ size_t i;
+ int n;
long id = -1;
virDomainDefPtr def;
unsigned long count;
goto error;
for (i = 0; i < n; i++) {
- int j;
+ size_t j;
if (virDomainBlkioDeviceWeightParseXML(nodes[i],
&def->blkio.devices[i]) < 0)
goto error;
if (chr->target.port == -1) {
int maxport = -1;
- int j;
+ size_t j;
for (j = 0; j < i; j++) {
if (def->parallels[j]->target.port > maxport)
maxport = def->parallels[j]->target.port;
if (chr->target.port == -1) {
int maxport = -1;
- int j;
+ size_t j;
for (j = 0; j < i; j++) {
if (def->serials[j]->target.port > maxport)
maxport = def->serials[j]->target.port;
if (chr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL &&
chr->info.addr.vioserial.port == 0) {
int maxport = 0;
- int j;
+ size_t j;
for (j = 0; j < i; j++) {
virDomainChrDefPtr thischr = def->channels[j];
if (thischr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL &&
if (n && VIR_ALLOC_N(def->videos, n) < 0)
goto error;
for (i = 0; i < n; i++) {
- size_t ii = def->nvideos;
- virDomainVideoDefPtr video = virDomainVideoDefParseXML(nodes[i],
+ size_t j = def->nvideos;
+ virDomainVideoDefPtr video = virDomainVideoDefParseXML(nodes[j],
def,
flags);
if (!video)
goto error;
}
- ii = 0;
+ j = 0;
primaryVideo = true;
}
if (VIR_INSERT_ELEMENT_INPLACE(def->videos,
- ii,
+ j,
def->nvideos,
video) < 0) {
virDomainVideoDefFree(video);
xmlNodePtr oldnode;
virDomainObjPtr obj;
xmlNodePtr *nodes = NULL;
- int i, n;
+ size_t i;
+ int n;
int state;
int reason = 0;
virDomainRedirFilterDefCheckABIStability(virDomainRedirFilterDefPtr src,
virDomainRedirFilterDefPtr dst)
{
- int i;
+ size_t i;
if (src->nusbdevs != dst->nusbdevs) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
virDomainDefCheckABIStability(virDomainDefPtr src,
virDomainDefPtr dst)
{
- int i;
+ size_t i;
if (src->virtType != dst->virtType) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
int controllerType,
int diskBus)
{
- int i;
+ size_t i;
int maxController = -1;
for (i = 0; i < def->ndisks; i++) {
maxController = def->disks[i]->info.addr.drive.controller;
}
+ if (maxController == -1)
+ return 0;
+
for (i = 0; i <= maxController; i++) {
if (virDomainDefMaybeAddController(def, controllerType, i, -1) < 0)
return -1;
virDomainDefMaybeAddVirtioSerialController(virDomainDefPtr def)
{
/* Look for any virtio serial or virtio console devs */
- int i;
+ size_t i;
for (i = 0; i < def->nchannels; i++) {
virDomainChrDefPtr channel = def->channels[i];
virDomainDefMaybeAddSmartcardController(virDomainDefPtr def)
{
/* Look for any smartcard devs */
- int i;
+ size_t i;
for (i = 0; i < def->nsmartcards; i++) {
virDomainSmartcardDefPtr smartcard = def->smartcards[i];
idx = smartcard->info.addr.ccid.controller;
} else if (smartcard->info.type
== VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
- int j;
+ size_t j;
int max = -1;
for (j = 0; j < def->nsmartcards; j++) {
int nvcpupin,
int vcpu)
{
- int i;
+ size_t i;
if (!def || !nvcpupin)
return 0;
int nvcpupin,
int vcpu)
{
- int i;
+ size_t i;
if (!def || !nvcpupin)
return NULL;
if (def->nhosts == 0) {
virBufferAddLit(buf, "/>\n");
} else {
- int i;
+ size_t i;
virBufferAddLit(buf, ">\n");
for (i = 0; i < def->nhosts; i++) {
virDomainFSIndexByName(virDomainDefPtr def, const char *name)
{
virDomainFSDefPtr fs;
- int i;
+ size_t i;
for (i = 0; i < def->nfss; i++) {
fs = def->fss[i];
{
const char *model = virDomainSoundModelTypeToString(def->model);
bool children = false;
- int i;
+ size_t i;
if (!model) {
virReportError(VIR_ERR_INTERNAL_ERROR,
const char *type = virDomainGraphicsTypeToString(def->type);
const char *listenAddr = NULL;
bool children = false;
- int i;
+ size_t i;
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
static bool
virDomainIsAllVcpupinInherited(virDomainDefPtr def)
{
- int i;
+ size_t i;
if (!def->cpumask) {
if (def->cputune.nvcpupin)
char uuidstr[VIR_UUID_STRING_BUFLEN];
const char *type = NULL;
int n;
- int i;
+ size_t i;
bool blkio = false;
virCheckFlags(DUMPXML_FLAGS |
const char *name = virDomainFeatureTypeToString(i);
if (!name) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected feature %d"), i);
+ _("unexpected feature %zu"), i);
goto error;
}
virBufferAsprintf(buf, " <%s", name);
virBuffer buf = VIR_BUFFER_INITIALIZER;
int state;
int reason;
- int i;
+ size_t i;
state = virDomainObjGetState(obj, &reason);
virBufferAsprintf(&buf, "<domstatus state='%s' reason='%s' pid='%lld'>\n",
static bool
virDomainDefHasUSB(virDomainDefPtr def)
{
- int i;
+ size_t i;
for (i = 0; i < def->ncontrollers; i++) {
if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
virDomainFSDefPtr
virDomainGetRootFilesystem(virDomainDefPtr def)
{
- int i;
+ size_t i;
for (i = 0; i < def->nfss; i++) {
if (STREQ(def->fss[i]->dst, "/"))
{
struct virDomainNameData data = { filter, conn,
0, 0, maxnames, names };
- int i;
+ size_t i;
virObjectLock(doms);
virHashForEach(doms->objs, virDomainObjListCopyInactiveNames, &data);
virObjectUnlock(doms);
virDomainChrDefIterator iter,
void *opaque)
{
- int i;
+ size_t i;
int rc = 0;
for (i = 0; i < def->nserials; i++) {
virDomainSmartcardDefIterator iter,
void *opaque)
{
- int i;
+ size_t i;
int rc = 0;
for (i = 0; i < def->nsmartcards; i++) {
return 0;
}
-/* Return listens[ii] from the appropriate union for the graphics
+/* Return listens[i] from the appropriate union for the graphics
* type, or NULL if this is an unsuitable type, or the index is out of
- * bounds. If force0 is TRUE, ii == 0, and there is no listen array,
+ * bounds. If force0 is TRUE, i == 0, and there is no listen array,
* allocate one with a single item. */
static virDomainGraphicsListenDefPtr
-virDomainGraphicsGetListen(virDomainGraphicsDefPtr def, size_t ii, bool force0)
+virDomainGraphicsGetListen(virDomainGraphicsDefPtr def, size_t i, bool force0)
{
if (def->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC ||
def->type == VIR_DOMAIN_GRAPHICS_TYPE_RDP ||
def->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
- if (!def->listens && (ii == 0) && force0) {
+ if (!def->listens && (i == 0) && force0) {
if (VIR_ALLOC(def->listens) >= 0)
def->nListens = 1;
}
- if (!def->listens || (def->nListens <= ii))
+ if (!def->listens || (def->nListens <= i))
return NULL;
- return &def->listens[ii];
+ return &def->listens[i];
}
/* it's a type that has no listens array */
* return 0 on success, -1 on failure. */
int
-virDomainGraphicsListenGetType(virDomainGraphicsDefPtr def, size_t ii)
+virDomainGraphicsListenGetType(virDomainGraphicsDefPtr def, size_t i)
{
virDomainGraphicsListenDefPtr listenInfo
- = virDomainGraphicsGetListen(def, ii, false);
+ = virDomainGraphicsGetListen(def, i, false);
if (!listenInfo)
return VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NONE;
* *will not* free any existing address or network based on a change
* in value of type. */
int
-virDomainGraphicsListenSetType(virDomainGraphicsDefPtr def, size_t ii, int val)
+virDomainGraphicsListenSetType(virDomainGraphicsDefPtr def, size_t i, int val)
{
virDomainGraphicsListenDefPtr listenInfo
- = virDomainGraphicsGetListen(def, ii, true);
+ = virDomainGraphicsGetListen(def, i, true);
if (!listenInfo)
return -1;
const char *
-virDomainGraphicsListenGetAddress(virDomainGraphicsDefPtr def, size_t ii)
+virDomainGraphicsListenGetAddress(virDomainGraphicsDefPtr def, size_t i)
{
virDomainGraphicsListenDefPtr listenInfo
- = virDomainGraphicsGetListen(def, ii, false);
+ = virDomainGraphicsGetListen(def, i, false);
/* even a network can have a listen address */
if (!listenInfo ||
/* Make a copy of up to len characters of address, and store it in
- * listens[ii].address. If setType is true, set the listen's type
+ * listens[i].address. If setType is true, set the listen's type
* to 'address', otherwise leave type alone. */
int
virDomainGraphicsListenSetAddress(virDomainGraphicsDefPtr def,
- size_t ii, const char *address,
+ size_t i, const char *address,
int len, bool setType)
{
virDomainGraphicsListenDefPtr listenInfo
- = virDomainGraphicsGetListen(def, ii, true);
+ = virDomainGraphicsGetListen(def, i, true);
if (!listenInfo)
return -1;
const char *
-virDomainGraphicsListenGetNetwork(virDomainGraphicsDefPtr def, size_t ii)
+virDomainGraphicsListenGetNetwork(virDomainGraphicsDefPtr def, size_t i)
{
virDomainGraphicsListenDefPtr listenInfo
- = virDomainGraphicsGetListen(def, ii, false);
+ = virDomainGraphicsGetListen(def, i, false);
if (!listenInfo ||
(listenInfo->type != VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK))
/* Make a copy of up to len characters of address, and store it in
- * listens[ii].network */
+ * listens[i].network */
int
virDomainGraphicsListenSetNetwork(virDomainGraphicsDefPtr def,
- size_t ii, const char *network, int len)
+ size_t i, const char *network, int len)
{
virDomainGraphicsListenDefPtr listenInfo
- = virDomainGraphicsGetListen(def, ii, true);
+ = virDomainGraphicsGetListen(def, i, true);
if (!listenInfo)
return -1;
bool isMac = false;
virDomainNetDefPtr net = NULL;
virMacAddr mac;
- int i;
+ size_t i;
if (virMacAddrParse(device, &mac) == 0)
isMac = true;
unsigned int flags)
{
int ret = -1;
- int i;
+ size_t i;
struct virDomainListData data = {
conn, NULL,
virSecurityLabelDefPtr
virDomainDefGetSecurityLabelDef(virDomainDefPtr def, const char *model)
{
- int i;
+ size_t i;
virSecurityLabelDefPtr seclabel = NULL;
if (def == NULL || model == NULL)
virSecurityDeviceLabelDefPtr
virDomainDiskDefGetSecurityLabelDef(virDomainDiskDefPtr def, const char *model)
{
- int i;
+ size_t i;
if (def == NULL)
return NULL;
virSecurityDeviceLabelDefPtr
virDomainChrDefGetSecurityLabelDef(virDomainChrDefPtr def, const char *model)
{
- int i;
+ size_t i;
if (def == NULL)
return NULL;
int virDomainHostdevFind(virDomainDefPtr def, virDomainHostdevDefPtr match,
virDomainHostdevDefPtr *found);
-int virDomainGraphicsListenGetType(virDomainGraphicsDefPtr def, size_t ii)
+int virDomainGraphicsListenGetType(virDomainGraphicsDefPtr def, size_t i)
ATTRIBUTE_NONNULL(1);
-int virDomainGraphicsListenSetType(virDomainGraphicsDefPtr def, size_t ii, int val)
+int virDomainGraphicsListenSetType(virDomainGraphicsDefPtr def, size_t i, int val)
ATTRIBUTE_NONNULL(1);
const char *virDomainGraphicsListenGetAddress(virDomainGraphicsDefPtr def,
- size_t ii)
+ size_t i)
ATTRIBUTE_NONNULL(1);
int virDomainGraphicsListenSetAddress(virDomainGraphicsDefPtr def,
- size_t ii, const char *address,
+ size_t i, const char *address,
int len, bool setType)
ATTRIBUTE_NONNULL(1);
const char *virDomainGraphicsListenGetNetwork(virDomainGraphicsDefPtr def,
- size_t ii)
+ size_t i)
ATTRIBUTE_NONNULL(1);
int virDomainGraphicsListenSetNetwork(virDomainGraphicsDefPtr def,
- size_t ii, const char *network, int len)
+ size_t i, const char *network, int len)
ATTRIBUTE_NONNULL(1);
int virDomainNetGetActualType(virDomainNetDefPtr iface);
static void
virDomainEventCallbackListFree(virDomainEventCallbackListPtr list)
{
- int i;
+ size_t i;
if (!list)
return;
virConnectDomainEventCallback callback)
{
int ret = 0;
- int i;
+ size_t i;
for (i = 0; i < cbList->count; i++) {
if (cbList->callbacks[i]->cb == VIR_DOMAIN_EVENT_CALLBACK(callback) &&
cbList->callbacks[i]->eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE &&
int callbackID)
{
int ret = 0;
- int i;
+ size_t i;
for (i = 0; i < cbList->count; i++) {
if (cbList->callbacks[i]->callbackID == callbackID &&
cbList->callbacks[i]->conn == conn) {
virConnectDomainEventCallback callback)
{
int ret = 0;
- int i;
+ size_t i;
for (i = 0; i < cbList->count; i++) {
if (cbList->callbacks[i]->cb == VIR_DOMAIN_EVENT_CALLBACK(callback) &&
cbList->callbacks[i]->eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE &&
int callbackID)
{
int ret = 0;
- int i;
+ size_t i;
for (i = 0; i < cbList->count; i++) {
if (cbList->callbacks[i]->callbackID == callbackID &&
cbList->callbacks[i]->conn == conn) {
virDomainEventCallbackListPurgeMarked(virDomainEventCallbackListPtr cbList)
{
int old_count = cbList->count;
- int i;
- for (i = 0; i < cbList->count; i++) {
- if (cbList->callbacks[i]->deleted) {
- virFreeCallback freecb = cbList->callbacks[i]->freecb;
+ 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[i]->opaque);
- virObjectUnref(cbList->callbacks[i]->conn);
- VIR_FREE(cbList->callbacks[i]);
+ (*freecb)(cbList->callbacks[n]->opaque);
+ virObjectUnref(cbList->callbacks[n]->conn);
+ VIR_FREE(cbList->callbacks[n]);
- if (i < (cbList->count - 1))
- memmove(cbList->callbacks + i,
- cbList->callbacks + i + 1,
+ if (n < (cbList->count - 1))
+ memmove(cbList->callbacks + n,
+ cbList->callbacks + n + 1,
sizeof(*(cbList->callbacks)) *
- (cbList->count - (i + 1)));
+ (cbList->count - (n + 1)));
cbList->count--;
- i--;
+ n--;
}
}
if (cbList->count < old_count &&
int *callbackID)
{
virDomainEventCallbackPtr event;
- int i;
+ size_t i;
int ret = 0;
/* Check incoming */
virDomainEventCallbackListPtr cbList,
int callbackID)
{
- int i;
+ size_t i;
for (i = 0; i < cbList->count; i++) {
if (cbList->callbacks[i]->deleted)
}
VIR_FREE(event->data.graphics.authScheme);
if (event->data.graphics.subject) {
- int i;
+ size_t i;
for (i = 0; i < event->data.graphics.subject->nidentity; i++) {
VIR_FREE(event->data.graphics.subject->identities[i].type);
VIR_FREE(event->data.graphics.subject->identities[i].name);
static void
virDomainEventQueueClear(virDomainEventQueuePtr queue)
{
- int i;
+ size_t i;
if (!queue)
return;
virDomainEventDispatchFunc dispatch,
void *opaque)
{
- int i;
+ size_t i;
/* Cache this now, since we may be dropping the lock,
and have more callbacks added. We're guaranteed not
to have any removed */
virDomainEventDispatchFunc dispatch,
void *opaque)
{
- int i;
+ size_t i;
for (i = 0; i < queue->count; i++) {
virDomainEventDispatch(queue->events[i], callbacks, dispatch, opaque);
void
virDomainConfVMNWFilterTeardown(virDomainObjPtr vm) {
- int i;
+ size_t i;
if (nwfilterDriver != NULL) {
for (i = 0; i < vm->def->nnets; i++)
static
void virInterfaceProtocolDefFree(virInterfaceProtocolDefPtr def) {
- int ii;
+ size_t i;
if (def == NULL)
return;
- for (ii = 0; ii < def->nips; ii++) {
- virInterfaceIpDefFree(def->ips[ii]);
+ for (i = 0; i < def->nips; i++) {
+ virInterfaceIpDefFree(def->ips[i]);
}
VIR_FREE(def->ips);
VIR_FREE(def->family);
void virInterfaceDefFree(virInterfaceDefPtr def)
{
- int i, pp;
+ size_t i;
+ int pp;
if (def == NULL)
return;
xmlXPathContextPtr ctxt) {
xmlNodePtr dhcp;
xmlNodePtr *ipNodes = NULL;
- int nIpNodes, ii, ret = -1;
+ int nIpNodes, ret = -1;
+ size_t i;
char *tmp;
tmp = virXPathString("string(./route[1]/@gateway)", ctxt);
goto error;
def->nips = 0;
- for (ii = 0; ii < nIpNodes; ii++) {
+ for (i = 0; i < nIpNodes; i++) {
virInterfaceIpDefPtr ip;
if (VIR_ALLOC(ip) < 0)
goto error;
- ctxt->node = ipNodes[ii];
+ ctxt->node = ipNodes[i];
ret = virInterfaceDefParseIp(ip, ctxt);
if (ret != 0) {
virInterfaceIpDefFree(ip);
xmlXPathContextPtr ctxt) {
xmlNodePtr dhcp, autoconf;
xmlNodePtr *ipNodes = NULL;
- int nIpNodes, ii, ret = -1;
+ int nIpNodes, ret = -1;
+ size_t i;
char *tmp;
tmp = virXPathString("string(./route[1]/@gateway)", ctxt);
goto error;
def->nips = 0;
- for (ii = 0; ii < nIpNodes; ii++) {
+ for (i = 0; i < nIpNodes; i++) {
virInterfaceIpDefPtr ip;
if (VIR_ALLOC(ip) < 0)
goto error;
- ctxt->node = ipNodes[ii];
+ ctxt->node = ipNodes[i];
ret = virInterfaceDefParseIp(ip, ctxt);
if (ret != 0) {
virInterfaceIpDefFree(ip);
xmlNodePtr *interfaces = NULL;
xmlNodePtr bridge;
virInterfaceDefPtr itf;
- int nbItf, i;
+ int nbItf;
+ size_t i;
int ret = 0;
bridge = ctxt->node;
xmlNodePtr *interfaces = NULL;
xmlNodePtr bond = ctxt->node;
virInterfaceDefPtr itf;
- int nbItf, i;
+ int nbItf;
+ size_t i;
int ret = 0;
nbItf = virXPathNodeSet("./interface", ctxt, &interfaces);
static int
virInterfaceBridgeDefFormat(virBufferPtr buf,
const virInterfaceDefPtr def, int level) {
- int i;
+ size_t i;
int ret = 0;
virBufferAsprintf(buf, "%*s <bridge", level*2, "");
static int
virInterfaceBondDefFormat(virBufferPtr buf,
const virInterfaceDefPtr def, int level) {
- int i;
+ size_t i;
int ret = 0;
virBufferAsprintf(buf, "%*s <bond", level*2, "");
static int
virInterfaceProtocolDefFormat(virBufferPtr buf, const virInterfaceDefPtr def,
int level) {
- int pp, ii;
+ size_t i, j;
- for (pp = 0; pp < def->nprotos; pp++) {
+ for (i = 0; i < def->nprotos; i++) {
virBufferAsprintf(buf, "%*s <protocol family='%s'>\n",
- level*2, "", def->protos[pp]->family);
+ level*2, "", def->protos[i]->family);
- if (def->protos[pp]->autoconf) {
+ if (def->protos[i]->autoconf) {
virBufferAsprintf(buf, "%*s <autoconf/>\n", level*2, "");
}
- if (def->protos[pp]->dhcp) {
- if (def->protos[pp]->peerdns == 0)
+ if (def->protos[i]->dhcp) {
+ if (def->protos[i]->peerdns == 0)
virBufferAsprintf(buf, "%*s <dhcp peerdns='no'/>\n",
level*2, "");
- else if (def->protos[pp]->peerdns == 1)
+ else if (def->protos[i]->peerdns == 1)
virBufferAsprintf(buf, "%*s <dhcp peerdns='yes'/>\n",
level*2, "");
else
virBufferAsprintf(buf, "%*s <dhcp/>\n", level*2, "");
}
- for (ii = 0; ii < def->protos[pp]->nips; ii++) {
- if (def->protos[pp]->ips[ii]->address != NULL) {
+ for (j = 0; j < def->protos[i]->nips; j++) {
+ if (def->protos[i]->ips[j]->address != NULL) {
virBufferAsprintf(buf, "%*s <ip address='%s'", level*2, "",
- def->protos[pp]->ips[ii]->address);
- if (def->protos[pp]->ips[ii]->prefix != 0) {
+ def->protos[i]->ips[j]->address);
+ if (def->protos[i]->ips[j]->prefix != 0) {
virBufferAsprintf(buf, " prefix='%d'",
- def->protos[pp]->ips[ii]->prefix);
+ def->protos[i]->ips[j]->prefix);
}
virBufferAddLit(buf, "/>\n");
}
}
- if (def->protos[pp]->gateway != NULL) {
+ if (def->protos[i]->gateway != NULL) {
virBufferAsprintf(buf, "%*s <route gateway='%s'/>\n",
- level*2, "", def->protos[pp]->gateway);
+ level*2, "", def->protos[i]->gateway);
}
virBufferAsprintf(buf, "%*s </protocol>\n", level*2, "");
const char *mac,
virInterfaceObjPtr *matches, int maxmatches)
{
- unsigned int i, matchct = 0;
+ size_t i;
+ unsigned int matchct = 0;
for (i = 0; i < interfaces->count; i++) {
interfaces,
const char *name)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < interfaces->count; i++) {
virInterfaceObjLock(interfaces->objs[i]);
void virInterfaceObjListFree(virInterfaceObjListPtr interfaces)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < interfaces->count; i++)
virInterfaceObjFree(interfaces->objs[i]);
virInterfaceObjListPtr dest)
{
int ret = -1;
- unsigned int i, cnt;
+ size_t i;
+ unsigned int cnt;
if (!src || !dest)
goto cleanup;
void virInterfaceRemove(virInterfaceObjListPtr interfaces,
const virInterfaceObjPtr iface)
{
- unsigned int i;
+ size_t i;
virInterfaceObjUnlock(iface);
for (i = 0; i < interfaces->count; i++) {
const char *trunk = NULL;
const char *nativeMode = NULL;
xmlNodePtr *tagNodes = NULL;
- int nTags, ii;
+ int nTags;
+ size_t i;
ctxt->node = node;
def->nativeMode = 0;
def->nativeTag = 0;
- for (ii = 0; ii < nTags; ii++) {
+ for (i = 0; i < nTags; i++) {
unsigned long id;
- ctxt->node = tagNodes[ii];
+ ctxt->node = tagNodes[i];
if (virXPathULong("string(./@id)", ctxt, &id) < 0) {
virReportError(VIR_ERR_XML_ERROR, "%s",
_("missing or invalid vlan tag id attribute"));
VIR_FREE(nativeMode);
def->nativeTag = id;
}
- def->tag[ii] = id;
+ def->tag[i] = id;
}
def->nTags = nTags;
int
virNetDevVlanFormat(virNetDevVlanPtr def, virBufferPtr buf)
{
- int ii;
+ size_t i;
if (def->nTags == 0)
return 0;
}
virBufferAsprintf(buf, "<vlan%s>\n", def->trunk ? " trunk='yes'" : "");
- for (ii = 0; ii < def->nTags; ii++) {
+ for (i = 0; i < def->nTags; i++) {
if (def->nativeMode != VIR_NATIVE_VLAN_MODE_DEFAULT &&
- def->nativeTag == def->tag[ii]) {
+ def->nativeTag == def->tag[i]) {
/* check the nativeMode in case we get <tag id='0'/>*/
const char *mode = virNativeVlanModeTypeToString(def->nativeMode);
if (!mode) {
_("Bad value for nativeMode"));
}
virBufferAsprintf(buf, " <tag id='%u' nativeMode='%s'/>\n",
- def->tag[ii], mode);
+ def->tag[i], mode);
} else {
- virBufferAsprintf(buf, " <tag id='%u'/>\n", def->tag[ii]);
+ virBufferAsprintf(buf, " <tag id='%u'/>\n", def->tag[i]);
}
}
virBufferAddLit(buf, "</vlan>\n");
virNetworkObjPtr virNetworkFindByUUID(const virNetworkObjListPtr nets,
const unsigned char *uuid)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < nets->count; i++) {
virNetworkObjLock(nets->objs[i]);
virNetworkObjPtr virNetworkFindByName(const virNetworkObjListPtr nets,
const char *name)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < nets->count; i++) {
virNetworkObjLock(nets->objs[i]);
static void
virNetworkForwardDefClear(virNetworkForwardDefPtr def)
{
- int ii;
+ size_t i;
- for (ii = 0; ii < def->npfs && def->pfs; ii++) {
- virNetworkForwardPfDefClear(&def->pfs[ii]);
+ for (i = 0; i < def->npfs && def->pfs; i++) {
+ virNetworkForwardPfDefClear(&def->pfs[i]);
}
VIR_FREE(def->pfs);
- for (ii = 0; ii < def->nifs && def->ifs; ii++) {
- virNetworkForwardIfDefClear(&def->ifs[ii]);
+ for (i = 0; i < def->nifs && def->ifs; i++) {
+ virNetworkForwardIfDefClear(&def->ifs[i]);
}
VIR_FREE(def->ifs);
}
void
virNetworkDefFree(virNetworkDefPtr def)
{
- int ii;
+ size_t i;
if (!def)
return;
virNetworkForwardDefClear(&def->forward);
- for (ii = 0; ii < def->nips && def->ips; ii++) {
- virNetworkIpDefClear(&def->ips[ii]);
+ for (i = 0; i < def->nips && def->ips; i++) {
+ virNetworkIpDefClear(&def->ips[i]);
}
VIR_FREE(def->ips);
- for (ii = 0; ii < def->nroutes && def->routes; ii++) {
- virNetworkRouteDefClear(&def->routes[ii]);
+ for (i = 0; i < def->nroutes && def->routes; i++) {
+ virNetworkRouteDefClear(&def->routes[i]);
}
VIR_FREE(def->routes);
- for (ii = 0; ii < def->nPortGroups && def->portGroups; ii++) {
- virPortGroupDefClear(&def->portGroups[ii]);
+ for (i = 0; i < def->nPortGroups && def->portGroups; i++) {
+ virPortGroupDefClear(&def->portGroups[i]);
}
VIR_FREE(def->portGroups);
void virNetworkObjListFree(virNetworkObjListPtr nets)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < nets->count; i++)
virNetworkObjFree(nets->objs[i]);
void virNetworkRemoveInactive(virNetworkObjListPtr nets,
const virNetworkObjPtr net)
{
- unsigned int i;
+ size_t i;
virNetworkObjUnlock(net);
for (i = 0; i < nets->count; i++) {
virNetworkDefGetIpByIndex(const virNetworkDefPtr def,
int family, size_t n)
{
- int ii;
+ size_t i;
if (!def->ips || n >= def->nips)
return NULL;
}
/* find the nth ip of type "family" */
- for (ii = 0; ii < def->nips; ii++) {
- if (VIR_SOCKET_ADDR_IS_FAMILY(&def->ips[ii].address, family)
+ for (i = 0; i < def->nips; i++) {
+ if (VIR_SOCKET_ADDR_IS_FAMILY(&def->ips[i].address, family)
&& (n-- <= 0)) {
- return &def->ips[ii];
+ return &def->ips[i];
}
}
/* failed to find enough of the right family */
xmlNodePtr *srvNodes = NULL;
xmlNodePtr *txtNodes = NULL;
int nhosts, nsrvs, ntxts;
- int ii, ret = -1;
+ size_t i;
+ int ret = -1;
xmlNodePtr save = ctxt->node;
ctxt->node = node;
if (VIR_ALLOC_N(def->hosts, nhosts) < 0)
goto cleanup;
- for (ii = 0; ii < nhosts; ii++) {
- if (virNetworkDNSHostDefParseXML(networkName, hostNodes[ii],
+ for (i = 0; i < nhosts; i++) {
+ if (virNetworkDNSHostDefParseXML(networkName, hostNodes[i],
&def->hosts[def->nhosts], false) < 0) {
goto cleanup;
}
if (VIR_ALLOC_N(def->srvs, nsrvs) < 0)
goto cleanup;
- for (ii = 0; ii < nsrvs; ii++) {
- if (virNetworkDNSSrvDefParseXML(networkName, srvNodes[ii], ctxt,
+ for (i = 0; i < nsrvs; i++) {
+ if (virNetworkDNSSrvDefParseXML(networkName, srvNodes[i], ctxt,
&def->srvs[def->nsrvs], false) < 0) {
goto cleanup;
}
if (VIR_ALLOC_N(def->txts, ntxts) < 0)
goto cleanup;
- for (ii = 0; ii < ntxts; ii++) {
- if (virNetworkDNSTxtDefParseXML(networkName, txtNodes[ii],
+ for (i = 0; i < ntxts; i++) {
+ if (virNetworkDNSTxtDefParseXML(networkName, txtNodes[i],
&def->txts[def->ntxts], false) < 0) {
goto cleanup;
}
xmlXPathContextPtr ctxt,
virNetworkForwardDefPtr def)
{
- int ii, ret = -1;
+ size_t i;
+ int ret = -1;
xmlNodePtr *forwardIfNodes = NULL;
xmlNodePtr *forwardPfNodes = NULL;
xmlNodePtr *forwardAddrNodes = NULL;
}
/* parse each <interface> */
- for (ii = 0; ii < nForwardIfs; ii++) {
- forwardDev = virXMLPropString(forwardIfNodes[ii], "dev");
+ for (i = 0; i < nForwardIfs; i++) {
+ forwardDev = virXMLPropString(forwardIfNodes[i], "dev");
if (!forwardDev) {
virReportError(VIR_ERR_XML_ERROR,
_("Missing required dev attribute in "
goto cleanup;
}
- if ((ii == 0) && (def->nifs == 1)) {
+ if ((i == 0) && (def->nifs == 1)) {
/* both <forward dev='x'> and <interface dev='x'/> are
* present. If they don't match, it's an error.
*/
continue;
}
- def->ifs[ii].device.dev = forwardDev;
+ def->ifs[i].device.dev = forwardDev;
forwardDev = NULL;
- def->ifs[ii].type = VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_NETDEV;
+ def->ifs[i].type = VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_NETDEV;
def->nifs++;
}
if (VIR_ALLOC_N(def->ifs, nForwardAddrs) < 0)
goto cleanup;
- for (ii = 0; ii < nForwardAddrs; ii++) {
- if (!(type = virXMLPropString(forwardAddrNodes[ii], "type"))) {
+ for (i = 0; i < nForwardAddrs; i++) {
+ if (!(type = virXMLPropString(forwardAddrNodes[i], "type"))) {
virReportError(VIR_ERR_XML_ERROR,
_("missing address type in network %s"),
networkName);
goto cleanup;
}
- if ((def->ifs[ii].type = virNetworkForwardHostdevDeviceTypeFromString(type)) < 0) {
+ if ((def->ifs[i].type = virNetworkForwardHostdevDeviceTypeFromString(type)) < 0) {
virReportError(VIR_ERR_XML_ERROR,
_("unknown address type '%s' in network %s"),
type, networkName);
goto cleanup;
}
- switch (def->ifs[ii].type) {
+ switch (def->ifs[i].type) {
case VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_PCI:
- if (virDevicePCIAddressParseXML(forwardAddrNodes[ii],
- &def->ifs[ii].device.pci) < 0) {
+ if (virDevicePCIAddressParseXML(forwardAddrNodes[i],
+ &def->ifs[i].device.pci) < 0) {
goto cleanup;
}
break;
goto error;
if (nPortGroups > 0) {
- int ii;
+ size_t i;
/* allocate array to hold all the portgroups */
if (VIR_ALLOC_N(def->portGroups, nPortGroups) < 0)
goto error;
/* parse each portgroup */
- for (ii = 0; ii < nPortGroups; ii++) {
- int ret = virNetworkPortGroupParseXML(&def->portGroups[ii],
- portGroupNodes[ii], ctxt);
+ for (i = 0; i < nPortGroups; i++) {
+ int ret = virNetworkPortGroupParseXML(&def->portGroups[i],
+ portGroupNodes[i], ctxt);
if (ret < 0)
goto error;
def->nPortGroups++;
goto error;
if (nIps > 0) {
- int ii;
+ size_t i;
/* allocate array to hold all the addrs */
if (VIR_ALLOC_N(def->ips, nIps) < 0)
goto error;
/* parse each addr */
- for (ii = 0; ii < nIps; ii++) {
- int ret = virNetworkIPDefParseXML(def->name, ipNodes[ii],
- ctxt, &def->ips[ii]);
+ for (i = 0; i < nIps; i++) {
+ int ret = virNetworkIPDefParseXML(def->name, ipNodes[i],
+ ctxt, &def->ips[i]);
if (ret < 0)
goto error;
def->nips++;
goto error;
if (nRoutes > 0) {
- int ii;
+ size_t i;
/* allocate array to hold all the route definitions */
if (VIR_ALLOC_N(def->routes, nRoutes) < 0)
goto error;
/* parse each definition */
- for (ii = 0; ii < nRoutes; ii++) {
- int ret = virNetworkRouteDefParseXML(def->name, routeNodes[ii],
- ctxt, &def->routes[ii]);
+ for (i = 0; i < nRoutes; i++) {
+ int ret = virNetworkRouteDefParseXML(def->name, routeNodes[i],
+ ctxt, &def->routes[i]);
if (ret < 0)
goto error;
def->nroutes++;
*/
nRoutes = def->nroutes;
nIps = def->nips;
- for (ii = 0; ii < nRoutes; ii++) {
- int jj;
+ for (i = 0; i < nRoutes; i++) {
+ size_t j;
virSocketAddr testAddr, testGw;
bool addrMatch;
- virNetworkRouteDefPtr gwdef = &def->routes[ii];
+ virNetworkRouteDefPtr gwdef = &def->routes[i];
addrMatch = false;
- for (jj = 0; jj < nIps; jj++) {
- virNetworkIpDefPtr def2 = &def->ips[jj];
+ for (j = 0; j < nIps; j++) {
+ virNetworkIpDefPtr def2 = &def->ips[j];
if (VIR_SOCKET_ADDR_FAMILY(&gwdef->gateway)
!= VIR_SOCKET_ADDR_FAMILY(&def2->address)) {
continue;
virNetworkDNSDefPtr def)
{
int result = 0;
- int i;
+ size_t i, j;
if (!(def->nhosts || def->nsrvs || def->ntxts))
goto out;
}
if (def->nhosts) {
- int ii, j;
-
- for (ii = 0; ii < def->nhosts; ii++) {
- char *ip = virSocketAddrFormat(&def->hosts[ii].ip);
+ for (i = 0; i < def->nhosts; i++) {
+ char *ip = virSocketAddrFormat(&def->hosts[i].ip);
virBufferAsprintf(buf, "<host ip='%s'>\n", ip);
virBufferAdjustIndent(buf, 2);
- for (j = 0; j < def->hosts[ii].nnames; j++)
+ for (j = 0; j < def->hosts[i].nnames; j++)
virBufferAsprintf(buf, "<hostname>%s</hostname>\n",
- def->hosts[ii].names[j]);
+ def->hosts[i].names[j]);
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</host>\n");
def->tftproot);
}
if ((def->nranges || def->nhosts)) {
- int ii;
+ size_t i;
virBufferAddLit(buf, "<dhcp>\n");
virBufferAdjustIndent(buf, 2);
- for (ii = 0; ii < def->nranges; ii++) {
- char *saddr = virSocketAddrFormat(&def->ranges[ii].start);
+ for (i = 0; i < def->nranges; i++) {
+ char *saddr = virSocketAddrFormat(&def->ranges[i].start);
if (!saddr)
goto error;
- char *eaddr = virSocketAddrFormat(&def->ranges[ii].end);
+ char *eaddr = virSocketAddrFormat(&def->ranges[i].end);
if (!eaddr) {
VIR_FREE(saddr);
goto error;
VIR_FREE(saddr);
VIR_FREE(eaddr);
}
- for (ii = 0; ii < def->nhosts; ii++) {
+ for (i = 0; i < def->nhosts; i++) {
virBufferAddLit(buf, "<host ");
- if (def->hosts[ii].mac)
- virBufferAsprintf(buf, "mac='%s' ", def->hosts[ii].mac);
- if (def->hosts[ii].id)
- virBufferAsprintf(buf, "id='%s' ", def->hosts[ii].id);
- if (def->hosts[ii].name)
- virBufferAsprintf(buf, "name='%s' ", def->hosts[ii].name);
- if (VIR_SOCKET_ADDR_VALID(&def->hosts[ii].ip)) {
- char *ipaddr = virSocketAddrFormat(&def->hosts[ii].ip);
+ if (def->hosts[i].mac)
+ virBufferAsprintf(buf, "mac='%s' ", def->hosts[i].mac);
+ if (def->hosts[i].id)
+ virBufferAsprintf(buf, "id='%s' ", def->hosts[i].id);
+ if (def->hosts[i].name)
+ virBufferAsprintf(buf, "name='%s' ", def->hosts[i].name);
+ if (VIR_SOCKET_ADDR_VALID(&def->hosts[i].ip)) {
+ char *ipaddr = virSocketAddrFormat(&def->hosts[i].ip);
if (!ipaddr)
goto error;
virBufferAsprintf(buf, "ip='%s' ", ipaddr);
{
unsigned char *uuid;
char uuidstr[VIR_UUID_STRING_BUFLEN];
- int ii, shortforward;
+ size_t i;
+ int shortforward;
virBufferAddLit(buf, "<network");
if (!(flags & VIR_NETWORK_XML_INACTIVE) && (def->connections > 0)) {
if (def->forward.nifs &&
(!def->forward.npfs || !(flags & VIR_NETWORK_XML_INACTIVE))) {
- for (ii = 0; ii < def->forward.nifs; ii++) {
+ for (i = 0; i < def->forward.nifs; i++) {
if (def->forward.type != VIR_NETWORK_FORWARD_HOSTDEV) {
virBufferEscapeString(buf, "<interface dev='%s'",
- def->forward.ifs[ii].device.dev);
+ def->forward.ifs[i].device.dev);
if (!(flags & VIR_NETWORK_XML_INACTIVE) &&
- (def->forward.ifs[ii].connections > 0)) {
+ (def->forward.ifs[i].connections > 0)) {
virBufferAsprintf(buf, " connections='%d'",
- def->forward.ifs[ii].connections);
+ def->forward.ifs[i].connections);
}
virBufferAddLit(buf, "/>\n");
}
else {
- if (def->forward.ifs[ii].type == VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_PCI) {
+ if (def->forward.ifs[i].type == VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_PCI) {
if (virDevicePCIAddressFormat(buf,
- def->forward.ifs[ii].device.pci,
+ def->forward.ifs[i].device.pci,
true) < 0)
goto error;
}
if (virNetDevBandwidthFormat(def->bandwidth, buf) < 0)
goto error;
- for (ii = 0; ii < def->nips; ii++) {
- if (virNetworkIpDefFormat(buf, &def->ips[ii]) < 0)
+ for (i = 0; i < def->nips; i++) {
+ if (virNetworkIpDefFormat(buf, &def->ips[i]) < 0)
goto error;
}
- for (ii = 0; ii < def->nroutes; ii++) {
- if (virNetworkRouteDefFormat(buf, &def->routes[ii]) < 0)
+ for (i = 0; i < def->nroutes; i++) {
+ if (virNetworkRouteDefFormat(buf, &def->routes[i]) < 0)
goto error;
}
if (virNetDevVPortProfileFormat(def->virtPortProfile, buf) < 0)
goto error;
- for (ii = 0; ii < def->nPortGroups; ii++)
- if (virPortGroupDefFormat(buf, &def->portGroups[ii]) < 0)
+ for (i = 0; i < def->nPortGroups; i++)
+ if (virPortGroupDefFormat(buf, &def->portGroups[i]) < 0)
goto error;
virBufferAdjustIndent(buf, -2);
virPortGroupDefPtr virPortGroupFindByName(virNetworkDefPtr net,
const char *portgroup)
{
- int ii;
- for (ii = 0; ii < net->nPortGroups; ii++) {
+ size_t i;
+ for (i = 0; i < net->nPortGroups; i++) {
if (portgroup) {
- if (STREQ(portgroup, net->portGroups[ii].name))
- return &net->portGroups[ii];
+ if (STREQ(portgroup, net->portGroups[i].name))
+ return &net->portGroups[i];
} else {
- if (net->portGroups[ii].isDefault)
- return &net->portGroups[ii];
+ if (net->portGroups[i].isDefault)
+ return &net->portGroups[i];
}
}
return NULL;
const char *bridge,
const char *skipname)
{
- unsigned int i;
+ size_t i;
unsigned int ret = 0;
for (i = 0; i < nets->count; i++) {
virNetworkIpDefByIndex(virNetworkDefPtr def, int parentIndex)
{
virNetworkIpDefPtr ipdef = NULL;
- int ii;
+ size_t i;
/* first find which ip element's dhcp host list to work on */
if (parentIndex >= 0) {
/* -1 means "find the most appropriate", which in this case
* means the one and only <ip> that has <dhcp> element
*/
- for (ii = 0;
- (ipdef = virNetworkDefGetIpByIndex(def, AF_UNSPEC, ii));
- ii++) {
+ for (i = 0;
+ (ipdef = virNetworkDefGetIpByIndex(def, AF_UNSPEC, i));
+ i++) {
if (ipdef->nranges || ipdef->nhosts)
break;
}
/* virNetworkUpdateFlags */
unsigned int fflags ATTRIBUTE_UNUSED)
{
- int ii, ret = -1;
+ size_t i;
+ int ret = -1;
virNetworkIpDefPtr ipdef = virNetworkIpDefByIndex(def, parentIndex);
virNetworkDHCPHostDef host;
/* search for the entry with this (mac|name),
* and update the IP+(mac|name) */
- for (ii = 0; ii < ipdef->nhosts; ii++) {
+ for (i = 0; i < ipdef->nhosts; i++) {
if ((host.mac &&
- !virMacAddrCompare(host.mac, ipdef->hosts[ii].mac)) ||
+ !virMacAddrCompare(host.mac, ipdef->hosts[i].mac)) ||
(host.name &&
- STREQ_NULLABLE(host.name, ipdef->hosts[ii].name))) {
+ STREQ_NULLABLE(host.name, ipdef->hosts[i].name))) {
break;
}
}
- if (ii == ipdef->nhosts) {
+ if (i == ipdef->nhosts) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("couldn't locate an existing dhcp host entry with "
"\"mac='%s'\" in network '%s'"),
* then clear out the extra copy to get rid of the duplicate pointers
* to its data (mac and name strings).
*/
- virNetworkDHCPHostDefClear(&ipdef->hosts[ii]);
- ipdef->hosts[ii] = host;
+ virNetworkDHCPHostDefClear(&ipdef->hosts[i]);
+ ipdef->hosts[i] = host;
memset(&host, 0, sizeof(host));
} else if ((command == VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST) ||
}
/* log error if an entry with same name/address/ip already exists */
- for (ii = 0; ii < ipdef->nhosts; ii++) {
+ for (i = 0; i < ipdef->nhosts; i++) {
if ((host.mac &&
- !virMacAddrCompare(host.mac, ipdef->hosts[ii].mac)) ||
+ !virMacAddrCompare(host.mac, ipdef->hosts[i].mac)) ||
(host.name &&
- STREQ_NULLABLE(host.name, ipdef->hosts[ii].name)) ||
+ STREQ_NULLABLE(host.name, ipdef->hosts[i].name)) ||
(VIR_SOCKET_ADDR_VALID(&host.ip) &&
- virSocketAddrEqual(&host.ip, &ipdef->hosts[ii].ip))) {
+ virSocketAddrEqual(&host.ip, &ipdef->hosts[i].ip))) {
char *ip = virSocketAddrFormat(&host.ip);
virReportError(VIR_ERR_OPERATION_INVALID,
}
/* find matching entry - all specified attributes must match */
- for (ii = 0; ii < ipdef->nhosts; ii++) {
+ for (i = 0; i < ipdef->nhosts; i++) {
if ((!host.mac ||
- !virMacAddrCompare(host.mac, ipdef->hosts[ii].mac)) &&
+ !virMacAddrCompare(host.mac, ipdef->hosts[i].mac)) &&
(!host.name ||
- STREQ_NULLABLE(host.name, ipdef->hosts[ii].name)) &&
+ STREQ_NULLABLE(host.name, ipdef->hosts[i].name)) &&
(!VIR_SOCKET_ADDR_VALID(&host.ip) ||
- virSocketAddrEqual(&host.ip, &ipdef->hosts[ii].ip))) {
+ virSocketAddrEqual(&host.ip, &ipdef->hosts[i].ip))) {
break;
}
}
- if (ii == ipdef->nhosts) {
+ if (i == ipdef->nhosts) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("couldn't locate a matching dhcp host entry "
"in network '%s'"), def->name);
}
/* remove it */
- virNetworkDHCPHostDefClear(&ipdef->hosts[ii]);
- VIR_DELETE_ELEMENT(ipdef->hosts, ii, ipdef->nhosts);
+ virNetworkDHCPHostDefClear(&ipdef->hosts[i]);
+ VIR_DELETE_ELEMENT(ipdef->hosts, i, ipdef->nhosts);
} else {
virNetworkDefUpdateUnknownCommand(command);
/* virNetworkUpdateFlags */
unsigned int fflags ATTRIBUTE_UNUSED)
{
- int ii, ret = -1;
+ size_t i;
+ int ret = -1;
virNetworkIpDefPtr ipdef = virNetworkIpDefByIndex(def, parentIndex);
virSocketAddrRange range;
goto cleanup;
/* check if an entry with same name/address/ip already exists */
- for (ii = 0; ii < ipdef->nranges; ii++) {
- if (virSocketAddrEqual(&range.start, &ipdef->ranges[ii].start) &&
- virSocketAddrEqual(&range.end, &ipdef->ranges[ii].end)) {
+ for (i = 0; i < ipdef->nranges; i++) {
+ if (virSocketAddrEqual(&range.start, &ipdef->ranges[i].start) &&
+ virSocketAddrEqual(&range.end, &ipdef->ranges[i].end)) {
break;
}
}
if ((command == VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST) ||
(command == VIR_NETWORK_UPDATE_COMMAND_ADD_LAST)) {
- if (ii < ipdef->nranges) {
+ if (i < ipdef->nranges) {
char *startip = virSocketAddrFormat(&range.start);
char *endip = virSocketAddrFormat(&range.end);
goto cleanup;
} else if (command == VIR_NETWORK_UPDATE_COMMAND_DELETE) {
- if (ii == ipdef->nranges) {
+ if (i == ipdef->nranges) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("couldn't locate a matching dhcp range entry "
"in network '%s'"), def->name);
/* remove it */
/* NB: nothing to clear from a RangeDef that's being freed */
- VIR_DELETE_ELEMENT(ipdef->ranges, ii, ipdef->nranges);
+ VIR_DELETE_ELEMENT(ipdef->ranges, i, ipdef->nranges);
} else {
virNetworkDefUpdateUnknownCommand(command);
/* virNetworkUpdateFlags */
unsigned int fflags ATTRIBUTE_UNUSED)
{
- int ii, ret = -1;
+ size_t i;
+ int ret = -1;
virNetworkForwardIfDef iface;
memset(&iface, 0, sizeof(iface));
}
/* check if an <interface> with same dev name already exists */
- for (ii = 0; ii < def->forward.nifs; ii++) {
- if (def->forward.ifs[ii].type
+ for (i = 0; i < def->forward.nifs; i++) {
+ if (def->forward.ifs[i].type
== VIR_NETWORK_FORWARD_HOSTDEV_DEVICE_NETDEV &&
- STREQ(iface.device.dev, def->forward.ifs[ii].device.dev))
+ STREQ(iface.device.dev, def->forward.ifs[i].device.dev))
break;
}
if ((command == VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST) ||
(command == VIR_NETWORK_UPDATE_COMMAND_ADD_LAST)) {
- if (ii < def->forward.nifs) {
+ if (i < def->forward.nifs) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("there is an existing interface entry "
"in network '%s' that matches "
goto cleanup;
} else if (command == VIR_NETWORK_UPDATE_COMMAND_DELETE) {
- if (ii == def->forward.nifs) {
+ if (i == def->forward.nifs) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("couldn't find an interface entry "
"in network '%s' matching <interface dev='%s'>"),
}
/* fail if the interface is being used */
- if (def->forward.ifs[ii].connections > 0) {
+ if (def->forward.ifs[i].connections > 0) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("unable to delete interface '%s' "
"in network '%s'. It is currently being used "
" by %d domains."),
iface.device.dev, def->name,
- def->forward.ifs[ii].connections);
+ def->forward.ifs[i].connections);
goto cleanup;
}
/* remove it */
- virNetworkForwardIfDefClear(&def->forward.ifs[ii]);
- VIR_DELETE_ELEMENT(def->forward.ifs, ii, def->forward.nifs);
+ virNetworkForwardIfDefClear(&def->forward.ifs[i]);
+ VIR_DELETE_ELEMENT(def->forward.ifs, i, def->forward.nifs);
} else {
virNetworkDefUpdateUnknownCommand(command);
/* virNetworkUpdateFlags */
unsigned int fflags ATTRIBUTE_UNUSED)
{
- int ii, foundName = -1, foundDefault = -1;
+ size_t i;
+ int foundName = -1, foundDefault = -1;
int ret = -1;
virPortGroupDef portgroup;
goto cleanup;
/* check if a portgroup with same name already exists */
- for (ii = 0; ii < def->nPortGroups; ii++) {
- if (STREQ(portgroup.name, def->portGroups[ii].name))
- foundName = ii;
- if (def->portGroups[ii].isDefault)
- foundDefault = ii;
+ for (i = 0; i < def->nPortGroups; i++) {
+ if (STREQ(portgroup.name, def->portGroups[i].name))
+ foundName = i;
+ if (def->portGroups[i].isDefault)
+ foundDefault = i;
}
if (foundName == -1 &&
((command == VIR_NETWORK_UPDATE_COMMAND_MODIFY) ||
/* virNetworkUpdateFlags */
unsigned int fflags ATTRIBUTE_UNUSED)
{
- int ii, jj, kk, foundIdx = -1, ret = -1;
+ size_t i, j, k;
+ int foundIdx = -1, ret = -1;
virNetworkDNSDefPtr dns = &def->dns;
virNetworkDNSHostDef host;
bool isAdd = (command == VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST ||
if (virNetworkDNSHostDefParseXML(def->name, ctxt->node, &host, !isAdd) < 0)
goto cleanup;
- for (ii = 0; ii < dns->nhosts; ii++) {
+ for (i = 0; i < dns->nhosts; i++) {
bool foundThisTime = false;
- if (virSocketAddrEqual(&host.ip, &dns->hosts[ii].ip))
+ if (virSocketAddrEqual(&host.ip, &dns->hosts[i].ip))
foundThisTime = true;
- for (jj = 0; jj < host.nnames && !foundThisTime; jj++) {
- for (kk = 0; kk < dns->hosts[ii].nnames && !foundThisTime; kk++) {
- if (STREQ(host.names[jj], dns->hosts[ii].names[kk]))
+ for (j = 0; j < host.nnames && !foundThisTime; j++) {
+ for (k = 0; k < dns->hosts[i].nnames && !foundThisTime; k++) {
+ if (STREQ(host.names[j], dns->hosts[i].names[k]))
foundThisTime = true;
}
}
if (foundThisTime) {
foundCt++;
- foundIdx = ii;
+ foundIdx = i;
}
}
/* virNetworkUpdateFlags */
unsigned int fflags ATTRIBUTE_UNUSED)
{
- int ii, foundIdx = -1, ret = -1;
+ size_t i;
+ int foundIdx = -1, ret = -1;
virNetworkDNSDefPtr dns = &def->dns;
virNetworkDNSSrvDef srv;
bool isAdd = (command == VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST ||
if (virNetworkDNSSrvDefParseXML(def->name, ctxt->node, ctxt, &srv, !isAdd) < 0)
goto cleanup;
- for (ii = 0; ii < dns->nsrvs; ii++) {
- if ((!srv.domain || STREQ_NULLABLE(srv.domain, dns->srvs[ii].domain)) &&
- (!srv.service || STREQ_NULLABLE(srv.service, dns->srvs[ii].service)) &&
- (!srv.protocol || STREQ_NULLABLE(srv.protocol, dns->srvs[ii].protocol)) &&
- (!srv.target || STREQ_NULLABLE(srv.target, dns->srvs[ii].target))) {
+ for (i = 0; i < dns->nsrvs; i++) {
+ if ((!srv.domain || STREQ_NULLABLE(srv.domain, dns->srvs[i].domain)) &&
+ (!srv.service || STREQ_NULLABLE(srv.service, dns->srvs[i].service)) &&
+ (!srv.protocol || STREQ_NULLABLE(srv.protocol, dns->srvs[i].protocol)) &&
+ (!srv.target || STREQ_NULLABLE(srv.target, dns->srvs[i].target))) {
foundCt++;
- foundIdx = ii;
+ foundIdx = i;
}
}
virNetworkPtr net = NULL;
int nnets = 0;
int ret = -1;
- int i;
+ size_t i;
if (nets && VIR_ALLOC_N(tmp_nets, netobjs.count + 1) < 0)
goto cleanup;
virNodeDeviceFindBySysfsPath(const virNodeDeviceObjListPtr devs,
const char *sysfs_path)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < devs->count; i++) {
virNodeDeviceObjLock(devs->objs[i]);
virNodeDeviceObjPtr virNodeDeviceFindByName(const virNodeDeviceObjListPtr devs,
const char *name)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < devs->count; i++) {
virNodeDeviceObjLock(devs->objs[i]);
void virNodeDeviceObjListFree(virNodeDeviceObjListPtr devs)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < devs->count; i++)
virNodeDeviceObjFree(devs->objs[i]);
VIR_FREE(devs->objs);
void virNodeDeviceObjRemove(virNodeDeviceObjListPtr devs,
const virNodeDeviceObjPtr dev)
{
- unsigned int i;
+ size_t i;
virNodeDeviceObjUnlock(dev);
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virNodeDevCapsDefPtr caps;
- unsigned int i = 0;
+ size_t i = 0;
virBufferAddLit(&buf, "<device>\n");
virBufferEscapeString(&buf, " <name>%s</name>\n", def->name);
union _virNodeDevCapData *data)
{
xmlNodePtr orignode, *nodes = NULL;
- int i, n, ret = -1;
+ size_t i;
+ int n, ret = -1;
unsigned long long val;
orignode = ctxt->node;
const char *virt_type)
{
xmlNodePtr orignode, *nodes = NULL;
- int ret = -1, n = 0, i;
+ int ret = -1, n = 0;
+ size_t i;
char *type = NULL;
orignode = ctxt->node;
xmlNodePtr origNode = ctxt->node;
xmlNodePtr *addrNodes = NULL;
char *numberStr = NULL;
- int nAddrNodes, ii, ret = -1;
+ int nAddrNodes, ret = -1;
+ size_t i;
virPCIDeviceAddressPtr pciAddr = NULL;
ctxt->node = iommuGroupNode;
if ((nAddrNodes = virXPathNodeSet("./address", ctxt, &addrNodes)) < 0)
goto cleanup;
- for (ii = 0; ii < nAddrNodes; ii++) {
+ for (i = 0; i < nAddrNodes; i++) {
virDevicePCIAddress addr = { 0, 0, 0, 0, 0 };
- if (virDevicePCIAddressParseXML(addrNodes[ii], &addr) < 0)
+ if (virDevicePCIAddressParseXML(addrNodes[i], &addr) < 0)
goto cleanup;
if (VIR_ALLOC(pciAddr) < 0)
goto cleanup;
virNodeDeviceDefPtr def;
virNodeDevCapsDefPtr *next_cap;
xmlNodePtr *nodes;
- int n, i;
+ int n;
+ size_t i;
if (VIR_ALLOC(def) < 0)
return NULL;
void virNodeDevCapsDefFree(virNodeDevCapsDefPtr caps)
{
- int i = 0;
+ size_t i = 0;
union _virNodeDevCapData *data = &caps->data;
switch (caps->type) {
virNodeDevicePtr device = NULL;
int ndevices = 0;
int ret = -1;
- int i;
+ size_t i;
if (devices && VIR_ALLOC_N(tmp_devices, devobjs.count + 1) < 0)
goto cleanup;
static int
intMapGetByInt(const struct int_map *intmap, int32_t attr, const char **res)
{
- int i = 0;
+ size_t i = 0;
bool found = false;
while (intmap[i].val && !found) {
intMapGetByString(const struct int_map *intmap, const char *str, int casecmp,
int32_t *result)
{
- int i = 0;
+ size_t i = 0;
bool found = false;
while (intmap[i].val && !found) {
void
virNWFilterRuleDefFree(virNWFilterRuleDefPtr def) {
- int i;
+ size_t i;
if (!def)
return;
void
virNWFilterDefFree(virNWFilterDefPtr def) {
- int i;
+ size_t i;
if (!def)
return;
void
virNWFilterObjListFree(virNWFilterObjListPtr nwfilters)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < nwfilters->count; i++)
virNWFilterObjFree(nwfilters->objs[i]);
VIR_FREE(nwfilters->objs);
nwItemDesc *item,
const char *var)
{
- int i = 0;
+ size_t i = 0;
virNWFilterVarAccessPtr varAccess;
varAccess = virNWFilterVarAccessParse(var);
virNWFilterObjRemove(virNWFilterObjListPtr nwfilters,
virNWFilterObjPtr nwfilter)
{
- unsigned int i;
+ size_t i;
virNWFilterObjUnlock(nwfilter);
const char *input, int32_t *flags, char sep)
{
int rc = 0;
- unsigned int i, j;
+ size_t i, j;
bool found;
i = 0;
printStringItems(virBufferPtr buf, const struct int_map *int_map,
int32_t flags, const char *sep)
{
- unsigned int i, c = 0;
+ size_t i;
+ unsigned int c = 0;
int32_t mask = 0x1;
while (mask) {
while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE) {
- int i = 0;
+ size_t i = 0;
while (1) {
if (found)
i = found_i;
virNWFilterObjFindByUUID(virNWFilterObjListPtr nwfilters,
const unsigned char *uuid)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < nwfilters->count; i++) {
virNWFilterObjLock(nwfilters->objs[i]);
virNWFilterObjPtr
virNWFilterObjFindByName(virNWFilterObjListPtr nwfilters, const char *name)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < nwfilters->count; i++) {
virNWFilterObjLock(nwfilters->objs[i]);
const char *filtername)
{
int rc = 0;
- int i;
+ size_t i;
virNWFilterEntryPtr entry;
virNWFilterObjPtr obj;
void
virNWFilterUnRegisterCallbackDriver(virNWFilterCallbackDriverPtr cbd)
{
- int i = 0;
+ size_t i = 0;
while (i < nCallbackDriver && callbackDrvArray[i] != cbd)
i++;
void
virNWFilterCallbackDriversLock(void)
{
- int i;
+ size_t i;
for (i = 0; i < nCallbackDriver; i++)
callbackDrvArray[i]->vmDriverLock();
void
virNWFilterCallbackDriversUnlock(void)
{
- int i;
+ size_t i;
for (i = 0; i < nCallbackDriver; i++)
callbackDrvArray[i]->vmDriverUnlock();
int
virNWFilterInstFiltersOnAllVMs(virConnectPtr conn)
{
- int i;
+ size_t i;
struct domUpdateCBStruct cb = {
.conn = conn,
.step = STEP_APPLY_CURRENT,
static int
virNWFilterTriggerVMFilterRebuild(virConnectPtr conn)
{
- int i;
+ size_t i;
int ret = 0;
struct domUpdateCBStruct cb = {
.conn = conn,
const virXMLAttr2Struct *att,
virNWFilterRuleDefPtr def)
{
- int i = 0, j;
+ size_t i = 0, j;
bool typeShown = false;
bool neverShown = true;
bool asHex;
static char *
virNWFilterRuleDefFormat(virNWFilterRuleDefPtr def)
{
- int i;
+ size_t i;
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBuffer buf2 = VIR_BUFFER_INITIALIZER;
char *data;
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
char uuid[VIR_UUID_STRING_BUFLEN];
- int i;
+ size_t i;
char *xml;
virBufferAsprintf(&buf, "<filter name='%s' chain='%s'",
void
virNWFilterVarValueFree(virNWFilterVarValuePtr val)
{
- unsigned i;
+ size_t i;
if (!val)
return;
virNWFilterVarValueCopy(const virNWFilterVarValuePtr val)
{
virNWFilterVarValuePtr res;
- unsigned i;
+ size_t i;
char *str;
if (VIR_ALLOC(res) < 0)
virNWFilterVarValueEqual(const virNWFilterVarValuePtr a,
const virNWFilterVarValuePtr b)
{
- unsigned int card, i, j;
+ unsigned int card;
+ size_t i, j;
const char *s;
if (!a || !b)
int
virNWFilterVarValueDelValue(virNWFilterVarValuePtr val, const char *value)
{
- unsigned int i;
+ size_t i;
switch (val->valType) {
case NWFILTER_VALUE_TYPE_SIMPLE:
void
virNWFilterVarCombIterFree(virNWFilterVarCombIterPtr ci)
{
- unsigned int i;
+ size_t i;
if (!ci)
return;
virNWFilterVarCombIterGetIndexByIterId(virNWFilterVarCombIterPtr ci,
unsigned int iterId)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < ci->nIter; i++)
if (ci->iter[i].iterId == iterId)
virNWFilterVarCombIterEntryAreUniqueEntries(virNWFilterVarCombIterEntryPtr cie,
virNWFilterHashTablePtr hash)
{
- unsigned int i, j;
+ size_t i, j;
virNWFilterVarValuePtr varValue, tmp;
const char *value;
size_t nVarAccess)
{
virNWFilterVarCombIterPtr res;
- unsigned int i, iterId;
+ size_t i;
+ unsigned int iterId;
int iterIndex = -1;
unsigned int nextIntIterId = VIR_NWFILTER_MAX_ITERID + 1;
virNWFilterVarCombIterPtr
virNWFilterVarCombIterNext(virNWFilterVarCombIterPtr ci)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < ci->nIter; i++) {
next:
virNWFilterVarCombIterGetVarValue(virNWFilterVarCombIterPtr ci,
const virNWFilterVarAccessPtr vap)
{
- unsigned int i, iterId;
+ size_t i;
+ unsigned int iterId;
bool found = false;
const char *res = NULL;
virNWFilterVarValuePtr value;
void
virNWFilterHashTableFree(virNWFilterHashTablePtr table)
{
- int i;
+ size_t i;
if (!table)
return;
virHashFree(table->hashTable);
virNWFilterHashTableRemoveEntry(virNWFilterHashTablePtr ht,
const char *entry)
{
- int i;
+ size_t i;
void *value = virHashSteal(ht->hashTable, entry);
if (value) {
const char *filterref)
{
virHashKeyValuePairPtr items;
- int i, j, card, numKeys;
+ size_t i, j;
+ int card, numKeys;
numKeys = virHashSize(table->hashTable);
void virDomainSnapshotDefFree(virDomainSnapshotDefPtr def)
{
- int i;
+ size_t i;
if (!def)
return;
virDomainSnapshotDefPtr def = NULL;
virDomainSnapshotDefPtr ret = NULL;
xmlNodePtr *nodes = NULL;
- int i;
+ size_t i;
+ int n;
char *creation = NULL, *state = NULL;
struct timeval tv;
int active;
def->file = memoryFile;
memoryFile = NULL;
- if ((i = virXPathNodeSet("./disks/*", ctxt, &nodes)) < 0)
+ if ((n = virXPathNodeSet("./disks/*", ctxt, &nodes)) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_SNAPSHOT_PARSE_DISKS) {
- def->ndisks = i;
+ def->ndisks = n;
if (def->ndisks && VIR_ALLOC_N(def->disks, def->ndisks) < 0)
goto cleanup;
for (i = 0; i < def->ndisks; i++) {
goto cleanup;
}
VIR_FREE(nodes);
- } else if (i) {
+ } else if (n) {
virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
_("unable to handle disk requests in snapshot"));
goto cleanup;
{
int ret = -1;
virBitmapPtr map = NULL;
- int i;
+ size_t i;
int ndisks;
bool inuse;
int internal)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
- int i;
+ size_t i;
virCheckFlags(VIR_DOMAIN_XML_SECURE |
VIR_DOMAIN_XML_UPDATE_CPU, NULL);
{
struct virDomainSnapshotNameData data = { names, maxnames, flags, 0,
false };
- int i;
+ size_t i;
if (!from) {
/* LIST_ROOTS and LIST_DESCENDANTS have the same bit value,
virDomainSnapshotPtr *list = NULL;
char **names;
int ret = -1;
- int i;
+ size_t i;
if (!snaps || count < 0)
return count;
bool
virDomainSnapshotDefIsExternal(virDomainSnapshotDefPtr def)
{
- int i;
+ size_t i;
if (def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL)
return true;
static virStoragePoolTypeInfoPtr
virStoragePoolTypeInfoLookup(int type)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < ARRAY_CARDINALITY(poolTypeInfo); i++)
if (poolTypeInfo[i].poolType == type)
return &poolTypeInfo[i];
void
virStorageVolDefFree(virStorageVolDefPtr def)
{
- int i;
+ size_t i;
if (!def)
return;
void
virStoragePoolSourceClear(virStoragePoolSourcePtr source)
{
- int i;
+ size_t i;
if (!source)
return;
void
virStoragePoolObjListFree(virStoragePoolObjListPtr pools)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < pools->count; i++)
virStoragePoolObjFree(pools->objs[i]);
VIR_FREE(pools->objs);
virStoragePoolObjRemove(virStoragePoolObjListPtr pools,
virStoragePoolObjPtr pool)
{
- unsigned int i;
+ size_t i;
virStoragePoolObjUnlock(pool);
int ret = -1;
xmlNodePtr relnode, *nodeset = NULL;
char *authType = NULL;
- int nsource, i;
+ int nsource;
+ size_t i;
virStoragePoolOptionsPtr options;
char *name = NULL;
char *port = NULL;
virStoragePoolOptionsPtr options,
virStoragePoolSourcePtr src)
{
- int i, j;
+ size_t i, j;
char uuid[VIR_UUID_STRING_BUFLEN];
virBufferAddLit(buf," <source>\n");
char *unit = NULL;
xmlNodePtr node;
xmlNodePtr *nodes = NULL;
- int i, n;
+ size_t i;
+ int n;
options = virStorageVolOptionsForPoolType(pool->type);
if (options == NULL)
virBufferEscapeString(buf, " <compat>%s</compat>\n", def->compat);
if (options->featureToString && def->features) {
- int i;
+ size_t i;
bool b;
bool empty = virBitmapIsAllClear(def->features);
virBufferAddLit(&buf, " <source>\n");
if (def->source.nextent) {
- int i;
+ size_t i;
const char *thispath = NULL;
for (i = 0; i < def->source.nextent; i++) {
if (thispath == NULL ||
virStoragePoolObjFindByUUID(virStoragePoolObjListPtr pools,
const unsigned char *uuid)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < pools->count; i++) {
virStoragePoolObjLock(pools->objs[i]);
virStoragePoolObjFindByName(virStoragePoolObjListPtr pools,
const char *name)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < pools->count; i++) {
virStoragePoolObjLock(pools->objs[i]);
virStoragePoolSourceFindDuplicateDevices(virStoragePoolObjPtr pool,
virStoragePoolDefPtr def)
{
- unsigned int i, j;
+ size_t i, j;
for (i = 0; i < pool->def->source.ndevice; i++) {
for (j = 0; j < def->source.ndevice; j++) {
void
virStoragePoolObjClearVols(virStoragePoolObjPtr pool)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < pool->volumes.count; i++)
virStorageVolDefFree(pool->volumes.objs[i]);
virStorageVolDefFindByKey(virStoragePoolObjPtr pool,
const char *key)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < pool->volumes.count; i++)
if (STREQ(pool->volumes.objs[i]->key, key))
virStorageVolDefFindByPath(virStoragePoolObjPtr pool,
const char *path)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < pool->volumes.count; i++)
if (STREQ(pool->volumes.objs[i]->target.path, path))
virStorageVolDefFindByName(virStoragePoolObjPtr pool,
const char *name)
{
- unsigned int i;
+ size_t i;
for (i = 0; i < pool->volumes.count; i++)
if (STREQ(pool->volumes.objs[i]->name, name))
virStoragePoolOptionsPtr options;
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *type;
- int i;
+ size_t i;
options = virStoragePoolOptionsForPoolType(def->type);
if (options == NULL)
virStoragePoolSourceFindDuplicate(virStoragePoolObjListPtr pools,
virStoragePoolDefPtr def)
{
- int i;
+ size_t i;
int ret = 1;
virStoragePoolObjPtr pool = NULL;
virStoragePoolObjPtr matchpool = NULL;
virStoragePoolPtr pool = NULL;
int npools = 0;
int ret = -1;
- int i;
+ size_t i;
if (pools && VIR_ALLOC_N(tmp_pools, poolobjs.count + 1) < 0)
goto cleanup;
xmlNodePtr *nodes = NULL;
virStorageEncryptionPtr ret;
char *format_str;
- int format, i, n;
+ int format, n;
+ size_t i;
if (VIR_ALLOC(ret) < 0)
return NULL;
projects / libvirt.git / commitdiff