[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] [PATCH 2/2] nwfilter: Rebuild filters only of new filter is different than current



Compare two filter definitions for equality and only rebuild the filters
if the two filters are found to be different. This improves performance
during an update of a filter with no obvious change or the reloading of
filters during a 'kill -SIGHUP'

---
 src/Makefile.am               |    1 
 src/conf/nwfilter_conf.c      |  213 ++++++++++++++++++++
 src/conf/nwfilter_params.c    |   18 +
 src/conf/nwfilter_params.h    |    2 
 src/conf/nwfilter_protocols.c |  447 ++++++++++++++++++++++++++++++++++++++++++
 src/conf/nwfilter_protocols.h |   56 +++++
 6 files changed, 737 insertions(+)

Index: libvirt-iterator/src/conf/nwfilter_conf.c
===================================================================
--- libvirt-iterator.orig/src/conf/nwfilter_conf.c
+++ libvirt-iterator/src/conf/nwfilter_conf.c
@@ -42,6 +42,7 @@
 #include "memory.h"
 #include "virterror_internal.h"
 #include "datatypes.h"
+#include "nwfilter_protocols.h"
 #include "nwfilter_params.h"
 #include "nwfilter_conf.h"
 #include "domain_conf.h"
@@ -140,6 +141,10 @@ static const struct int_map chain_priori
     INTMAP_ENTRY_LAST,
 };
 
+static bool virNWFilterDefEqual(const virNWFilterDefPtr def1,
+                                const virNWFilterDefPtr def2,
+                                bool cmpUUIDs);
+
 /*
  * only one filter update allowed
  */
@@ -407,6 +412,134 @@ virNWFilterRuleDefAddString(virNWFilterR
     return nwf->strings[nwf->nstrings-1];
 }
 
+static bool
+virNWFilterRuleDefEqual(const virNWFilterRuleDefPtr def1,
+                        const virNWFilterRuleDefPtr def2)
+{
+    unsigned int i, j;
+    bool equal;
+
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (def1->priority != def2->priority ||
+        def1->flags != def2->flags ||
+        def1->action != def2->action ||
+        def1->tt != def2->tt ||
+        def1->prtclType != def2->prtclType)
+        return false;
+
+    switch (def1->prtclType) {
+    case VIR_NWFILTER_RULE_PROTOCOL_NONE:
+        return true;
+    case VIR_NWFILTER_RULE_PROTOCOL_MAC:
+        equal = virNWFilterEthHdrFilterDefEqual(&def1->p.ethHdrFilter,
+                                                &def2->p.ethHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_VLAN:
+        equal = virNWFilterVlanHdrFilterDefEqual(&def1->p.vlanHdrFilter,
+                                                 &def2->p.vlanHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_STP:
+        equal = virNWFilterStpHdrFilterDefEqual(&def1->p.stpHdrFilter,
+                                                &def2->p.stpHdrFilter);
+    case VIR_NWFILTER_RULE_PROTOCOL_ARP:
+    case VIR_NWFILTER_RULE_PROTOCOL_RARP:
+        equal = virNWFilterArpHdrFilterDefEqual(&def1->p.arpHdrFilter,
+                                                &def2->p.arpHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_IP:
+        equal = virNWFilterIpHdrFilterDefEqual(&def1->p.ipHdrFilter,
+                                               &def2->p.ipHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_IPV6:
+        equal = virNWFilterIpv6HdrFilterDefEqual(&def1->p.ipv6HdrFilter,
+                                                 &def2->p.ipv6HdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_TCP:
+    case VIR_NWFILTER_RULE_PROTOCOL_TCPoIPV6:
+        equal = virNWFilterTcpHdrFilterDefEqual(&def1->p.tcpHdrFilter,
+                                                &def2->p.tcpHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_ICMP:
+    case VIR_NWFILTER_RULE_PROTOCOL_ICMPV6:
+        equal = virNWFilterIcmpHdrFilterDefEqual(&def1->p.icmpHdrFilter,
+                                                 &def2->p.icmpHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_IGMP:
+        equal = virNWFilterIgmpHdrFilterDefEqual(&def1->p.igmpHdrFilter,
+                                                 &def2->p.igmpHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_UDP:
+    case VIR_NWFILTER_RULE_PROTOCOL_UDPoIPV6:
+        equal = virNWFilterUdpHdrFilterDefEqual(&def1->p.udpHdrFilter,
+                                                &def2->p.udpHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_UDPLITE:
+    case VIR_NWFILTER_RULE_PROTOCOL_UDPLITEoIPV6:
+        equal = virNWFilterUdpliteHdrFilterDefEqual(&def1->p.udpliteHdrFilter,
+                                                    &def2->p.udpliteHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_ESP:
+    case VIR_NWFILTER_RULE_PROTOCOL_ESPoIPV6:
+        equal = virNWFilterEspHdrFilterDefEqual(&def1->p.espHdrFilter,
+                                                &def2->p.espHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_AH:
+    case VIR_NWFILTER_RULE_PROTOCOL_AHoIPV6:
+        equal = virNWFilterAhHdrFilterDefEqual(&def1->p.ahHdrFilter,
+                                               &def2->p.ahHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_SCTP:
+    case VIR_NWFILTER_RULE_PROTOCOL_SCTPoIPV6:
+        equal = virNWFilterSctpHdrFilterDefEqual(&def1->p.sctpHdrFilter,
+                                                 &def2->p.sctpHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_ALL:
+    case VIR_NWFILTER_RULE_PROTOCOL_ALLoIPV6:
+        equal = virNWFilterAllHdrFilterDefEqual(&def1->p.allHdrFilter,
+                                                &def2->p.allHdrFilter);
+        break;
+    case VIR_NWFILTER_RULE_PROTOCOL_LAST:
+        return false;
+    }
+
+    if (!equal)
+        return false;
+
+    if (def1->nVarAccess != def2->nVarAccess)
+        return false;
+
+    for (i = 0; i < def1->nVarAccess; i++) {
+        equal = false;
+        for (j = 0; j < def2->nVarAccess; j++) {
+            equal = virNWFilterVarAccessEqual(def1->varAccess[i],
+                                              def2->varAccess[j]);
+            if (equal)
+                break;
+        }
+        if (!equal)
+            return false;
+    }
+
+    if (def1->nstrings != def2->nstrings)
+        return false;
+
+    for (i = 0; i < def1->nstrings; i++) {
+        equal = false;
+        for (j = 0; j < def2->nstrings; j++) {
+            equal = STREQ(def1->strings[i], def2->strings[j]);
+            if (equal)
+                break;
+        }
+        if (!equal)
+            return false;
+    }
+    return true;
+}
 
 void
 virNWFilterObjRemove(virNWFilterObjListPtr nwfilters,
@@ -2817,6 +2950,14 @@ virNWFilterObjAssignDef(virConnectPtr co
     virNWFilterLockFilterUpdates();
 
     if ((nwfilter = virNWFilterObjFindByName(nwfilters, def->name))) {
+
+        if (virNWFilterDefEqual(def, nwfilter->def, false)) {
+            virNWFilterDefFree(nwfilter->def);
+            nwfilter->def = def;
+            virNWFilterUnlockFilterUpdates();
+            return nwfilter;
+        }
+
         nwfilter->newDef = def;
         /* trigger the update on VMs referencing the filter */
         if (virNWFilterTriggerVMFilterRebuild(conn)) {
@@ -3226,6 +3367,22 @@ virNWFilterIncludeDefFormat(virNWFilterI
     return virBufferContentAndReset(&buf);
 }
 
+static bool
+virNWFilterIncludeDefEqual(const virNWFilterIncludeDefPtr def1,
+                           const virNWFilterIncludeDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!STREQ(def1->filterref, def2->filterref) ||
+        !virNWFilterHashTableEqual(def1->params, def2->params))
+        return false;
+
+    return true;
+}
 
 static char *
 virNWFilterEntryFormat(virNWFilterEntryPtr entry)
@@ -3235,6 +3392,22 @@ virNWFilterEntryFormat(virNWFilterEntryP
     return virNWFilterIncludeDefFormat(entry->include);
 }
 
+static bool
+virNWFilterEntryEqual(const virNWFilterEntryPtr def1,
+                      const virNWFilterEntryPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!virNWFilterRuleDefEqual(def1->rule, def2->rule) ||
+        !virNWFilterIncludeDefEqual(def1->include, def2->include))
+        return false;
+
+    return true;
+}
 
 char *
 virNWFilterDefFormat(virNWFilterDefPtr def)
@@ -3278,6 +3451,46 @@ virNWFilterDefFormat(virNWFilterDefPtr d
     return NULL;
 }
 
+/* Compare two filter definitions for equality.
+ * Both filters must have the same content and all content must appear in the
+ * same order.
+ *
+ * @def1: the 1st filter
+ * @def2: the 2nd filter
+ * @cmpUUIDs: whether to compare the UUIDs of the two filters
+ *
+ * Returns true if both filters are equal, false otherwise.
+ */
+static bool
+virNWFilterDefEqual(const virNWFilterDefPtr def1, const virNWFilterDefPtr def2,
+                    bool cmpUUIDs)
+{
+    unsigned int i;
+    bool equal;
+
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!STREQ(def1->name, def2->name) ||
+        (cmpUUIDs && memcmp(def1->uuid, def2->uuid, sizeof(def1->uuid)) != 0) ||
+        !STREQ(def1->chainsuffix, def2->chainsuffix) ||
+        def1->chainPriority != def2->chainPriority ||
+        def1->nentries != def2->nentries)
+        return false;
+
+    /* the order of the filter entries must be the same in both */
+    for (i = 0; i < def1->nentries; i++) {
+        equal = virNWFilterEntryEqual(def1->filterEntries[i],
+                                      def2->filterEntries[i]);
+        if (!equal)
+            return false;
+    }
+
+    return true;
+}
 
 char *virNWFilterConfigFile(const char *dir,
                             const char *name)
Index: libvirt-iterator/src/conf/nwfilter_params.c
===================================================================
--- libvirt-iterator.orig/src/conf/nwfilter_params.c
+++ libvirt-iterator/src/conf/nwfilter_params.c
@@ -747,6 +747,19 @@ err_exit:
     return -1;
 }
 
+bool
+virNWFilterHashTableEqual(const virNWFilterHashTablePtr hash1,
+                          const virNWFilterHashTablePtr hash2)
+{
+    if (hash1 == hash2)
+        return true;
+
+    if (!hash1 || !hash2)
+        return false;
+
+    return virHashEqual(hash1->hashTable, hash2->hashTable,
+                           (virHashValueComparator)strcmp);
+}
 
 static bool
 isValidVarName(const char *var)
@@ -896,6 +909,11 @@ bool
 virNWFilterVarAccessEqual(const virNWFilterVarAccessPtr a,
                           const virNWFilterVarAccessPtr b)
 {
+    if (a == b)
+        return true;
+    if (!a || !b)
+        return false;
+
     if (a->accessType != b->accessType)
         return false;
 
Index: libvirt-iterator/src/conf/nwfilter_params.h
===================================================================
--- libvirt-iterator.orig/src/conf/nwfilter_params.h
+++ libvirt-iterator/src/conf/nwfilter_params.h
@@ -84,6 +84,8 @@ void *virNWFilterHashTableRemoveEntry(vi
                                       const char *name);
 int virNWFilterHashTablePutAll(virNWFilterHashTablePtr src,
                                virNWFilterHashTablePtr dest);
+bool virNWFilterHashTableEqual(const virNWFilterHashTablePtr hash1,
+                               const virNWFilterHashTablePtr hash2);
 
 # define VALID_VARNAME \
   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
Index: libvirt-iterator/src/Makefile.am
===================================================================
--- libvirt-iterator.orig/src/Makefile.am
+++ libvirt-iterator/src/Makefile.am
@@ -152,6 +152,7 @@ NETWORK_CONF_SOURCES =						\
 # Network filter driver generic impl APIs
 NWFILTER_PARAM_CONF_SOURCES =					\
 		conf/nwfilter_params.c conf/nwfilter_params.h	\
+		conf/nwfilter_protocols.c conf/nwfilter_protocols.h \
 		conf/nwfilter_conf.h
 
 NWFILTER_CONF_SOURCES =					\
Index: libvirt-iterator/src/conf/nwfilter_protocols.c
===================================================================
--- /dev/null
+++ libvirt-iterator/src/conf/nwfilter_protocols.c
@@ -0,0 +1,447 @@
+/*
+ * nwfilter_protocols.c: protocol handling
+ *
+ * Copyright (C) 2011 IBM Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Stefan Berger <stefanb us ibm com>
+ */
+
+#include <config.h>
+
+#include "internal.h"
+
+#include "uuid.h"
+#include "virterror_internal.h"
+#include "datatypes.h"
+#include "nwfilter_params.h"
+#include "nwfilter_conf.h"
+#include "nwfilter_protocols.h"
+
+#define VIR_FROM_THIS VIR_FROM_NWFILTER
+
+#define NWITEMDESCEQUAL(ITEM) \
+    virNWFilterNWItemDescEqual(&def1->ITEM, &def2->ITEM)
+
+static bool
+virNWFilterNWItemDescEqual(const nwItemDescPtr def1,
+                           const nwItemDescPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (def1->flags != def2->flags ||
+        !virNWFilterVarAccessEqual(def1->varAccess, def2->varAccess) ||
+        def1->datatype != def2->datatype)
+        return false;
+
+    switch (def1->datatype) {
+    case DATATYPE_STRINGCOPY:
+        if (strcmp(def1->u.string, def2->u.string))
+            return false;
+        break;
+    case DATATYPE_UINT16:
+    case DATATYPE_UINT8:
+    case DATATYPE_UINT16_HEX:
+    case DATATYPE_UINT8_HEX:
+    case DATATYPE_MACADDR:
+    case DATATYPE_MACMASK:
+    case DATATYPE_IPADDR:
+    case DATATYPE_IPMASK:
+    case DATATYPE_IPV6ADDR:
+    case DATATYPE_IPV6MASK:
+    case DATATYPE_STRING:
+    case DATATYPE_BOOLEAN:
+    case DATATYPE_UINT32:
+    case DATATYPE_UINT32_HEX:
+        if (memcmp(&def1->u, &def2->u, sizeof(def1->u)))
+            return false;
+        break;
+    case DATATYPE_LAST:
+        return false;
+     }
+
+    return true;
+}
+
+static bool
+virNWFilterEthHdrDataDefEqual(const ethHdrDataDefPtr def1,
+                              const ethHdrDataDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !NWITEMDESCEQUAL(dataSrcMACMask) ||
+        !NWITEMDESCEQUAL(dataDstMACAddr) ||
+        !NWITEMDESCEQUAL(dataDstMACMask))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterEthHdrFilterDefEqual(const ethHdrFilterDefPtr def1,
+                                const ethHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!virNWFilterEthHdrDataDefEqual(&def1->ethHdr, &def2->ethHdr) ||
+        !NWITEMDESCEQUAL(dataProtocolID) ||
+        !NWITEMDESCEQUAL(dataComment))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterVlanHdrFilterDefEqual(const vlanHdrFilterDefPtr def1,
+                                 const vlanHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!virNWFilterEthHdrDataDefEqual(&def1->ethHdr, &def2->ethHdr) ||
+        !NWITEMDESCEQUAL(dataVlanID) ||
+        !NWITEMDESCEQUAL(dataVlanEncap) ||
+        !NWITEMDESCEQUAL(dataComment))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterStpHdrFilterDefEqual(const stpHdrFilterDefPtr def1,
+                                const stpHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!virNWFilterEthHdrDataDefEqual(&def1->ethHdr, &def2->ethHdr) ||
+        !NWITEMDESCEQUAL(dataType) ||
+        !NWITEMDESCEQUAL(dataFlags) ||
+        !NWITEMDESCEQUAL(dataRootPri) ||
+        !NWITEMDESCEQUAL(dataRootPriHi) ||
+        !NWITEMDESCEQUAL(dataRootAddr) ||
+        !NWITEMDESCEQUAL(dataRootAddrMask) ||
+        !NWITEMDESCEQUAL(dataRootCost) ||
+        !NWITEMDESCEQUAL(dataRootCostHi) ||
+        !NWITEMDESCEQUAL(dataSndrPrio) ||
+        !NWITEMDESCEQUAL(dataSndrPrioHi) ||
+        !NWITEMDESCEQUAL(dataSndrAddr) ||
+        !NWITEMDESCEQUAL(dataSndrAddrMask) ||
+        !NWITEMDESCEQUAL(dataPort) ||
+        !NWITEMDESCEQUAL(dataPortHi) ||
+        !NWITEMDESCEQUAL(dataAge) ||
+        !NWITEMDESCEQUAL(dataAgeHi) ||
+        !NWITEMDESCEQUAL(dataMaxAge) ||
+        !NWITEMDESCEQUAL(dataMaxAgeHi) ||
+        !NWITEMDESCEQUAL(dataHelloTime) ||
+        !NWITEMDESCEQUAL(dataHelloTimeHi) ||
+        !NWITEMDESCEQUAL(dataFwdDelay) ||
+        !NWITEMDESCEQUAL(dataFwdDelayHi) ||
+        !NWITEMDESCEQUAL(dataComment))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterArpHdrFilterDefEqual(const arpHdrFilterDefPtr def1,
+                                const arpHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!virNWFilterEthHdrDataDefEqual(&def1->ethHdr, &def2->ethHdr) ||
+        !NWITEMDESCEQUAL(dataHWType) ||
+        !NWITEMDESCEQUAL(dataProtocolType) ||
+        !NWITEMDESCEQUAL(dataOpcode) ||
+        !NWITEMDESCEQUAL(dataARPSrcMACAddr) ||
+        !NWITEMDESCEQUAL(dataARPSrcIPAddr) ||
+        !NWITEMDESCEQUAL(dataARPDstMACAddr) ||
+        !NWITEMDESCEQUAL(dataARPDstIPAddr) ||
+        !NWITEMDESCEQUAL(dataGratuitousARP) ||
+        !NWITEMDESCEQUAL(dataComment))
+        return false;
+
+    return true;
+}
+
+static bool
+virNWFilterIpHdrDataDefEqual(const ipHdrDataDefPtr def1,
+                             const ipHdrDataDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataIPVersion) ||
+        !NWITEMDESCEQUAL(dataSrcIPAddr) ||
+        !NWITEMDESCEQUAL(dataSrcIPMask) ||
+        !NWITEMDESCEQUAL(dataDstIPAddr) ||
+        !NWITEMDESCEQUAL(dataDstIPMask) ||
+        !NWITEMDESCEQUAL(dataProtocolID) ||
+        !NWITEMDESCEQUAL(dataSrcIPFrom) ||
+        !NWITEMDESCEQUAL(dataSrcIPTo) ||
+        !NWITEMDESCEQUAL(dataDstIPFrom) ||
+        !NWITEMDESCEQUAL(dataDstIPTo) ||
+        !NWITEMDESCEQUAL(dataDSCP) ||
+        !NWITEMDESCEQUAL(dataState) ||
+        !NWITEMDESCEQUAL(dataConnlimitAbove) ||
+        !NWITEMDESCEQUAL(dataComment))
+        return false;
+
+    return true;
+}
+
+static bool
+virNWFilterPortDataDefEqual(const portDataDefPtr def1,
+                            const portDataDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcPortStart) ||
+        !NWITEMDESCEQUAL(dataSrcPortEnd) ||
+        !NWITEMDESCEQUAL(dataDstPortStart) ||
+        !NWITEMDESCEQUAL(dataDstPortEnd))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterIpHdrFilterDefEqual(const ipHdrFilterDefPtr def1,
+                               const ipHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!virNWFilterEthHdrDataDefEqual(&def1->ethHdr, &def2->ethHdr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr) ||
+        !virNWFilterPortDataDefEqual(&def1->portData, &def2->portData))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterIpv6HdrFilterDefEqual(const ipv6HdrFilterDefPtr def1,
+                                 const ipv6HdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!virNWFilterEthHdrDataDefEqual(&def1->ethHdr, &def2->ethHdr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr) ||
+        !virNWFilterPortDataDefEqual(&def1->portData, &def2->portData))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterIcmpHdrFilterDefEqual(const icmpHdrFilterDefPtr def1,
+                                 const icmpHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr) ||
+        !NWITEMDESCEQUAL(dataICMPType) ||
+        !NWITEMDESCEQUAL(dataICMPCode) ||
+        !NWITEMDESCEQUAL(dataStateFlags))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterAllHdrFilterDefEqual(const allHdrFilterDefPtr def1,
+                                const allHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterIgmpHdrFilterDefEqual(const igmpHdrFilterDefPtr def1,
+                                 const igmpHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterTcpHdrFilterDefEqual(const tcpHdrFilterDefPtr def1,
+                                const tcpHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr) ||
+        !virNWFilterPortDataDefEqual(&def1->portData, &def2->portData) ||
+        !NWITEMDESCEQUAL(dataTCPOption) ||
+        !NWITEMDESCEQUAL(dataTCPFlags))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterUdpHdrFilterDefEqual(const udpHdrFilterDefPtr def1,
+                                const udpHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr) ||
+        !virNWFilterPortDataDefEqual(&def1->portData, &def2->portData))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterSctpHdrFilterDefEqual(const sctpHdrFilterDefPtr def1,
+                                 const sctpHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr) ||
+        !virNWFilterPortDataDefEqual(&def1->portData, &def2->portData))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterEspHdrFilterDefEqual(const espHdrFilterDefPtr def1,
+                                const espHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterAhHdrFilterDefEqual(const ahHdrFilterDefPtr def1,
+                               const ahHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr))
+        return false;
+
+    return true;
+}
+
+bool
+virNWFilterUdpliteHdrFilterDefEqual(const udpliteHdrFilterDefPtr def1,
+                                    const udpliteHdrFilterDefPtr def2)
+{
+    if (def1 == def2)
+        return true;
+
+    if (!def1 || !def2)
+        return false;
+
+    if (!NWITEMDESCEQUAL(dataSrcMACAddr) ||
+        !virNWFilterIpHdrDataDefEqual(&def1->ipHdr, &def2->ipHdr))
+        return false;
+
+    return true;
+}
+
Index: libvirt-iterator/src/conf/nwfilter_protocols.h
===================================================================
--- /dev/null
+++ libvirt-iterator/src/conf/nwfilter_protocols.h
@@ -0,0 +1,56 @@
+/*
+ * nwfilter_protocols.h: protocol handling
+ *
+ * Copyright (C) 2011 IBM Corporation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Stefan Berger <stefanb us ibm com>
+ */
+
+#include "datatypes.h"
+#include "nwfilter_params.h"
+#include "nwfilter_conf.h"
+
+bool virNWFilterEthHdrFilterDefEqual(const ethHdrFilterDefPtr def1,
+                                     const ethHdrFilterDefPtr def2);
+bool virNWFilterVlanHdrFilterDefEqual(const vlanHdrFilterDefPtr def1,
+                                      const vlanHdrFilterDefPtr def2);
+bool virNWFilterStpHdrFilterDefEqual(const stpHdrFilterDefPtr def1,
+                                     const stpHdrFilterDefPtr def2);
+bool virNWFilterArpHdrFilterDefEqual(const arpHdrFilterDefPtr def1,
+                                     const arpHdrFilterDefPtr def2);
+bool virNWFilterIpHdrFilterDefEqual(const ipHdrFilterDefPtr def1,
+                                    const ipHdrFilterDefPtr def2);
+bool virNWFilterIpv6HdrFilterDefEqual(const ipv6HdrFilterDefPtr def1,
+                                      const ipv6HdrFilterDefPtr def2);
+bool virNWFilterIcmpHdrFilterDefEqual(const icmpHdrFilterDefPtr def1,
+                                      const icmpHdrFilterDefPtr def2);
+bool virNWFilterAllHdrFilterDefEqual(const allHdrFilterDefPtr def1,
+                                     const allHdrFilterDefPtr def2);
+bool virNWFilterIgmpHdrFilterDefEqual(const igmpHdrFilterDefPtr def1,
+                                      const igmpHdrFilterDefPtr def2);
+bool virNWFilterTcpHdrFilterDefEqual(const tcpHdrFilterDefPtr def1,
+                                     const tcpHdrFilterDefPtr def2);
+bool virNWFilterUdpHdrFilterDefEqual(const udpHdrFilterDefPtr def1,
+                                     const udpHdrFilterDefPtr def2);
+bool virNWFilterSctpHdrFilterDefEqual(const sctpHdrFilterDefPtr def1,
+                                      const sctpHdrFilterDefPtr def2);
+bool virNWFilterEspHdrFilterDefEqual(const espHdrFilterDefPtr def1,
+                                     const espHdrFilterDefPtr def2);
+bool virNWFilterAhHdrFilterDefEqual(const ahHdrFilterDefPtr def1,
+                                    const ahHdrFilterDefPtr def2);
+bool virNWFilterUdpliteHdrFilterDefEqual(const udpliteHdrFilterDefPtr def1,
+                                         const udpliteHdrFilterDefPtr def2);


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]