From 3bf24abc8c30df2d3075de7c6632b66b25e6ef30 Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Wed, 7 Apr 2010 23:02:18 +0200 Subject: [PATCH] nwfilter: Support for learning a VM's IP address This patch implements support for learning a VM's IP address. It uses the pcap library to listen on the VM's backend network interface (tap) or the physical ethernet device (macvtap) and tries to capture packets with source or destination MAC address of the VM and learn from DHCP Offers, ARP traffic, or first-sent IPv4 packet what the IP address of the VM's interface is. This then allows to instantiate the network traffic filtering rules without the user having to provide the IP parameter somewhere in the filter description or in the interface description as a parameter. This only supports to detect the parameter IP, which is for the assumed single IPv4 address of a VM. There is not support for interfaces that may have multiple IP addresses (IP aliasing) or IPv6 that may then require more than one valid IP address to be detected. A VM can have multiple independent interfaces that each uses a different IP address and in that case it will be attempted to detect each one of the address independently. So, when for example an interface description in the domain XML has looked like this up to now: you may omit the IP parameter: Internally I am walking the 'tree' of a VM's referenced network filters and determine with the given variables which variables are missing. Now, the above IP parameter may be missing and this causes a libvirt-internal thread to be started that uses the pcap library's API to listen to the backend interface (in case of macvtap to the physical interface) in an attempt to determine the missing IP parameter. If the backend interface disappears the thread terminates assuming the VM was brought down. In case of a macvtap device a timeout is being used to wait for packets from the given VM (filtering by VM's interface MAC address). If the VM's macvtap device disappeared the thread also terminates. In all other cases it tries to determine the IP address of the VM and will then apply the rules late on the given interface, which would have happened immediately if the IP parameter had been explicitly given. In case an error happens while the firewall rules are applied, the VM's backend interface is 'down'ed preventing it to communicate. Reasons for failure for applying the network firewall rules may that an ebtables/iptables command failes or OOM errors. Essentially the same failure reasons may occur as when the firewall rules are applied immediately on VM start, except that due to the late application of the filtering rules the VM now is already running and cannot be hindered anymore from starting. Bringing down the whole VM would probably be considered too drastic. While a VM's IP address is attempted to be determined only limited updates to network filters are allowed. In particular it is prevented that filters are modified in such a way that they would introduce new variables. A caveat: The algorithm does not know which one is the appropriate IP address of a VM. If the VM spoofs an IP address in its first ARP traffic or IPv4 packets its filtering rules will be instantiated for this IP address, thus 'locking' it to the found IP address. So, it's still 'safer' to explicitly provide the IP address of a VM's interface in the filter description if it is known beforehand. * configure.ac: detect libpcap * libvirt.spec.in: require libpcap[-devel] if qemu is built * src/internal.h: add the new ATTRIBUTE_PACKED define * src/Makefile.am src/libvirt_private.syms: add the new modules and symbols * src/nwfilter/nwfilter_learnipaddr.[ch]: new module being added * src/nwfilter/nwfilter_driver.c src/conf/nwfilter_conf.[ch] src/nwfilter/nwfilter_ebiptables_driver.[ch] src/nwfilter/nwfilter_gentech_driver.[ch]: plu the new functionality in * tests/nwfilterxml2xmltest: extend testing --- configure.ac | 39 ++ libvirt.spec.in | 9 + src/Makefile.am | 14 +- src/conf/nwfilter_conf.c | 7 +- src/conf/nwfilter_conf.h | 3 + src/internal.h | 17 + src/libvirt_private.syms | 12 + src/nwfilter/nwfilter_driver.c | 11 +- src/nwfilter/nwfilter_ebiptables_driver.c | 236 ++++++++ src/nwfilter/nwfilter_ebiptables_driver.h | 8 + src/nwfilter/nwfilter_gentech_driver.c | 406 +++++++++++++- src/nwfilter/nwfilter_gentech_driver.h | 14 +- src/nwfilter/nwfilter_learnipaddr.c | 622 ++++++++++++++++++++++ src/nwfilter/nwfilter_learnipaddr.h | 67 +++ tests/nwfilterxml2xmltest | Bin 0 -> 462966 bytes 15 files changed, 1427 insertions(+), 38 deletions(-) create mode 100644 src/nwfilter/nwfilter_learnipaddr.c create mode 100644 src/nwfilter/nwfilter_learnipaddr.h create mode 100755 tests/nwfilterxml2xmltest diff --git a/configure.ac b/configure.ac index e13961efa7..dd1298f178 100644 --- a/configure.ac +++ b/configure.ac @@ -41,6 +41,7 @@ XMLRPC_REQUIRED=1.14.0 HAL_REQUIRED=0.5.0 DEVMAPPER_REQUIRED=1.0.0 LIBCURL_REQUIRED="7.18.0" +LIBPCAP_REQUIRED="1.0.0" dnl Checks for C compiler. AC_PROG_CC @@ -1045,6 +1046,39 @@ AC_SUBST([NUMACTL_CFLAGS]) AC_SUBST([NUMACTL_LIBS]) +dnl pcap lib +LIBPCAP_CONFIG="pcap-config" +LIBPCAP_CFLAGS="" +LIBPCAP_LIBS="" +LIBPCAP_FOUND="no" + +AC_ARG_WITH([libpcap], AC_HELP_STRING([--with-libpcap=@<:@PFX@:>@], [libpcap location])) +if test "$with_qemu" = "yes"; then + if test "x$with_libpcap" != "xno" ; then + if test "x$with_libpcap" != "x" ; then + LIBPCAP_CONFIG=$with_libpcap/bin/$LIBPCAP_CONFIG + fi + AC_MSG_CHECKING(libpcap $LIBPCAP_CONFIG >= $LIBPCAP_REQUIRED ) + if ! $LIBPCAP_CONFIG --libs > /dev/null 2>&1 ; then + AC_MSG_RESULT(no) + else + LIBPCAP_LIBS="`$LIBPCAP_CONFIG --libs`" + LIBPCAP_CFLAGS="`$LIBPCAP_CONFIG --cflags`" + LIBPCAP_FOUND="yes" + AC_MSG_RESULT(yes) + fi + fi +fi + +if test "x$LIBPCAP_FOUND" = "xyes"; then + AC_DEFINE_UNQUOTED([HAVE_LIBPCAP], 1, [whether libpcap can be used]) +fi + +AC_SUBST([LIBPCAP_CFLAGS]) +AC_SUBST([LIBPCAP_LIBS]) + + + dnl dnl Checks for the UML driver dnl @@ -2129,6 +2163,11 @@ AC_MSG_NOTICE([ xmlrpc: $XMLRPC_CFLAGS $XMLRPC_LIBS]) else AC_MSG_NOTICE([ xmlrpc: no]) fi +if test "$with_qemu" = "yes" ; then +AC_MSG_NOTICE([ pcap: $LIBPCAP_CFLAGS $LIBPCAP_LIBS]) +else +AC_MSG_NOTICE([ pcap: no]) +fi AC_MSG_NOTICE([]) AC_MSG_NOTICE([Test suite]) AC_MSG_NOTICE([]) diff --git a/libvirt.spec.in b/libvirt.spec.in index dcbc139dcb..834b1a666e 100644 --- a/libvirt.spec.in +++ b/libvirt.spec.in @@ -61,6 +61,7 @@ %define with_udev 0%{!?_without_udev:0} %define with_hal 0%{!?_without_hal:0} %define with_yajl 0%{!?_without_yajl:0} +%define with_libpcap 0%{!?_without_libpcap:0} # Non-server/HV driver defaults which are always enabled %define with_python 0%{!?_without_python:1} @@ -147,6 +148,11 @@ %define with_yajl 0%{!?_without_yajl:%{server_drivers}} %endif +# Enable libpcap library +%if %{with_qemu} +%define with_libpcap 0%{!?_without_libpcap:%{server_drivers}} +%endif + # Force QEMU to run as non-root %if 0%{?fedora} >= 12 || 0%{?rhel} >= 6 %define qemu_user qemu @@ -266,6 +272,9 @@ BuildRequires: libpciaccess-devel >= 0.10.9 %if %{with_yajl} BuildRequires: yajl-devel %endif +%if %{with_libpcap} +BuildRequires: libpcap-devel +%endif %if %{with_avahi} BuildRequires: avahi-devel %endif diff --git a/src/Makefile.am b/src/Makefile.am index cd1848ef18..db69ab96b8 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -308,7 +308,9 @@ NWFILTER_DRIVER_SOURCES = \ nwfilter/nwfilter_gentech_driver.c \ nwfilter/nwfilter_gentech_driver.h \ nwfilter/nwfilter_ebiptables_driver.c \ - nwfilter/nwfilter_ebiptables_driver.h + nwfilter/nwfilter_ebiptables_driver.h \ + nwfilter/nwfilter_learnipaddr.c \ + nwfilter/nwfilter_learnipaddr.h # Security framework and drivers for various models @@ -764,10 +766,11 @@ else libvirt_la_LIBADD += libvirt_driver_nwfilter.la noinst_LTLIBRARIES += libvirt_driver_nwfilter.la endif -libvirt_driver_nwfilter_la_CFLAGS = \ +libvirt_driver_nwfilter_la_CFLAGS = $(LIBPCAP_CFLAGS) \ -I@top_srcdir@/src/conf +libvirt_driver_nwfilter_la_LDFLAGS = $(LIBPCAP_LIBS) if WITH_DRIVER_MODULES -libvirt_driver_nwfilter_la_LDFLAGS = -module -avoid-version ../gnulib/lib/libgnu.la +libvirt_driver_nwfilter_la_LDFLAGS += -module -avoid-version ../gnulib/lib/libgnu.la endif libvirt_driver_nwfilter_la_SOURCES = $(NWFILTER_DRIVER_SOURCES) endif @@ -912,6 +915,7 @@ libvirt_la_LDFLAGS = $(VERSION_SCRIPT_FLAGS)libvirt.syms \ -version-info $(LIBVIRT_VERSION_INFO) \ $(COVERAGE_CFLAGS:-f%=-Wc,-f%) \ $(LIBXML_LIBS) \ + $(LIBPCAP_LIBS) \ $(DRIVER_MODULE_LIBS) \ $(CYGWIN_EXTRA_LDFLAGS) $(MINGW_EXTRA_LDFLAGS) libvirt_la_CFLAGS = $(COVERAGE_CFLAGS) -DIN_LIBVIRT @@ -960,8 +964,8 @@ libvirt_lxc_SOURCES = \ $(NODE_INFO_SOURCES) \ $(ENCRYPTION_CONF_SOURCES) \ $(DOMAIN_CONF_SOURCES) \ - $(NWFILTER_PARAM_CONF_SOURCES) \ - $(CPU_CONF_SOURCES) + $(CPU_CONF_SOURCES) \ + $(NWFILTER_PARAM_CONF_SOURCES) libvirt_lxc_LDFLAGS = $(WARN_CFLAGS) $(COVERAGE_LDCFLAGS) $(CAPNG_LIBS) $(YAJL_LIBS) libvirt_lxc_LDADD = $(LIBXML_LIBS) $(NUMACTL_LIBS) ../gnulib/lib/libgnu.la libvirt_lxc_CFLAGS = \ diff --git a/src/conf/nwfilter_conf.c b/src/conf/nwfilter_conf.c index 16c1a255ba..3991c3bf98 100644 --- a/src/conf/nwfilter_conf.c +++ b/src/conf/nwfilter_conf.c @@ -114,17 +114,18 @@ struct int_map { */ static virMutex updateMutex; -static void +void virNWFilterLockFilterUpdates(void) { virMutexLock(&updateMutex); } -static void +void virNWFilterUnlockFilterUpdates(void) { virMutexUnlock(&updateMutex); } + /* * attribute names for the rules XML */ @@ -2615,7 +2616,7 @@ int virNWFilterConfLayerInit(virHashIterator domUpdateCB) { virNWFilterDomainFWUpdateCB = domUpdateCB; - if (virMutexInit(&updateMutex)) + if (virMutexInitRecursive(&updateMutex)) return 1; return 0; diff --git a/src/conf/nwfilter_conf.h b/src/conf/nwfilter_conf.h index 37d75dfe54..fc3ce16e7a 100644 --- a/src/conf/nwfilter_conf.h +++ b/src/conf/nwfilter_conf.h @@ -558,6 +558,9 @@ virNWFilterDefPtr virNWFilterDefParseFile(virConnectPtr conn, void virNWFilterPoolObjLock(virNWFilterPoolObjPtr obj); void virNWFilterPoolObjUnlock(virNWFilterPoolObjPtr obj); +void virNWFilterLockFilterUpdates(void); +void virNWFilterUnlockFilterUpdates(void); + int virNWFilterConfLayerInit(virHashIterator domUpdateCB); void virNWFilterConfLayerShutdown(void); diff --git a/src/internal.h b/src/internal.h index 807288b868..2e73210d0e 100644 --- a/src/internal.h +++ b/src/internal.h @@ -138,6 +138,23 @@ # endif # endif +/** + * ATTRIBUTE_PACKED + * + * force a structure to be packed, i.e. not following architecture and + * compiler best alignments for its sub components. It's needed for example + * for the network filetering code when defining the content of raw + * ethernet packets. + * Others compiler than gcc may use something different e.g. #pragma pack(1) + */ +# ifndef ATTRIBUTE_PACKED +# if __GNUC_PREREQ (3, 3) +# define ATTRIBUTE_PACKED __attribute__((packed)) +# else +# error "Need an __attribute__((packed)) equivalent" +# endif +# endif + # ifndef ATTRIBUTE_NONNULL # if __GNUC_PREREQ (3, 3) # define ATTRIBUTE_NONNULL(m) __attribute__((__nonnull__(m))) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 1682b25cd1..814e2d8bc8 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -499,6 +499,8 @@ virNWFilterRegisterCallbackDriver; virNWFilterTestUnassignDef; virNWFilterConfLayerInit; virNWFilterConfLayerShutdown; +virNWFilterLockFilterUpdates; +virNWFilterUnlockFilterUpdates; #nwfilter_params.h @@ -514,6 +516,16 @@ virNWFilterInstantiateFilter; virNWFilterTeardownFilter; +#nwfilter_learnipaddr.h +ipAddressMap; +ipAddressMapLock; +pendingLearnReq; +pendingLearnReqLock; +virNWFilterGetIpAddrForIfname; +virNWFilterDelIpAddrForIfname; +virNWFilterLookupLearnReq; + + # pci.h pciGetDevice; pciFreeDevice; diff --git a/src/nwfilter/nwfilter_driver.c b/src/nwfilter/nwfilter_driver.c index 58df4e126a..f366005c70 100644 --- a/src/nwfilter/nwfilter_driver.c +++ b/src/nwfilter/nwfilter_driver.c @@ -37,6 +37,8 @@ #include "nwfilter_gentech_driver.h" +#include "nwfilter_learnipaddr.h" + #define VIR_FROM_THIS VIR_FROM_NWFILTER #define nwfilterLog(msg...) fprintf(stderr, msg) @@ -65,9 +67,12 @@ static int nwfilterDriverStartup(int privileged) { char *base = NULL; - if (virNWFilterConfLayerInit(virNWFilterDomainFWUpdateCB) < 0) + if (virNWFilterLearnInit() < 0) return -1; + if (virNWFilterConfLayerInit(virNWFilterDomainFWUpdateCB) < 0) + goto conf_init_err; + if (VIR_ALLOC(driverState) < 0) goto alloc_err_exit; @@ -120,6 +125,9 @@ error: alloc_err_exit: virNWFilterConfLayerShutdown(); +conf_init_err: + virNWFilterLearnShutdown(); + return -1; } @@ -413,5 +421,6 @@ static virStateDriver stateDriver = { int nwfilterRegister(void) { virRegisterNWFilterDriver(&nwfilterDriver); virRegisterStateDriver(&stateDriver); + virNWFilterLearnInit(); return 0; } diff --git a/src/nwfilter/nwfilter_ebiptables_driver.c b/src/nwfilter/nwfilter_ebiptables_driver.c index 4ec7edffc0..23c50dfd12 100644 --- a/src/nwfilter/nwfilter_ebiptables_driver.c +++ b/src/nwfilter/nwfilter_ebiptables_driver.c @@ -2519,6 +2519,242 @@ ebiptablesInstCommand(virBufferPtr buf, } +/** + * ebtablesApplyBasicRules + * + * @conn: virConnect object + * @ifname: name of the backend-interface to which to apply the rules + * @macaddr: MAC address the VM is using in packets sent through the + * interface + * + * Returns 0 on success, 1 on failure with the rules removed + * + * Apply basic filtering rules on the given interface + * - filtering for MAC address spoofing + * - allowing IPv4 & ARP traffic + */ +int +ebtablesApplyBasicRules(const char *ifname, + const unsigned char *macaddr) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + int cli_status; + char chain[MAX_CHAINNAME_LENGTH]; + char chainPrefix = CHAINPREFIX_HOST_IN_TEMP; + char macaddr_str[VIR_MAC_STRING_BUFLEN]; + + virFormatMacAddr(macaddr, macaddr_str); + + ebtablesUnlinkTmpRootChain(&buf, 1, ifname); + ebtablesUnlinkTmpRootChain(&buf, 0, ifname); + ebtablesRemoveTmpSubChains(&buf, ifname); + ebtablesRemoveTmpRootChain(&buf, 1, ifname); + ebtablesRemoveTmpRootChain(&buf, 0, ifname); + ebiptablesExecCLI(&buf, &cli_status); + + ebtablesCreateTmpRootChain(&buf, 1, ifname, 1); + + PRINT_ROOT_CHAIN(chain, chainPrefix, ifname); + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -s ! %s -j DROP") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain, + macaddr_str, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -p IPv4 -j ACCEPT") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -p ARP -j ACCEPT") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -j DROP") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain, + CMD_STOPONERR(1)); + + ebtablesLinkTmpRootChain(&buf, 1, ifname, 1); + + if (ebiptablesExecCLI(&buf, &cli_status) || cli_status != 0) + goto tear_down_tmpebchains; + + return 0; + +tear_down_tmpebchains: + ebtablesRemoveBasicRules(ifname); + + virNWFilterReportError(VIR_ERR_BUILD_FIREWALL, + "%s", + _("Some rules could not be created.")); + + return 1; +} + + +/** + * ebtablesApplyDHCPOnlyRules + * + * @ifname: name of the backend-interface to which to apply the rules + * @macaddr: MAC address the VM is using in packets sent through the + * interface + * @dhcpserver: The DHCP server from which the VM may receive traffic + * from; may be NULL + * + * Returns 0 on success, 1 on failure with the rules removed + * + * Apply filtering rules so that the VM can only send and receive + * DHCP traffic and nothing else. + */ +int +ebtablesApplyDHCPOnlyRules(const char *ifname, + const unsigned char *macaddr, + const char *dhcpserver) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + int cli_status; + char chain_in [MAX_CHAINNAME_LENGTH], + chain_out[MAX_CHAINNAME_LENGTH]; + char macaddr_str[VIR_MAC_STRING_BUFLEN]; + char *srcIPParam = NULL; + + if (dhcpserver) { + virBufferVSprintf(&buf, " --ip-src %s", dhcpserver); + if (virBufferError(&buf)) + return 1; + srcIPParam = virBufferContentAndReset(&buf); + } + + virFormatMacAddr(macaddr, macaddr_str); + + ebtablesUnlinkTmpRootChain(&buf, 1, ifname); + ebtablesUnlinkTmpRootChain(&buf, 0, ifname); + ebtablesRemoveTmpSubChains(&buf, ifname); + ebtablesRemoveTmpRootChain(&buf, 1, ifname); + ebtablesRemoveTmpRootChain(&buf, 0, ifname); + ebiptablesExecCLI(&buf, &cli_status); + + ebtablesCreateTmpRootChain(&buf, 1, ifname, 1); + ebtablesCreateTmpRootChain(&buf, 0, ifname, 1); + + PRINT_ROOT_CHAIN(chain_in , CHAINPREFIX_HOST_IN_TEMP , ifname); + PRINT_ROOT_CHAIN(chain_out, CHAINPREFIX_HOST_OUT_TEMP, ifname); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s" + " -s %s -d Broadcast " + " -p ipv4 --ip-protocol udp" + " --ip-src 0.0.0.0 --ip-dst 255.255.255.255" + " --ip-sport 68 --ip-dport 67" + " -j ACCEPT") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain_in, + macaddr_str, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -j DROP") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain_in, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s" + " -d %s" + " -p ipv4 --ip-protocol udp" + " %s" + " --ip-sport 67 --ip-dport 68" + " -j ACCEPT") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain_out, + macaddr_str, + srcIPParam != NULL ? srcIPParam : "", + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -j DROP") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain_out, + CMD_STOPONERR(1)); + + ebtablesLinkTmpRootChain(&buf, 1, ifname, 1); + ebtablesLinkTmpRootChain(&buf, 0, ifname, 1); + + if (ebiptablesExecCLI(&buf, &cli_status) || cli_status != 0) + goto tear_down_tmpebchains; + + VIR_FREE(srcIPParam); + + return 0; + +tear_down_tmpebchains: + ebtablesRemoveBasicRules(ifname); + + virNWFilterReportError(VIR_ERR_BUILD_FIREWALL, + "%s", + _("Some rules could not be created.")); + + VIR_FREE(srcIPParam); + + return 1; +} + + +int +ebtablesRemoveBasicRules(const char *ifname) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + int cli_status; + + ebtablesUnlinkTmpRootChain(&buf, 1, ifname); + ebtablesUnlinkTmpRootChain(&buf, 0, ifname); + ebtablesRemoveTmpSubChains(&buf, ifname); + ebtablesRemoveTmpRootChain(&buf, 1, ifname); + ebtablesRemoveTmpRootChain(&buf, 0, ifname); + + ebiptablesExecCLI(&buf, &cli_status); + return 0; +} + + static int ebiptablesRuleOrderSort(const void *a, const void *b) { diff --git a/src/nwfilter/nwfilter_ebiptables_driver.h b/src/nwfilter/nwfilter_ebiptables_driver.h index d99de3b719..4129d05d8d 100644 --- a/src/nwfilter/nwfilter_ebiptables_driver.h +++ b/src/nwfilter/nwfilter_ebiptables_driver.h @@ -45,4 +45,12 @@ extern virNWFilterTechDriver ebiptables_driver; # define EBIPTABLES_DRIVER_ID "ebiptables" + +int ebtablesApplyBasicRules(const char *ifname, + const unsigned char *macaddr); +int ebtablesApplyDHCPOnlyRules(const char *ifname, + const unsigned char *macaddr, + const char *dhcpServer); +int ebtablesRemoveBasicRules(const char *ifname); + #endif diff --git a/src/nwfilter/nwfilter_gentech_driver.c b/src/nwfilter/nwfilter_gentech_driver.c index 76967c10a2..270dc2b05b 100644 --- a/src/nwfilter/nwfilter_gentech_driver.c +++ b/src/nwfilter/nwfilter_gentech_driver.c @@ -24,6 +24,9 @@ #include #include +#include +#include +#include #include "internal.h" @@ -34,12 +37,16 @@ #include "virterror_internal.h" #include "nwfilter_gentech_driver.h" #include "nwfilter_ebiptables_driver.h" +#include "nwfilter_learnipaddr.h" #define VIR_FROM_THIS VIR_FROM_NWFILTER #define NWFILTER_STD_VAR_MAC "MAC" +#define NWFILTER_STD_VAR_IP "IP" + +static int _virNWFilterTeardownFilter(const char *ifname); static virNWFilterTechDriverPtr filter_tech_drivers[] = { @@ -108,6 +115,8 @@ virNWFilterRuleInstFree(virNWFilterRuleInstPtr inst) * @tables: pointer to hash tabel to add values to * @macaddr: The string of the MAC address to add to the hash table, * may be NULL + * @ipaddr: The string of the IP address to add to the hash table; + * may be NULL * * Returns 0 in case of success, 1 in case an error happened with * error having been reported. @@ -116,7 +125,8 @@ virNWFilterRuleInstFree(virNWFilterRuleInstPtr inst) */ static int virNWFilterVarHashmapAddStdValues(virNWFilterHashTablePtr table, - char *macaddr) + char *macaddr, + char *ipaddr) { if (macaddr) { if (virHashAddEntry(table->hashTable, @@ -128,6 +138,16 @@ virNWFilterVarHashmapAddStdValues(virNWFilterHashTablePtr table, } } + if (ipaddr) { + if (virHashAddEntry(table->hashTable, + NWFILTER_STD_VAR_IP, + ipaddr) < 0) { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("Could not add variable 'IP' to hashmap")); + return 1; + } + } + return 0; } @@ -135,22 +155,24 @@ virNWFilterVarHashmapAddStdValues(virNWFilterHashTablePtr table, /** * virNWFilterCreateVarHashmap: * @macaddr: pointer to string containing formatted MAC address of interface + * @ipaddr: pointer to string containing formatted IP address used by + * VM on this interface; may be NULL * * Create a hashmap used for evaluating the firewall rules. Initializes - * it with the standard variable 'MAC'. + * it with the standard variable 'MAC' and 'IP' if provided. * * Returns pointer to hashmap, NULL if an error occcurred and error message * is attached to the virConnect object. */ virNWFilterHashTablePtr -virNWFilterCreateVarHashmap(char *macaddr) { +virNWFilterCreateVarHashmap(char *macaddr, char *ipaddr) { virNWFilterHashTablePtr table = virNWFilterHashTableCreate(0); if (!table) { virReportOOMError(); return NULL; } - if (virNWFilterVarHashmapAddStdValues(table, macaddr)) { + if (virNWFilterVarHashmapAddStdValues(table, macaddr, ipaddr)) { virNWFilterHashTableFree(table); return NULL; } @@ -276,9 +298,9 @@ _virNWFilterInstantiateRec(virConnectPtr conn, virNWFilterHashTablePtr vars, int *nEntries, virNWFilterRuleInstPtr **insts, - enum instCase useNewFilter, int *foundNewFilter) + enum instCase useNewFilter, int *foundNewFilter, + virNWFilterDriverStatePtr driver) { - virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData; virNWFilterPoolObjPtr obj; int rc = 0; int i; @@ -356,7 +378,95 @@ _virNWFilterInstantiateRec(virConnectPtr conn, tmpvars, nEntries, insts, useNewFilter, - foundNewFilter); + foundNewFilter, + driver); + + virNWFilterHashTableFree(tmpvars); + + virNWFilterPoolObjUnlock(obj); + if (rc) + break; + } else { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, + _("referenced filter '%s' is missing"), + inc->filterref); + rc = 1; + break; + } + } + } + return rc; +} + + +static int +virNWFilterDetermineMissingVarsRec(virConnectPtr conn, + virNWFilterDefPtr filter, + virNWFilterHashTablePtr vars, + virNWFilterHashTablePtr missing_vars, + int useNewFilter, + virNWFilterDriverStatePtr driver) +{ + virNWFilterPoolObjPtr obj; + int rc = 0; + int i, j; + virNWFilterDefPtr next_filter; + + for (i = 0; i < filter->nentries; i++) { + virNWFilterRuleDefPtr rule = filter->filterEntries[i]->rule; + virNWFilterIncludeDefPtr inc = filter->filterEntries[i]->include; + if (rule) { + // check all variables of this rule + for (j = 0; j < rule->nvars; j++) { + if (!virHashLookup(vars->hashTable, rule->vars[j])) { + virNWFilterHashTablePut(missing_vars, rule->vars[j], + strdup("1"), 1); + } + } + } else if (inc) { + VIR_DEBUG("Following filter %s\n", inc->filterref); + obj = virNWFilterPoolObjFindByName(&driver->pools, + inc->filterref); + if (obj) { + + if (obj->wantRemoved) { + virNWFilterReportError(VIR_ERR_NO_NWFILTER, + _("Filter '%s' is in use."), + inc->filterref); + rc = 1; + virNWFilterPoolObjUnlock(obj); + break; + } + + // create a temporary hashmap for depth-first tree traversal + virNWFilterHashTablePtr tmpvars = + virNWFilterCreateVarsFrom(inc->params, + vars); + if (!tmpvars) { + virReportOOMError(); + rc = 1; + virNWFilterPoolObjUnlock(obj); + break; + } + + next_filter = obj->def; + + switch (useNewFilter) { + case INSTANTIATE_FOLLOW_NEWFILTER: + if (obj->newDef) { + next_filter = obj->newDef; + } + break; + case INSTANTIATE_ALWAYS: + break; + } + + rc = virNWFilterDetermineMissingVarsRec(conn, + next_filter, + tmpvars, + missing_vars, + useNewFilter, + driver); virNWFilterHashTableFree(tmpvars); @@ -429,9 +539,12 @@ virNWFilterInstantiate(virConnectPtr conn, enum virDomainNetType nettype, virNWFilterDefPtr filter, const char *ifname, + const char *linkdev, virNWFilterHashTablePtr vars, enum instCase useNewFilter, int *foundNewFilter, - bool teardownOld) + bool teardownOld, + const unsigned char *macaddr, + virNWFilterDriverStatePtr driver) { int rc; int j, nptrs; @@ -440,6 +553,44 @@ virNWFilterInstantiate(virConnectPtr conn, void **ptrs = NULL; int instantiate = 1; + virNWFilterLockFilterUpdates(); + + virNWFilterHashTablePtr missing_vars = virNWFilterHashTableCreate(0); + if (!missing_vars) { + virReportOOMError(); + rc = 1; + goto err_exit; + } + + rc = virNWFilterDetermineMissingVarsRec(conn, + filter, + vars, + missing_vars, + useNewFilter, + driver); + if (rc) + goto err_exit; + + if (virHashSize(missing_vars->hashTable) == 1) { + if (virHashLookup(missing_vars->hashTable, + NWFILTER_STD_VAR_IP) != NULL) { + if (virNWFilterLookupLearnReq(ifname) == NULL) { + rc = virNWFilterLearnIPAddress(ifname, + linkdev, + nettype, macaddr, + filter->name, + vars, driver, + DETECT_DHCP|DETECT_STATIC); + } + goto err_exit; + } + rc = 1; + goto err_exit; + } else if (virHashSize(missing_vars->hashTable) > 1) { + rc = 1; + goto err_exit; + } + rc = _virNWFilterInstantiateRec(conn, techdriver, nettype, @@ -447,7 +598,8 @@ virNWFilterInstantiate(virConnectPtr conn, ifname, vars, &nEntries, &insts, - useNewFilter, foundNewFilter); + useNewFilter, foundNewFilter, + driver); if (rc) goto err_exit; @@ -478,24 +630,33 @@ virNWFilterInstantiate(virConnectPtr conn, err_exit: + virNWFilterUnlockFilterUpdates(); + for (j = 0; j < nEntries; j++) virNWFilterRuleInstFree(insts[j]); VIR_FREE(insts); + virNWFilterHashTableFree(missing_vars); + return rc; } static int -_virNWFilterInstantiateFilter(virConnectPtr conn, - const virDomainNetDefPtr net, - bool teardownOld, - enum instCase useNewFilter) +__virNWFilterInstantiateFilter(virConnectPtr conn, + bool teardownOld, + const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + enum instCase useNewFilter, + virNWFilterDriverStatePtr driver) { int rc; const char *drvname = EBIPTABLES_DRIVER_ID; - virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData; virNWFilterTechDriverPtr techdriver; virNWFilterPoolObjPtr obj; virNWFilterHashTablePtr vars, vars1; @@ -503,6 +664,8 @@ _virNWFilterInstantiateFilter(virConnectPtr conn, char vmmacaddr[VIR_MAC_STRING_BUFLEN] = {0}; int foundNewFilter = 0; char *str_macaddr = NULL; + const char *ipaddr; + char *str_ipaddr = NULL; techdriver = virNWFilterTechDriverForName(drvname); @@ -514,25 +677,25 @@ _virNWFilterInstantiateFilter(virConnectPtr conn, return 1; } - VIR_DEBUG("filter name: %s", net->filter); + VIR_DEBUG("filter name: %s", filtername); - obj = virNWFilterPoolObjFindByName(&driver->pools, net->filter); + obj = virNWFilterPoolObjFindByName(&driver->pools, filtername); if (!obj) { virNWFilterReportError(VIR_ERR_NO_NWFILTER, _("Could not find filter '%s'"), - net->filter); + filtername); return 1; } if (obj->wantRemoved) { virNWFilterReportError(VIR_ERR_NO_NWFILTER, _("Filter '%s' is in use."), - net->filter); + filtername); rc = 1; goto err_exit; } - virFormatMacAddr(net->mac, vmmacaddr); + virFormatMacAddr(macaddr, vmmacaddr); str_macaddr = strdup(vmmacaddr); if (!str_macaddr) { virReportOOMError(); @@ -540,16 +703,27 @@ _virNWFilterInstantiateFilter(virConnectPtr conn, goto err_exit; } - vars1 = virNWFilterCreateVarHashmap(str_macaddr); + ipaddr = virNWFilterGetIpAddrForIfname(ifname); + if (ipaddr) { + str_ipaddr = strdup(ipaddr); + if (!str_ipaddr) { + virReportOOMError(); + rc = 1; + goto err_exit; + } + } + + vars1 = virNWFilterCreateVarHashmap(str_macaddr, str_ipaddr); if (!vars1) { rc = 1; goto err_exit; } str_macaddr = NULL; + str_ipaddr = NULL; vars = virNWFilterCreateVarsFrom(vars1, - net->filterparams); + filterparams); if (!vars) { rc = 1; goto err_exit_vars1; @@ -571,12 +745,15 @@ _virNWFilterInstantiateFilter(virConnectPtr conn, rc = virNWFilterInstantiate(conn, techdriver, - net->type, + nettype, filter, - net->ifname, + ifname, + linkdev, vars, useNewFilter, &foundNewFilter, - teardownOld); + teardownOld, + macaddr, + driver); virNWFilterHashTableFree(vars); @@ -584,15 +761,180 @@ err_exit_vars1: virNWFilterHashTableFree(vars1); err_exit: - virNWFilterPoolObjUnlock(obj); + VIR_FREE(str_ipaddr); VIR_FREE(str_macaddr); return rc; } +static int +_virNWFilterInstantiateFilter(virConnectPtr conn, + const virDomainNetDefPtr net, + bool teardownOld, + enum instCase useNewFilter) +{ + const char *linkdev = (net->type == VIR_DOMAIN_NET_TYPE_DIRECT) + ? net->data.direct.linkdev + : NULL; + return __virNWFilterInstantiateFilter(conn, + teardownOld, + net->ifname, + linkdev, + net->type, + net->mac, + net->filter, + net->filterparams, + useNewFilter, + conn->nwfilterPrivateData); +} + + +// FIXME: move chgIfFlags, ifUp, checkIf into common file & share w/ macvtap.c + +/* + * chgIfFlags: Change flags on an interface + * @ifname : name of the interface + * @flagclear : the flags to clear + * @flagset : the flags to set + * + * The new flags of the interface will be calculated as + * flagmask = (~0 ^ flagclear) + * newflags = (curflags & flagmask) | flagset; + * + * Returns 0 on success, errno on failure. + */ +static int chgIfFlags(const char *ifname, short flagclear, short flagset) { + struct ifreq ifr; + int rc = 0; + int flags; + short flagmask = (~0 ^ flagclear); + int fd = socket(PF_PACKET, SOCK_DGRAM, 0); + + if (fd < 0) + return errno; + + if (virStrncpy(ifr.ifr_name, + ifname, strlen(ifname), sizeof(ifr.ifr_name)) == NULL) { + rc = ENODEV; + goto err_exit; + } + + if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) { + rc = errno; + goto err_exit; + } + + flags = (ifr.ifr_flags & flagmask) | flagset; + + if (ifr.ifr_flags != flags) { + ifr.ifr_flags = flags; + + if (ioctl(fd, SIOCSIFFLAGS, &ifr) < 0) + rc = errno; + } + +err_exit: + close(fd); + return rc; +} + +/* + * ifUp + * @name: name of the interface + * @up: 1 for up, 0 for down + * + * Function to control if an interface is activated (up, 1) or not (down, 0) + * + * Returns 0 in case of success or an errno code in case of failure. + */ +static int +ifUp(const char *name, int up) +{ + return chgIfFlags(name, + (up) ? 0 : IFF_UP, + (up) ? IFF_UP : 0); +} + + +/** + * checkIf + * + * @ifname: Name of the interface + * @macaddr: expected MAC address of the interface + * + * FIXME: the interface's index is another good parameter to check + * + * Determine whether a given interface is still available. If so, + * it must have the given MAC address. + * + * Returns an error code ENODEV in case the interface does not exist + * anymore or its MAC address is different, 0 otherwise. + */ +int +checkIf(const char *ifname, const unsigned char *macaddr) +{ + struct ifreq ifr; + int fd = socket(PF_PACKET, SOCK_DGRAM, 0); + int rc = 0; + + if (fd < 0) + return errno; + + if (virStrncpy(ifr.ifr_name, + ifname, strlen(ifname), sizeof(ifr.ifr_name)) == NULL) { + rc = ENODEV; + goto err_exit; + } + + if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) { + rc = errno; + goto err_exit; + } + + if (memcmp(&ifr.ifr_hwaddr.sa_data, macaddr, 6) != 0) + rc = ENODEV; + + err_exit: + close(fd); + return rc; +} + + +int +virNWFilterInstantiateFilterLate(virConnectPtr conn, + const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + virNWFilterDriverStatePtr driver) +{ + int rc; + rc = __virNWFilterInstantiateFilter(conn, + 1, + ifname, + linkdev, + nettype, + macaddr, + filtername, + filterparams, + INSTANTIATE_ALWAYS, + driver); + if (rc) { + //something went wrong... 'DOWN' the interface + if (ifUp(ifname ,0)) { + // assuming interface disappeared... + _virNWFilterTeardownFilter(ifname); + } + } + return rc; +} + + int virNWFilterInstantiateFilter(virConnectPtr conn, const virDomainNetDefPtr net) @@ -649,8 +991,8 @@ virNWFilterTearOldFilter(virConnectPtr conn, } -int -virNWFilterTeardownFilter(const virDomainNetDefPtr net) +static int +_virNWFilterTeardownFilter(const char *ifname) { const char *drvname = EBIPTABLES_DRIVER_ID; virNWFilterTechDriverPtr techdriver; @@ -663,13 +1005,21 @@ virNWFilterTeardownFilter(const virDomainNetDefPtr net) drvname); return 1; } + techdriver->allTeardown(ifname); - techdriver->allTeardown(net->ifname); + virNWFilterDelIpAddrForIfname(ifname); return 0; } +int +virNWFilterTeardownFilter(const virDomainNetDefPtr net) +{ + return _virNWFilterTeardownFilter(net->ifname); +} + + void virNWFilterDomainFWUpdateCB(void *payload, const char *name ATTRIBUTE_UNUSED, diff --git a/src/nwfilter/nwfilter_gentech_driver.h b/src/nwfilter/nwfilter_gentech_driver.h index 1068102357..ebb0b64f72 100644 --- a/src/nwfilter/nwfilter_gentech_driver.h +++ b/src/nwfilter/nwfilter_gentech_driver.h @@ -45,12 +45,24 @@ int virNWFilterRollbackUpdateFilter(virConnectPtr conn, int virNWFilterTearOldFilter(virConnectPtr conn, const virDomainNetDefPtr net); +int virNWFilterInstantiateFilterLate(virConnectPtr conn, + const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + virNWFilterDriverStatePtr driver); + int virNWFilterTeardownFilter(const virDomainNetDefPtr net); -virNWFilterHashTablePtr virNWFilterCreateVarHashmap(char *macaddr); +virNWFilterHashTablePtr virNWFilterCreateVarHashmap(char *macaddr, + char *ipaddr); void virNWFilterDomainFWUpdateCB(void *payload, const char *name ATTRIBUTE_UNUSED, void *data); +int checkIf(const char *ifname, const unsigned char *macaddr); + #endif diff --git a/src/nwfilter/nwfilter_learnipaddr.c b/src/nwfilter/nwfilter_learnipaddr.c new file mode 100644 index 0000000000..4a74582967 --- /dev/null +++ b/src/nwfilter/nwfilter_learnipaddr.c @@ -0,0 +1,622 @@ +/* + * nwfilter_learnipaddr.c: support for learning IP address used by a VM + * on an interface + * + * Copyright (C) 2010 IBM Corp. + * Copyright (C) 2010 Stefan Berger + * + * 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 + */ + +#include + +#ifdef HAVE_LIBPCAP +# include +#endif + +#include +#include + +#include +#include +#include +#include +#include + +#include "internal.h" + +#include "buf.h" +#include "memory.h" +#include "logging.h" +#include "datatypes.h" +#include "virterror_internal.h" +#include "threads.h" +#include "conf/nwfilter_params.h" +#include "conf/domain_conf.h" +#include "nwfilter_gentech_driver.h" +#include "nwfilter_ebiptables_driver.h" +#include "nwfilter_learnipaddr.h" + +#define VIR_FROM_THIS VIR_FROM_NWFILTER + + +/* structure of an ARP request/reply message */ +struct f_arphdr { + struct arphdr arphdr; + uint8_t ar_sha[ETH_ALEN]; + uint32_t ar_sip; + uint8_t ar_tha[ETH_ALEN]; + uint32_t ar_tip; +} ATTRIBUTE_PACKED; + + +/* structure representing DHCP message */ +struct dhcp { + uint8_t op; + uint8_t htype; + uint8_t hlen; + uint8_t hops; + uint32_t xid; + uint16_t secs; + uint16_t flags; + uint32_t ciaddr; + uint32_t yiaddr; + uint32_t siaddr; + uint32_t giaddr; + uint8_t chaddr[16]; + /* omitted */ +} ATTRIBUTE_PACKED; + + +struct ether_vlan_header +{ + uint8_t dhost[ETH_ALEN]; + uint8_t shost[ETH_ALEN]; + uint16_t vlan_type; + uint16_t vlan_flags; + uint16_t ether_type; +} ATTRIBUTE_PACKED; + + +static virMutex pendingLearnReqLock; +static virHashTablePtr pendingLearnReq; + +static virMutex ipAddressMapLock; +static virNWFilterHashTablePtr ipAddressMap; + + +static void +virNWFilterIPAddrLearnReqFree(virNWFilterIPAddrLearnReqPtr req) { + if (!req) + return; + + VIR_FREE(req->filtername); + virNWFilterHashTableFree(req->filterparams); + + VIR_FREE(req); +} + + +#if HAVE_LIBPCAP + +static int +virNWFilterRegisterLearnReq(virNWFilterIPAddrLearnReqPtr req) { + int res = -1; + virMutexLock(&pendingLearnReqLock); + + if (!virHashLookup(pendingLearnReq, req->ifname)) + res = virHashAddEntry(pendingLearnReq, req->ifname, req); + + virMutexUnlock(&pendingLearnReqLock); + + return res; +} + +#endif + + +virNWFilterIPAddrLearnReqPtr +virNWFilterLookupLearnReq(const char *ifname) { + void *res; + + virMutexLock(&pendingLearnReqLock); + + res = virHashLookup(pendingLearnReq, ifname); + + virMutexUnlock(&pendingLearnReqLock); + + return res; +} + + +static void +freeLearnReqEntry(void *payload, const char *name ATTRIBUTE_UNUSED) { + virNWFilterIPAddrLearnReqFree(payload); +} + + +#ifdef HAVE_LIBPCAP + +static virNWFilterIPAddrLearnReqPtr +virNWFilterDeregisterLearnReq(const char *ifname) { + virNWFilterIPAddrLearnReqPtr res; + + virMutexLock(&pendingLearnReqLock); + + res = virHashLookup(pendingLearnReq, ifname); + + if (res) + virHashRemoveEntry(pendingLearnReq, ifname, NULL); + + virMutexUnlock(&pendingLearnReqLock); + + return res; +} + + + +static int +virNWFilterAddIpAddrForIfname(const char *ifname, char *addr) { + int ret; + + virMutexLock(&ipAddressMapLock); + + ret = virNWFilterHashTablePut(ipAddressMap, ifname, addr, 1); + + virMutexUnlock(&ipAddressMapLock); + + return ret; +} +#endif + + +void +virNWFilterDelIpAddrForIfname(const char *ifname) { + + virMutexLock(&ipAddressMapLock); + + if (virHashLookup(ipAddressMap->hashTable, ifname)) + virNWFilterHashTableRemoveEntry(ipAddressMap, ifname); + + virMutexUnlock(&ipAddressMapLock); +} + + +const char * +virNWFilterGetIpAddrForIfname(const char *ifname) { + const char *res; + + virMutexLock(&ipAddressMapLock); + + res = virHashLookup(ipAddressMap->hashTable, ifname); + + virMutexUnlock(&ipAddressMapLock); + + return res; +} + + +#ifdef HAVE_LIBPCAP + +/** + * learnIPAddressThread + * arg: pointer to virNWFilterIPAddrLearnReq structure + * + * Learn the IP address being used on an interface. Use ARP Request and + * Reply messages, DHCP offers and the first IP packet being sent from + * the VM to detect the IP address it is using. Detects only one IP address + * per interface (IP aliasing not supported). The method on how the + * IP address is detected can be chosen through flags. DETECT_DHCP will + * require that the IP address is detected from a DHCP OFFER, DETECT_STATIC + * will require that the IP address was taken from an ARP packet or an IPv4 + * packet. Both flags can be set at the same time. + */ +static void * +learnIPAddressThread(void *arg) +{ + char errbuf[PCAP_ERRBUF_SIZE] = {0}; + pcap_t *handle; + struct bpf_program fp; + struct pcap_pkthdr header; + const u_char *packet; + struct ether_header *ether_hdr; + struct ether_vlan_header *vlan_hdr; + virNWFilterIPAddrLearnReqPtr req = arg; + uint32_t vmaddr = 0; + unsigned int ethHdrSize; + char *listen_if = (strlen(req->linkdev) != 0) ? req->linkdev + : req->ifname; + int to_ms = (strlen(req->linkdev) != 0) ? 1000 + : 0; + char macaddr[VIR_MAC_STRING_BUFLEN]; + virBuffer buf = VIR_BUFFER_INITIALIZER; + char *filter= NULL; + uint16_t etherType; + enum howDetect howDetected = 0; + + req->status = 0; + + handle = pcap_open_live(listen_if, BUFSIZ, 0, to_ms, errbuf); + + if (handle == NULL) { + VIR_DEBUG("Couldn't open device %s: %s\n", listen_if, errbuf); + req->status = ENODEV; + goto done; + } + + virFormatMacAddr(req->macaddr, macaddr); + + switch (req->howDetect) { + case DETECT_DHCP: + virBufferVSprintf(&buf, " ether dst %s" + " and src port 67 and dst port 68", + macaddr); + break; + default: + virBufferVSprintf(&buf, "ether host %s", macaddr); + } + + if (virBufferError(&buf)) { + req->status = ENOMEM; + goto done; + } + + filter = virBufferContentAndReset(&buf); + + if (pcap_compile(handle, &fp, filter, 1, 0) != 0 || + pcap_setfilter(handle, &fp) != 0) { + VIR_DEBUG("Couldn't compile or set filter '%s'.\n", filter); + req->status = EINVAL; + goto done; + } + + while (req->status == 0 && vmaddr == 0) { + packet = pcap_next(handle, &header); + + if (!packet) { + if (to_ms == 0) { + /* assuming IF disappeared */ + req->status = ENODEV; + break; + } + /* listening on linkdev, check whether VM's dev is still there */ + if (checkIf(req->ifname, req->macaddr)) { + req->status = ENODEV; + break; + } + continue; + } + + if (header.len >= sizeof(struct ether_header)) { + ether_hdr = (struct ether_header*)packet; + + switch (ntohs(ether_hdr->ether_type)) { + + case ETHERTYPE_IP: + ethHdrSize = sizeof(struct ether_header); + etherType = ntohs(ether_hdr->ether_type); + break; + + case ETHERTYPE_VLAN: + ethHdrSize = sizeof(struct ether_vlan_header); + vlan_hdr = (struct ether_vlan_header *)packet; + if (ntohs(vlan_hdr->ether_type) != ETHERTYPE_IP || + header.len < ethHdrSize) + continue; + etherType = ntohs(vlan_hdr->ether_type); + break; + + default: + continue; + } + + if (memcmp(ether_hdr->ether_shost, + req->macaddr, + VIR_MAC_BUFLEN) == 0) { + // packets from the VM + + if (etherType == ETHERTYPE_IP && + (header.len >= ethHdrSize + + sizeof(struct iphdr))) { + struct iphdr *iphdr = (struct iphdr*)(packet + + ethHdrSize); + vmaddr = iphdr->saddr; + // skip eth. bcast and mcast addresses, + // and zero address in DHCP Requests + if ((ntohl(vmaddr) & 0xc0000000) || vmaddr == 0) { + vmaddr = 0; + continue; + } + + howDetected = DETECT_STATIC; + } else if (etherType == ETHERTYPE_ARP && + (header.len >= ethHdrSize + + sizeof(struct f_arphdr))) { + struct f_arphdr *arphdr = (struct f_arphdr*)(packet + + ethHdrSize); + switch (ntohs(arphdr->arphdr.ar_op)) { + case ARPOP_REPLY: + vmaddr = arphdr->ar_sip; + howDetected = DETECT_STATIC; + break; + case ARPOP_REQUEST: + vmaddr = arphdr->ar_tip; + howDetected = DETECT_STATIC; + break; + } + } + } else if (memcmp(ether_hdr->ether_dhost, + req->macaddr, + VIR_MAC_BUFLEN) == 0) { + // packets to the VM + if (etherType == ETHERTYPE_IP && + (header.len >= ethHdrSize + + sizeof(struct iphdr))) { + struct iphdr *iphdr = (struct iphdr*)(packet + + ethHdrSize); + if ((iphdr->protocol == IPPROTO_UDP) && + (header.len >= ethHdrSize + + iphdr->ihl * 4 + + sizeof(struct udphdr))) { + struct udphdr *udphdr= (struct udphdr *) + ((char *)iphdr + iphdr->ihl * 4); + if (ntohs(udphdr->source) == 67 && + ntohs(udphdr->dest) == 68 && + header.len >= ethHdrSize + + iphdr->ihl * 4 + + sizeof(struct udphdr) + + sizeof(struct dhcp)) { + struct dhcp *dhcp = (struct dhcp *) + ((char *)udphdr + sizeof(udphdr)); + if (dhcp->op == 2 /* DHCP OFFER */ && + !memcmp(&dhcp->chaddr[0], + req->macaddr, + 6)) { + vmaddr = dhcp->yiaddr; + howDetected = DETECT_DHCP; + } + } + } + } + } + } + if (vmaddr && (req->howDetect & howDetected) == 0) { + vmaddr = 0; + howDetected = 0; + } + } /* while */ + + done: + VIR_FREE(filter); + + if (handle) + pcap_close(handle); + + ebtablesRemoveBasicRules(req->ifname); + + if (req->status == 0) { + int ret; + char inetaddr[INET_ADDRSTRLEN]; + inet_ntop(AF_INET, &vmaddr, inetaddr, sizeof(inetaddr)); + + virNWFilterAddIpAddrForIfname(req->ifname, strdup(inetaddr)); + + ret = virNWFilterInstantiateFilterLate(NULL, + req->ifname, + req->linkdev, + req->nettype, + req->macaddr, + req->filtername, + req->filterparams, + req->driver); + VIR_DEBUG("Result from applying firewall rules on " + "%s with IP addr %s : %d\n", req->ifname, inetaddr, ret); + } + + memset(&req->thread, 0x0, sizeof(req->thread)); + + VIR_DEBUG("pcap thread terminating for interface %s\n",req->ifname); + + virNWFilterDeregisterLearnReq(req->ifname); + + virNWFilterIPAddrLearnReqFree(req); + + return 0; +} + + +/** + * virNWFilterLearnIPAddress + * @conn: pointer to virConnect object + * @ifname: the name of the interface + * @linkdev : the name of the link device; currently only used in case of a + * macvtap device + * @nettype : the type of interface + * @macaddr : the MAC address of the interface + * @filtername : the name of the top-level filter to apply to the interface + * once its IP address has been detected + * @driver : the network filter driver + * @howDetect : the method on how the thread is supposed to detect the + * IP address; must choose any of the available flags + * + * Instruct to learn the IP address being used on a given interface (ifname). + * Unless there already is a thread attempting to learn the IP address + * being used on the interface, a thread is started that will listen on + * the traffic being sent on the interface (or link device) with the + * MAC address that is provided. Will then launch the application of the + * firewall rules on the interface. + */ +int +virNWFilterLearnIPAddress(const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + virNWFilterDriverStatePtr driver, + enum howDetect howDetect) { + int rc; + virNWFilterIPAddrLearnReqPtr req = NULL; + virNWFilterHashTablePtr ht = NULL; + + if (howDetect == 0) + return 1; + + if (VIR_ALLOC(req) < 0) { + virReportOOMError(); + goto err_no_req; + } + + ht = virNWFilterHashTableCreate(0); + if (ht == NULL) { + virReportOOMError(); + goto err_no_ht; + } + + if (virNWFilterHashTablePutAll(filterparams, ht)) + goto err_free_ht; + + req->filtername = strdup(filtername); + if (req->filtername == NULL) { + virReportOOMError(); + goto err_free_ht; + } + + if (virStrcpyStatic(req->ifname, ifname) == NULL) { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, + _("Destination buffer for ifname ('%s') " + "not large enough"), ifname); + goto err_free_ht; + } + + if (linkdev) { + if (virStrcpyStatic(req->linkdev, linkdev) == NULL) { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, + _("Destination buffer for linkdev ('%s') " + "not large enough"), linkdev); + goto err_free_ht; + } + } + req->nettype = nettype; + memcpy(req->macaddr, macaddr, sizeof(req->macaddr)); + req->driver = driver; + req->filterparams = ht; + ht = NULL; + req->howDetect = howDetect; + + rc = virNWFilterRegisterLearnReq(req); + + if (rc) + goto err_free_ht; + + switch (howDetect) { + case DETECT_DHCP: + if (ebtablesApplyDHCPOnlyRules(ifname, + macaddr, + NULL)) + goto err_free_ht; + break; + default: + if (ebtablesApplyBasicRules(ifname, + macaddr)) + goto err_free_ht; + } + + + if (pthread_create(&req->thread, + NULL, + learnIPAddressThread, + req) != 0) + goto err_remove_rules; + + return 0; + +err_remove_rules: + ebtablesRemoveBasicRules(ifname); +err_free_ht: + virNWFilterHashTableFree(ht); +err_no_ht: + virNWFilterIPAddrLearnReqFree(req); +err_no_req: + return 1; +} + +#else + +int +virNWFilterLearnIPAddress(const char *ifname ATTRIBUTE_UNUSED, + const char *linkdev ATTRIBUTE_UNUSED, + enum virDomainNetType nettype ATTRIBUTE_UNUSED, + const unsigned char *macaddr ATTRIBUTE_UNUSED, + const char *filtername ATTRIBUTE_UNUSED, + virNWFilterHashTablePtr filterparams ATTRIBUTE_UNUSED, + virNWFilterDriverStatePtr driver ATTRIBUTE_UNUSED, + enum howDetect howDetect ATTRIBUTE_UNUSED) { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("IP parameter must be given since libvirt " + "was not compiled with IP address learning " + "support")); + return 1; +} +#endif /* HAVE_LIBPCAP */ + + +/** + * virNWFilterLearnInit + * Initialization of this layer + */ +int +virNWFilterLearnInit(void) { + pendingLearnReq = virHashCreate(0); + if (!pendingLearnReq) { + virReportOOMError(); + return 1; + } + + if (virMutexInit(&pendingLearnReqLock)) { + virNWFilterLearnShutdown(); + return 1; + } + + ipAddressMap = virNWFilterHashTableCreate(0); + if (!ipAddressMap) { + virReportOOMError(); + virNWFilterLearnShutdown(); + return 1; + } + + if (virMutexInit(&ipAddressMapLock)) { + virNWFilterLearnShutdown(); + return 1; + } + + return 0; +} + + +/** + * virNWFilterLearnShutdown + * Shutdown of this layer + */ +void +virNWFilterLearnShutdown(void) { + virHashFree(pendingLearnReq, freeLearnReqEntry); + pendingLearnReq = NULL; + + virNWFilterHashTableFree(ipAddressMap); + ipAddressMap = NULL; +} diff --git a/src/nwfilter/nwfilter_learnipaddr.h b/src/nwfilter/nwfilter_learnipaddr.h new file mode 100644 index 0000000000..ffdd342a95 --- /dev/null +++ b/src/nwfilter/nwfilter_learnipaddr.h @@ -0,0 +1,67 @@ +/* + * nwfilter_learnipaddr.h: support for learning IP address used by a VM + * on an interface + * + * Copyright (C) 2010 IBM Corp. + * Copyright (C) 2010 Stefan Berger + * + * 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 + */ + +#ifndef __NWFILTER_LEARNIPADDR_H +# define __NWFILTER_LEARNIPADDR_H + +enum howDetect { + DETECT_DHCP = 1, + DETECT_STATIC = 2, +}; + +typedef struct _virNWFilterIPAddrLearnReq virNWFilterIPAddrLearnReq; +typedef virNWFilterIPAddrLearnReq *virNWFilterIPAddrLearnReqPtr; +struct _virNWFilterIPAddrLearnReq { + char ifname[IF_NAMESIZE]; + char linkdev[IF_NAMESIZE]; + enum virDomainNetType nettype; + unsigned char macaddr[VIR_MAC_BUFLEN]; + char *filtername; + virNWFilterHashTablePtr filterparams; + virNWFilterDriverStatePtr driver; + enum howDetect howDetect; + + int status; + pthread_t thread; +}; + +int virNWFilterLearnIPAddress(const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + virNWFilterDriverStatePtr driver, + enum howDetect howDetect); + +virNWFilterIPAddrLearnReqPtr virNWFilterLookupLearnReq(const char *ifname); + + +void virNWFilterDelIpAddrForIfname(const char *ifname); +const char *virNWFilterGetIpAddrForIfname(const char *ifname); + +int virNWFilterLearnInit(void); +void virNWFilterLearnShutdown(void); + +#endif /* __NWFILTER_LEARNIPADDR_H */ diff --git a/tests/nwfilterxml2xmltest b/tests/nwfilterxml2xmltest new file mode 100755 index 0000000000000000000000000000000000000000..7382a9fb54cc5bb215ff0f5625a21c743a0bcc15 GIT binary patch literal 462966 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[`5FlcHW@T*{t>2RZ9PpBe+ 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 literal 0 HcmV?d00001