/** * virGetSecret: * @conn: the hypervisor connection * @uuid: secret UUID * * Lookup if the secret is already registered for that connection, if so return * a pointer to it, otherwise allocate a new structure, and register it in the * table. In any case a corresponding call to virObjectUnref() is needed to not * leak data. * * Returns a pointer to the secret, or NULL in case of failure */ virSecretPtr virGetSecret(virConnectPtr conn, const unsigned char *uuid, int usageType, const char *usageID) { virSecretPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(uuid, NULL); virCheckNonNullArgReturn(usageID, NULL); if (!(ret = virObjectNew(virSecretClass))) return NULL; memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); ret->usageType = usageType; if (VIR_STRDUP(ret->usageID, usageID) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetInterface: * @conn: the hypervisor connection * @name: pointer to the interface name * @mac: pointer to the mac * * Lookup if the interface is already registered for that connection, * if yes return a new pointer to it (possibly updating the MAC * address), if no allocate a new structure, and register it in the * table. In any case a corresponding call to virObjectUnref() is * needed to not leak data. * * Returns a pointer to the interface, or NULL in case of failure */ virInterfacePtr virGetInterface(virConnectPtr conn, const char *name, const char *mac) { virInterfacePtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); /* a NULL mac from caller is okay. Treat it as blank */ if (mac == NULL) mac = ""; if (!(ret = virObjectNew(virInterfaceClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0 || VIR_STRDUP(ret->mac, mac) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetNWFilter: * @conn: the hypervisor connection * @name: pointer to the network filter pool name * @uuid: pointer to the uuid * * Allocates a new network filter object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the network filter object, or NULL on error. */ virNWFilterPtr virGetNWFilter(virConnectPtr conn, const char *name, const unsigned char *uuid) { virNWFilterPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; virCheckConnectGoto(conn, error); virCheckNonNullArgGoto(name, error); virCheckNonNullArgGoto(uuid, error); if (!(ret = virObjectNew(virNWFilterClass))) goto error; if (VIR_STRDUP(ret->name, name) < 0) goto error; memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetNWFilterBinding: * @conn: the hypervisor connection * @portdev: pointer to the network filter port device name * @filtername: name of the network filter * * Allocates a new network filter binding object. When the object is no longer * needed, virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the network filter binding object, or NULL on error. */ virNWFilterBindingPtr virGetNWFilterBinding(virConnectPtr conn, const char *portdev, const char *filtername) { virNWFilterBindingPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; virCheckConnectGoto(conn, error); virCheckNonNullArgGoto(portdev, error); if (!(ret = virObjectNew(virNWFilterBindingClass))) goto error; if (VIR_STRDUP(ret->portdev, portdev) < 0) goto error; if (VIR_STRDUP(ret->filtername, filtername) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetNWFilter: * @conn: the hypervisor connection * @name: pointer to the network filter pool name * @uuid: pointer to the uuid * * Lookup if the network filter is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virObjectUnref() is needed to not leak data. * * Returns a pointer to the network, or NULL in case of failure */ virNWFilterPtr virGetNWFilter(virConnectPtr conn, const char *name, const unsigned char *uuid) { virNWFilterPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); virCheckNonNullArgReturn(uuid, NULL); if (!(ret = virObjectNew(virNWFilterClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0) goto error; memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetSecret: * @conn: the hypervisor connection * @uuid: secret UUID * * Allocates a new secret object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the secret object, or NULL on error. */ virSecretPtr virGetSecret(virConnectPtr conn, const unsigned char *uuid, int usageType, const char *usageID) { virSecretPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; virCheckConnectGoto(conn, error); virCheckNonNullArgGoto(uuid, error); if (!(ret = virObjectNew(virSecretClass))) return NULL; memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); ret->usageType = usageType; if (VIR_STRDUP(ret->usageID, usageID ? usageID : "") < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetStoragePool: * @conn: the hypervisor connection * @name: pointer to the storage pool name * @uuid: pointer to the uuid * @privateData: pointer to driver specific private data * @freeFunc: private data cleanup function pointer specific to driver * * Allocates a new storage pool object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the storage pool object, or NULL on error. */ virStoragePoolPtr virGetStoragePool(virConnectPtr conn, const char *name, const unsigned char *uuid, void *privateData, virFreeCallback freeFunc) { virStoragePoolPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; virCheckConnectGoto(conn, error); virCheckNonNullArgGoto(name, error); virCheckNonNullArgGoto(uuid, error); if (!(ret = virObjectNew(virStoragePoolClass))) goto error; if (VIR_STRDUP(ret->name, name) < 0) goto error; ret->conn = virObjectRef(conn); memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); /* set the driver specific data */ ret->privateData = privateData; ret->privateDataFreeFunc = freeFunc; return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetStorageVol: * @conn: the hypervisor connection * @pool: pool owning the volume * @name: pointer to the storage vol name * @key: pointer to unique key of the volume * @privateData: pointer to driver specific private data * @freeFunc: private data cleanup function pointer specific to driver * * Allocates a new storage volume object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the storage volume object, or NULL on error. */ virStorageVolPtr virGetStorageVol(virConnectPtr conn, const char *pool, const char *name, const char *key, void *privateData, virFreeCallback freeFunc) { virStorageVolPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; virCheckConnectGoto(conn, error); virCheckNonNullArgGoto(pool, error); virCheckNonNullArgGoto(name, error); virCheckNonNullArgGoto(key, error); if (!(ret = virObjectNew(virStorageVolClass))) goto error; if (VIR_STRDUP(ret->pool, pool) < 0 || VIR_STRDUP(ret->name, name) < 0 || VIR_STRDUP(ret->key, key) < 0) goto error; ret->conn = virObjectRef(conn); /* set driver specific data */ ret->privateData = privateData; ret->privateDataFreeFunc = freeFunc; return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetInterface: * @conn: the hypervisor connection * @name: pointer to the interface name * @mac: pointer to the mac * * Allocates a new interface object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the interface object, or NULL on error. */ virInterfacePtr virGetInterface(virConnectPtr conn, const char *name, const char *mac) { virInterfacePtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; virCheckConnectGoto(conn, error); virCheckNonNullArgGoto(name, error); /* a NULL mac from caller is okay. Treat it as blank */ if (mac == NULL) mac = ""; if (!(ret = virObjectNew(virInterfaceClass))) goto error; if (VIR_STRDUP(ret->name, name) < 0 || VIR_STRDUP(ret->mac, mac) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetNodeDevice: * @conn: the hypervisor connection * @name: device name (unique on node) * * Lookup if the device is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virObjectUnref() is needed to not leak data. * * Returns a pointer to the node device, or NULL in case of failure */ virNodeDevicePtr virGetNodeDevice(virConnectPtr conn, const char *name) { virNodeDevicePtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); if (!(ret = virObjectNew(virNodeDeviceClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
virDomainSnapshotPtr virGetDomainSnapshot(virDomainPtr domain, const char *name) { virDomainSnapshotPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_DOMAIN(domain)) { virLibConnError(VIR_ERR_INVALID_DOMAIN, "%s", _("bad domain")); return NULL; } virCheckNonNullArgReturn(name, NULL); if (!(ret = virObjectNew(virDomainSnapshotClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0) goto cleanup; ret->domain = virObjectRef(domain); return ret; cleanup: virObjectUnref(ret); return NULL; }
virConnectCloseCallbackDataPtr virNewConnectCloseCallbackData(void) { if (virDataTypesInitialize() < 0) return NULL; return virObjectLockableNew(virConnectCloseCallbackDataClass); }
/** * virGetConnect: * * Allocates a new hypervisor connection object. * * Returns a pointer to the connection object, or NULL on error. */ virConnectPtr virGetConnect(void) { if (virDataTypesInitialize() < 0) return NULL; return virObjectLockableNew(virConnectClass); }
virStreamPtr virGetStream(virConnectPtr conn) { virStreamPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!(ret = virObjectNew(virStreamClass))) return NULL; ret->conn = virObjectRef(conn); return ret; }
virAdmConnectPtr virAdmConnectNew(void) { virAdmConnectPtr ret; if (virDataTypesInitialize() < 0) return NULL; if (!(ret = virObjectLockableNew(virAdmConnectClass))) return NULL; if (!(ret->closeCallback = virObjectLockableNew(virAdmConnectCloseCallbackDataClass))) goto error; return ret; error: virObjectUnref(ret); return NULL; }
virAdmServerPtr virAdmGetServer(virAdmConnectPtr conn, const char *name) { virAdmServerPtr ret = NULL; if (virDataTypesInitialize() < 0) goto error; if (!(ret = virObjectNew(virAdmServerClass))) goto error; if (VIR_STRDUP(ret->name, name) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
virAdmClientPtr virAdmGetClient(virAdmServerPtr srv, const unsigned long long id, unsigned long long timestamp, unsigned int transport) { virAdmClientPtr ret = NULL; if (virDataTypesInitialize() < 0) goto error; if (!(ret = virObjectNew(virAdmClientClass))) goto error; ret->id = id; ret->timestamp = timestamp; ret->transport = transport; ret->srv = virObjectRef(srv); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetConnect: * * Allocates a new hypervisor connection structure * * Returns a new pointer or NULL in case of error. */ virConnectPtr virGetConnect(void) { virConnectPtr ret; if (virDataTypesInitialize() < 0) return NULL; if (!(ret = virObjectNew(virConnectClass))) return NULL; if (!(ret->closeCallback = virObjectNew(virConnectCloseCallbackDataClass))) goto error; if (virMutexInit(&ret->lock) < 0) goto error; return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetStorageVol: * @conn: the hypervisor connection * @pool: pool owning the volume * @name: pointer to the storage vol name * @key: pointer to unique key of the volume * @privateData: pointer to driver specific private data * @freeFunc: private data cleanup function pointer specfic to driver * * Lookup if the storage vol is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virObjectUnref() is needed to not leak data. * * Returns a pointer to the storage vol, or NULL in case of failure */ virStorageVolPtr virGetStorageVol(virConnectPtr conn, const char *pool, const char *name, const char *key, void *privateData, virFreeCallback freeFunc) { virStorageVolPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(pool, NULL); virCheckNonNullArgReturn(name, NULL); virCheckNonNullArgReturn(key, NULL); if (!(ret = virObjectNew(virStorageVolClass))) return NULL; if (VIR_STRDUP(ret->pool, pool) < 0 || VIR_STRDUP(ret->name, name) < 0 || VIR_STRDUP(ret->key, key) < 0) goto error; ret->conn = virObjectRef(conn); /* set driver specific data */ ret->privateData = privateData; ret->privateDataFreeFunc = freeFunc; return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetDomainSnapshot: * @domain: the domain to snapshot * @name: pointer to the domain snapshot name * * Allocates a new domain snapshot object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the domain snapshot object, or NULL on error. */ virDomainSnapshotPtr virGetDomainSnapshot(virDomainPtr domain, const char *name) { virDomainSnapshotPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; virCheckDomainGoto(domain, error); virCheckNonNullArgGoto(name, error); if (!(ret = virObjectNew(virDomainSnapshotClass))) goto error; if (VIR_STRDUP(ret->name, name) < 0) goto error; ret->domain = virObjectRef(domain); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetNodeDevice: * @conn: the hypervisor connection * @name: device name (unique on node) * * Allocates a new node device object. When the object is no longer needed, * virObjectUnref() must be called in order to not leak data. * * Returns a pointer to the node device object, or NULL on error. */ virNodeDevicePtr virGetNodeDevice(virConnectPtr conn, const char *name) { virNodeDevicePtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; virCheckConnectGoto(conn, error); virCheckNonNullArgGoto(name, error); if (!(ret = virObjectNew(virNodeDeviceClass))) goto error; if (VIR_STRDUP(ret->name, name) < 0) goto error; ret->conn = virObjectRef(conn); return ret; error: virObjectUnref(ret); return NULL; }
/** * virGetStoragePool: * @conn: the hypervisor connection * @name: pointer to the storage pool name * @uuid: pointer to the uuid * @privateData: pointer to driver specific private data * @freeFunc: private data cleanup function pointer specfic to driver * * Lookup if the storage pool is already registered for that connection, * if yes return a new pointer to it, if no allocate a new structure, * and register it in the table. In any case a corresponding call to * virObjectUnref() is needed to not leak data. * * Returns a pointer to the storage pool, or NULL in case of failure */ virStoragePoolPtr virGetStoragePool(virConnectPtr conn, const char *name, const unsigned char *uuid, void *privateData, virFreeCallback freeFunc) { virStoragePoolPtr ret = NULL; if (virDataTypesInitialize() < 0) return NULL; if (!VIR_IS_CONNECT(conn)) { virLibConnError(VIR_ERR_INVALID_CONN, "%s", _("no connection")); return NULL; } virCheckNonNullArgReturn(name, NULL); virCheckNonNullArgReturn(uuid, NULL); if (!(ret = virObjectNew(virStoragePoolClass))) return NULL; if (VIR_STRDUP(ret->name, name) < 0) goto error; ret->conn = virObjectRef(conn); memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); /* set the driver specific data */ ret->privateData = privateData; ret->privateDataFreeFunc = freeFunc; return ret; error: virObjectUnref(ret); return NULL; }