Adds the virNetwork API and hooks up the API to driver methods. The API closely mirrors the domains API with the following exceptions: - Networks don't have IDs - only names and UUIDs - There is no virNetworkCreateFlags We use a seperate driver vtable for the networks support and require at least one network driver. Signed-off-by: Mark McLoughlin Index: libvirt/include/libvirt/libvirt.h.in =================================================================== --- libvirt.orig/include/libvirt/libvirt.h.in +++ libvirt/include/libvirt/libvirt.h.in @@ -443,6 +443,90 @@ int virDomainGetVcpus (virDomainPtr do int virDomainAttachDevice(virDomainPtr domain, char *xml); int virDomainDetachDevice(virDomainPtr domain, char *xml); +/* + * Virtual Networks API + */ + +/** + * virNetwork: + * + * a virNetwork is a private structure representing a virtual network. + */ +typedef struct _virNetwork virNetwork; + +/** + * virNetworkPtr: + * + * a virNetworkPtr is pointer to a virNetwork private structure, this is the + * type used to reference a virtual network in the API. + */ +typedef virNetwork *virNetworkPtr; + +/* + * List active networks + */ +int virConnectNumOfNetworks (virConnectPtr conn); +int virConnectListNetworks (virConnectPtr conn, + const char **names, + int maxnames); + +/* + * List inactive networks + */ +int virConnectNumOfDefinedNetworks (virConnectPtr conn); +int virConnectListDefinedNetworks (virConnectPtr conn, + const char **names, + int maxnames); + +/* + * Lookup network by name or uuid + */ +virNetworkPtr virNetworkLookupByName (virConnectPtr conn, + const char *name); +virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn, + const unsigned char *uuid); +virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn, + const char *uuid); + +/* + * Create active transient network + */ +virNetworkPtr virNetworkCreateXML (virConnectPtr conn, + const char *xmlDesc); + +/* + * Define inactive persistent network + */ +virNetworkPtr virNetworkDefineXML (virConnectPtr conn, + const char *xmlDesc); + +/* + * Delete persistent network + */ +int virNetworkUndefine (virNetworkPtr network); + +/* + * Activate persistent network + */ +int virNetworkCreate (virNetworkPtr network); + +/* + * Network destroy/free + */ +int virNetworkDestroy (virNetworkPtr network); +int virNetworkFree (virNetworkPtr network); + +/* + * Network informations + */ +const char* virNetworkGetName (virNetworkPtr network); +int virNetworkGetUUID (virNetworkPtr network, + unsigned char *uuid); +int virNetworkGetUUIDString (virNetworkPtr network, + char *buf); +char * virNetworkGetXMLDesc (virNetworkPtr network, + int flags); + #ifdef __cplusplus } #endif Index: libvirt/include/libvirt/virterror.h =================================================================== --- libvirt.orig/include/libvirt/virterror.h +++ libvirt/include/libvirt/virterror.h @@ -48,6 +48,7 @@ typedef enum { VIR_FROM_PROXY, /* Error in the proxy code */ VIR_FROM_CONF, /* Error in the configuration file handling */ VIR_FROM_QEMU, /* Error at the QEMU daemon */ + VIR_FROM_NET, /* Error when operating on a network */ } virErrorDomain; @@ -114,7 +115,9 @@ typedef enum { VIR_ERR_PARSE_FAILED, /* failed to parse a conf file */ VIR_ERR_CONF_SYNTAX, /* failed to parse the syntax of a conf file */ VIR_ERR_WRITE_FAILED, /* failed to write a conf file */ - VIR_ERR_XML_DETAIL /* detail of an XML error */ + VIR_ERR_XML_DETAIL, /* detail of an XML error */ + VIR_ERR_INVALID_NETWORK, /* invalid network object */ + VIR_ERR_NETWORK_EXIST, /* the network already exist */ } virErrorNumber; /** Index: libvirt/src/driver.h =================================================================== --- libvirt.orig/src/driver.h +++ libvirt/src/driver.h @@ -188,6 +188,65 @@ struct _virDriver { virDrvDomainDetachDevice domainDetachDevice; }; +typedef int + (*virDrvNumOfNetworks) (virConnectPtr conn); +typedef int + (*virDrvListNetworks) (virConnectPtr conn, + const char **names, + int maxnames); +typedef int + (*virDrvNumOfDefinedNetworks) (virConnectPtr conn); +typedef int + (*virDrvListDefinedNetworks) (virConnectPtr conn, + const char **names, + int maxnames); +typedef virNetworkPtr + (*virDrvNetworkLookupByUUID) (virConnectPtr conn, + const unsigned char *uuid); +typedef virNetworkPtr + (*virDrvNetworkLookupByName) (virConnectPtr conn, + const char *name); +typedef virNetworkPtr + (*virDrvNetworkCreateXML) (virConnectPtr conn, + const char *xmlDesc); +typedef virNetworkPtr + (*virDrvNetworkDefineXML) (virConnectPtr conn, const char *xml); +typedef int + (*virDrvNetworkUndefine) (virNetworkPtr network); +typedef int + (*virDrvNetworkCreate) (virNetworkPtr network); +typedef int + (*virDrvNetworkDestroy) (virNetworkPtr network); +typedef char * + (*virDrvNetworkDumpXML) (virNetworkPtr network, + int flags); + +typedef struct _virNetworkDriver virNetworkDriver; +typedef virNetworkDriver *virNetworkDriverPtr; + +/** + * _virNetworkDriver: + * + * Structure associated to a network virtualization driver, defining the various + * entry points for it. + */ +struct _virNetworkDriver { + virDrvOpen open; + virDrvClose close; + virDrvNumOfNetworks numOfNetworks; + virDrvListNetworks listNetworks; + virDrvNumOfDefinedNetworks numOfDefinedNetworks; + virDrvListDefinedNetworks listDefinedNetworks; + virDrvNetworkLookupByUUID networkLookupByUUID; + virDrvNetworkLookupByName networkLookupByName; + virDrvNetworkCreateXML networkCreateXML; + virDrvNetworkDefineXML networkDefineXML; + virDrvNetworkUndefine networkUndefine; + virDrvNetworkCreate networkCreate; + virDrvNetworkDestroy networkDestroy; + virDrvNetworkDumpXML networkDumpXML; +}; + /* * Registration @@ -195,6 +254,7 @@ struct _virDriver { * lookup based on the URI given in a virConnectOpen(ReadOnly) */ int virRegisterDriver(virDriverPtr); +int virRegisterNetworkDriver(virNetworkDriverPtr); #ifdef __cplusplus } Index: libvirt/src/hash.c =================================================================== --- libvirt.orig/src/hash.c +++ libvirt/src/hash.c @@ -637,6 +637,20 @@ virDomainFreeName(virDomainPtr domain, c } /** + * virNetworkFreeName: + * @network: a network object + * + * Destroy the network object, this is just used by the network hash callback. + * + * Returns 0 in case of success and -1 in case of failure. + */ +static int +virNetworkFreeName(virNetworkPtr network, const char *name ATTRIBUTE_UNUSED) +{ + return (virNetworkFree(network)); +} + +/** * virGetConnect: * * Allocates a new hypervisor connection structure @@ -660,6 +674,9 @@ virGetConnect(void) { ret->domains = virHashCreate(20); if (ret->domains == NULL) goto failed; + ret->networks = virHashCreate(20); + if (ret->networks == NULL) + goto failed; ret->hashes_mux = xmlNewMutex(); if (ret->hashes_mux == NULL) goto failed; @@ -671,6 +688,8 @@ failed: if (ret != NULL) { if (ret->domains != NULL) virHashFree(ret->domains, (virHashDeallocator) virDomainFreeName); + if (ret->networks != NULL) + virHashFree(ret->networks, (virHashDeallocator) virNetworkFreeName); if (ret->hashes_mux != NULL) xmlFreeMutex(ret->hashes_mux); free(ret); @@ -705,6 +724,8 @@ virFreeConnect(virConnectPtr conn) { if (conn->domains != NULL) virHashFree(conn->domains, (virHashDeallocator) virDomainFreeName); + if (conn->networks != NULL) + virHashFree(conn->networks, (virHashDeallocator) virNetworkFreeName); if (conn->hashes_mux != NULL) xmlFreeMutex(conn->hashes_mux); free(conn); @@ -893,6 +914,139 @@ done: xmlMutexUnlock(conn->hashes_mux); return(ret); } + +/** + * virGetNetwork: + * @conn: the hypervisor connection + * @name: pointer to the network name or NULL + * @uuid: pointer to the uuid or NULL + * + * Lookup if the network 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 + * virFreeNetwork() is needed to not leak data. + * + * Returns a pointer to the network, or NULL in case of failure + */ +virNetworkPtr +virGetNetwork(virConnectPtr conn, const char *name, const unsigned char *uuid) { + virNetworkPtr ret = NULL; + + if ((!VIR_IS_CONNECT(conn)) || ((name == NULL) && (uuid == NULL)) || + (conn->hashes_mux == NULL)) { + virHashError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return(NULL); + } + xmlMutexLock(conn->hashes_mux); + + /* TODO search by UUID first as they are better differenciators */ + + ret = (virNetworkPtr) virHashLookup(conn->networks, name); + if (ret != NULL) { + /* TODO check the UUID */ + goto done; + } + + /* + * not found, allocate a new one + */ + ret = (virNetworkPtr) malloc(sizeof(virNetwork)); + if (ret == NULL) { + virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating network")); + goto error; + } + memset(ret, 0, sizeof(virNetwork)); + ret->name = strdup(name); + if (ret->name == NULL) { + virHashError(conn, VIR_ERR_NO_MEMORY, _("allocating network")); + goto error; + } + ret->magic = VIR_NETWORK_MAGIC; + ret->conn = conn; + if (uuid != NULL) + memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN); + + if (virHashAddEntry(conn->networks, name, ret) < 0) { + virHashError(conn, VIR_ERR_INTERNAL_ERROR, + _("failed to add network to connection hash table")); + goto error; + } + conn->uses++; +done: + ret->uses++; + xmlMutexUnlock(conn->hashes_mux); + return(ret); + +error: + xmlMutexUnlock(conn->hashes_mux); + if (ret != NULL) { + if (ret->name != NULL) + free(ret->name ); + free(ret); + } + return(NULL); +} + +/** + * virFreeNetwork: + * @conn: the hypervisor connection + * @network: the network to release + * + * Release the given network, if the reference count drops to zero, then + * the network is really freed. + * + * Returns the reference count or -1 in case of failure. + */ +int +virFreeNetwork(virConnectPtr conn, virNetworkPtr network) { + int ret = 0; + + if ((!VIR_IS_CONNECT(conn)) || (!VIR_IS_CONNECTED_NETWORK(network)) || + (network->conn != conn) || (conn->hashes_mux == NULL)) { + virHashError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return(-1); + } + xmlMutexLock(conn->hashes_mux); + + /* + * decrement the count for the network + */ + network->uses--; + ret = network->uses; + if (ret > 0) + goto done; + + /* 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")); + goto done; + } + network->magic = -1; + if (network->name) + free(network->name); + free(network); + + /* + * decrement the count for the connection + */ + conn->uses--; + if (conn->uses > 0) + goto done; + + if (conn->networks != NULL) + virHashFree(conn->networks, (virHashDeallocator) virNetworkFreeName); + if (conn->hashes_mux != NULL) + xmlFreeMutex(conn->hashes_mux); + free(conn); + return(0); + +done: + xmlMutexUnlock(conn->hashes_mux); + return(ret); +} + /* * Local variables: * indent-tabs-mode: nil Index: libvirt/src/internal.h =================================================================== --- libvirt.orig/src/internal.h +++ libvirt/src/internal.h @@ -84,6 +84,16 @@ extern "C" { #define VIR_IS_DOMAIN(obj) ((obj) && (obj)->magic==VIR_DOMAIN_MAGIC) #define VIR_IS_CONNECTED_DOMAIN(obj) (VIR_IS_DOMAIN(obj) && VIR_IS_CONNECT((obj)->conn)) +/** + * VIR_NETWORK_MAGIC: + * + * magic value used to protect the API when pointers to network structures + * are passed down by the uers. + */ +#define VIR_NETWORK_MAGIC 0xDEAD1234 +#define VIR_IS_NETWORK(obj) ((obj) && (obj)->magic==VIR_NETWORK_MAGIC) +#define VIR_IS_CONNECTED_NETWORK(obj) (VIR_IS_NETWORK(obj) && VIR_IS_CONNECT((obj)->conn)) + #define MAX_DRIVERS 10 /* @@ -104,6 +114,10 @@ struct _virConnect { virDriverPtr drivers[MAX_DRIVERS]; int nb_drivers; + /* the list of available network drivers */ + virNetworkDriverPtr networkDrivers[MAX_DRIVERS]; + int nb_network_drivers; + /* extra data needed by drivers */ int handle; /* internal handle used for hypercall */ struct xs_handle *xshandle;/* handle to talk to the xenstore */ @@ -125,8 +139,9 @@ struct _virConnect { void *userData; /* the user data */ /* misc */ - xmlMutexPtr hashes_mux;/* a mutex to protect the domain hash table */ + xmlMutexPtr hashes_mux;/* a mutex to protect the domain and networks hash tables */ virHashTablePtr domains;/* hash table for known domains */ + virHashTablePtr networks;/* hash table for known domains */ int flags; /* a set of connection flags */ }; @@ -158,6 +173,19 @@ struct _virDomain { char *xml; /* the XML description for defined domains */ }; +/** +* _virNetwork: +* +* Internal structure associated to a domain +*/ +struct _virNetwork { + unsigned int magic; /* specific value to check */ + int uses; /* reference count */ + virConnectPtr conn; /* pointer back to the connection */ + char *name; /* the network external name */ + unsigned char uuid[VIR_UUID_BUFLEN]; /* the network unique identifier */ +}; + /* * Internal routines */ @@ -196,6 +224,11 @@ int virFreeDomain (virConnectPtr conn, virDomainPtr domain); virDomainPtr virGetDomainByID(virConnectPtr conn, int id); +virNetworkPtr virGetNetwork (virConnectPtr conn, + const char *name, + const unsigned char *uuid); +int virFreeNetwork (virConnectPtr conn, + virNetworkPtr domain); #ifdef __cplusplus } Index: libvirt/src/libvirt.c =================================================================== --- libvirt.orig/src/libvirt.c +++ libvirt/src/libvirt.c @@ -42,6 +42,7 @@ */ static virDriverPtr virDriverTab[MAX_DRIVERS]; +static virNetworkDriverPtr virNetworkDriverTab[MAX_DRIVERS]; static int initialized = 0; /** @@ -68,8 +69,10 @@ virInitialize(void) /* * should not be needed but... */ - for (i = 0;i < MAX_DRIVERS;i++) + for (i = 0;i < MAX_DRIVERS;i++) { virDriverTab[i] = NULL; + virNetworkDriverTab[i] = NULL; + } /* * Note that the order is important the first ones have a higher priority @@ -135,16 +138,36 @@ virLibDomainError(virDomainPtr domain, v } /** - * virRegisterDriver: - * @driver: pointer to a driver block - * - * Register a virtualization driver + * virLibNetworkError: + * @conn: the connection if available + * @error: the error noumber + * @info: extra information string * - * Returns the driver priority or -1 in case of error. + * Handle an error at the connection level */ -int -virRegisterDriver(virDriverPtr driver) +static void +virLibNetworkError(virNetworkPtr network, virErrorNumber error, + const char *info) +{ + virConnectPtr conn = NULL; + const char *errmsg; + + if (error == VIR_ERR_OK) + return; + + errmsg = __virErrorMsg(error, info); + if (error != VIR_ERR_INVALID_NETWORK) { + conn = network->conn; + } + /* XXX: should be able to pass network pointer here */ + __virRaiseError(conn, NULL, VIR_FROM_NET, error, VIR_ERR_ERROR, + errmsg, info, NULL, 0, 0, errmsg, info); +} + +static int +_virRegisterDriver(void *driver, int isNetwork) { + void **drivers; int i; if (!initialized) @@ -155,13 +178,14 @@ virRegisterDriver(virDriverPtr driver) virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__); return(-1); } + drivers = isNetwork ? (void **) virNetworkDriverTab : (void **) virDriverTab; for (i = 0;i < MAX_DRIVERS;i++) { - if (virDriverTab[i] == driver) + if (drivers[i] == driver) return(i); } for (i = 0;i < MAX_DRIVERS;i++) { - if (virDriverTab[i] == NULL) { - virDriverTab[i] = driver; + if (drivers[i] == NULL) { + drivers[i] = driver; return(i); } } @@ -170,6 +194,34 @@ virRegisterDriver(virDriverPtr driver) } /** + * virRegisterNetworkDriver: + * @driver: pointer to a network driver block + * + * Register a network virtualization driver + * + * Returns the driver priority or -1 in case of error. + */ +int +virRegisterNetworkDriver(virNetworkDriverPtr driver) +{ + return _virRegisterDriver(driver, 1); +} + +/** + * virRegisterDriver: + * @driver: pointer to a driver block + * + * Register a virtualization driver + * + * Returns the driver priority or -1 in case of error. + */ +int +virRegisterDriver(virDriverPtr driver) +{ + return _virRegisterDriver(driver, 0); +} + +/** * virGetVersion: * @libVer: return value for the library version (OUT) * @type: the type of connection/driver looked at @@ -265,7 +317,14 @@ virConnectOpen(const char *name) } } - if (ret->nb_drivers == 0) { + for (i = 0;i < MAX_DRIVERS;i++) { + if ((virNetworkDriverTab[i] != NULL) && (virNetworkDriverTab[i]->open != NULL) && + (res = virNetworkDriverTab[i]->open(ret, name, VIR_DRV_OPEN_QUIET)) == 0) { + ret->networkDrivers[ret->nb_network_drivers++] = virNetworkDriverTab[i]; + } + } + + if (ret->nb_drivers == 0 || ret->nb_network_drivers == 0) { /* we failed to find an adequate driver */ virLibConnError(NULL, VIR_ERR_NO_SUPPORT, name); goto failed; @@ -279,6 +338,10 @@ failed: if ((ret->drivers[i] != NULL) && (ret->drivers[i]->close != NULL)) ret->drivers[i]->close(ret); } + for (i = 0;i < ret->nb_network_drivers;i++) { + if ((ret->networkDrivers[i] != NULL) && (ret->networkDrivers[i]->close != NULL)) + ret->networkDrivers[i]->close(ret); + } virFreeConnect(ret); } return (NULL); @@ -321,6 +384,10 @@ virConnectOpenReadOnly(const char *name) ret->drivers[ret->nb_drivers++] = virDriverTab[i]; } + if ((virNetworkDriverTab[i] != NULL) && (virNetworkDriverTab[i]->open != NULL) && + (res = virNetworkDriverTab[i]->open(ret, name, VIR_DRV_OPEN_QUIET)) == 0) { + ret->networkDrivers[ret->nb_network_drivers++] = virNetworkDriverTab[i]; + } } if (ret->nb_drivers == 0) { if (name == NULL) @@ -341,6 +408,10 @@ failed: if ((ret->drivers[i] != NULL) && (ret->drivers[i]->close != NULL)) ret->drivers[i]->close(ret); } + for (i = 0;i < ret->nb_network_drivers;i++) { + if ((ret->networkDrivers[i] != NULL) && (ret->networkDrivers[i]->close != NULL)) + ret->networkDrivers[i]->close(ret); + } virFreeConnect(ret); } return (NULL); @@ -368,6 +439,10 @@ virConnectClose(virConnectPtr conn) if ((conn->drivers[i] != NULL) && (conn->drivers[i]->close != NULL)) conn->drivers[i]->close(conn); } + for (i = 0;i < conn->nb_network_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && (conn->networkDrivers[i]->close != NULL)) + conn->networkDrivers[i]->close(conn); + } if (virFreeConnect(conn) < 0) return (-1); return (0); @@ -2053,3 +2128,607 @@ virDomainDetachDevice(virDomainPtr domai virLibConnError(conn, VIR_ERR_CALL_FAILED, __FUNCTION__); return (-1); } + +/** + * virConnectNumOfNetworks: + * @conn: pointer to the hypervisor connection + * + * Provides the number of active networks. + * + * Returns the number of network found or -1 in case of error + */ +int +virConnectNumOfNetworks(virConnectPtr conn) +{ + int ret = -1; + int i; + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return (-1); + } + + /* Go though the driver registered entry points */ + for (i = 0;i < conn->nb_network_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->numOfNetworks != NULL)) { + ret = conn->networkDrivers[i]->numOfNetworks(conn); + if (ret >= 0) + return(ret); + } + } + + return(-1); +} + +/** + * virConnectListNetworks: + * @conn: pointer to the hypervisor connection + * @names: array to collect the list of names of active networks + * @maxnames: size of @names + * + * Collect the list of active networks, and store their names in @names + * + * Returns the number of networks found or -1 in case of error + */ +int +virConnectListNetworks(virConnectPtr conn, const char **names, int maxnames) +{ + int ret = -1; + int i; + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return (-1); + } + + if ((names == NULL) || (maxnames <= 0)) { + virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (-1); + } + + /* Go though the driver registered entry points */ + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->listNetworks != NULL)) { + ret = conn->networkDrivers[i]->listNetworks(conn, names, maxnames); + if (ret >= 0) + return(ret); + } + } + + return (-1); +} + +/** + * virConnectNumOfDefinedNetworks: + * @conn: pointer to the hypervisor connection + * + * Provides the number of inactive networks. + * + * Returns the number of networks found or -1 in case of error + */ +int +virConnectNumOfDefinedNetworks(virConnectPtr conn) +{ + int ret = -1; + int i; + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return (-1); + } + + /* Go though the driver registered entry points */ + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->numOfDefinedNetworks != NULL)) { + ret = conn->networkDrivers[i]->numOfDefinedNetworks(conn); + if (ret >= 0) + return(ret); + } + } + + return(-1); +} + +/** + * virConnectListDefinedNetworks: + * @conn: pointer to the hypervisor connection + * @names: pointer to an array to store the names + * @maxnames: size of the array + * + * list the inactive networks, stores the pointers to the names in @names + * + * Returns the number of names provided in the array or -1 in case of error + */ +int +virConnectListDefinedNetworks(virConnectPtr conn, const char **names, + int maxnames) { + int ret = -1; + int i; + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return (-1); + } + + if ((names == NULL) || (maxnames <= 0)) { + virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (-1); + } + + /* Go though the driver registered entry points */ + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->listDefinedNetworks != NULL)) { + ret = conn->networkDrivers[i]->listDefinedNetworks(conn, names, maxnames); + if (ret >= 0) + return(ret); + } + } + + return (-1); +} + +/** + * virNetworkLookupByName: + * @conn: pointer to the hypervisor connection + * @name: name for the network + * + * Try to lookup a network on the given hypervisor based on its name. + * + * Returns a new network object or NULL in case of failure + */ +virNetworkPtr +virNetworkLookupByName(virConnectPtr conn, const char *name) +{ + virNetworkPtr ret = NULL; + int i; + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return (NULL); + } + if (name == NULL) { + virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (NULL); + } + + /* Go though the driver registered entry points */ + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->networkLookupByName != NULL)) { + ret = conn->networkDrivers[i]->networkLookupByName(conn, name); + if (ret) + return(ret); + } + } + return (NULL); +} + +/** + * virNetworkLookupByUUID: + * @conn: pointer to the hypervisor connection + * @uuid: the raw UUID for the network + * + * Try to lookup a network on the given hypervisor based on its UUID. + * + * Returns a new network object or NULL in case of failure + */ +virNetworkPtr +virNetworkLookupByUUID(virConnectPtr conn, const unsigned char *uuid) +{ + virNetworkPtr ret; + int i; + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return (NULL); + } + if (uuid == NULL) { + virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (NULL); + } + + /* Go though the driver registered entry points */ + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->networkLookupByUUID != NULL)) { + ret = conn->networkDrivers[i]->networkLookupByUUID(conn, uuid); + if (ret) + return(ret); + } + } + + return (NULL); +} + +/** + * virNetworkLookupByUUIDString: + * @conn: pointer to the hypervisor connection + * @uuidstr: the string UUID for the network + * + * Try to lookup a network on the given hypervisor based on its UUID. + * + * Returns a new network object or NULL in case of failure + */ +virNetworkPtr +virNetworkLookupByUUIDString(virConnectPtr conn, const char *uuidstr) +{ + int raw[VIR_UUID_BUFLEN], i; + unsigned char uuid[VIR_UUID_BUFLEN]; + int ret; + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return (NULL); + } + if (uuidstr == NULL) { + virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (NULL); + } + + /* XXX: sexpr_uuid() also supports 'xxxx-xxxx-xxxx-xxxx' format. + * We needn't it here. Right? + */ + ret = sscanf(uuidstr, + "%02x%02x%02x%02x-" + "%02x%02x-" + "%02x%02x-" + "%02x%02x-" + "%02x%02x%02x%02x%02x%02x", + raw + 0, raw + 1, raw + 2, raw + 3, + raw + 4, raw + 5, raw + 6, raw + 7, + raw + 8, raw + 9, raw + 10, raw + 11, + raw + 12, raw + 13, raw + 14, raw + 15); + + if (ret!=VIR_UUID_BUFLEN) { + virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (NULL); + } + for (i = 0; i < VIR_UUID_BUFLEN; i++) + uuid[i] = raw[i] & 0xFF; + + return virNetworkLookupByUUID(conn, &uuid[0]); +} + +/** + * virNetworkCreateXML: + * @conn: pointer to the hypervisor connection + * @xmlDesc: an XML description of the network + * + * Create and start a new virtual network, based on an XML description + * similar to the one returned by virNetworkGetXMLDesc() + * + * Returns a new network object or NULL in case of failure + */ +virNetworkPtr +virNetworkCreateXML(virConnectPtr conn, const char *xmlDesc) +{ + virNetworkPtr ret; + int i; + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return (NULL); + } + if (xmlDesc == NULL) { + virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (NULL); + } + if (conn->flags & VIR_CONNECT_RO) { + virLibConnError(conn, VIR_ERR_OPERATION_DENIED, __FUNCTION__); + return (NULL); + } + + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->networkCreateXML != NULL)) { + ret = conn->networkDrivers[i]->networkCreateXML(conn, xmlDesc); + if (ret != NULL) + return(ret); + } + } + return(NULL); +} + +/** + * virNetworkDefineXML: + * @conn: pointer to the hypervisor connection + * @xml: the XML description for the network, preferably in UTF-8 + * + * Define a network, but does not create it + * + * Returns NULL in case of error, a pointer to the network otherwise + */ +virNetworkPtr +virNetworkDefineXML(virConnectPtr conn, const char *xml) { + virNetworkPtr ret = NULL; + int i; + + if (!VIR_IS_CONNECT(conn)) { + virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return (NULL); + } + if (conn->flags & VIR_CONNECT_RO) { + virLibConnError(conn, VIR_ERR_OPERATION_DENIED, __FUNCTION__); + return (NULL); + } + if (xml == NULL) { + virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (NULL); + } + + /* Go though the driver registered entry points */ + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->networkDefineXML != NULL)) { + ret = conn->networkDrivers[i]->networkDefineXML(conn, xml); + if (ret) + return(ret); + } + } + + return(ret); +} + +/** + * virNetworkUndefine: + * @network: pointer to a defined network + * + * Undefine a network but does not stop it if it is running + * + * Returns 0 in case of success, -1 in case of error + */ +int +virNetworkUndefine(virNetworkPtr network) { + int ret, i; + virConnectPtr conn; + + if (!VIR_IS_CONNECTED_NETWORK(network)) { + virLibNetworkError(network, VIR_ERR_INVALID_NETWORK, __FUNCTION__); + return (-1); + } + conn = network->conn; + if (conn->flags & VIR_CONNECT_RO) { + virLibNetworkError(network, VIR_ERR_OPERATION_DENIED, __FUNCTION__); + return (-1); + } + + /* Go though the driver registered entry points */ + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->networkUndefine != NULL)) { + ret = conn->networkDrivers[i]->networkUndefine(network); + if (ret >= 0) + return(ret); + } + } + + return(-1); +} + +/** + * virNetworkCreate: + * @network: pointer to a defined network + * + * Create and start a defined network. If the call succeed the network + * moves from the defined to the running networks pools. + * + * Returns 0 in case of success, -1 in case of error + */ +int +virNetworkCreate(virNetworkPtr network) { + int i, ret = -1; + virConnectPtr conn; + if (network == NULL) { + TODO + return (-1); + } + if (!VIR_IS_CONNECTED_NETWORK(network)) { + virLibNetworkError(network, VIR_ERR_INVALID_NETWORK, __FUNCTION__); + return (-1); + } + conn = network->conn; + if (conn->flags & VIR_CONNECT_RO) { + virLibNetworkError(network, VIR_ERR_OPERATION_DENIED, __FUNCTION__); + return (-1); + } + + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->networkCreate != NULL)) { + ret = conn->networkDrivers[i]->networkCreate(network); + if (ret == 0) + return(ret); + } + } + return(ret); +} + +/** + * virNetworkDestroy: + * @network: a network object + * + * Destroy the network object. The running instance is shutdown if not down + * already and all resources used by it are given back to the hypervisor. + * The data structure is freed and should not be used thereafter if the + * call does not return an error. + * This function may requires priviledged access + * + * Returns 0 in case of success and -1 in case of failure. + */ +int +virNetworkDestroy(virNetworkPtr network) +{ + int i; + virConnectPtr conn; + + if (!VIR_IS_CONNECTED_NETWORK(network)) { + virLibNetworkError(network, VIR_ERR_INVALID_NETWORK, __FUNCTION__); + return (-1); + } + + conn = network->conn; + if (conn->flags & VIR_CONNECT_RO) { + virLibNetworkError(network, VIR_ERR_OPERATION_DENIED, __FUNCTION__); + return (-1); + } + + /* + * Go though the driver registered entry points + */ + for (i = 0;i < conn->nb_drivers;i++) { + if ((conn->networkDrivers[i] != NULL) && + (conn->networkDrivers[i]->networkDestroy != NULL)) { + if (conn->networkDrivers[i]->networkDestroy(network) == 0) + return (0); + } + } + + virLibConnError(conn, VIR_ERR_CALL_FAILED, __FUNCTION__); + return (-1); +} + +/** + * virNetworkFree: + * @network: a network object + * + * Free the network object. The running instance is kept alive. + * The data structure is freed and should not be used thereafter. + * + * Returns 0 in case of success and -1 in case of failure. + */ +int +virNetworkFree(virNetworkPtr network) +{ + if (!VIR_IS_NETWORK(network)) { + virLibNetworkError(network, VIR_ERR_INVALID_NETWORK, __FUNCTION__); + return (-1); + } + if (virFreeNetwork(network->conn, network) < 0) + return (-1); + return(0); +} + +/** + * virNetworkGetName: + * @network: a network object + * + * Get the public name for that network + * + * Returns a pointer to the name or NULL, the string need not be deallocated + * its lifetime will be the same as the network object. + */ +const char * +virNetworkGetName(virNetworkPtr network) +{ + if (!VIR_IS_NETWORK(network)) { + virLibNetworkError(network, VIR_ERR_INVALID_NETWORK, __FUNCTION__); + return (NULL); + } + return (network->name); +} + +/** + * virNetworkGetUUID: + * @network: a network object + * @uuid: pointer to a VIR_UUID_BUFLEN bytes array + * + * Get the UUID for a network + * + * Returns -1 in case of error, 0 in case of success + */ +int +virNetworkGetUUID(virNetworkPtr network, unsigned char *uuid) +{ + if (!VIR_IS_NETWORK(network)) { + virLibNetworkError(network, VIR_ERR_INVALID_NETWORK, __FUNCTION__); + return (-1); + } + if (uuid == NULL) { + virLibNetworkError(network, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (-1); + } + + memcpy(uuid, &network->uuid[0], VIR_UUID_BUFLEN); + + return (0); +} + +/** + * virNetworkGetUUIDString: + * @network: a network object + * @buf: pointer to a VIR_UUID_STRING_BUFLEN bytes array + * + * Get the UUID for a network as string. For more information about + * UUID see RFC4122. + * + * Returns -1 in case of error, 0 in case of success + */ +int +virNetworkGetUUIDString(virNetworkPtr network, char *buf) +{ + unsigned char uuid[VIR_UUID_BUFLEN]; + + if (!VIR_IS_NETWORK(network)) { + virLibNetworkError(network, VIR_ERR_INVALID_NETWORK, __FUNCTION__); + return (-1); + } + if (buf == NULL) { + virLibNetworkError(network, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (-1); + } + + if (virNetworkGetUUID(network, &uuid[0])) + return (-1); + + snprintf(buf, VIR_UUID_STRING_BUFLEN, + "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + uuid[0], uuid[1], uuid[2], uuid[3], + uuid[4], uuid[5], uuid[6], uuid[7], + uuid[8], uuid[9], uuid[10], uuid[11], + uuid[12], uuid[13], uuid[14], uuid[15]); + return (0); +} + +/** + * virNetworkGetXMLDesc: + * @network: a network object + * @flags: and OR'ed set of extraction flags, not used yet + * + * Provide an XML description of the network. The description may be reused + * later to relaunch the network with virNetworkCreateXML(). + * + * Returns a 0 terminated UTF-8 encoded XML instance, or NULL in case of error. + * the caller must free() the returned value. + */ +char * +virNetworkGetXMLDesc(virNetworkPtr network, int flags) +{ + int i; + char *ret = NULL; + if (!VIR_IS_NETWORK(network)) { + virLibNetworkError(network, VIR_ERR_INVALID_NETWORK, __FUNCTION__); + return (NULL); + } + if (flags != 0) { + virLibNetworkError(network, VIR_ERR_INVALID_ARG, __FUNCTION__); + return (NULL); + } + + for (i = 0;i < network->conn->nb_network_drivers;i++) { + if ((network->conn->networkDrivers[i] != NULL) && + (network->conn->networkDrivers[i]->networkDumpXML != NULL)) { + ret = network->conn->networkDrivers[i]->networkDumpXML(network, flags); + if (ret) + break; + } + } + if (!ret) { + virLibConnError(network->conn, VIR_ERR_CALL_FAILED, __FUNCTION__); + return (NULL); + } + return(ret); +} Index: libvirt/src/libvirt_sym.version =================================================================== --- libvirt.orig/src/libvirt_sym.version +++ libvirt/src/libvirt_sym.version @@ -57,5 +57,24 @@ virDomainAttachDevice; virDomainDetachDevice; + + virConnectNumOfNetworks; + virConnectListNetworks; + virConnectNumOfDefinedNetworks; + virConnectListDefinedNetworks; + virNetworkLookupByName; + virNetworkLookupByUUID; + virNetworkLookupByUUIDString; + virNetworkCreateXML; + virNetworkDefineXML; + virNetworkUndefine; + virNetworkCreate; + virNetworkDestroy; + virNetworkFree; + virNetworkGetName; + virNetworkGetUUID; + virNetworkGetUUIDString; + virNetworkGetXMLDesc; + local: *; }; Index: libvirt/src/virterror.c =================================================================== --- libvirt.orig/src/virterror.c +++ libvirt/src/virterror.c @@ -271,6 +271,9 @@ virDefaultErrorFunc(virErrorPtr err) case VIR_FROM_QEMU: dom = "QEMU "; break; + case VIR_FROM_NET: + dom = "Network "; + break; } if ((err->dom != NULL) && (err->code != VIR_ERR_INVALID_DOMAIN)) { domain = err->dom->name; @@ -585,6 +588,18 @@ __virErrorMsg(virErrorNumber error, cons else errmsg = "%s"; break; + case VIR_ERR_INVALID_NETWORK: + if (info == NULL) + errmsg = _("invalid network pointer in"); + else + errmsg = _("invalid network pointer in %s"); + break; + case VIR_ERR_NETWORK_EXIST: + if (info == NULL) + errmsg = _("this network exists already"); + else + errmsg = _("network %s exists already"); + break; } return (errmsg); } --