Tue Feb 14 15:52:34 EST 2007 Mark McLoughlin <markmc@redhat.com>

* qemud/protocol.h: add the protocol for virtual networks

        * qemud/dispatch.c: implement the protocol

        * qemud/driver.[ch]: add stubs for the driver

        * qemud/internal.h: add struct qemud_network

        * src/qemu_internal.c: add a virtual networks driver

qemud/dispatch.c

@@ -462,6 +462,243 @@ static int qemudDispatchDomainUndefine(struct qemud_server *server, struct qemud
     return 0;
 }
 
+static int qemudDispatchNumNetworks(struct qemud_server *server, struct qemud_client *client,
+                                    struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != 0)
+        return -1;
+
+    int nnetworks = qemudNumNetworks(server);
+    if (nnetworks < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NUM_NETWORKS;
+        out->header.dataSize = sizeof(out->data.numNetworksReply);
+        out->data.numNetworksReply.numNetworks = nnetworks;
+    }
+    return 0;
+}
+
+static int qemudDispatchListNetworks(struct qemud_server *server, struct qemud_client *client,
+                                     struct qemud_packet *in, struct qemud_packet *out) {
+    char **names;
+    int i;
+    if (in->header.dataSize != 0)
+        return -1;
+
+    if (!(names = malloc(sizeof(char *)*QEMUD_MAX_NUM_NETWORKS)))
+        return -1;
+
+    for (i = 0 ; i < QEMUD_MAX_NUM_NETWORKS ; i++) {
+        names[i] = out->data.listNetworksReply.networks[i];
+    }
+
+    int nnetworks = qemudListNetworks(server,
+                                      names,
+                                      QEMUD_MAX_NUM_NETWORKS);
+    free(names);
+    if (nnetworks < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_LIST_NETWORKS;
+        out->header.dataSize = sizeof(out->data.listNetworksReply);
+        out->data.listNetworksReply.numNetworks = nnetworks;
+    }
+    return 0;
+}
+
+static int qemudDispatchNumDefinedNetworks(struct qemud_server *server, struct qemud_client *client,
+                                           struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != 0)
+        return -1;
+
+    int nnetworks = qemudNumDefinedNetworks(server);
+    if (nnetworks < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NUM_DEFINED_NETWORKS;
+        out->header.dataSize = sizeof(out->data.numDefinedNetworksReply);
+        out->data.numDefinedNetworksReply.numNetworks = nnetworks;
+    }
+    return 0;
+}
+
+static int qemudDispatchListDefinedNetworks(struct qemud_server *server, struct qemud_client *client,
+                                            struct qemud_packet *in, struct qemud_packet *out) {
+    char **names;
+    int i;
+    if (in->header.dataSize != 0)
+        return -1;
+
+    if (!(names = malloc(sizeof(char *)*QEMUD_MAX_NUM_NETWORKS)))
+        return -1;
+
+    for (i = 0 ; i < QEMUD_MAX_NUM_NETWORKS ; i++) {
+        names[i] = out->data.listDefinedNetworksReply.networks[i];
+    }
+
+    int nnetworks = qemudListDefinedNetworks(server,
+                                             names,
+                                             QEMUD_MAX_NUM_NETWORKS);
+    free(names);
+    if (nnetworks < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_LIST_DEFINED_NETWORKS;
+        out->header.dataSize = sizeof(out->data.listDefinedNetworksReply);
+        out->data.listDefinedNetworksReply.numNetworks = nnetworks;
+    }
+    return 0;
+}
+
+static int qemudDispatchNetworkLookupByName(struct qemud_server *server, struct qemud_client *client,
+                                            struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != sizeof(in->data.networkLookupByNameRequest))
+        return -1;
+
+    /* Paranoia NULL termination */
+    in->data.networkLookupByNameRequest.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+    struct qemud_network *network = qemudFindNetworkByName(server, in->data.networkLookupByNameRequest.name);
+    if (!network) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NETWORK_LOOKUP_BY_NAME;
+        out->header.dataSize = sizeof(out->data.networkLookupByNameReply);
+        memcpy(out->data.networkLookupByNameReply.uuid, network->def.uuid, QEMUD_UUID_RAW_LEN);
+    }
+    return 0;
+}
+
+static int qemudDispatchNetworkLookupByUUID(struct qemud_server *server, struct qemud_client *client,
+                                            struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != sizeof(in->data.networkLookupByUUIDRequest))
+        return -1;
+
+    struct qemud_network *network = qemudFindNetworkByUUID(server, in->data.networkLookupByUUIDRequest.uuid);
+    if (!network) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NETWORK_LOOKUP_BY_UUID;
+        out->header.dataSize = sizeof(out->data.networkLookupByUUIDReply);
+        strncpy(out->data.networkLookupByUUIDReply.name, network->def.name, QEMUD_MAX_NAME_LEN-1);
+        out->data.networkLookupByUUIDReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+    }
+    return 0;
+}
+
+static int qemudDispatchNetworkCreate(struct qemud_server *server, struct qemud_client *client,
+                                      struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != sizeof(in->data.networkCreateRequest))
+        return -1;
+
+    in->data.networkCreateRequest.xml[QEMUD_MAX_XML_LEN-1] ='\0';
+
+    struct qemud_network *network = qemudNetworkCreate(server, in->data.networkCreateRequest.xml);
+    if (!network) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NETWORK_CREATE;
+        out->header.dataSize = sizeof(out->data.networkCreateReply);
+        memcpy(out->data.networkCreateReply.uuid, network->def.uuid, QEMUD_UUID_RAW_LEN);
+        strncpy(out->data.networkCreateReply.name, network->def.name, QEMUD_MAX_NAME_LEN-1);
+        out->data.networkCreateReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+    }
+    return 0;
+}
+
+static int qemudDispatchNetworkDefine(struct qemud_server *server, struct qemud_client *client,
+                                      struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != sizeof(in->data.networkDefineRequest))
+        return -1;
+
+    in->data.networkDefineRequest.xml[QEMUD_MAX_XML_LEN-1] ='\0';
+
+    struct qemud_network *network = qemudNetworkDefine(server, in->data.networkDefineRequest.xml);
+    if (!network) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NETWORK_DEFINE;
+        out->header.dataSize = sizeof(out->data.networkDefineReply);
+        memcpy(out->data.networkDefineReply.uuid, network->def.uuid, QEMUD_UUID_RAW_LEN);
+        strncpy(out->data.networkDefineReply.name, network->def.name, QEMUD_MAX_NAME_LEN-1);
+        out->data.networkDefineReply.name[QEMUD_MAX_NAME_LEN-1] = '\0';
+    }
+    return 0;
+}
+
+static int qemudDispatchNetworkUndefine(struct qemud_server *server, struct qemud_client *client,
+                                        struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != sizeof(in->data.networkUndefineRequest))
+        return -1;
+
+    int ret = qemudNetworkUndefine(server, in->data.networkUndefineRequest.uuid);
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NETWORK_UNDEFINE;
+        out->header.dataSize = 0;
+    }
+    return 0;
+}
+
+static int qemudDispatchNetworkStart(struct qemud_server *server, struct qemud_client *client,
+                                     struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != sizeof(in->data.networkStartRequest))
+        return -1;
+
+    struct qemud_network *network = qemudFindNetworkByUUID(server, in->data.networkStartRequest.uuid);
+    if (!network || qemudNetworkStart(server, network) < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NETWORK_START;
+        out->header.dataSize = 0;
+    }
+    return 0;
+}
+
+static int qemudDispatchNetworkDestroy(struct qemud_server *server, struct qemud_client *client,
+                                      struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != sizeof(in->data.networkDestroyRequest))
+        return -1;
+
+    int ret = qemudNetworkDestroy(server, in->data.networkDestroyRequest.uuid);
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NETWORK_DESTROY;
+        out->header.dataSize = 0;
+    }
+    return 0;
+}
+
+static int qemudDispatchNetworkDumpXML(struct qemud_server *server, struct qemud_client *client,
+                                      struct qemud_packet *in, struct qemud_packet *out) {
+    if (in->header.dataSize != sizeof(in->data.networkDumpXMLRequest))
+        return -1;
+
+    int ret = qemudNetworkDumpXML(server,
+                                  in->data.networkDumpXMLRequest.uuid,
+                                  out->data.networkDumpXMLReply.xml, QEMUD_MAX_XML_LEN);
+    if (ret < 0) {
+        if (qemudDispatchFailure(server, client, out) < 0)
+            return -1;
+    } else {
+        out->header.type = QEMUD_PKT_NETWORK_DUMP_XML;
+        out->header.dataSize = sizeof(out->data.networkDumpXMLReply);
+    }
+    return 0;
+}
+
 
 typedef int (*clientFunc)(struct qemud_server *server, struct qemud_client *client,
                           struct qemud_packet *in, struct qemud_packet *out);
@@ -490,7 +727,19 @@ clientFunc funcsTransmitRW[QEMUD_PKT_MAX] = {
     qemudDispatchNumDefinedDomains,
     qemudDispatchDomainStart,
     qemudDispatchDomainDefine,
-    qemudDispatchDomainUndefine
+    qemudDispatchDomainUndefine,
+    qemudDispatchNumNetworks,
+    qemudDispatchListNetworks,
+    qemudDispatchNumDefinedNetworks,
+    qemudDispatchListDefinedNetworks,
+    qemudDispatchNetworkLookupByUUID,
+    qemudDispatchNetworkLookupByName,
+    qemudDispatchNetworkCreate,
+    qemudDispatchNetworkDefine,
+    qemudDispatchNetworkUndefine,
+    qemudDispatchNetworkStart,
+    qemudDispatchNetworkDestroy,
+    qemudDispatchNetworkDumpXML,
 };
 
 clientFunc funcsTransmitRO[QEMUD_PKT_MAX] = {
@@ -515,6 +764,18 @@ clientFunc funcsTransmitRO[QEMUD_PKT_MAX] = {
     NULL,
     NULL,
     NULL,
+    qemudDispatchNumNetworks,
+    qemudDispatchListNetworks,
+    qemudDispatchNumDefinedNetworks,
+    qemudDispatchListDefinedNetworks,
+    qemudDispatchNetworkLookupByUUID,
+    qemudDispatchNetworkLookupByName,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    qemudDispatchNetworkDumpXML,
 };
 
 /*

qemud/driver.c

@@ -545,6 +545,70 @@ int qemudDomainUndefine(struct qemud_server *server, const unsigned char *uuid)
     return 0;
 }
 
+struct qemud_network *qemudFindNetworkByUUID(const struct qemud_server *server,
+                                             const unsigned char *uuid) {
+    server = NULL; uuid = NULL;
+    return NULL;
+}
+
+struct qemud_network *qemudFindNetworkByName(const struct qemud_server *server,
+                                             const char *name) {
+    server = NULL; name = NULL;
+    return NULL;
+}
+
+int qemudNumNetworks(struct qemud_server *server) {
+    server = NULL;
+    return 0;
+}
+
+int qemudListNetworks(struct qemud_server *server, char *const*names, int nnames) {
+    server = NULL; names = NULL; nnames = 0;
+    return 0;
+}
+
+int qemudNumDefinedNetworks(struct qemud_server *server) {
+    server = NULL;
+    return 0;
+}
+
+int qemudListDefinedNetworks(struct qemud_server *server, char *const*names, int nnames) {
+    server = NULL; names = NULL; nnames = 0;
+    return 0;
+}
+
+struct qemud_network *qemudNetworkCreate(struct qemud_server *server, const char *xml) {
+    server = NULL; xml = NULL;
+    return NULL;
+}
+
+struct qemud_network *qemudNetworkDefine(struct qemud_server *server, const char *xml) {
+    server = NULL; xml = NULL;
+    return NULL;
+}
+
+int qemudNetworkUndefine(struct qemud_server *server, const unsigned char *uuid) {
+    qemudReportError(server, VIR_ERR_INVALID_NETWORK, "no network with matching uuid");
+    uuid = NULL;
+    return -1;
+}
+
+int qemudNetworkStart(struct qemud_server *server, struct qemud_network *network) {
+    server = NULL; network = NULL;
+    return 1;
+}
+
+int qemudNetworkDestroy(struct qemud_server *server, const unsigned char *uuid) {
+    uuid = NULL;
+    qemudReportError(server, VIR_ERR_INVALID_NETWORK, "no network with matching uuid");
+    return -1;
+}
+
+int qemudNetworkDumpXML(struct qemud_server *server, const unsigned char *uuid, char *xml, int xmllen) {
+    qemudReportError(server, VIR_ERR_INVALID_NETWORK, "no network with matching uuid");
+    uuid = NULL; xml = NULL; xmllen = 0;
+    return -1;
+}
 
 /*
  * Local variables:

qemud/driver.h

@@ -86,6 +86,34 @@ struct qemud_vm *qemudDomainDefine(struct qemud_server *server,
 int qemudDomainUndefine(struct qemud_server *server,
                         const unsigned char *uuid);
 
+struct qemud_network *qemudFindNetworkByUUID(const struct qemud_server *server,
+                                             const unsigned char *uuid);
+struct qemud_network *qemudFindNetworkByName(const struct qemud_server *server,
+                                             const char *name);
+
+int qemudNumNetworks(struct qemud_server *server);
+int qemudListNetworks(struct qemud_server *server,
+                      char *const*names,
+                      int nnames);
+int qemudNumDefinedNetworks(struct qemud_server *server);
+int qemudListDefinedNetworks(struct qemud_server *server,
+                             char *const*names,
+                             int nnames);
+struct qemud_network *qemudNetworkCreate(struct qemud_server *server,
+                                         const char *xml);
+struct qemud_network *qemudNetworkDefine(struct qemud_server *server,
+                                         const char *xml);
+int qemudNetworkUndefine(struct qemud_server *server,
+                         const unsigned char *uuid);
+int qemudNetworkStart(struct qemud_server *server,
+                      struct qemud_network *network);
+int qemudNetworkDestroy(struct qemud_server *server,
+                        const unsigned char *uuid);
+int qemudNetworkDumpXML(struct qemud_server *server,
+                        const unsigned char *uuid,
+                        char *xml,
+                        int xmllen);
+
 #endif
 
 

qemud/internal.h

@@ -199,6 +199,18 @@ struct qemud_vm {
     struct qemud_vm *next;
 };
 
+/* Virtual Network main configuration */
+struct qemud_network_def {
+    unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    char name[QEMUD_MAX_NAME_LEN];
+};
+
+/* Virtual Network runtime state */
+struct qemud_network {
+    struct qemud_network_def def;
+    struct qemud_network *next;
+};
+
 /* Stores the per-client connection state */
 struct qemud_client {
     int fd;

qemud/protocol.h

@@ -50,6 +50,18 @@ enum {
     QEMUD_PKT_DOMAIN_START,
     QEMUD_PKT_DOMAIN_DEFINE,
     QEMUD_PKT_DOMAIN_UNDEFINE,
+    QEMUD_PKT_NUM_NETWORKS,
+    QEMUD_PKT_LIST_NETWORKS,
+    QEMUD_PKT_NUM_DEFINED_NETWORKS,
+    QEMUD_PKT_LIST_DEFINED_NETWORKS,
+    QEMUD_PKT_NETWORK_LOOKUP_BY_UUID,
+    QEMUD_PKT_NETWORK_LOOKUP_BY_NAME,
+    QEMUD_PKT_NETWORK_CREATE,
+    QEMUD_PKT_NETWORK_DEFINE,
+    QEMUD_PKT_NETWORK_UNDEFINE,
+    QEMUD_PKT_NETWORK_START,
+    QEMUD_PKT_NETWORK_DESTROY,
+    QEMUD_PKT_NETWORK_DUMP_XML,
 
     QEMUD_PKT_MAX,
 } qemud_packet_type;
@@ -62,6 +74,7 @@ enum {
 #define QEMUD_MAX_NAME_LEN 50
 #define QEMUD_MAX_XML_LEN 4096
 #define QEMUD_MAX_NUM_DOMAINS 100
+#define QEMUD_MAX_NUM_NETWORKS 100
 #define QEMUD_MAX_ERROR_LEN 1024
 
 /* Possible guest VM states */
@@ -200,6 +213,63 @@ union qemud_packet_data {
     struct {
         unsigned char uuid[QEMUD_UUID_RAW_LEN];
     } domainUndefineRequest;
+    struct {
+        int32_t numNetworks;
+    } numNetworksReply;
+    struct {
+        int32_t numNetworks;
+        char networks[QEMUD_MAX_NUM_NETWORKS][QEMUD_MAX_NAME_LEN];
+    } listNetworksReply;
+    struct {
+        int32_t numNetworks;
+    } numDefinedNetworksReply;
+    struct {
+        int32_t numNetworks;
+        char networks[QEMUD_MAX_NUM_NETWORKS][QEMUD_MAX_NAME_LEN];
+    } listDefinedNetworksReply;
+    struct {
+        char name[QEMUD_MAX_NAME_LEN];
+    } networkLookupByNameRequest;
+    struct {
+        int32_t id;
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } networkLookupByNameReply;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } networkLookupByUUIDRequest;
+    struct {
+        int32_t id;
+        char name[QEMUD_MAX_NAME_LEN];
+    } networkLookupByUUIDReply;
+    struct {
+        char xml[QEMUD_MAX_XML_LEN];
+    } networkCreateRequest;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+        char name[QEMUD_MAX_NAME_LEN];
+    } networkCreateReply;
+    struct {
+        char xml[QEMUD_MAX_XML_LEN];
+    } networkDefineRequest;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+        char name[QEMUD_MAX_NAME_LEN];
+    } networkDefineReply;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } networkUndefineRequest;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } networkStartRequest;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } networkDestroyRequest;
+    struct {
+        unsigned char uuid[QEMUD_UUID_RAW_LEN];
+    } networkDumpXMLRequest;
+    struct {
+        char xml[QEMUD_MAX_XML_LEN];
+    } networkDumpXMLReply;
 };
 
 /* Each packet has header & data */