+Mon Oct 13 18:45:43 CEST 2008 Jim Meyering <meyering@redhat.com>
+
+ avoid many format string warnings
+
+ Building with --disable-nls exposed many new warnings like these:
+ virsh.c:4952: warning: format not a string literal and no format ...
+ util.c:163: warning: format not a string literal and no format arguments
+ All but one of the following changes add a "%s" argument before
+ the offending _(...) argument.
+
+ This was the only manual change:
+ * src/lxc_driver.c (lxcVersion): Use %s and strerror(errno)
+ rather than %m, to avoid a warning from gcc -Wformat-security.
+
+ Add "%s" before each warned about format-string-with-no-%-directive:
+ * src/domain_conf.c (virDomainHostdevSubsysUsbDefParseXML)
+ (virDomainDefParseString, virDomainDefParseFile):
+ * src/hash.c (virGetConnect, __virGetDomain, virReleaseDomain)
+ (__virGetNetwork, virReleaseNetwork, __virGetStoragePool)
+ (virReleaseStoragePool, __virGetStorageVol, virReleaseStorageVol):
+ * src/lxc_container.c (lxcContainerChild):
+ * src/lxc_driver.c (lxcDomainDefine, lxcDomainUndefine)
+ (lxcDomainGetInfo, lxcGetOSType, lxcDomainDumpXML)
+ (lxcSetupInterfaces, lxcDomainStart, lxcDomainCreateAndStart)
+ (lxcVersion, lxcGetSchedulerParameters):
+ * src/network_conf.c (virNetworkDefParseString)
+ (virNetworkDefParseFile):
+ * src/openvz_conf.c (openvzReadNetworkConf, openvzLoadDomains):
+ * src/openvz_driver.c (openvzDomainDefineCmd)
+ (openvzDomainGetInfo, openvzDomainDumpXML, openvzDomainShutdown)
+ (openvzDomainReboot, ADD_ARG_LIT, openvzDomainDefineXML)
+ (openvzDomainCreateXML, openvzDomainCreate, openvzDomainUndefine)
+ (openvzDomainSetAutostart, openvzDomainGetAutostart)
+ (openvzDomainSetVcpus):
+ * src/qemu_driver.c (qemudDomainBlockPeek, qemudDomainMemoryPeek):
+ * src/remote_internal.c (remoteDomainBlockPeek)
+ (remoteDomainMemoryPeek, remoteAuthPolkit):
+ * src/sexpr.c (sexpr_new, _string2sexpr):
+ * src/storage_backend_disk.c (virStorageBackendDiskMakeDataVol)
+ (virStorageBackendDiskCreateVol):
+ * src/storage_backend_fs.c
+ (virStorageBackendFileSystemNetFindPoolSources):
+ * src/storage_backend_logical.c (virStorageBackendLogicalFindLVs)
+ (virStorageBackendLogicalFindPoolSources):
+ * src/test.c (testOpenDefault, testOpenFromFile, testOpen)
+ (testGetDomainInfo, testDomainRestore)
+ (testNodeGetCellsFreeMemory):
+ * src/util.c (virExec):
+ * src/virsh.c (cmdAttachDevice, cmdDetachDevice)
+ (cmdAttachInterface, cmdDetachInterface, cmdAttachDisk)
+ (cmdDetachDisk, cmdEdit):
+ * src/xend_internal.c (do_connect, wr_sync, xend_op_ext)
+ (urlencode, xenDaemonDomainCreateXML)
+ (xenDaemonDomainLookupByName_ids, xenDaemonDomainLookupByID)
+ (xenDaemonParseSxprOS, xend_parse_sexp_desc_char)
+ (xenDaemonParseSxprChar, xenDaemonParseSxprDisks)
+ (xenDaemonParseSxpr, sexpr_to_xend_topology, sexpr_to_domain)
+ (xenDaemonDomainFetch, xenDaemonDomainGetAutostart)
+ (xenDaemonDomainSetAutostart, xenDaemonDomainMigratePerform)
+ (xenDaemonDomainDefineXML, xenDaemonGetSchedulerType)
+ (xenDaemonGetSchedulerParameters)
+ (xenDaemonSetSchedulerParameters, xenDaemonDomainBlockPeek)
+ (xenDaemonFormatSxprChr, virDomainXMLDevID):
+ * src/xm_internal.c (xenXMConfigCacheRefresh, xenXMDomainPinVcpu)
+ (xenXMDomainCreate, xenXMDomainDefineXML)
+ (xenXMDomainAttachDevice, xenXMDomainDetachDevice):
+ * src/xml.c (virXPathString, virXPathNumber, virXPathLong)
+ (virXPathULong, virXPathBoolean, virXPathNode, virXPathNodeSet):
+ * src/xs_internal.c (xenStoreOpen):
+
Mon Oct 13 16:24:00 BST 2008 Richard W.M. Jones <rjones@redhat.com>
Documentation for NIC model selection.
if (def->source.subsys.usb.vendor == 0 &&
def->source.subsys.usb.product != 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("missing vendor"));
+ "%s", _("missing vendor"));
goto out;
}
if (def->source.subsys.usb.vendor != 0 &&
def->source.subsys.usb.product == 0) {
virDomainReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("missing product"));
+ "%s", _("missing product"));
goto out;
}
if (!xml) {
if (conn && conn->err.code == VIR_ERR_NONE)
virDomainReportError(conn, VIR_ERR_XML_ERROR,
- _("failed to parse xml document"));
+ "%s", _("failed to parse xml document"));
goto cleanup;
}
if (!xml) {
if (conn && conn->err.code == VIR_ERR_NONE)
virDomainReportError(conn, VIR_ERR_XML_ERROR,
- _("failed to parse xml document"));
+ "%s", _("failed to parse xml document"));
goto cleanup;
}
virConnectPtr ret;
if (VIR_ALLOC(ret) < 0) {
- virHashError(NULL, VIR_ERR_NO_MEMORY, _("allocating connection"));
+ virHashError(NULL, VIR_ERR_NO_MEMORY, "%s", _("allocating connection"));
goto failed;
}
ret->magic = VIR_CONNECT_MAGIC;
/* TODO check the UUID */
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
- virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating domain"));
+ virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating domain"));
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
- virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating domain"));
+ virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating domain"));
goto error;
}
ret->magic = VIR_DOMAIN_MAGIC;
if (virHashAddEntry(conn->domains, name, ret) < 0) {
virHashError(conn, VIR_ERR_INTERNAL_ERROR,
- _("failed to add domain to connection hash table"));
+ "%s", _("failed to add domain to connection hash table"));
goto error;
}
conn->refs++;
/* TODO search by UUID first as they are better differenciators */
if (virHashRemoveEntry(conn->domains, domain->name, NULL) < 0)
virHashError(conn, VIR_ERR_INTERNAL_ERROR,
- _("domain missing from connection hash table"));
+ "%s", _("domain missing from connection hash table"));
if (conn->err.dom == domain)
conn->err.dom = NULL;
/* TODO check the UUID */
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
- virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating network"));
+ virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating network"));
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
- virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating network"));
+ virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating network"));
goto error;
}
ret->magic = VIR_NETWORK_MAGIC;
if (virHashAddEntry(conn->networks, name, ret) < 0) {
virHashError(conn, VIR_ERR_INTERNAL_ERROR,
- _("failed to add network to connection hash table"));
+ "%s", _("failed to add network to connection hash table"));
goto error;
}
conn->refs++;
/* TODO search by UUID first as they are better differenciators */
if (virHashRemoveEntry(conn->networks, network->name, NULL) < 0)
virHashError(conn, VIR_ERR_INTERNAL_ERROR,
- _("network missing from connection hash table"));
+ "%s", _("network missing from connection hash table"));
if (conn->err.net == network)
conn->err.net = NULL;
/* TODO check the UUID */
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
- virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating storage pool"));
+ virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage pool"));
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
- virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating storage pool"));
+ virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage pool"));
goto error;
}
ret->magic = VIR_STORAGE_POOL_MAGIC;
if (virHashAddEntry(conn->storagePools, name, ret) < 0) {
virHashError(conn, VIR_ERR_INTERNAL_ERROR,
- _("failed to add storage pool to connection hash table"));
+ "%s", _("failed to add storage pool to connection hash table"));
goto error;
}
conn->refs++;
/* TODO search by UUID first as they are better differenciators */
if (virHashRemoveEntry(conn->storagePools, pool->name, NULL) < 0)
virHashError(conn, VIR_ERR_INTERNAL_ERROR,
- _("pool missing from connection hash table"));
+ "%s", _("pool missing from connection hash table"));
pool->magic = -1;
VIR_FREE(pool->name);
ret = (virStorageVolPtr) virHashLookup(conn->storageVols, key);
if (ret == NULL) {
if (VIR_ALLOC(ret) < 0) {
- virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating storage vol"));
+ virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage vol"));
goto error;
}
ret->pool = strdup(pool);
if (ret->pool == NULL) {
- virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating storage vol"));
+ virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage vol"));
goto error;
}
ret->name = strdup(name);
if (ret->name == NULL) {
- virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating storage vol"));
+ virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage vol"));
goto error;
}
strncpy(ret->key, key, sizeof(ret->key)-1);
if (virHashAddEntry(conn->storageVols, key, ret) < 0) {
virHashError(conn, VIR_ERR_INTERNAL_ERROR,
- _("failed to add storage vol to connection hash table"));
+ "%s", _("failed to add storage vol to connection hash table"));
goto error;
}
conn->refs++;
/* TODO search by UUID first as they are better differenciators */
if (virHashRemoveEntry(conn->storageVols, vol->key, NULL) < 0)
virHashError(conn, VIR_ERR_INTERNAL_ERROR,
- _("vol missing from connection hash table"));
+ "%s", _("vol missing from connection hash table"));
vol->magic = -1;
VIR_FREE(vol->name);
if (NULL == vmDef) {
lxcError(NULL, NULL, VIR_ERR_INTERNAL_ERROR,
- _("lxcChild() passed invalid vm definition"));
+ "%s", _("lxcChild() passed invalid vm definition"));
return -1;
}
if ((def->nets != NULL) && !(driver->have_netns)) {
lxcError(conn, NULL, VIR_ERR_NO_SUPPORT,
- _("System lacks NETNS support"));
+ "%s", _("System lacks NETNS support"));
virDomainDefFree(def);
return NULL;
}
if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return -1;
}
if (virDomainIsActive(vm)) {
lxcError(dom->conn, dom, VIR_ERR_INTERNAL_ERROR,
- _("cannot delete active domain"));
+ "%s", _("cannot delete active domain"));
return -1;
}
if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return -1;
}
if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return NULL;
}
if (!vm) {
lxcError(dom->conn, dom, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return NULL;
}
DEBUG("bridge: %s", bridge);
if (NULL == bridge) {
lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
- _("failed to get bridge for interface"));
+ "%s", _("failed to get bridge for interface"));
goto error_exit;
}
if (NULL == def->nets[i]->ifname) {
lxcError(NULL, NULL, VIR_ERR_INTERNAL_ERROR,
- _("failed to allocate veth names"));
+ "%s", _("failed to allocate veth names"));
goto error_exit;
}
if ((vm->def->nets != NULL) && !(driver->have_netns)) {
lxcError(conn, NULL, VIR_ERR_NO_SUPPORT,
- _("System lacks NETNS support"));
+ "%s", _("System lacks NETNS support"));
goto cleanup;
}
if ((def->nets != NULL) && !(driver->have_netns)) {
virDomainDefFree(def);
lxcError(conn, NULL, VIR_ERR_NO_SUPPORT,
- _("System lacks NETNS support"));
+ "%s", _("System lacks NETNS support"));
goto return_point;
}
if (uname(&ver) != 0) {
lxcError(conn, NULL, VIR_ERR_INTERNAL_ERROR,
- _("uname(): %m"));
+ _("uname(): %s"), strerror(errno));
return -1;
}
if ((*nparams) != 1) {
lxcError(NULL, _domain, VIR_ERR_INVALID_ARG,
- _("Invalid parameter count"));
+ "%s", _("Invalid parameter count"));
return -1;
}
if (!xml) {
if (conn && conn->err.code == VIR_ERR_NONE)
virNetworkReportError(conn, VIR_ERR_XML_ERROR,
- _("failed to parse xml document"));
+ "%s", _("failed to parse xml document"));
goto cleanup;
}
if (!xml) {
if (conn && conn->err.code == VIR_ERR_NONE)
virNetworkReportError(conn, VIR_ERR_XML_ERROR,
- _("failed to parse xml document"));
+ "%s", _("failed to parse xml document"));
goto cleanup;
}
len = next - p;
if (len > 16) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Too long network device name"));
+ "%s", _("Too long network device name"));
goto error;
}
len = next - p;
if (len != 17) { //should be 17
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Wrong length MAC address"));
+ "%s", _("Wrong length MAC address"));
goto error;
}
strncpy(cpy_temp, p, len);
cpy_temp[len] = '\0';
if (openvzParseMac(cpy_temp, net->mac)<0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Wrong MAC address"));
+ "%s", _("Wrong MAC address"));
goto error;
}
} else if (STRPREFIX(p, "host_mac=")) {
return -1;
if ((fp = popen(VZLIST " -a -ovpsid,status -H 2>/dev/null", "r")) == NULL) {
- openvzError(NULL, VIR_ERR_INTERNAL_ERROR, _("popen failed"));
+ openvzError(NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("popen failed"));
return -1;
}
break;
openvzError(NULL, VIR_ERR_INTERNAL_ERROR,
- _("Failed to parse vzlist output"));
+ "%s", _("Failed to parse vzlist output"));
goto cleanup;
}
if (ret == -1) {
openvzError(NULL, VIR_ERR_INTERNAL_ERROR,
- _("UUID in config file malformed"));
+ "%s", _("UUID in config file malformed"));
goto cleanup;
}
if (vmdef == NULL){
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Container is not defined"));
+ "%s", _("Container is not defined"));
return -1;
}
if (!vm) {
openvzError(dom->conn, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return -1;
}
if (!vm) {
openvzError(dom->conn, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return NULL;
}
if (!vm) {
openvzError(dom->conn, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return -1;
}
if (vm->state != VIR_DOMAIN_RUNNING) {
openvzError(dom->conn, VIR_ERR_INTERNAL_ERROR,
- _("domain is not in running state"));
+ "%s", _("domain is not in running state"));
return -1;
}
if (!vm) {
openvzError(dom->conn, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return -1;
}
if (vm->state != VIR_DOMAIN_RUNNING) {
openvzError(dom->conn, VIR_ERR_INTERNAL_ERROR,
- _("domain is not in running state"));
+ "%s", _("domain is not in running state"));
return -1;
}
return 0;
if (vpsid == NULL) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Container ID is not specified"));
+ "%s", _("Container ID is not specified"));
return -1;
}
if (openvzDomainDefineCmd(conn, prog, OPENVZ_MAX_ARG, vmdef) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Error creating command for container"));
+ "%s", _("Error creating command for container"));
goto exit;
}
if (openvzSetDefinedUUID(strtoI(vmdef->name), vmdef->uuid) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Could not set UUID"));
+ "%s", _("Could not set UUID"));
goto exit;
}
for (i = 0 ; i < vmdef->nnets ; i++) {
if (openvzDomainSetNetwork(conn, vmdef->name, vmdef->nets[i]) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Could not configure network"));
+ "%s", _("Could not configure network"));
goto exit;
}
}
if (vmdef->vcpus > 0) {
if (openvzDomainSetVcpus(dom, vmdef->vcpus) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Could not set number of virtual cpu"));
+ "%s", _("Could not set number of virtual cpu"));
goto exit;
}
}
if (openvzDomainDefineCmd(conn, progcreate, OPENVZ_MAX_ARG, vmdef) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Error creating command for container"));
+ "%s", _("Error creating command for container"));
goto exit;
}
if (openvzSetDefinedUUID(strtoI(vmdef->name), vmdef->uuid) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Could not set UUID"));
+ "%s", _("Could not set UUID"));
goto exit;
}
for (i = 0 ; i < vmdef->nnets ; i++) {
if (openvzDomainSetNetwork(conn, vmdef->name, vmdef->nets[i]) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Could not configure network"));
+ "%s", _("Could not configure network"));
goto exit;
}
}
if (vmdef->vcpus > 0) {
if (openvzDomainSetVcpus(dom, vmdef->vcpus) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Could not set number of virtual cpu"));
+ "%s", _("Could not set number of virtual cpu"));
goto exit;
}
}
if (!vm) {
openvzError(dom->conn, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching id"));
+ "%s", _("no domain with matching id"));
return -1;
}
if (vm->state != VIR_DOMAIN_SHUTOFF) {
openvzError(dom->conn, VIR_ERR_OPERATION_DENIED,
- _("domain is not in shutoff state"));
+ "%s", _("domain is not in shutoff state"));
return -1;
}
const char *prog[] = { VZCTL, "--quiet", "destroy", vm ? vm->def->name : NULL, NULL };
if (!vm) {
- openvzError(conn, VIR_ERR_INVALID_DOMAIN, _("no domain with matching uuid"));
+ openvzError(conn, VIR_ERR_INVALID_DOMAIN, "%s", _("no domain with matching uuid"));
return -1;
}
if (virDomainIsActive(vm)) {
- openvzError(conn, VIR_ERR_INTERNAL_ERROR, _("cannot delete active domain"));
+ openvzError(conn, VIR_ERR_INTERNAL_ERROR, "%s", _("cannot delete active domain"));
return -1;
}
"--save", NULL };
if (!vm) {
- openvzError(conn, VIR_ERR_INVALID_DOMAIN, _("no domain with matching uuid"));
+ openvzError(conn, VIR_ERR_INVALID_DOMAIN, "%s", _("no domain with matching uuid"));
return -1;
}
char value[1024];
if (!vm) {
- openvzError(conn, VIR_ERR_INVALID_DOMAIN, _("no domain with matching uuid"));
+ openvzError(conn, VIR_ERR_INVALID_DOMAIN, "%s", _("no domain with matching uuid"));
return -1;
}
if (openvzReadConfigParam(strtoI(vm->def->name), "ONBOOT", value, sizeof(value)) < 0) {
- openvzError(conn, VIR_ERR_INTERNAL_ERROR, _("Could not read container config"));
+ openvzError(conn, VIR_ERR_INTERNAL_ERROR, "%s", _("Could not read container config"));
return -1;
}
if (!vm) {
openvzError(conn, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return -1;
}
if (nvcpus <= 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
- _("VCPUs should be >= 1"));
+ "%s", _("VCPUs should be >= 1"));
return -1;
}
if (!vm) {
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_DOMAIN,
- _("no domain with matching uuid"));
+ "%s", _("no domain with matching uuid"));
return -1;
}
if (!path || path[0] == '\0') {
qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
- _("NULL or empty path"));
+ "%s", _("NULL or empty path"));
return -1;
}
goto found;
}
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
- _("invalid path"));
+ "%s", _("invalid path"));
return -1;
found:
if (flags != VIR_MEMORY_VIRTUAL) {
qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
- _("QEMU driver only supports virtual memory addrs"));
+ "%s", _("QEMU driver only supports virtual memory addrs"));
return -1;
}
if (ret.buffer.buffer_len != size) {
errorf (domain->conn, VIR_ERR_RPC,
- _("returned buffer is not same size as requested"));
+ "%s", _("returned buffer is not same size as requested"));
free (ret.buffer.buffer_val);
return -1;
}
if (ret.buffer.buffer_len != size) {
errorf (domain->conn, VIR_ERR_RPC,
- _("returned buffer is not same size as requested"));
+ "%s", _("returned buffer is not same size as requested"));
free (ret.buffer.buffer_val);
return -1;
}
if ((*(auth->cb))(&cred, 1, auth->cbdata) < 0) {
__virRaiseError (in_open ? NULL : conn, NULL, NULL, VIR_FROM_REMOTE,
VIR_ERR_AUTH_FAILED, VIR_ERR_ERROR, NULL, NULL, NULL, 0, 0,
- _("Failed to collect auth credentials"));
+ "%s", _("Failed to collect auth credentials"));
return -1;
}
} else {
struct sexpr *ret;
if (VIR_ALLOC(ret) < 0) {
- virSexprError(VIR_ERR_NO_MEMORY, _("failed to allocate a node"));
+ virSexprError(VIR_ERR_NO_MEMORY, "%s", _("failed to allocate a node"));
return (NULL);
}
ret->kind = SEXPR_NIL;
ret->u.value = strndup(start, ptr - start);
if (ret->u.value == NULL) {
virSexprError(VIR_ERR_NO_MEMORY,
- _("failed to copy a string"));
+ "%s", _("failed to copy a string"));
goto error;
}
ret->u.value = strndup(start, ptr - start);
if (ret->u.value == NULL) {
virSexprError(VIR_ERR_NO_MEMORY,
- _("failed to copy a string"));
+ "%s", _("failed to copy a string"));
goto error;
}
}
if (vol == NULL) {
if (VIR_ALLOC(vol) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("volume"));
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
return -1;
}
if (VIR_REALLOC_N(pool->volumes.objs,
pool->volumes.count+1) < 0) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("volume"));
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
virStorageVolDefFree(vol);
return -1;
}
*/
tmp = strrchr(groups[0], '/');
if ((vol->name = strdup(tmp ? tmp + 1 : groups[0])) == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("volume"));
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
return -1;
}
}
if (vol->target.path == NULL) {
if ((devpath = strdup(groups[0])) == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("volume"));
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
return -1;
}
if (vol->key == NULL) {
/* XXX base off a unique key of the underlying disk */
if ((vol->key = strdup(vol->target.path)) == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("volume"));
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("volume"));
return -1;
}
}
if (vol->source.extents == NULL) {
if (VIR_ALLOC(vol->source.extents) < 0) {
virStorageReportError(conn, VIR_ERR_NO_MEMORY,
- _("volume extents"));
+ "%s", _("volume extents"));
return -1;
}
vol->source.nextent = 1;
if (virStrToLong_ull(groups[3], NULL, 10,
&vol->source.extents[0].start) < 0) {
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("cannot parse device start location"));
+ "%s", _("cannot parse device start location"));
return -1;
}
if (virStrToLong_ull(groups[4], NULL, 10,
&vol->source.extents[0].end) < 0) {
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("cannot parse device end location"));
+ "%s", _("cannot parse device end location"));
return -1;
}
if ((vol->source.extents[0].path =
strdup(pool->def->source.devices[0].path)) == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("extents"));
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("extents"));
return -1;
}
}
}
if (smallestExtent == -1) {
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("no large enough free extent"));
+ "%s", _("no large enough free extent"));
return -1;
}
startOffset = dev->freeExtents[smallestExtent].start;
retval = virStringListJoin(state.list, SOURCES_START_TAG, SOURCES_END_TAG, "\n");
if (retval == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("retval"));
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("retval"));
goto cleanup;
}
vol,
&exitstatus) < 0) {
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("lvs command failed"));
+ "%s", _("lvs command failed"));
return -1;
}
retval = virStringListJoin(descs, SOURCES_START_TAG, SOURCES_END_TAG, "\n");
if (retval == NULL) {
- virStorageReportError(conn, VIR_ERR_NO_MEMORY, _("retval"));
+ virStorageReportError(conn, VIR_ERR_NO_MEMORY, "%s", _("retval"));
goto cleanup;
}
conn->privateData = privconn;
if (gettimeofday(&tv, NULL) < 0) {
- testError(NULL, VIR_ERR_INTERNAL_ERROR, _("getting time of day"));
+ testError(NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("getting time of day"));
goto error;
}
goto error;
if ((fd = open(file, O_RDONLY)) < 0) {
- testError(NULL, VIR_ERR_INTERNAL_ERROR, _("loading host definition file"));
+ testError(NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("loading host definition file"));
goto error;
}
if (!(xml = xmlReadFd(fd, file, NULL,
XML_PARSE_NOENT | XML_PARSE_NONET |
XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) {
- testError(NULL, VIR_ERR_INTERNAL_ERROR, _("host"));
+ testError(NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("host"));
goto error;
}
close(fd);
root = xmlDocGetRootElement(xml);
if ((root == NULL) || (!xmlStrEqual(root->name, BAD_CAST "node"))) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node"));
goto error;
}
ctxt = xmlXPathNewContext(xml);
if (ctxt == NULL) {
- testError(NULL, VIR_ERR_INTERNAL_ERROR, _("creating xpath context"));
+ testError(NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("creating xpath context"));
goto error;
}
if (ret == 0) {
nodeInfo->nodes = l;
} else if (ret == -2) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node cpu numa nodes"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node cpu numa nodes"));
goto error;
}
if (ret == 0) {
nodeInfo->sockets = l;
} else if (ret == -2) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node cpu sockets"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node cpu sockets"));
goto error;
}
if (ret == 0) {
nodeInfo->cores = l;
} else if (ret == -2) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node cpu cores"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node cpu cores"));
goto error;
}
if (ret == 0) {
nodeInfo->threads = l;
} else if (ret == -2) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node cpu threads"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node cpu threads"));
goto error;
}
nodeInfo->cpus = l;
}
} else if (ret == -2) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node active cpu"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node active cpu"));
goto error;
}
ret = virXPathLong(conn, "string(/node/cpu/mhz[1])", ctxt, &l);
if (ret == 0) {
nodeInfo->mhz = l;
} else if (ret == -2) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node cpu mhz"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node cpu mhz"));
goto error;
}
if (ret == 0) {
nodeInfo->memory = l;
} else if (ret == -2) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node memory"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node memory"));
goto error;
}
ret = virXPathNodeSet(conn, "/node/domain", ctxt, &domains);
if (ret < 0) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node domain list"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node domain list"));
goto error;
}
char *absFile = testBuildFilename(file, relFile);
VIR_FREE(relFile);
if (!absFile) {
- testError(NULL, VIR_ERR_INTERNAL_ERROR, _("resolving domain filename"));
+ testError(NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("resolving domain filename"));
goto error;
}
def = virDomainDefParseFile(conn, privconn->caps, absFile);
ret = virXPathNodeSet(conn, "/node/network", ctxt, &networks);
if (ret < 0) {
- testError(NULL, VIR_ERR_XML_ERROR, _("node network list"));
+ testError(NULL, VIR_ERR_XML_ERROR, "%s", _("node network list"));
goto error;
}
for (i = 0 ; i < ret ; i++) {
char *absFile = testBuildFilename(file, relFile);
VIR_FREE(relFile);
if (!absFile) {
- testError(NULL, VIR_ERR_INTERNAL_ERROR, _("resolving network filename"));
+ testError(NULL, VIR_ERR_INTERNAL_ERROR, "%s", _("resolving network filename"));
goto error;
}
|| uri->path[0] == '\0'
|| (uri->path[0] == '/' && uri->path[1] == '\0')) {
testError (NULL, VIR_ERR_INVALID_ARG,
- _("testOpen: supply a path or use test:///default"));
+ "%s", _("testOpen: supply a path or use test:///default"));
return VIR_DRV_OPEN_ERROR;
}
if (gettimeofday(&tv, NULL) < 0) {
testError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("getting time of day"));
+ "%s", _("getting time of day"));
return (-1);
}
if ((fd = open(path, O_RDONLY)) < 0) {
testError(conn, VIR_ERR_INTERNAL_ERROR,
- _("cannot read domain image"));
+ "%s", _("cannot read domain image"));
return (-1);
}
if (read(fd, magic, sizeof(magic)) != sizeof(magic)) {
testError(conn, VIR_ERR_INTERNAL_ERROR,
- _("incomplete save header"));
+ "%s", _("incomplete save header"));
close(fd);
return (-1);
}
if (memcmp(magic, TEST_SAVE_MAGIC, sizeof(magic))) {
testError(conn, VIR_ERR_INTERNAL_ERROR,
- _("mismatched header magic"));
+ "%s", _("mismatched header magic"));
close(fd);
return (-1);
}
if (read(fd, (char*)&len, sizeof(len)) != sizeof(len)) {
testError(conn, VIR_ERR_INTERNAL_ERROR,
- _("failed to read metadata length"));
+ "%s", _("failed to read metadata length"));
close(fd);
return (-1);
}
if (len < 1 || len > 8192) {
testError(conn, VIR_ERR_INTERNAL_ERROR,
- _("length of metadata out of range"));
+ "%s", _("length of metadata out of range"));
close(fd);
return (-1);
}
}
if (read(fd, xml, len) != len) {
testError(conn, VIR_ERR_INTERNAL_ERROR,
- _("incomplete metdata"));
+ "%s", _("incomplete metdata"));
close(fd);
return (-1);
}
if (startCell > privconn->numCells) {
testError(conn, VIR_ERR_INVALID_ARG,
- _("Range exceeds available cells"));
+ "%s", _("Range exceeds available cells"));
return -1;
}
if ((flags & VIR_EXEC_NONBLOCK) &&
virSetNonBlock(pipeout[0]) == -1) {
ReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Failed to set non-blocking file descriptor flag"));
+ "%s", _("Failed to set non-blocking file descriptor flag"));
goto cleanup;
}
if (virSetCloseExec(pipeout[0]) == -1) {
ReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Failed to set close-on-exec file descriptor flag"));
+ "%s", _("Failed to set close-on-exec file descriptor flag"));
goto cleanup;
}
if ((flags & VIR_EXEC_NONBLOCK) &&
virSetNonBlock(pipeerr[0]) == -1) {
ReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Failed to set non-blocking file descriptor flag"));
+ "%s", _("Failed to set non-blocking file descriptor flag"));
goto cleanup;
}
if (virSetCloseExec(pipeerr[0]) == -1) {
ReportError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Failed to set close-on-exec file descriptor flag"));
+ "%s", _("Failed to set close-on-exec file descriptor flag"));
goto cleanup;
}
virDomainFree(dom);
return FALSE;
} else {
- vshPrint(ctl, _("Device attached successfully\n"));
+ vshPrint(ctl, "%s", _("Device attached successfully\n"));
}
virDomainFree(dom);
virDomainFree(dom);
return FALSE;
} else {
- vshPrint(ctl, _("Device detached successfully\n"));
+ vshPrint(ctl, "%s", _("Device detached successfully\n"));
}
virDomainFree(dom);
if (virDomainAttachDevice(dom, buf)) {
goto cleanup;
} else {
- vshPrint(ctl, _("Interface attached successfully\n"));
+ vshPrint(ctl, "%s", _("Interface attached successfully\n"));
}
ret = TRUE;
if (ret != 0)
ret = FALSE;
else {
- vshPrint(ctl, _("Interface detached successfully\n"));
+ vshPrint(ctl, "%s", _("Interface detached successfully\n"));
ret = TRUE;
}
if (virDomainAttachDevice(dom, buf))
goto cleanup;
else
- vshPrint(ctl, _("Disk attached successfully\n"));
+ vshPrint(ctl, "%s", _("Disk attached successfully\n"));
ret = TRUE;
if (ret != 0)
ret = FALSE;
else {
- vshPrint(ctl, _("Disk detached successfully\n"));
+ vshPrint(ctl, "%s", _("Disk detached successfully\n"));
ret = TRUE;
}
if (STRNEQ (doc, doc_reread)) {
vshError (ctl, FALSE,
- _("ERROR: the XML configuration was changed by another user"));
+ "%s", _("ERROR: the XML configuration was changed by another user"));
goto cleanup;
}
s = socket(priv->type, SOCK_STREAM, 0);
if (s == -1) {
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("failed to create a socket"));
+ "%s", _("failed to create a socket"));
return -1;
}
*/
if (getuid() == 0) {
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("failed to connect to xend"));
+ "%s", _("failed to connect to xend"));
}
}
if (len == -1) {
if (do_read)
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("failed to read from Xen Daemon"));
+ "%s", _("failed to read from Xen Daemon"));
else
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("failed to read from Xen Daemon"));
+ "%s", _("failed to read from Xen Daemon"));
return (-1);
}
}
if (virBufferError(&buf)) {
- virXendError(NULL, VIR_ERR_NO_MEMORY, _("allocate buffer"));
+ virXendError(NULL, VIR_ERR_NO_MEMORY, "%s", _("allocate buffer"));
return -1;
}
size_t i;
if (VIR_ALLOC_N(buffer, len * 3 + 1) < 0) {
- virXendError(NULL, VIR_ERR_NO_MEMORY, _("allocate new buffer"));
+ virXendError(NULL, VIR_ERR_NO_MEMORY, "%s", _("allocate new buffer"));
return (NULL);
}
ptr = buffer;
if (ptr == NULL) {
/* this should be caught at the interface but ... */
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("failed to urlencode the create S-Expr"));
+ "%s", _("failed to urlencode the create S-Expr"));
return (-1);
}
value = sexpr_node(root, "domain/domid");
if (value == NULL) {
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing domid"));
+ "%s", _("domain information incomplete, missing domid"));
goto error;
}
ret = strtol(value, NULL, 0);
if ((ret == 0) && (value[0] != '0')) {
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("domain information incorrect domid not numeric"));
+ "%s", _("domain information incorrect domid not numeric"));
ret = -1;
} else if (uuid != NULL) {
if (sexpr_uuid(uuid, root, "domain/uuid") < 0) {
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing uuid"));
+ "%s", _("domain information incomplete, missing uuid"));
}
}
name = sexpr_node(root, "domain/name");
if (name == NULL) {
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing name"));
+ "%s", _("domain information incomplete, missing name"));
goto error;
}
if (domname)
if (sexpr_uuid(uuid, root, "domain/uuid") < 0) {
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing uuid"));
+ "%s", _("domain information incomplete, missing uuid"));
goto error;
}
if (def->os.loader == NULL) {
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing HVM loader"));
+ "%s", _("domain information incomplete, missing HVM loader"));
return(-1);
}
} else {
!def->os.kernel &&
!def->os.bootloader) {
virXendError(xend, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing kernel & bootloader"));
+ "%s", _("domain information incomplete, missing kernel & bootloader"));
return -1;
}
value += sizeof("unix:")-1;
} else {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Unknown char device type"));
+ "%s", _("Unknown char device type"));
return -1;
}
if (offset == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("malformed char device string"));
+ "%s", _("malformed char device string"));
goto error;
}
if (offset == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("malformed char device string"));
+ "%s", _("malformed char device string"));
goto error;
}
offset3 = strchr(offset2, ':');
if (offset3 == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("malformed char device string"));
+ "%s", _("malformed char device string"));
goto error;
}
if (ret == -1) {
no_memory:
virXendError(conn, VIR_ERR_NO_MEMORY,
- _("no memory for char device config"));
+ "%s", _("no memory for char device config"));
}
error:
if (offset == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("malformed char device string"));
+ "%s", _("malformed char device string"));
goto error;
}
if (offset == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("malformed char device string"));
+ "%s", _("malformed char device string"));
goto error;
}
offset3 = strchr(offset2, ':');
if (offset3 == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("malformed char device string"));
+ "%s", _("malformed char device string"));
goto error;
}
if (dst == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, vbd has no dev"));
+ "%s", _("domain information incomplete, vbd has no dev"));
goto error;
}
!hvm ||
STRNEQ(offset, ":cdrom")) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, vbd has no src"));
+ "%s", _("domain information incomplete, vbd has no src"));
goto error;
}
}
offset = strchr(src, ':');
if (!offset) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("cannot parse vbd filename, missing driver name"));
+ "%s", _("cannot parse vbd filename, missing driver name"));
goto error;
}
offset = strchr(src, ':');
if (!offset) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("cannot parse vbd filename, missing driver type"));
+ "%s", _("cannot parse vbd filename, missing driver type"));
goto error;
}
tmp = sexpr_node(root, "domain/domid");
if (tmp == NULL && xendConfigVersion < 3) { /* Old XenD, domid was mandatory */
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing id"));
+ "%s", _("domain information incomplete, missing id"));
goto error;
}
def->virtType = VIR_DOMAIN_VIRT_XEN;
goto no_memory;
if (def->name == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing name"));
+ "%s", _("domain information incomplete, missing name"));
goto error;
}
tmp = sexpr_node(root, "domain/uuid");
if (tmp == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing name"));
+ "%s", _("domain information incomplete, missing name"));
goto error;
}
virUUIDParse(tmp, def->uuid);
nodeToCpu = sexpr_node(root, "node/node_to_cpu");
if (nodeToCpu == NULL) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("failed to parse topology information"));
+ "%s", _("failed to parse topology information"));
return -1;
}
return (0);
parse_error:
- virXendError(conn, VIR_ERR_XEN_CALL, _("topology syntax error"));
+ virXendError(conn, VIR_ERR_XEN_CALL, "%s", _("topology syntax error"));
error:
VIR_FREE(cpuNums);
VIR_FREE(cpuset);
memory_error:
VIR_FREE(cpuNums);
VIR_FREE(cpuset);
- virXendError(conn, VIR_ERR_NO_MEMORY, _("allocate buffer"));
+ virXendError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocate buffer"));
return (-1);
}
error:
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("failed to parse Xend domain information"));
+ "%s", _("failed to parse Xend domain information"));
if (ret != NULL)
virUnrefDomain(ret);
return(NULL);
root = sexpr_get(conn, "/xend/domain/%d?detail=1", domid);
if (root == NULL) {
virXendError (conn, VIR_ERR_XEN_CALL,
- _("xenDaemonDomainFetch failed to"
+ "%s", _("xenDaemonDomainFetch failed to"
" find this domain"));
return (NULL);
}
root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
if (root == NULL) {
virXendError (domain->conn, VIR_ERR_XEN_CALL,
- _("xenDaemonGetAutostart failed to find this domain"));
+ "%s", _("xenDaemonGetAutostart failed to find this domain"));
return (-1);
}
root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name);
if (root == NULL) {
virXendError (domain->conn, VIR_ERR_XEN_CALL,
- _("xenDaemonSetAutostart failed to find this domain"));
+ "%s", _("xenDaemonSetAutostart failed to find this domain"));
return (-1);
}
if (autostr) {
if (!STREQ(autostr, "ignore") && !STREQ(autostr, "start")) {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("unexpected value from on_xend_start"));
+ "%s", _("unexpected value from on_xend_start"));
goto error;
}
: strdup("ignore"));
if (!(autonode->u.s.car->u.value)) {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("no memory"));
+ "%s", _("no memory"));
goto error;
}
if (sexpr2string(root, buf, sizeof(buf)) == 0) {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("sexpr2string failed"));
+ "%s", _("sexpr2string failed"));
goto error;
}
if (xend_op(domain->conn, "", "op", "new", "config", buf, NULL) != 0) {
virXendError(domain->conn, VIR_ERR_XEN_CALL,
- _("Failed to redefine sexpr"));
+ "%s", _("Failed to redefine sexpr"));
goto error;
}
} else {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("on_xend_start not present in sexpr"));
+ "%s", _("on_xend_start not present in sexpr"));
goto error;
}
/* Xen doesn't support renaming domains during migration. */
if (dname) {
virXendError (conn, VIR_ERR_NO_SUPPORT,
- _("xenDaemonDomainMigrate: Xen does not support"
+ "%s", _("xenDaemonDomainMigrate: Xen does not support"
" renaming domains during migration"));
return -1;
}
*/
if (bandwidth) {
virXendError (conn, VIR_ERR_NO_SUPPORT,
- _("xenDaemonDomainMigrate: Xen does not support"
+ "%s", _("xenDaemonDomainMigrate: Xen does not support"
" bandwidth limits during migration"));
return -1;
}
}
if (flags != 0) {
virXendError (conn, VIR_ERR_NO_SUPPORT,
- _("xenDaemonDomainMigrate: unsupported flag"));
+ "%s", _("xenDaemonDomainMigrate: unsupported flag"));
return -1;
}
xmlURIPtr uriptr = xmlParseURI (uri);
if (!uriptr) {
virXendError (conn, VIR_ERR_INVALID_ARG,
- _("xenDaemonDomainMigrate: invalid URI"));
+ "%s", _("xenDaemonDomainMigrate: invalid URI"));
return -1;
}
if (uriptr->scheme && STRCASENEQ (uriptr->scheme, "xenmigr")) {
virXendError (conn, VIR_ERR_INVALID_ARG,
- _("xenDaemonDomainMigrate: only xenmigr://"
+ "%s", _("xenDaemonDomainMigrate: only xenmigr://"
" migrations are supported by Xen"));
xmlFreeURI (uriptr);
return -1;
}
if (!uriptr->server) {
virXendError (conn, VIR_ERR_INVALID_ARG,
- _("xenDaemonDomainMigrate: a hostname must be"
+ "%s", _("xenDaemonDomainMigrate: a hostname must be"
" specified in the URI"));
xmlFreeURI (uriptr);
return -1;
}
hostname = strdup (uriptr->server);
if (!hostname) {
- virXendError (conn, VIR_ERR_NO_MEMORY, _("strdup failed"));
+ virXendError (conn, VIR_ERR_NO_MEMORY, "%s", _("strdup failed"));
xmlFreeURI (uriptr);
return -1;
}
if (sscanf (p+1, "%d", &port_nr) != 1) {
virXendError (conn, VIR_ERR_INVALID_ARG,
- _("xenDaemonDomainMigrate: invalid port number"));
+ "%s", _("xenDaemonDomainMigrate: invalid port number"));
return -1;
}
snprintf (port, sizeof port, "%d", port_nr);
n = p - uri; /* n = Length of hostname in bytes. */
hostname = strdup (uri);
if (!hostname) {
- virXendError (conn, VIR_ERR_NO_MEMORY, _("strdup failed"));
+ virXendError (conn, VIR_ERR_NO_MEMORY, "%s", _("strdup failed"));
return -1;
}
hostname[n] = '\0';
else { /* "hostname" (or IP address) */
hostname = strdup (uri);
if (!hostname) {
- virXendError (conn, VIR_ERR_NO_MEMORY, _("strdup failed"));
+ virXendError (conn, VIR_ERR_NO_MEMORY, "%s", _("strdup failed"));
return -1;
}
}
if (!(def = virDomainDefParseString(conn, priv->caps, xmlDesc))) {
virXendError(conn, VIR_ERR_XML_ERROR,
- _("failed to parse domain description"));
+ "%s", _("failed to parse domain description"));
return (NULL);
}
if (!(sexpr = xenDaemonFormatSxpr(conn, def, priv->xendConfigVersion))) {
virXendError(conn, VIR_ERR_XML_ERROR,
- _("failed to build sexpr"));
+ "%s", _("failed to build sexpr"));
goto error;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xendConfigVersion < 4) {
virXendError (domain->conn, VIR_ERR_NO_SUPPORT,
- _("unsupported in xendConfigVersion < 4"));
+ "%s", _("unsupported in xendConfigVersion < 4"));
return NULL;
}
ret = sexpr_node(root, "node/xen_scheduler");
if (ret == NULL){
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("node information incomplete, missing scheduler name"));
+ "%s", _("node information incomplete, missing scheduler name"));
goto error;
}
if (STREQ (ret, "credit")) {
schedulertype = strdup("credit");
if (schedulertype == NULL){
- virXendError(domain->conn, VIR_ERR_SYSTEM_ERROR, _("strdup failed"));
+ virXendError(domain->conn, VIR_ERR_SYSTEM_ERROR, "%s", _("strdup failed"));
goto error;
}
*nparams = XEN_SCHED_CRED_NPARAM;
} else if (STREQ (ret, "sedf")) {
schedulertype = strdup("sedf");
if (schedulertype == NULL){
- virXendError(domain->conn, VIR_ERR_SYSTEM_ERROR, _("strdup failed"));
+ virXendError(domain->conn, VIR_ERR_SYSTEM_ERROR, "%s", _("strdup failed"));
goto error;
}
*nparams = XEN_SCHED_SEDF_NPARAM;
} else {
- virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR, _("Unknown scheduler"));
+ virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR, "%s", _("Unknown scheduler"));
goto error;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xendConfigVersion < 4) {
virXendError (domain->conn, VIR_ERR_NO_SUPPORT,
- _("unsupported in xendConfigVersion < 4"));
+ "%s", _("unsupported in xendConfigVersion < 4"));
return (-1);
}
sched_type = xenDaemonGetSchedulerType(domain, &sched_nparam);
if (sched_type == NULL) {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("Failed to get a scheduler name"));
+ "%s", _("Failed to get a scheduler name"));
goto error;
}
/* get cpu_weight/cpu_cap from xend/domain */
if (sexpr_node(root, "domain/cpu_weight") == NULL) {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing cpu_weight"));
+ "%s", _("domain information incomplete, missing cpu_weight"));
goto error;
}
if (sexpr_node(root, "domain/cpu_cap") == NULL) {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing cpu_cap"));
+ "%s", _("domain information incomplete, missing cpu_cap"));
goto error;
}
ret = 0;
break;
default:
- virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR, _("Unknown scheduler"));
+ virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR, "%s", _("Unknown scheduler"));
goto error;
}
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
if (priv->xendConfigVersion < 4) {
virXendError (domain->conn, VIR_ERR_NO_SUPPORT,
- _("unsupported in xendConfigVersion < 4"));
+ "%s", _("unsupported in xendConfigVersion < 4"));
return (-1);
}
sched_type = xenDaemonGetSchedulerType(domain, &sched_nparam);
if (sched_type == NULL) {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("Failed to get a scheduler name"));
+ "%s", _("Failed to get a scheduler name"));
goto error;
}
weight = sexpr_node(root, "domain/cpu_weight");
if (weight == NULL) {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing cpu_weight"));
+ "%s", _("domain information incomplete, missing cpu_weight"));
goto error;
}
snprintf(buf_weight, sizeof(buf_weight), "%s", weight);
cap = sexpr_node(root, "domain/cpu_cap");
if (cap == NULL) {
virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("domain information incomplete, missing cpu_cap"));
+ "%s", _("domain information incomplete, missing cpu_cap"));
goto error;
}
snprintf(buf_cap, sizeof(buf_cap), "%s", cap);
break;
}
default:
- virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR, _("Unknown scheduler"));
+ virXendError(domain->conn, VIR_ERR_INTERNAL_ERROR, "%s", _("Unknown scheduler"));
goto error;
}
else {
/* This call always fails for dom0. */
virXendError (domain->conn, VIR_ERR_NO_SUPPORT,
- _("domainBlockPeek is not supported for dom0"));
+ "%s", _("domainBlockPeek is not supported for dom0"));
return -1;
}
if (!type) {
virXendError(conn, VIR_ERR_INTERNAL_ERROR,
- _("unexpected chr device type"));
+ "%s", _("unexpected chr device type"));
return -1;
}
ref[ref_len - 1] = '\0';
} else {
virXendError(NULL, VIR_ERR_NO_SUPPORT,
- _("hotplug of device type not supported"));
+ "%s", _("hotplug of device type not supported"));
return -1;
}
virDomainDefFree(entry->def);
VIR_FREE(entry);
xenXMError (conn, VIR_ERR_INTERNAL_ERROR,
- _("xenXMConfigCacheRefresh: virHashAddEntry"));
+ "%s", _("xenXMConfigCacheRefresh: virHashAddEntry"));
goto cleanup;
}
}
}
if (domain->conn->flags & VIR_CONNECT_RO) {
xenXMError (domain->conn, VIR_ERR_INVALID_ARG,
- _("read only connection"));
+ "%s", _("read only connection"));
return -1;
}
if (domain->id != -1) {
xenXMError (domain->conn, VIR_ERR_INVALID_ARG,
- _("not inactive domain"));
+ "%s", _("not inactive domain"));
return -1;
}
if (!(filename = virHashLookup(nameConfigMap, domain->name))) {
- xenXMError (domain->conn, VIR_ERR_INTERNAL_ERROR, _("virHashLookup"));
+ xenXMError (domain->conn, VIR_ERR_INTERNAL_ERROR, "%s", _("virHashLookup"));
return -1;
}
if (!(entry = virHashLookup(configCache, filename))) {
xenXMError (domain->conn, VIR_ERR_INTERNAL_ERROR,
- _("can't retrieve config file for domain"));
+ "%s", _("can't retrieve config file for domain"));
return -1;
}
}
if (virBufferError(&mapbuf)) {
- xenXMError(domain->conn, VIR_ERR_NO_MEMORY, _("allocate buffer"));
+ xenXMError(domain->conn, VIR_ERR_NO_MEMORY, "%s", _("allocate buffer"));
return -1;
}
mapstr = virBufferContentAndReset(&mapbuf);
if (VIR_ALLOC_N(cpuset, maxcpu) < 0) {
- xenXMError(domain->conn, VIR_ERR_NO_MEMORY, _("allocate buffer"));
+ xenXMError(domain->conn, VIR_ERR_NO_MEMORY, "%s", _("allocate buffer"));
goto cleanup;
}
if (virDomainCpuSetParse(domain->conn,
if (!(sexpr = xenDaemonFormatSxpr(domain->conn, entry->def, priv->xendConfigVersion))) {
xenXMError(domain->conn, VIR_ERR_XML_ERROR,
- _("failed to build sexpr"));
+ "%s", _("failed to build sexpr"));
return (-1);
}
if (!(oldfilename = (char *)virHashLookup(nameConfigMap, def->name))) {
xenXMError(conn, VIR_ERR_INTERNAL_ERROR,
- _("can't retrieve config filename for domain to overwrite"));
+ "%s", _("can't retrieve config filename for domain to overwrite"));
goto error;
}
if (!(entry = virHashLookup(configCache, oldfilename))) {
xenXMError(conn, VIR_ERR_INTERNAL_ERROR,
- _("can't retrieve config entry for domain to overwrite"));
+ "%s", _("can't retrieve config entry for domain to overwrite"));
goto error;
}
/* Remove the name -> filename mapping */
if (virHashRemoveEntry(nameConfigMap, def->name, NULL) < 0) {
xenXMError(conn, VIR_ERR_INTERNAL_ERROR,
- _("failed to remove old domain from config map"));
+ "%s", _("failed to remove old domain from config map"));
goto error;
}
/* Remove the config record itself */
if (virHashRemoveEntry(configCache, oldfilename, xenXMConfigFree) < 0) {
xenXMError(conn, VIR_ERR_INTERNAL_ERROR,
- _("failed to remove old domain from config map"));
+ "%s", _("failed to remove old domain from config map"));
goto error;
}
if ((strlen(configDir) + 1 + strlen(def->name) + 1) > PATH_MAX) {
xenXMError(conn, VIR_ERR_INTERNAL_ERROR,
- _("config file name is too long"));
+ "%s", _("config file name is too long"));
goto error;
}
goto error;
if (VIR_ALLOC(entry) < 0) {
- xenXMError(conn, VIR_ERR_NO_MEMORY, _("config"));
+ xenXMError(conn, VIR_ERR_NO_MEMORY, "%s", _("config"));
goto error;
}
if ((entry->refreshedAt = time(NULL)) == ((time_t)-1)) {
xenXMError(conn, VIR_ERR_INTERNAL_ERROR,
- _("unable to get current time"));
+ "%s", _("unable to get current time"));
goto error;
}
if (virHashAddEntry(configCache, filename, entry) < 0) {
xenXMError(conn, VIR_ERR_INTERNAL_ERROR,
- _("unable to store config file handle"));
+ "%s", _("unable to store config file handle"));
goto error;
}
if (virHashAddEntry(nameConfigMap, def->name, entry->filename) < 0) {
virHashRemoveEntry(configCache, filename, NULL);
xenXMError(conn, VIR_ERR_INTERNAL_ERROR,
- _("unable to store config file handle"));
+ "%s", _("unable to store config file handle"));
goto error;
}
default:
xenXMError(domain->conn, VIR_ERR_XML_ERROR,
- _("unknown device"));
+ "%s", _("unknown device"));
goto cleanup;
}
}
default:
xenXMError(domain->conn, VIR_ERR_XML_ERROR,
- _("unknown device"));
+ "%s", _("unknown device"));
goto cleanup;
}
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Invalid parameter to virXPathString()"));
+ "%s", _("Invalid parameter to virXPathString()"));
return (NULL);
}
relnode = ctxt->node;
ret = strdup((char *) obj->stringval);
xmlXPathFreeObject(obj);
if (ret == NULL) {
- virXMLError(conn, VIR_ERR_NO_MEMORY, _("strdup failed"));
+ virXMLError(conn, VIR_ERR_NO_MEMORY, "%s", _("strdup failed"));
}
ctxt->node = relnode;
return (ret);
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Invalid parameter to virXPathNumber()"));
+ "%s", _("Invalid parameter to virXPathNumber()"));
return (-1);
}
relnode = ctxt->node;
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Invalid parameter to virXPathNumber()"));
+ "%s", _("Invalid parameter to virXPathNumber()"));
return (-1);
}
relnode = ctxt->node;
if ((ctxt == NULL) || (xpath == NULL) || (value == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Invalid parameter to virXPathNumber()"));
+ "%s", _("Invalid parameter to virXPathNumber()"));
return (-1);
}
relnode = ctxt->node;
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Invalid parameter to virXPathBoolean()"));
+ "%s", _("Invalid parameter to virXPathBoolean()"));
return (-1);
}
relnode = ctxt->node;
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Invalid parameter to virXPathNode()"));
+ "%s", _("Invalid parameter to virXPathNode()"));
return (NULL);
}
relnode = ctxt->node;
if ((ctxt == NULL) || (xpath == NULL)) {
virXMLError(conn, VIR_ERR_INTERNAL_ERROR,
- _("Invalid parameter to virXPathNodeSet()"));
+ "%s", _("Invalid parameter to virXPathNodeSet()"));
return (-1);
}
*/
if (getuid() == 0) {
virXenStoreError(NULL, VIR_ERR_NO_XEN,
- _("failed to connect to Xen Store"));
+ "%s", _("failed to connect to Xen Store"));
}
return (-1);
}
projects / people / liuw / libxenctrl-split / libvirt.git / commitdiff