---
qemud/remote.c | 235 ++++++++++++++++++++++++
qemud/remote_dispatch_args.h | 8 +
qemud/remote_dispatch_prototypes.h | 63 +++++++
qemud/remote_dispatch_ret.h | 6 +
qemud/remote_dispatch_table.h | 50 +++++
qemud/remote_protocol.c | 156 ++++++++++++++++
qemud/remote_protocol.h | 127 +++++++++++++
qemud/remote_protocol.x | 90 +++++++++-
src/datatypes.c | 154 ++++++++++++++++
src/datatypes.h | 6 +
src/libvirt.c | 10 -
src/remote_internal.c | 351 ++++++++++++++++++++++++++++++++++++
12 files changed, 1245 insertions(+), 11 deletions(-)
diff --git a/qemud/remote.c b/qemud/remote.c
index 8d24a3a..6dfd83a 100644
--- a/qemud/remote.c
+++ b/qemud/remote.c
@@ -60,10 +60,12 @@ static void remoteDispatchFormatError (remote_error *rerr,
ATTRIBUTE_FORMAT(printf, 2, 3);
static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain);
static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network network);
+static virInterfacePtr get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface interface);
static virStoragePoolPtr get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool);
static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol);
static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
+static void make_nonnull_interface (remote_nonnull_interface *interface_dst, virInterfacePtr interface_src);
static void make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src);
static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src);
static void make_nonnull_node_device (remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src);
@@ -2559,6 +2561,225 @@ remoteDispatchNumOfNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
}
+/*-------------------------------------------------------------*/
+static int
+remoteDispatchNumOfInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_interfaces_ret *ret)
+{
+
+ ret->num = virConnectNumOfInterfaces (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchListInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_interfaces_args *args,
+ remote_list_interfaces_ret *ret)
+{
+
+ if (args->maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxnames > REMOTE_INTERFACE_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virConnectListInterfaces (conn,
+ ret->names.names_val, args->maxnames);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_len);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_lookup_by_name_args *args,
+ remote_interface_lookup_by_name_ret *ret)
+{
+ virInterfacePtr interface;
+
+ interface = virInterfaceLookupByName (conn, args->name);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_interface (&ret->interface, interface);
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceLookupByMac (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_lookup_by_mac_args *args,
+ remote_interface_lookup_by_mac_ret *ret)
+{
+ virInterfacePtr interface;
+
+ interface = virInterfaceLookupByMAC (conn, (unsigned char *) args->mac);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_interface (&ret->interface, interface);
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceGetXmlDesc (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_get_xml_desc_args *args,
+ remote_interface_get_xml_desc_ret *ret)
+{
+ virInterfacePtr interface;
+
+ interface = get_nonnull_interface (conn, args->interface);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->xml = virInterfaceGetXMLDesc (interface, args->flags);
+ if (!ret->xml) {
+ virInterfaceFree(interface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_define_xml_args *args,
+ remote_interface_define_xml_ret *ret)
+{
+ virInterfacePtr interface;
+
+ interface = virInterfaceDefineXML (conn, args->xml, args->flags);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_interface (&ret->interface, interface);
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_undefine_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virInterfacePtr interface;
+
+ interface = get_nonnull_interface (conn, args->interface);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virInterfaceUndefine (interface) == -1) {
+ virInterfaceFree(interface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_create_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virInterfacePtr interface;
+
+ interface = get_nonnull_interface (conn, args->interface);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virInterfaceCreate (interface, args->flags) == -1) {
+ virInterfaceFree(interface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_destroy_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virInterfacePtr interface;
+
+ interface = get_nonnull_interface (conn, args->interface);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virInterfaceDestroy (interface, args->flags) == -1) {
+ virInterfaceFree(interface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(interface);
+ return 0;
+}
+
+/*-------------------------------------------------------------*/
+
static int
remoteDispatchAuthList (struct qemud_server *server,
struct qemud_client *client,
@@ -4527,6 +4748,12 @@ get_nonnull_network (virConnectPtr conn, remote_nonnull_network network)
return virGetNetwork (conn, network.name, BAD_CAST network.uuid);
}
+static virInterfacePtr
+get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface interface)
+{
+ return virGetInterface (conn, interface.name, BAD_CAST interface.mac);
+}
+
static virStoragePoolPtr
get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool)
{
@@ -4558,6 +4785,14 @@ make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src)
}
static void
+make_nonnull_interface (remote_nonnull_interface *interface_dst,
+ virInterfacePtr interface_src)
+{
+ interface_dst->name = strdup (interface_src->name);
+ memcpy (interface_dst->mac, interface_src->mac, VIR_MAC_BUFLEN);
+}
+
+static void
make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src)
{
pool_dst->name = strdup (pool_src->name);
diff --git a/qemud/remote_dispatch_args.h b/qemud/remote_dispatch_args.h
index 58eccf5..2297a48 100644
--- a/qemud/remote_dispatch_args.h
+++ b/qemud/remote_dispatch_args.h
@@ -105,3 +105,11 @@
remote_domain_get_security_label_args val_remote_domain_get_security_label_args;
remote_node_device_create_xml_args val_remote_node_device_create_xml_args;
remote_node_device_destroy_args val_remote_node_device_destroy_args;
+ remote_list_interfaces_args val_remote_list_interfaces_args;
+ remote_interface_lookup_by_name_args val_remote_interface_lookup_by_name_args;
+ remote_interface_lookup_by_mac_args val_remote_interface_lookup_by_mac_args;
+ remote_interface_get_xml_desc_args val_remote_interface_get_xml_desc_args;
+ remote_interface_define_xml_args val_remote_interface_define_xml_args;
+ remote_interface_undefine_args val_remote_interface_undefine_args;
+ remote_interface_create_args val_remote_interface_create_args;
+ remote_interface_destroy_args val_remote_interface_destroy_args;
diff --git a/qemud/remote_dispatch_prototypes.h b/qemud/remote_dispatch_prototypes.h
index 96dcb2a..80044c1 100644
--- a/qemud/remote_dispatch_prototypes.h
+++ b/qemud/remote_dispatch_prototypes.h
@@ -408,6 +408,55 @@ static int remoteDispatchGetVersion(
remote_error *err,
void *args,
remote_get_version_ret *ret);
+static int remoteDispatchInterfaceCreate(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_create_args *args,
+ void *ret);
+static int remoteDispatchInterfaceDefineXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_define_xml_args *args,
+ remote_interface_define_xml_ret *ret);
+static int remoteDispatchInterfaceDestroy(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_destroy_args *args,
+ void *ret);
+static int remoteDispatchInterfaceGetXmlDesc(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_get_xml_desc_args *args,
+ remote_interface_get_xml_desc_ret *ret);
+static int remoteDispatchInterfaceLookupByMac(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_lookup_by_mac_args *args,
+ remote_interface_lookup_by_mac_ret *ret);
+static int remoteDispatchInterfaceLookupByName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_lookup_by_name_args *args,
+ remote_interface_lookup_by_name_ret *ret);
+static int remoteDispatchInterfaceUndefine(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_undefine_args *args,
+ void *ret);
static int remoteDispatchListDefinedDomains(
struct qemud_server *server,
struct qemud_client *client,
@@ -436,6 +485,13 @@ static int remoteDispatchListDomains(
remote_error *err,
remote_list_domains_args *args,
remote_list_domains_ret *ret);
+static int remoteDispatchListInterfaces(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_interfaces_args *args,
+ remote_list_interfaces_ret *ret);
static int remoteDispatchListNetworks(
struct qemud_server *server,
struct qemud_client *client,
@@ -667,6 +723,13 @@ static int remoteDispatchNumOfDomains(
remote_error *err,
void *args,
remote_num_of_domains_ret *ret);
+static int remoteDispatchNumOfInterfaces(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_interfaces_ret *ret);
static int remoteDispatchNumOfNetworks(
struct qemud_server *server,
struct qemud_client *client,
diff --git a/qemud/remote_dispatch_ret.h b/qemud/remote_dispatch_ret.h
index 3325c8b..1c5380a 100644
--- a/qemud/remote_dispatch_ret.h
+++ b/qemud/remote_dispatch_ret.h
@@ -89,3 +89,9 @@
remote_domain_get_security_label_ret val_remote_domain_get_security_label_ret;
remote_node_get_security_model_ret val_remote_node_get_security_model_ret;
remote_node_device_create_xml_ret val_remote_node_device_create_xml_ret;
+ remote_num_of_interfaces_ret val_remote_num_of_interfaces_ret;
+ remote_list_interfaces_ret val_remote_list_interfaces_ret;
+ remote_interface_lookup_by_name_ret val_remote_interface_lookup_by_name_ret;
+ remote_interface_lookup_by_mac_ret val_remote_interface_lookup_by_mac_ret;
+ remote_interface_get_xml_desc_ret val_remote_interface_get_xml_desc_ret;
+ remote_interface_define_xml_ret val_remote_interface_define_xml_ret;
diff --git a/qemud/remote_dispatch_table.h b/qemud/remote_dispatch_table.h
index ac7f9b9..68e67e5 100644
--- a/qemud/remote_dispatch_table.h
+++ b/qemud/remote_dispatch_table.h
@@ -627,3 +627,53 @@
.args_filter = (xdrproc_t) xdr_remote_node_device_destroy_args,
.ret_filter = (xdrproc_t) xdr_void,
},
+{ /* (unused) => 125 */
+ .fn = NULL,
+ .args_filter = (xdrproc_t) xdr_void,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
+{ /* NumOfInterfaces => 126 */
+ .fn = (dispatch_fn) remoteDispatchNumOfInterfaces,
+ .args_filter = (xdrproc_t) xdr_void,
+ .ret_filter = (xdrproc_t) xdr_remote_num_of_interfaces_ret,
+},
+{ /* ListInterfaces => 127 */
+ .fn = (dispatch_fn) remoteDispatchListInterfaces,
+ .args_filter = (xdrproc_t) xdr_remote_list_interfaces_args,
+ .ret_filter = (xdrproc_t) xdr_remote_list_interfaces_ret,
+},
+{ /* InterfaceLookupByName => 128 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceLookupByName,
+ .args_filter = (xdrproc_t) xdr_remote_interface_lookup_by_name_args,
+ .ret_filter = (xdrproc_t) xdr_remote_interface_lookup_by_name_ret,
+},
+{ /* InterfaceLookupByMac => 129 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceLookupByMac,
+ .args_filter = (xdrproc_t) xdr_remote_interface_lookup_by_mac_args,
+ .ret_filter = (xdrproc_t) xdr_remote_interface_lookup_by_mac_ret,
+},
+{ /* InterfaceGetXmlDesc => 130 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceGetXmlDesc,
+ .args_filter = (xdrproc_t) xdr_remote_interface_get_xml_desc_args,
+ .ret_filter = (xdrproc_t) xdr_remote_interface_get_xml_desc_ret,
+},
+{ /* InterfaceDefineXml => 131 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceDefineXml,
+ .args_filter = (xdrproc_t) xdr_remote_interface_define_xml_args,
+ .ret_filter = (xdrproc_t) xdr_remote_interface_define_xml_ret,
+},
+{ /* InterfaceUndefine => 132 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceUndefine,
+ .args_filter = (xdrproc_t) xdr_remote_interface_undefine_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
+{ /* InterfaceCreate => 133 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceCreate,
+ .args_filter = (xdrproc_t) xdr_remote_interface_create_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
+{ /* InterfaceDestroy => 134 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceDestroy,
+ .args_filter = (xdrproc_t) xdr_remote_interface_destroy_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
diff --git a/qemud/remote_protocol.c b/qemud/remote_protocol.c
index af3c792..578857d 100644
--- a/qemud/remote_protocol.c
+++ b/qemud/remote_protocol.c
@@ -36,6 +36,15 @@ xdr_remote_uuid (XDR *xdrs, remote_uuid objp)
}
bool_t
+xdr_remote_mac (XDR *xdrs, remote_mac objp)
+{
+
+ if (!xdr_opaque (xdrs, objp, VIR_MAC_BUFLEN))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
xdr_remote_nonnull_domain (XDR *xdrs, remote_nonnull_domain *objp)
{
@@ -60,6 +69,17 @@ xdr_remote_nonnull_network (XDR *xdrs, remote_nonnull_network *objp)
}
bool_t
+xdr_remote_nonnull_interface (XDR *xdrs, remote_nonnull_interface *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_remote_mac (xdrs, objp->mac))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
xdr_remote_nonnull_storage_pool (XDR *xdrs, remote_nonnull_storage_pool *objp)
{
@@ -1478,6 +1498,142 @@ xdr_remote_network_set_autostart_args (XDR *xdrs, remote_network_set_autostart_a
}
bool_t
+xdr_remote_num_of_interfaces_ret (XDR *xdrs, remote_num_of_interfaces_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_interfaces_args (XDR *xdrs, remote_list_interfaces_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_interfaces_ret (XDR *xdrs, remote_list_interfaces_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_INTERFACE_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_name_args (XDR *xdrs, remote_interface_lookup_by_name_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_name_ret (XDR *xdrs, remote_interface_lookup_by_name_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_mac_args (XDR *xdrs, remote_interface_lookup_by_mac_args *objp)
+{
+
+ if (!xdr_remote_mac (xdrs, objp->mac))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_mac_ret (XDR *xdrs, remote_interface_lookup_by_mac_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_get_xml_desc_args (XDR *xdrs, remote_interface_get_xml_desc_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_get_xml_desc_ret (XDR *xdrs, remote_interface_get_xml_desc_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_define_xml_args (XDR *xdrs, remote_interface_define_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_define_xml_ret (XDR *xdrs, remote_interface_define_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_undefine_args (XDR *xdrs, remote_interface_undefine_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_create_args (XDR *xdrs, remote_interface_create_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_destroy_args (XDR *xdrs, remote_interface_destroy_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
xdr_remote_auth_list_ret (XDR *xdrs, remote_auth_list_ret *objp)
{
char **objp_cpp0 = (char **) (void *) &objp->types.types_val;
diff --git a/qemud/remote_protocol.h b/qemud/remote_protocol.h
index 9d67e58..7201720 100644
--- a/qemud/remote_protocol.h
+++ b/qemud/remote_protocol.h
@@ -28,6 +28,7 @@ typedef remote_nonnull_string *remote_string;
#define REMOTE_CPUMAPS_MAX 16384
#define REMOTE_MIGRATE_COOKIE_MAX 256
#define REMOTE_NETWORK_NAME_LIST_MAX 256
+#define REMOTE_INTERFACE_NAME_LIST_MAX 256
#define REMOTE_STORAGE_POOL_NAME_LIST_MAX 256
#define REMOTE_STORAGE_VOL_NAME_LIST_MAX 1024
#define REMOTE_NODE_DEVICE_NAME_LIST_MAX 16384
@@ -44,6 +45,8 @@ typedef remote_nonnull_string *remote_string;
typedef char remote_uuid[VIR_UUID_BUFLEN];
+typedef char remote_mac[VIR_MAC_BUFLEN];
+
struct remote_nonnull_domain {
remote_nonnull_string name;
remote_uuid uuid;
@@ -57,6 +60,12 @@ struct remote_nonnull_network {
};
typedef struct remote_nonnull_network remote_nonnull_network;
+struct remote_nonnull_interface {
+ remote_nonnull_string name;
+ remote_mac mac;
+};
+typedef struct remote_nonnull_interface remote_nonnull_interface;
+
struct remote_nonnull_storage_pool {
remote_nonnull_string name;
remote_uuid uuid;
@@ -822,6 +831,83 @@ struct remote_network_set_autostart_args {
};
typedef struct remote_network_set_autostart_args remote_network_set_autostart_args;
+struct remote_num_of_interfaces_ret {
+ int num;
+};
+typedef struct remote_num_of_interfaces_ret remote_num_of_interfaces_ret;
+
+struct remote_list_interfaces_args {
+ int maxnames;
+};
+typedef struct remote_list_interfaces_args remote_list_interfaces_args;
+
+struct remote_list_interfaces_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_list_interfaces_ret remote_list_interfaces_ret;
+
+struct remote_interface_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_interface_lookup_by_name_args remote_interface_lookup_by_name_args;
+
+struct remote_interface_lookup_by_name_ret {
+ remote_nonnull_interface interface;
+};
+typedef struct remote_interface_lookup_by_name_ret remote_interface_lookup_by_name_ret;
+
+struct remote_interface_lookup_by_mac_args {
+ remote_mac mac;
+};
+typedef struct remote_interface_lookup_by_mac_args remote_interface_lookup_by_mac_args;
+
+struct remote_interface_lookup_by_mac_ret {
+ remote_nonnull_interface interface;
+};
+typedef struct remote_interface_lookup_by_mac_ret remote_interface_lookup_by_mac_ret;
+
+struct remote_interface_get_xml_desc_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+typedef struct remote_interface_get_xml_desc_args remote_interface_get_xml_desc_args;
+
+struct remote_interface_get_xml_desc_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_interface_get_xml_desc_ret remote_interface_get_xml_desc_ret;
+
+struct remote_interface_define_xml_args {
+ remote_nonnull_string xml;
+ int flags;
+};
+typedef struct remote_interface_define_xml_args remote_interface_define_xml_args;
+
+struct remote_interface_define_xml_ret {
+ remote_nonnull_interface interface;
+};
+typedef struct remote_interface_define_xml_ret remote_interface_define_xml_ret;
+
+struct remote_interface_undefine_args {
+ remote_nonnull_interface interface;
+};
+typedef struct remote_interface_undefine_args remote_interface_undefine_args;
+
+struct remote_interface_create_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+typedef struct remote_interface_create_args remote_interface_create_args;
+
+struct remote_interface_destroy_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+typedef struct remote_interface_destroy_args remote_interface_destroy_args;
+
struct remote_auth_list_ret {
struct {
u_int types_len;
@@ -1415,6 +1501,15 @@ enum remote_procedure {
REMOTE_PROC_NODE_GET_SECURITY_MODEL = 122,
REMOTE_PROC_NODE_DEVICE_CREATE_XML = 123,
REMOTE_PROC_NODE_DEVICE_DESTROY = 124,
+ REMOTE_PROC_NUM_OF_INTERFACES = 126,
+ REMOTE_PROC_LIST_INTERFACES = 127,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME = 128,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC = 129,
+ REMOTE_PROC_INTERFACE_GET_XML_DESC = 130,
+ REMOTE_PROC_INTERFACE_DEFINE_XML = 131,
+ REMOTE_PROC_INTERFACE_UNDEFINE = 132,
+ REMOTE_PROC_INTERFACE_CREATE = 133,
+ REMOTE_PROC_INTERFACE_DESTROY = 134,
};
typedef enum remote_procedure remote_procedure;
@@ -1448,8 +1543,10 @@ typedef struct remote_message_header remote_message_header;
extern bool_t xdr_remote_nonnull_string (XDR *, remote_nonnull_string*);
extern bool_t xdr_remote_string (XDR *, remote_string*);
extern bool_t xdr_remote_uuid (XDR *, remote_uuid);
+extern bool_t xdr_remote_mac (XDR *, remote_mac);
extern bool_t xdr_remote_nonnull_domain (XDR *, remote_nonnull_domain*);
extern bool_t xdr_remote_nonnull_network (XDR *, remote_nonnull_network*);
+extern bool_t xdr_remote_nonnull_interface (XDR *, remote_nonnull_interface*);
extern bool_t xdr_remote_nonnull_storage_pool (XDR *, remote_nonnull_storage_pool*);
extern bool_t xdr_remote_nonnull_storage_vol (XDR *, remote_nonnull_storage_vol*);
extern bool_t xdr_remote_nonnull_node_device (XDR *, remote_nonnull_node_device*);
@@ -1573,6 +1670,20 @@ extern bool_t xdr_remote_network_get_bridge_name_ret (XDR *, remote_network_get
extern bool_t xdr_remote_network_get_autostart_args (XDR *, remote_network_get_autostart_args*);
extern bool_t xdr_remote_network_get_autostart_ret (XDR *, remote_network_get_autostart_ret*);
extern bool_t xdr_remote_network_set_autostart_args (XDR *, remote_network_set_autostart_args*);
+extern bool_t xdr_remote_num_of_interfaces_ret (XDR *, remote_num_of_interfaces_ret*);
+extern bool_t xdr_remote_list_interfaces_args (XDR *, remote_list_interfaces_args*);
+extern bool_t xdr_remote_list_interfaces_ret (XDR *, remote_list_interfaces_ret*);
+extern bool_t xdr_remote_interface_lookup_by_name_args (XDR *, remote_interface_lookup_by_name_args*);
+extern bool_t xdr_remote_interface_lookup_by_name_ret (XDR *, remote_interface_lookup_by_name_ret*);
+extern bool_t xdr_remote_interface_lookup_by_mac_args (XDR *, remote_interface_lookup_by_mac_args*);
+extern bool_t xdr_remote_interface_lookup_by_mac_ret (XDR *, remote_interface_lookup_by_mac_ret*);
+extern bool_t xdr_remote_interface_get_xml_desc_args (XDR *, remote_interface_get_xml_desc_args*);
+extern bool_t xdr_remote_interface_get_xml_desc_ret (XDR *, remote_interface_get_xml_desc_ret*);
+extern bool_t xdr_remote_interface_define_xml_args (XDR *, remote_interface_define_xml_args*);
+extern bool_t xdr_remote_interface_define_xml_ret (XDR *, remote_interface_define_xml_ret*);
+extern bool_t xdr_remote_interface_undefine_args (XDR *, remote_interface_undefine_args*);
+extern bool_t xdr_remote_interface_create_args (XDR *, remote_interface_create_args*);
+extern bool_t xdr_remote_interface_destroy_args (XDR *, remote_interface_destroy_args*);
extern bool_t xdr_remote_auth_list_ret (XDR *, remote_auth_list_ret*);
extern bool_t xdr_remote_auth_sasl_init_ret (XDR *, remote_auth_sasl_init_ret*);
extern bool_t xdr_remote_auth_sasl_start_args (XDR *, remote_auth_sasl_start_args*);
@@ -1662,8 +1773,10 @@ extern bool_t xdr_remote_message_header (XDR *, remote_message_header*);
extern bool_t xdr_remote_nonnull_string ();
extern bool_t xdr_remote_string ();
extern bool_t xdr_remote_uuid ();
+extern bool_t xdr_remote_mac ();
extern bool_t xdr_remote_nonnull_domain ();
extern bool_t xdr_remote_nonnull_network ();
+extern bool_t xdr_remote_nonnull_interface ();
extern bool_t xdr_remote_nonnull_storage_pool ();
extern bool_t xdr_remote_nonnull_storage_vol ();
extern bool_t xdr_remote_nonnull_node_device ();
@@ -1787,6 +1900,20 @@ extern bool_t xdr_remote_network_get_bridge_name_ret ();
extern bool_t xdr_remote_network_get_autostart_args ();
extern bool_t xdr_remote_network_get_autostart_ret ();
extern bool_t xdr_remote_network_set_autostart_args ();
+extern bool_t xdr_remote_num_of_interfaces_ret ();
+extern bool_t xdr_remote_list_interfaces_args ();
+extern bool_t xdr_remote_list_interfaces_ret ();
+extern bool_t xdr_remote_interface_lookup_by_name_args ();
+extern bool_t xdr_remote_interface_lookup_by_name_ret ();
+extern bool_t xdr_remote_interface_lookup_by_mac_args ();
+extern bool_t xdr_remote_interface_lookup_by_mac_ret ();
+extern bool_t xdr_remote_interface_get_xml_desc_args ();
+extern bool_t xdr_remote_interface_get_xml_desc_ret ();
+extern bool_t xdr_remote_interface_define_xml_args ();
+extern bool_t xdr_remote_interface_define_xml_ret ();
+extern bool_t xdr_remote_interface_undefine_args ();
+extern bool_t xdr_remote_interface_create_args ();
+extern bool_t xdr_remote_interface_destroy_args ();
extern bool_t xdr_remote_auth_list_ret ();
extern bool_t xdr_remote_auth_sasl_init_ret ();
extern bool_t xdr_remote_auth_sasl_start_args ();
diff --git a/qemud/remote_protocol.x b/qemud/remote_protocol.x
index 2c79949..6abc908 100644
--- a/qemud/remote_protocol.x
+++ b/qemud/remote_protocol.x
@@ -79,6 +79,9 @@ const REMOTE_MIGRATE_COOKIE_MAX = 256;
/* Upper limit on lists of network names. */
const REMOTE_NETWORK_NAME_LIST_MAX = 256;
+/* Upper limit on lists of interface names. */
+const REMOTE_INTERFACE_NAME_LIST_MAX = 256;
+
/* Upper limit on lists of storage pool names. */
const REMOTE_STORAGE_POOL_NAME_LIST_MAX = 256;
@@ -133,6 +136,9 @@ const REMOTE_SECURITY_DOI_MAX = VIR_SECURITY_DOI_BUFLEN;
/* UUID. VIR_UUID_BUFLEN definition comes from libvirt.h */
typedef opaque remote_uuid[VIR_UUID_BUFLEN];
+/* MAC. VIR_MAC_BUFLEN definition comes from libvirt.h */
+typedef opaque remote_mac[VIR_MAC_BUFLEN];
+
/* A domain which may not be NULL. */
struct remote_nonnull_domain {
remote_nonnull_string name;
@@ -146,6 +152,12 @@ struct remote_nonnull_network {
remote_uuid uuid;
};
+/* An interface which may not be NULL. */
+struct remote_nonnull_interface {
+ remote_nonnull_string name;
+ remote_mac mac;
+};
+
/* A storage pool which may not be NULL. */
struct remote_nonnull_storage_pool {
remote_nonnull_string name;
@@ -770,6 +782,71 @@ struct remote_network_set_autostart_args {
};
+/* Interface calls: */
+
+struct remote_num_of_interfaces_ret {
+ int num;
+};
+
+struct remote_list_interfaces_args {
+ int maxnames;
+};
+
+struct remote_list_interfaces_ret {
+ remote_nonnull_string names<REMOTE_INTERFACE_NAME_LIST_MAX>;
+};
+
+struct remote_interface_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+
+struct remote_interface_lookup_by_name_ret {
+ remote_nonnull_interface interface;
+};
+
+struct remote_interface_lookup_by_mac_args {
+ remote_mac mac;
+};
+
+struct remote_interface_lookup_by_mac_ret {
+ remote_nonnull_interface interface;
+};
+
+struct remote_interface_get_xml_desc_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+
+struct remote_interface_get_xml_desc_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_interface_define_xml_args {
+ remote_nonnull_string xml;
+ int flags;
+};
+
+struct remote_interface_define_xml_ret {
+ remote_nonnull_interface interface;
+};
+
+struct remote_interface_undefine_args {
+ remote_nonnull_interface interface;
+};
+
+struct remote_interface_create_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+
+struct remote_interface_destroy_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+
+
+/* Auth calls: */
+
struct remote_auth_list_ret {
remote_auth_type types<REMOTE_AUTH_TYPE_LIST_MAX>;
};
@@ -1286,7 +1363,18 @@ enum remote_procedure {
REMOTE_PROC_NODE_GET_SECURITY_MODEL = 122,
REMOTE_PROC_NODE_DEVICE_CREATE_XML = 123,
- REMOTE_PROC_NODE_DEVICE_DESTROY = 124
+ REMOTE_PROC_NODE_DEVICE_DESTROY = 124,
+
+ REMOTE_PROC_NUM_OF_INTERFACES = 126,
+ REMOTE_PROC_LIST_INTERFACES = 127,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME = 128,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC = 129,
+ REMOTE_PROC_INTERFACE_GET_XML_DESC = 130,
+ REMOTE_PROC_INTERFACE_DEFINE_XML = 131,
+ REMOTE_PROC_INTERFACE_UNDEFINE = 132,
+ REMOTE_PROC_INTERFACE_CREATE = 133,
+ REMOTE_PROC_INTERFACE_DESTROY = 134
+
};
/* Custom RPC structure. */
diff --git a/src/datatypes.c b/src/datatypes.c
index b1013f2..8593e2b 100644
--- a/src/datatypes.c
+++ b/src/datatypes.c
@@ -67,6 +67,20 @@ virNetworkFreeName(virNetworkPtr network, const char *name ATTRIBUTE_UNUSED)
}
/**
+ * virInterfaceFreeName:
+ * @interface: a interface object
+ *
+ * Destroy the interface object, this is just used by the interface hash callback.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+static int
+virInterfaceFreeName(virInterfacePtr interface, const char *name ATTRIBUTE_UNUSED)
+{
+ return (virUnrefInterface(interface));
+}
+
+/**
* virStoragePoolFreeName:
* @pool: a pool object
*
@@ -119,12 +133,16 @@ virGetConnect(void) {
ret->networkDriver = NULL;
ret->privateData = NULL;
ret->networkPrivateData = NULL;
+ ret->interfacePrivateData = NULL;
ret->domains = virHashCreate(20);
if (ret->domains == NULL)
goto failed;
ret->networks = virHashCreate(20);
if (ret->networks == NULL)
goto failed;
+ ret->interfaces = virHashCreate(20);
+ if (ret->interfaces == NULL)
+ goto failed;
ret->storagePools = virHashCreate(20);
if (ret->storagePools == NULL)
goto failed;
@@ -144,6 +162,8 @@ failed:
virHashFree(ret->domains, (virHashDeallocator) virDomainFreeName);
if (ret->networks != NULL)
virHashFree(ret->networks, (virHashDeallocator) virNetworkFreeName);
+ if (ret->interfaces != NULL)
+ virHashFree(ret->interfaces, (virHashDeallocator) virInterfaceFreeName);
if (ret->storagePools != NULL)
virHashFree(ret->storagePools, (virHashDeallocator) virStoragePoolFreeName);
if (ret->storageVols != NULL)
@@ -173,6 +193,8 @@ virReleaseConnect(virConnectPtr conn) {
virHashFree(conn->domains, (virHashDeallocator) virDomainFreeName);
if (conn->networks != NULL)
virHashFree(conn->networks, (virHashDeallocator) virNetworkFreeName);
+ if (conn->interfaces != NULL)
+ virHashFree(conn->interfaces, (virHashDeallocator) virInterfaceFreeName);
if (conn->storagePools != NULL)
virHashFree(conn->storagePools, (virHashDeallocator) virStoragePoolFreeName);
if (conn->storageVols != NULL)
@@ -488,6 +510,138 @@ virUnrefNetwork(virNetworkPtr network) {
/**
+ * 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, if no allocate a new structure,
+ * and register it in the table. In any case a corresponding call to
+ * virUnrefInterface() 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 unsigned char *mac) {
+ virInterfacePtr ret = NULL;
+
+ if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (mac == NULL)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(NULL);
+ }
+ virMutexLock(&conn->lock);
+
+ /* TODO search by MAC first as they are better differentiators */
+
+ ret = (virInterfacePtr) virHashLookup(conn->interfaces, name);
+ /* TODO check the MAC */
+ if (ret == NULL) {
+ if (VIR_ALLOC(ret) < 0) {
+ virReportOOMError(conn);
+ goto error;
+ }
+ ret->name = strdup(name);
+ if (ret->name == NULL) {
+ virReportOOMError(conn);
+ goto error;
+ }
+ ret->magic = VIR_INTERFACE_MAGIC;
+ ret->conn = conn;
+ if (mac != NULL)
+ memcpy(&(ret->mac[0]), mac, VIR_MAC_BUFLEN);
+
+ if (virHashAddEntry(conn->interfaces, name, ret) < 0) {
+ virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+ _("failed to add interface to connection hash table"));
+ goto error;
+ }
+ conn->refs++;
+ }
+ ret->refs++;
+ virMutexUnlock(&conn->lock);
+ return(ret);
+
+ error:
+ virMutexUnlock(&conn->lock);
+ if (ret != NULL) {
+ VIR_FREE(ret->name);
+ VIR_FREE(ret);
+ }
+ return(NULL);
+}
+
+/**
+ * virReleaseInterface:
+ * @interface: the interface to release
+ *
+ * Unconditionally release all memory associated with a interface.
+ * The conn.lock mutex must be held prior to calling this, and will
+ * be released prior to this returning. The interface obj must not
+ * be used once this method returns.
+ *
+ * It will also unreference the associated connection object,
+ * which may also be released if its ref count hits zero.
+ */
+static void
+virReleaseInterface(virInterfacePtr interface) {
+ virConnectPtr conn = interface->conn;
+ DEBUG("release interface %p %s", interface, interface->name);
+
+ /* TODO search by MAC first as they are better differenciators */
+ if (virHashRemoveEntry(conn->interfaces, interface->name, NULL) < 0)
+ virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+ _("interface missing from connection hash table"));
+
+ interface->magic = -1;
+ VIR_FREE(interface->name);
+ VIR_FREE(interface);
+
+ DEBUG("unref connection %p %d", conn, conn->refs);
+ conn->refs--;
+ if (conn->refs == 0) {
+ virReleaseConnect(conn);
+ /* Already unlocked mutex */
+ return;
+ }
+
+ virMutexUnlock(&conn->lock);
+}
+
+
+/**
+ * virUnrefInterface:
+ * @interface: the interface to unreference
+ *
+ * Unreference the interface. If the use count drops to zero, the structure is
+ * actually freed.
+ *
+ * Returns the reference count or -1 in case of failure.
+ */
+int
+virUnrefInterface(virInterfacePtr interface) {
+ int refs;
+
+ if (!VIR_IS_CONNECTED_INTERFACE(interface)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(-1);
+ }
+ virMutexLock(&interface->conn->lock);
+ DEBUG("unref interface %p %s %d", interface, interface->name, interface->refs);
+ interface->refs--;
+ refs = interface->refs;
+ if (refs == 0) {
+ virReleaseInterface(interface);
+ /* Already unlocked mutex */
+ return (0);
+ }
+
+ virMutexUnlock(&interface->conn->lock);
+ return (refs);
+}
+
+
+/**
* virGetStoragePool:
* @conn: the hypervisor connection
* @name: pointer to the storage pool name
diff --git a/src/datatypes.h b/src/datatypes.h
index deac9df..e56755b 100644
--- a/src/datatypes.h
+++ b/src/datatypes.h
@@ -145,6 +145,7 @@ struct _virConnect {
virHashTablePtr domains; /* hash table for known domains */
virHashTablePtr networks; /* hash table for known domains */
+ virHashTablePtr interfaces; /* hash table for known interfaces */
virHashTablePtr storagePools;/* hash table for known storage pools */
virHashTablePtr storageVols;/* hash table for known storage vols */
virHashTablePtr nodeDevices; /* hash table for known node devices */
@@ -250,6 +251,11 @@ virNetworkPtr virGetNetwork(virConnectPtr conn,
const unsigned char *uuid);
int virUnrefNetwork(virNetworkPtr network);
+virInterfacePtr virGetInterface(virConnectPtr conn,
+ const char *name,
+ const unsigned char *mac);
+int virUnrefInterface(virInterfacePtr interface);
+
virStoragePoolPtr virGetStoragePool(virConnectPtr conn,
const char *name,
const unsigned char *uuid);
diff --git a/src/libvirt.c b/src/libvirt.c
index 4bd85a7..15f107a 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -5958,18 +5958,8 @@ virInterfaceFree(virInterfacePtr interface)
virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
return (-1);
}
-#if 0
- /*
- * FIXME: This needs to be uncommented when the stubs are replaced
- * with actual functionality.
- */
-
if (virUnrefInterface(interface) < 0)
return (-1);
-#else
- interface->refs--;
-#endif
-
return(0);
}
diff --git a/src/remote_internal.c b/src/remote_internal.c
index 24226e5..6bc2b9c 100644
--- a/src/remote_internal.c
+++ b/src/remote_internal.c
@@ -211,11 +211,13 @@ static void errorf (virConnectPtr conn, virErrorNumber code,
static void server_error (virConnectPtr conn, remote_error *err);
static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain);
static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network network);
+static virInterfacePtr get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface interface);
static virStoragePoolPtr get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool);
static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol);
static virNodeDevicePtr get_nonnull_node_device (virConnectPtr conn, remote_nonnull_node_device dev);
static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
+static void make_nonnull_interface (remote_nonnull_interface *interface_dst, virInterfacePtr interface_src);
static void make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr vol_src);
static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src);
void remoteDomainEventFired(int watch, int fd, int event, void *data);
@@ -3684,6 +3686,325 @@ done:
/*----------------------------------------------------------------------*/
static virDrvOpenStatus
+remoteInterfaceOpen (virConnectPtr conn,
+ virConnectAuthPtr auth,
+ int flags)
+{
+ if (inside_daemon)
+ return VIR_DRV_OPEN_DECLINED;
+
+ if (conn &&
+ conn->driver &&
+ STREQ (conn->driver->name, "remote")) {
+ struct private_data *priv;
+
+ /* If we're here, the remote driver is already
+ * in use due to a) a QEMU uri, or b) a remote
+ * URI. So we can re-use existing connection
+ */
+ priv = conn->privateData;
+ remoteDriverLock(priv);
+ priv->localUses++;
+ conn->interfacePrivateData = priv;
+ remoteDriverUnlock(priv);
+ return VIR_DRV_OPEN_SUCCESS;
+ } else {
+ /* Using a non-remote driver, so we need to open a
+ * new connection for interface APIs, forcing it to
+ * use the UNIX transport. This handles Xen driver
+ * which doesn't have its own impl of the interface APIs.
+ */
+ struct private_data *priv;
+ int ret;
+ ret = remoteOpenSecondaryDriver(conn,
+ auth,
+ flags,
+ &priv);
+ if (ret == VIR_DRV_OPEN_SUCCESS)
+ conn->interfacePrivateData = priv;
+ return ret;
+ }
+}
+
+static int
+remoteInterfaceClose (virConnectPtr conn)
+{
+ int rv = 0;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+ priv->localUses--;
+ if (!priv->localUses) {
+ rv = doRemoteClose(conn, priv);
+ conn->interfacePrivateData = NULL;
+ remoteDriverUnlock(priv);
+ virMutexDestroy(&priv->lock);
+ VIR_FREE(priv);
+ }
+ if (priv)
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfInterfaces (virConnectPtr conn)
+{
+ int rv = -1;
+ remote_num_of_interfaces_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_INTERFACES,
+ (xdrproc_t) xdr_void, (char *) NULL,
+ (xdrproc_t) xdr_remote_num_of_interfaces_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteListInterfaces (virConnectPtr conn, char **const names, int maxnames)
+{
+ int rv = -1;
+ int i;
+ remote_list_interfaces_args args;
+ remote_list_interfaces_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ if (maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) {
+ errorf (conn, VIR_ERR_RPC,
+ _("too many remote interfaces: %d > %d"),
+ maxnames, REMOTE_INTERFACE_NAME_LIST_MAX);
+ goto done;
+ }
+ args.maxnames = maxnames;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_LIST_INTERFACES,
+ (xdrproc_t) xdr_remote_list_interfaces_args, (char *) &args,
+ (xdrproc_t) xdr_remote_list_interfaces_ret, (char *) &ret) == -1)
+ goto done;
+
+ if (ret.names.names_len > maxnames) {
+ errorf (conn, VIR_ERR_RPC,
+ _("too many remote interfaces: %d > %d"),
+ ret.names.names_len, maxnames);
+ goto cleanup;
+ }
+
+ /* This call is caller-frees (although that isn't clear from
+ * the documentation). However xdr_free will free up both the
+ * names and the list of pointers, so we have to strdup the
+ * names here.
+ */
+ for (i = 0; i < ret.names.names_len; ++i)
+ names[i] = strdup (ret.names.names_val[i]);
+
+ rv = ret.names.names_len;
+
+cleanup:
+ xdr_free ((xdrproc_t) xdr_remote_list_interfaces_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virInterfacePtr
+remoteInterfaceLookupByName (virConnectPtr conn,
+ const char *name)
+{
+ virInterfacePtr interface = NULL;
+ remote_interface_lookup_by_name_args args;
+ remote_interface_lookup_by_name_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ args.name = (char *) name;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME,
+ (xdrproc_t) xdr_remote_interface_lookup_by_name_args, (char *) &args,
+ (xdrproc_t) xdr_remote_interface_lookup_by_name_ret, (char *) &ret) == -1)
+ goto done;
+
+ interface = get_nonnull_interface (conn, ret.interface);
+ xdr_free ((xdrproc_t) &xdr_remote_interface_lookup_by_name_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return interface;
+}
+
+static virInterfacePtr
+remoteInterfaceLookupByMAC (virConnectPtr conn,
+ const unsigned char *mac)
+{
+ virInterfacePtr interface = NULL;
+ remote_interface_lookup_by_mac_args args;
+ remote_interface_lookup_by_mac_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ memcpy (args.mac, mac, VIR_MAC_BUFLEN);
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC,
+ (xdrproc_t) xdr_remote_interface_lookup_by_mac_args, (char *) &args,
+ (xdrproc_t) xdr_remote_interface_lookup_by_mac_ret, (char *) &ret) == -1)
+ goto done;
+
+ interface = get_nonnull_interface (conn, ret.interface);
+ xdr_free ((xdrproc_t) &xdr_remote_interface_lookup_by_mac_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return interface;
+}
+
+static char *
+remoteInterfaceGetXMLDesc (virInterfacePtr interface,
+ int flags)
+{
+ char *rv = NULL;
+ remote_interface_get_xml_desc_args args;
+ remote_interface_get_xml_desc_ret ret;
+ struct private_data *priv = interface->conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface (&args.interface, interface);
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (interface->conn, priv, 0, REMOTE_PROC_INTERFACE_GET_XML_DESC,
+ (xdrproc_t) xdr_remote_interface_get_xml_desc_args, (char *) &args,
+ (xdrproc_t) xdr_remote_interface_get_xml_desc_ret, (char *) &ret) == -1)
+ goto done;
+
+ /* Caller frees. */
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virInterfacePtr
+remoteInterfaceDefineXML (virConnectPtr conn,
+ const char *xmlDesc,
+ int flags)
+{
+ virInterfacePtr interface = NULL;
+ remote_interface_define_xml_args args;
+ remote_interface_define_xml_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ args.xml = (char *) xmlDesc;
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_DEFINE_XML,
+ (xdrproc_t) xdr_remote_interface_define_xml_args, (char *) &args,
+ (xdrproc_t) xdr_remote_interface_define_xml_ret, (char *) &ret) == -1)
+ goto done;
+
+ interface = get_nonnull_interface (conn, ret.interface);
+ xdr_free ((xdrproc_t) &xdr_remote_interface_define_xml_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return interface;
+}
+
+static int
+remoteInterfaceUndefine (virInterfacePtr interface)
+{
+ int rv = -1;
+ remote_interface_undefine_args args;
+ struct private_data *priv = interface->conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface (&args.interface, interface);
+
+ if (call (interface->conn, priv, 0, REMOTE_PROC_INTERFACE_UNDEFINE,
+ (xdrproc_t) xdr_remote_interface_undefine_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteInterfaceCreate (virInterfacePtr interface,
+ int flags)
+{
+ int rv = -1;
+ remote_interface_create_args args;
+ struct private_data *priv = interface->conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface (&args.interface, interface);
+ args.flags = flags;
+
+ if (call (interface->conn, priv, 0, REMOTE_PROC_INTERFACE_CREATE,
+ (xdrproc_t) xdr_remote_interface_create_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteInterfaceDestroy (virInterfacePtr interface,
+ int flags)
+{
+ int rv = -1;
+ remote_interface_destroy_args args;
+ struct private_data *priv = interface->conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface (&args.interface, interface);
+ args.flags = flags;
+
+ if (call (interface->conn, priv, 0, REMOTE_PROC_INTERFACE_DESTROY,
+ (xdrproc_t) xdr_remote_interface_destroy_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/*----------------------------------------------------------------------*/
+
+static virDrvOpenStatus
remoteStorageOpen (virConnectPtr conn,
virConnectAuthPtr auth,
int flags)
@@ -6851,6 +7172,12 @@ get_nonnull_network (virConnectPtr conn, remote_nonnull_network network)
return virGetNetwork (conn, network.name, BAD_CAST network.uuid);
}
+static virInterfacePtr
+get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface interface)
+{
+ return virGetInterface (conn, interface.name, BAD_CAST interface.mac);
+}
+
static virStoragePoolPtr
get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool)
{
@@ -6886,6 +7213,14 @@ make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src)
}
static void
+make_nonnull_interface (remote_nonnull_interface *interface_dst,
+ virInterfacePtr interface_src)
+{
+ interface_dst->name = interface_src->name;
+ memcpy (interface_dst->mac, interface_src->mac, VIR_MAC_BUFLEN);
+}
+
+static void
make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src)
{
pool_dst->name = pool_src->name;
@@ -6996,6 +7331,21 @@ static virNetworkDriver network_driver = {
.networkSetAutostart = remoteNetworkSetAutostart,
};
+static virInterfaceDriver interface_driver = {
+ .name = "remote",
+ .open = remoteInterfaceOpen,
+ .close = remoteInterfaceClose,
+ .numOfInterfaces = remoteNumOfInterfaces,
+ .listInterfaces = remoteListInterfaces,
+ .interfaceLookupByName = remoteInterfaceLookupByName,
+ .interfaceLookupByMAC = remoteInterfaceLookupByMAC,
+ .interfaceGetXMLDesc = remoteInterfaceGetXMLDesc,
+ .interfaceDefineXML = remoteInterfaceDefineXML,
+ .interfaceUndefine = remoteInterfaceUndefine,
+ .interfaceCreate = remoteInterfaceCreate,
+ .interfaceDestroy = remoteInterfaceDestroy,
+};
+
static virStorageDriver storage_driver = {
.name = "remote",
.open = remoteStorageOpen,
@@ -7067,6 +7417,7 @@ remoteRegister (void)
{
if (virRegisterDriver (&driver) == -1) return -1;
if (virRegisterNetworkDriver (&network_driver) == -1) return -1;
+ if (virRegisterInterfaceDriver (&interface_driver) == -1) return -1;
if (virRegisterStorageDriver (&storage_driver) == -1) return -1;
if (virRegisterDeviceMonitor (&dev_monitor) == -1) return -1;
#ifdef WITH_LIBVIRTD
--
1.6.0.6
--
Libvir-list mailing list
Libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list