test: reject unknown flags

* src/test/test_driver.c (testOpen, testDomainCoreDump)
(testOpenNetwork, testNetworkGetXMLDesc, testOpenInterface)
(testInterfaceChangeBegin, testInterfaceChangeCommit)
(testInterfaceChangeRollback, testInterfaceGetXMLDesc)
(testInterfaceDefineXML, testInterfaceCreate)
(testInterfaceDestroy, testStorageOpen, testStoragePoolStart)
(testStorageFindPoolSources, testStoragePoolCreate)
(testStoragePoolDefine, testStoragePoolBuild)
(testStoragePoolDelete, testStoragePoolRefresh)
(testStoragePoolGetXMLDesc, testStorageVolumeCreateXML)
(testStorageVolumeCreateXMLFrom, testStorageVolumeDelete)
(testStorageVolumeGetXMLDesc, testDevMonOpen)
(testNodeNumOfDevices, testNodeListDevices)
(testNodeDeviceGetXMLDesc, testNodeDeviceCreateXML)
(testSecretOpen, testNWFilterOpen): Reject unknown flags.

diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index 17eb242db98f8ea144c06153a4b1b3f3c1ad81a7..f3fb320f266e40b6ba684c0e8e518965675ba50b 100644 (file)
--- a/src/test/test_driver.c
+++ b/src/test/test_driver.c
@@ -1102,11 +1102,13 @@ static int testOpenFromFile(virConnectPtr conn,
 
 static virDrvOpenStatus testOpen(virConnectPtr conn,
                                  virConnectAuthPtr auth ATTRIBUTE_UNUSED,
-                                 unsigned int flags ATTRIBUTE_UNUSED)
+                                 unsigned int flags)
 {
     int ret;
     testConnPtr privconn;
 
+    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
+
     if (!conn->uri)
         return VIR_DRV_OPEN_DECLINED;
 
@@ -1909,7 +1911,7 @@ cleanup:
 
 static int testDomainCoreDump(virDomainPtr domain,
                               const char *to,
-                              unsigned int flags ATTRIBUTE_UNUSED)
+                              unsigned int flags)
 {
     testConnPtr privconn = domain->conn->privateData;
     int fd = -1;
@@ -1917,6 +1919,8 @@ static int testDomainCoreDump(virDomainPtr domain,
     virDomainEventPtr event = NULL;
     int ret = -1;
 
+    virCheckFlags(VIR_DUMP_CRASH, -1);
+
     testDriverLock(privconn);
     privdom = virDomainFindByName(&privconn->domains,
                                   domain->name);
@@ -2849,7 +2853,10 @@ error:
 
 static virDrvOpenStatus testOpenNetwork(virConnectPtr conn,
                                         virConnectAuthPtr auth ATTRIBUTE_UNUSED,
-                                        unsigned int flags ATTRIBUTE_UNUSED) {
+                                        unsigned int flags)
+{
+    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
+
     if (STRNEQ(conn->driver->name, "Test"))
         return VIR_DRV_OPEN_DECLINED;
 
@@ -3184,12 +3191,14 @@ cleanup:
 }
 
 static char *testNetworkGetXMLDesc(virNetworkPtr network,
-                                   unsigned int flags ATTRIBUTE_UNUSED)
+                                   unsigned int flags)
 {
     testConnPtr privconn = network->conn->privateData;
     virNetworkObjPtr privnet;
     char *ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(privconn);
     privnet = virNetworkFindByName(&privconn->networks,
                                    network->name);
@@ -3298,8 +3307,10 @@ cleanup:
 
 static virDrvOpenStatus testOpenInterface(virConnectPtr conn,
                                           virConnectAuthPtr auth ATTRIBUTE_UNUSED,
-                                          unsigned int flags ATTRIBUTE_UNUSED)
+                                          unsigned int flags)
 {
+    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
+
     if (STRNEQ(conn->driver->name, "Test"))
         return VIR_DRV_OPEN_DECLINED;
 
@@ -3482,11 +3493,13 @@ cleanup:
 }
 
 static int testInterfaceChangeBegin(virConnectPtr conn,
-                                    unsigned int flags ATTRIBUTE_UNUSED)
+                                    unsigned int flags)
 {
     testConnPtr privconn = conn->privateData;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
     if (privconn->transaction_running) {
         testError(VIR_ERR_OPERATION_INVALID,
@@ -3507,11 +3520,13 @@ cleanup:
 }
 
 static int testInterfaceChangeCommit(virConnectPtr conn,
-                                     unsigned int flags ATTRIBUTE_UNUSED)
+                                     unsigned int flags)
 {
     testConnPtr privconn = conn->privateData;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
 
     if (!privconn->transaction_running) {
@@ -3532,11 +3547,13 @@ cleanup:
 }
 
 static int testInterfaceChangeRollback(virConnectPtr conn,
-                                       unsigned int flags ATTRIBUTE_UNUSED)
+                                       unsigned int flags)
 {
     testConnPtr privconn = conn->privateData;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
 
     if (!privconn->transaction_running) {
@@ -3561,12 +3578,14 @@ cleanup:
 }
 
 static char *testInterfaceGetXMLDesc(virInterfacePtr iface,
-                                     unsigned int flags ATTRIBUTE_UNUSED)
+                                     unsigned int flags)
 {
     testConnPtr privconn = iface->conn->privateData;
     virInterfaceObjPtr privinterface;
     char *ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(privconn);
     privinterface = virInterfaceFindByName(&privconn->ifaces,
                                            iface->name);
@@ -3587,13 +3606,15 @@ cleanup:
 
 
 static virInterfacePtr testInterfaceDefineXML(virConnectPtr conn, const char *xmlStr,
-                                              unsigned int flags ATTRIBUTE_UNUSED)
+                                              unsigned int flags)
 {
     testConnPtr privconn = conn->privateData;
     virInterfaceDefPtr def;
     virInterfaceObjPtr iface = NULL;
     virInterfacePtr ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(privconn);
     if ((def = virInterfaceDefParseString(xmlStr)) == NULL)
         goto cleanup;
@@ -3637,12 +3658,14 @@ cleanup:
 }
 
 static int testInterfaceCreate(virInterfacePtr iface,
-                               unsigned int flags ATTRIBUTE_UNUSED)
+                               unsigned int flags)
 {
     testConnPtr privconn = iface->conn->privateData;
     virInterfaceObjPtr privinterface;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
     privinterface = virInterfaceFindByName(&privconn->ifaces,
                                            iface->name);
@@ -3668,12 +3691,14 @@ cleanup:
 }
 
 static int testInterfaceDestroy(virInterfacePtr iface,
-                                unsigned int flags ATTRIBUTE_UNUSED)
+                                unsigned int flags)
 {
     testConnPtr privconn = iface->conn->privateData;
     virInterfaceObjPtr privinterface;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
     privinterface = virInterfaceFindByName(&privconn->ifaces,
                                            iface->name);
@@ -3722,7 +3747,10 @@ static int testStoragePoolObjSetDefaults(virStoragePoolObjPtr pool) {
 
 static virDrvOpenStatus testStorageOpen(virConnectPtr conn,
                                         virConnectAuthPtr auth ATTRIBUTE_UNUSED,
-                                        unsigned int flags ATTRIBUTE_UNUSED) {
+                                        unsigned int flags)
+{
+    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
+
     if (STRNEQ(conn->driver->name, "Test"))
         return VIR_DRV_OPEN_DECLINED;
 
@@ -3927,11 +3955,14 @@ cleanup:
 
 static int
 testStoragePoolStart(virStoragePoolPtr pool,
-                     unsigned int flags ATTRIBUTE_UNUSED) {
+                     unsigned int flags)
+{
     testConnPtr privconn = pool->conn->privateData;
     virStoragePoolObjPtr privpool;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
     privpool = virStoragePoolObjFindByName(&privconn->pools,
                                            pool->name);
@@ -3961,12 +3992,14 @@ static char *
 testStorageFindPoolSources(virConnectPtr conn ATTRIBUTE_UNUSED,
                            const char *type,
                            const char *srcSpec,
-                           unsigned int flags ATTRIBUTE_UNUSED)
+                           unsigned int flags)
 {
     virStoragePoolSourcePtr source = NULL;
     int pool_type;
     char *ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     pool_type = virStoragePoolTypeFromString(type);
     if (!pool_type) {
         testError(VIR_ERR_INTERNAL_ERROR,
@@ -4015,12 +4048,15 @@ cleanup:
 static virStoragePoolPtr
 testStoragePoolCreate(virConnectPtr conn,
                       const char *xml,
-                      unsigned int flags ATTRIBUTE_UNUSED) {
+                      unsigned int flags)
+{
     testConnPtr privconn = conn->privateData;
     virStoragePoolDefPtr def;
     virStoragePoolObjPtr pool = NULL;
     virStoragePoolPtr ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(privconn);
     if (!(def = virStoragePoolDefParseString(xml)))
         goto cleanup;
@@ -4058,12 +4094,15 @@ cleanup:
 static virStoragePoolPtr
 testStoragePoolDefine(virConnectPtr conn,
                       const char *xml,
-                      unsigned int flags ATTRIBUTE_UNUSED) {
+                      unsigned int flags)
+{
     testConnPtr privconn = conn->privateData;
     virStoragePoolDefPtr def;
     virStoragePoolObjPtr pool = NULL;
     virStoragePoolPtr ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(privconn);
     if (!(def = virStoragePoolDefParseString(xml)))
         goto cleanup;
@@ -4125,11 +4164,14 @@ cleanup:
 
 static int
 testStoragePoolBuild(virStoragePoolPtr pool,
-                     unsigned int flags ATTRIBUTE_UNUSED) {
+                     unsigned int flags)
+{
     testConnPtr privconn = pool->conn->privateData;
     virStoragePoolObjPtr privpool;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
     privpool = virStoragePoolObjFindByName(&privconn->pools,
                                            pool->name);
@@ -4193,11 +4235,14 @@ cleanup:
 
 static int
 testStoragePoolDelete(virStoragePoolPtr pool,
-                      unsigned int flags ATTRIBUTE_UNUSED) {
+                      unsigned int flags)
+{
     testConnPtr privconn = pool->conn->privateData;
     virStoragePoolObjPtr privpool;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
     privpool = virStoragePoolObjFindByName(&privconn->pools,
                                            pool->name);
@@ -4225,11 +4270,14 @@ cleanup:
 
 static int
 testStoragePoolRefresh(virStoragePoolPtr pool,
-                       unsigned int flags ATTRIBUTE_UNUSED) {
+                       unsigned int flags)
+{
     testConnPtr privconn = pool->conn->privateData;
     virStoragePoolObjPtr privpool;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
     privpool = virStoragePoolObjFindByName(&privconn->pools,
                                            pool->name);
@@ -4289,11 +4337,14 @@ cleanup:
 
 static char *
 testStoragePoolGetXMLDesc(virStoragePoolPtr pool,
-                          unsigned int flags ATTRIBUTE_UNUSED) {
+                          unsigned int flags)
+{
     testConnPtr privconn = pool->conn->privateData;
     virStoragePoolObjPtr privpool;
     char *ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(privconn);
     privpool = virStoragePoolObjFindByName(&privconn->pools,
                                            pool->name);
@@ -4568,12 +4619,15 @@ testStorageVolumeLookupByPath(virConnectPtr conn,
 static virStorageVolPtr
 testStorageVolumeCreateXML(virStoragePoolPtr pool,
                            const char *xmldesc,
-                           unsigned int flags ATTRIBUTE_UNUSED) {
+                           unsigned int flags)
+{
     testConnPtr privconn = pool->conn->privateData;
     virStoragePoolObjPtr privpool;
     virStorageVolDefPtr privvol = NULL;
     virStorageVolPtr ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(privconn);
     privpool = virStoragePoolObjFindByName(&privconn->pools,
                                            pool->name);
@@ -4649,12 +4703,15 @@ static virStorageVolPtr
 testStorageVolumeCreateXMLFrom(virStoragePoolPtr pool,
                                const char *xmldesc,
                                virStorageVolPtr clonevol,
-                               unsigned int flags ATTRIBUTE_UNUSED) {
+                               unsigned int flags)
+{
     testConnPtr privconn = pool->conn->privateData;
     virStoragePoolObjPtr privpool;
     virStorageVolDefPtr privvol = NULL, origvol = NULL;
     virStorageVolPtr ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(privconn);
     privpool = virStoragePoolObjFindByName(&privconn->pools,
                                            pool->name);
@@ -4738,13 +4795,16 @@ cleanup:
 
 static int
 testStorageVolumeDelete(virStorageVolPtr vol,
-                        unsigned int flags ATTRIBUTE_UNUSED) {
+                        unsigned int flags)
+{
     testConnPtr privconn = vol->conn->privateData;
     virStoragePoolObjPtr privpool;
     virStorageVolDefPtr privvol;
     int i;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(privconn);
     privpool = virStoragePoolObjFindByName(&privconn->pools,
                                            vol->pool);
@@ -4863,12 +4923,15 @@ cleanup:
 
 static char *
 testStorageVolumeGetXMLDesc(virStorageVolPtr vol,
-                            unsigned int flags ATTRIBUTE_UNUSED) {
+                            unsigned int flags)
+{
     testConnPtr privconn = vol->conn->privateData;
     virStoragePoolObjPtr privpool;
     virStorageVolDefPtr privvol;
     char *ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(privconn);
     privpool = virStoragePoolObjFindByName(&privconn->pools,
                                            vol->pool);
@@ -4948,7 +5011,10 @@ cleanup:
 /* Node device implementations */
 static virDrvOpenStatus testDevMonOpen(virConnectPtr conn,
                                        virConnectAuthPtr auth ATTRIBUTE_UNUSED,
-                                       unsigned int flags ATTRIBUTE_UNUSED) {
+                                       unsigned int flags)
+{
+    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
+
     if (STRNEQ(conn->driver->name, "Test"))
         return VIR_DRV_OPEN_DECLINED;
 
@@ -4964,12 +5030,14 @@ static int testDevMonClose(virConnectPtr conn) {
 static int
 testNodeNumOfDevices(virConnectPtr conn,
                      const char *cap,
-                     unsigned int flags ATTRIBUTE_UNUSED)
+                     unsigned int flags)
 {
     testConnPtr driver = conn->privateData;
     int ndevs = 0;
     unsigned int i;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(driver);
     for (i = 0; i < driver->devs.count; i++)
         if ((cap == NULL) ||
@@ -4985,12 +5053,14 @@ testNodeListDevices(virConnectPtr conn,
                     const char *cap,
                     char **const names,
                     int maxnames,
-                    unsigned int flags ATTRIBUTE_UNUSED)
+                    unsigned int flags)
 {
     testConnPtr driver = conn->privateData;
     int ndevs = 0;
     unsigned int i;
 
+    virCheckFlags(0, -1);
+
     testDriverLock(driver);
     for (i = 0; i < driver->devs.count && ndevs < maxnames; i++) {
         virNodeDeviceObjLock(driver->devs.objs[i]);
@@ -5041,12 +5111,14 @@ cleanup:
 
 static char *
 testNodeDeviceGetXMLDesc(virNodeDevicePtr dev,
-                         unsigned int flags ATTRIBUTE_UNUSED)
+                         unsigned int flags)
 {
     testConnPtr driver = dev->conn->privateData;
     virNodeDeviceObjPtr obj;
     char *ret = NULL;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(driver);
     obj = virNodeDeviceFindByName(&driver->devs, dev->name);
     testDriverUnlock(driver);
@@ -5172,7 +5244,7 @@ cleanup:
 static virNodeDevicePtr
 testNodeDeviceCreateXML(virConnectPtr conn,
                         const char *xmlDesc,
-                        unsigned int flags ATTRIBUTE_UNUSED)
+                        unsigned int flags)
 {
     testConnPtr driver = conn->privateData;
     virNodeDeviceDefPtr def = NULL;
@@ -5182,6 +5254,8 @@ testNodeDeviceCreateXML(virConnectPtr conn,
     virNodeDevicePtr dev = NULL;
     virNodeDevCapsDefPtr caps;
 
+    virCheckFlags(0, NULL);
+
     testDriverLock(driver);
 
     def = virNodeDeviceDefParseString(xmlDesc, CREATE_DEVICE);
@@ -5402,7 +5476,10 @@ static void testDomainEventQueue(testConnPtr driver,
 
 static virDrvOpenStatus testSecretOpen(virConnectPtr conn,
                                        virConnectAuthPtr auth ATTRIBUTE_UNUSED,
-                                       unsigned int flags ATTRIBUTE_UNUSED) {
+                                       unsigned int flags)
+{
+    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
+
     if (STRNEQ(conn->driver->name, "Test"))
         return VIR_DRV_OPEN_DECLINED;
 
@@ -5418,7 +5495,10 @@ static int testSecretClose(virConnectPtr conn) {
 
 static virDrvOpenStatus testNWFilterOpen(virConnectPtr conn,
                                          virConnectAuthPtr auth ATTRIBUTE_UNUSED,
-                                         unsigned int flags ATTRIBUTE_UNUSED) {
+                                         unsigned int flags)
+{
+    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
+
     if (STRNEQ(conn->driver->name, "Test"))
         return VIR_DRV_OPEN_DECLINED;