testing/ipt-netflow: fix build again

Use upstream source repo rather than Rush's github clone

3 files changed, 4413 insertions, 0 deletions

diff --git a/testing/ipt-netflow/APKBUILD b/testing/ipt-netflow/APKBUILD
new file mode 100644
index 0000000000..2adb8e03ae
--- /dev/null
+++ b/testing/ipt-netflow/APKBUILD
@@ -0,0 +1,49 @@
+# Contributor: Rush Future <rush.zlo@gmail.com>
+# Maintainer: Natanael Copa <ncopa@alpinelinux.org>
+pkgname=ipt-netflow
+pkgver=1.8_git20140103
+_ver=${pkgver%_git*}
+pkgrel=0
+pkgdesc="Kernel netflow sensor"
+url="http://ipt-netflow.sourceforge.net."
+arch="all"
+license="GPL3+"
+makedepends="iptables-dev bash"
+source="$pkgname-$_ver.tar.gz::https://github.com/aabc/ipt-netflow/archive/v$_ver.tar.gz
+	git.patch
+	kernel-vs-userspace.patch
+	"
+
+_builddir="$srcdir/$pkgname-$_ver"
+prepare() {
+	cd "$_builddir"
+	for i in $source; do
+		case $i in
+		*.patch) msg $i; patch -p1 -i "$srcdir"/$i || return 1;;
+		esac
+	done
+}
+
+build() {
+	cd "$_builddir"
+	./configure \
+		--ipt-inc=/usr/include \
+		--disable-kernel \
+		|| return 1
+	make libipt_NETFLOW.so || return 1
+}
+
+package() {
+	cd "$_builddir"
+	make linstall DESTDIR=$pkgdir || return 1
+}
+
+md5sums="922a7d9dd17f28a2c3551a1c5e9849eb  ipt-netflow-1.8.tar.gz
+77875a5979589bca8c49a8331e7cc22b  git.patch
+59adcee5cd4cec4e09f432f567ff8243  kernel-vs-userspace.patch"
+sha256sums="eefe766eda6d4d918e4cc919b5d5acd2b681a258246017ab7948b80f0cb95112  ipt-netflow-1.8.tar.gz
+75ea3afe9532699d4fd1bef7f198dfaa97b3a310234a86b48371522ae0704a60  git.patch
+a897d88212b56c3d06645f8fc9fe7ce5b7accfa1d45b96917b3ba747605a82bc  kernel-vs-userspace.patch"
+sha512sums="c413515deeac1d604e36a53b39edcf340d6c3f78c29e53979fede8aa013e324ada4622b571ac5270f7495ab6982096cd2bd9e9283c9cc2cc7360aa5c3954792d  ipt-netflow-1.8.tar.gz
+3fade2ceb00ddae15dd6b1eacebc36480efe0c5c2d050e050e0aef37382ad72ca454f4d23080b7263ab2f078f72db4572e2514d3faca113d8e437437f7c3afcf  git.patch
+dfc37ccc010559994a94290aee99dbc75c47732cbc06492366bff081bafced7bccc5144b5119dc8f0ad8dea1392684ef7f592d15131da2fa1227516dc7d8d3ce  kernel-vs-userspace.patch"
diff --git a/testing/ipt-netflow/git.patch b/testing/ipt-netflow/git.patch
new file mode 100644
index 0000000000..faa49ffdc7
--- /dev/null
+++ b/testing/ipt-netflow/git.patch
@@ -0,0 +1,4308 @@
+diff --git a/Makefile.in b/Makefile.in
+index 30ebbfe..0a82c67 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -1,43 +1,73 @@
+-#
++# Edit Makefile.in and run ./configure
+ 
+ KVERSION = @KVERSION@
+ KDIR = @KDIR@
++KINSTDIR = $(shell dirname @KDIR@)
+ IPTABLES_CFLAGS = @IPTABLES_CFLAGS@
+ IPTABLES_MODULES = @IPTABLES_MODULES@
++DEPMOD = depmod -a
+ 
++# https://www.kernel.org/doc/Documentation/kbuild/modules.txt
++# https://www.kernel.org/doc/Documentation/kbuild/makefiles.txt
+ obj-m = ipt_NETFLOW.o
+ 
+-ipt_NETFLOW.ko: ipt_NETFLOW.c ipt_NETFLOW.h
++all: ipt_NETFLOW.ko libipt_NETFLOW.so libip6t_NETFLOW.so
++ipt_NETFLOW.ko: version.h ipt_NETFLOW.c ipt_NETFLOW.h Makefile
+ 	@echo Compiling for kernel $(KVERSION)
+ 	make -C $(KDIR) M=$(CURDIR) modules
+-all: ipt_NETFLOW.ko libipt_NETFLOW.so
+-minstall:
+-	make -C $(KDIR) M=$(CURDIR) modules_install
++	@touch $@
++sparse: | version.h ipt_NETFLOW.c ipt_NETFLOW.h Makefile
++	@rm -f ipt_NETFLOW.ko ipt_NETFLOW.o
++	@echo Compiling for kernel $(KVERSION)
++	make -C $(KDIR) M=$(CURDIR) modules C=1
++	@touch ipt_NETFLOW.ko
++minstall: | ipt_NETFLOW.ko
++	make -C $(KDIR) M=$(CURDIR) modules_install INSTALL_MOD_PATH=$(DESTDIR)
++	$(DEPMOD)
+ mclean:
+ 	make -C $(KDIR) M=$(CURDIR) clean
+ lclean:
+ 	-rm -f *.so *_sh.o
+ clean: mclean lclean
+-	-rm -f *.so *.o modules.order
++	-rm -f *.so *.o modules.order version.h
++
++%_sh.o: libipt_NETFLOW.c
++	gcc -O2 -Wall -Wunused $(IPTABLES_CFLAGS) -fPIC -o $@ -c libipt_NETFLOW.c
++
++%.so: %_sh.o
++	gcc -shared -o $@ $<
+ 
+-libipt_NETFLOW.so: libipt_NETFLOW.c
+-	gcc -O2 -Wall -Wunused -I$(KDIR)/include $(IPTABLES_CFLAGS) -fPIC -o libipt_NETFLOW_sh.o -c libipt_NETFLOW.c
+-	gcc -shared  -o libipt_NETFLOW.so libipt_NETFLOW_sh.o
++version.h: ipt_NETFLOW.c ipt_NETFLOW.h Makefile
++	@if [ -d .git ] && type git >/dev/null 2>&1; then \
++		 echo "#define GITVERSION \"`git describe --dirty`\""; \
++	fi > version.h
+ 
+-linstall: ipt_NETFLOW.ko libipt_NETFLOW.so
+-	cp -a libipt_NETFLOW.so $(IPTABLES_MODULES)
++linstall: | libipt_NETFLOW.so libip6t_NETFLOW.so
++	install -D libipt_NETFLOW.so $(DESTDIR)$(IPTABLES_MODULES)/libipt_NETFLOW.so
++	install -D libip6t_NETFLOW.so $(DESTDIR)$(IPTABLES_MODULES)/libip6t_NETFLOW.so
+ 
+ install: minstall linstall
+ 
++uninstall:
++	-rm -f $(DESTDIR)$(IPTABLES_MODULES)/libipt_NETFLOW.so
++	-rm -f $(DESTDIR)$(IPTABLES_MODULES)/libip6t_NETFLOW.so
++	-rm -f $(DESTDIR)$(KINSTDIR)/extra/ipt_NETFLOW.ko
++
+ Makefile: Makefile.in configure
+ 	./configure --make
+ 
+ load: all
+-	insmod ipt_NETFLOW.ko active_timeout=5
+-	iptables -A OUTPUT -d 0/0 -j NETFLOW
+-	iptables -A INPUT -d 0/0 -j NETFLOW
++	-insmod ipt_NETFLOW.ko active_timeout=5 protocol=9
++	-iptables -I OUTPUT -j NETFLOW
++	-iptables -I INPUT -j NETFLOW
++	-ip6tables -I OUTPUT -j NETFLOW
++	-ip6tables -I INPUT -j NETFLOW
+ 
+ unload:
+-	iptables -D OUTPUT -d 0/0 -j NETFLOW
+-	iptables -D INPUT -d 0/0 -j NETFLOW
+-	rmmod ipt_NETFLOW.ko
++	-iptables -D OUTPUT -j NETFLOW
++	-iptables -D INPUT -j NETFLOW
++	-ip6tables -D OUTPUT -j NETFLOW
++	-ip6tables -D INPUT -j NETFLOW
++	-rmmod ipt_NETFLOW.ko
++
++reload: unload load
+diff --git a/README b/README
+index 213f02c..56a4fde 100644
+--- a/README
++++ b/README
+@@ -1,10 +1,17 @@
+-ipt_NETFLOW linux 2.6 kernel module by <abc@telekom.ru> -- 11 Feb 2008
++ipt_NETFLOW linux 2.6.x-3.x kernel module by <abc@telekom.ru> -- 2008-2013.
++
++   High performance NetFlow v5, v9, IPFIX flow data export module for Linux
++   kernel. Supporting IPv4 and IPv6. Created to be useful for highly loaded
++   linux router. It should be used as iptables target. Also can export NAT
++   translation events using NetFlow Event Logging (NEL) for v9, IPFIX, or
++   specially crafted v5 flows.
++
+ 
+ ============================
+ = OBTAINING LATEST VERSION =
+ ============================
+ 
+-   $ git clone git://ipt-netflow.git.sourceforge.net/gitroot/ipt-netflow/ipt-netflow
++   $ git clone git://git.code.sf.net/p/ipt-netflow/code ipt-netflow
+    $ cd ipt-netflow
+ 
+ 
+@@ -12,94 +19,220 @@ ipt_NETFLOW linux 2.6 kernel module by <abc@telekom.ru> -- 11 Feb 2008
+ = INSTALLATION =
+ ================
+ 
+-1. Besides kernel you will need iptables/netfilter source matching your
+-     installation or just fresh install from there: ftp://ftp.netfilter.org/pub/iptables/snapshot/
+-   I have this: ftp://ftp.netfilter.org/pub/iptables/snapshot/iptables-1.3.7-20070329.tar.bz2
+-   Unpack it somewhere and build with make.
++   Four easy steps.
++
++** 1. Prepare Kernel source
++
++   If you have package system install kernel-devel package, otherwise install
++   raw kernel source from http://kernel.org matching _exactly_ version of your
++   installed kernel.
++
++   a) What to do for Centos:
++
++      ~# yum install kernel-devel
++
++   b) What to do for Debian:
++
++      ~# apt-get install module-assistant
++      ~# m-a prepare
++
++   c) Otherwise, if you downloaded raw kernel sources don't forget to create
++    .config by copying it from your distribution's kernel. Its copy could reside
++    in /boot or sometimes in /proc, examples:
++
++      kernel-src-dir/# cp /boot/config-`uname -r` .config
++    or
++      kernel-src-dir/# zcat /proc/config.gz > .config
++
++    Assuming you unpacked kernel source into `kernel-src-dir/' directory.
++    Then run:
++
++      kernel-src-dir/# make oldconfig
++
++    After that you'll need to prepare kernel for modules build:
++
++      kernel-src-dir/# make prepare modules_prepare
++
++   Note: Don't try to `make prepare' in Centos kernel-devel package directory
++     (which is usually something like /usr/src/kernels/2.6.32-431.el6.x86_64)
++     as this is wrong and meaningless.
++
++** 2. Prepare Iptables
++
++   Before this step it also would be useful to install pkg-config if don't
++   already have.
++
++   If you have package system just install iptables-devel (or iptables-dev)
++   package, otherwise install iptables source matching version of your
++   installation from ftp://ftp.netfilter.org/pub/iptables/
++
++   a) What to do for Centos:
++
++      # yum install iptables-devel
++
++   b) What to do for Debian:
++
++      # apt-get install iptables-dev pkg-config
+ 
+-2. Run ./configure script and it will create Makefile
++   c) Otherwise, for raw iptables source build it and make install.
+ 
+-3. make all install; depmod
+-   This will install kernel module and iptable specific library.
++** 3. Now, to actually build the module run:
+ 
+-Troubleshooting:
+-   1) Sometimes you will want to add CC=gcc-3 to make command.
+-   Example: make CC=gcc-3.3
++      ~/ipt-netflow# ./configure
++      ~/ipt-netflow# make all install
++      ~/ipt-netflow# depmod
+ 
+-   2) Compile module with actual kernel source compiled.
+-   I.e. first compile kernel and boot into it, and then compile module.
++   This will install kernel module and iptables specific library.
+ 
+-   3) For autoloading module after reboot: set net.netflow.destination (or load
+-   module, if idestination set on load) after interfaces are up. Becasue module
+-   needs exporting interface (usually lo) to establish export connection.
++   Troubleshooting:
+ 
+-4. After this point you should be able to load module
+-     and use -j NETFLOW target in your iptables. See next section.
++     a) Sometimes you will want to add CC=gcc-3 to make command.
++     Example: make CC=gcc-3.3
++
++     b) Compile module with actual kernel source compiled.
++     I.e. first compile kernel and boot into it, and then compile module.
++     If you are using kernel-devel package check that its version matches
++     your kernel package.
++
++     c) If you have sources in non-standard places or configure isn't able to
++     find something run ./configure --help to see how to specify paths manually.
++
++** 4. After this point you should be able to load module and
++     use -j NETFLOW target in your iptables. See next section.
+ 
+ 
+ ===========
+ = RUNNING =
+ ===========
+ 
+-1. You can load module by insmod like this:
+-   # insmod ipt_NETFLOW.ko destination=127.0.0.1:2055 debug=1
++1. You can load module directly by insmod like this:
++
++     # insmod ipt_NETFLOW.ko destination=127.0.0.1:2055 debug=1
+ 
+    Or if properly installed (make install; depmod) by this:
+-   # modprobe ipt_NETFLOW destination=127.0.0.1:2055
++
++     # modprobe ipt_NETFLOW destination=127.0.0.1:2055
+ 
+    See, you may add options in insmod/modprobe command line, or add
+-     them in /etc/ to modules.conf or modprobe.conf like thus:
+-   options ipt_NETFLOW destination=127.0.0.1:2055
++   them in /etc/modprobe.conf or /etc/modprobe.d/ipt_NETFLOW.conf
++   like thus:
++
++     options ipt_NETFLOW destination=127.0.0.1:2055 protocol=9 natevents=1
+ 
+ 2. Statistics is in /proc/net/stat/ipt_netflow
+-   To view slab statistics: grep ipt_netflow /proc/slabinfo
++   To view boring slab statistics: grep ipt_netflow /proc/slabinfo
+ 
+ 3. You can view parameters and control them via sysctl, example:
+-   # sysctl -w net.netflow.hashsize=32768
+ 
+-4. Example of directing all traffic into module:
+-   # iptables -A FORWARD -j NETFLOW
+-   # iptables -A INPUT -j NETFLOW
+-   # iptables -A OUTPUT -j NETFLOW
++     # sysctl net.netflow
++     # sysctl net.netflow.hashsize=32768
++
++   Note: For after-reboot configuration I recommend to store module parameters
++   in modprobe configs instead of storing them in /etc/sysctl.conf, as it's
++   less clear when init process will apply sysctl.conf, before of after
++   module's load.
++
++4. Example of directing all IPv4 traffic into the module:
++
++     # iptables -I FORWARD -j NETFLOW
++     # iptables -I INPUT -j NETFLOW
++     # iptables -I OUTPUT -j NETFLOW
++
++   Note: It is preferable (because easier to understand) to _insert_
++   NETFLOW target at the top of the chain, otherwise not all traffic may
++   reach NETFLOW if your iptables configuration is complicated and some
++   other rule inadvertently consume the traffic (dropping or acepting before
++   NETFLOW is reached). It's always good to test your configuration.
++   Use  iptables -L -nvx  to check pkts/bytes counters on the rules.
++
++5. If you want to account IPv6 traffic you should use protocol 9 or 10.
++   Example of directing all IPv6 traffic into the module:
+ 
++     # sysctl net.netflow.protocol=10
++     # ip6tables -I FORWARD -j NETFLOW
++     # ip6tables -I INPUT -j NETFLOW
++     # ip6tables -I OUTPUT -j NETFLOW
++
++   Note: First enable right version of protocol and after that add ip6tables
++     rules, otherwise you will get errors in dmesg.
++
++6. If you want to account NAT events (NEL):
++
++     # sysctl net.netflow.natevents=1
++
++   Note that natevents feature is completely independent from traffic accounting
++   (it's using so called conntrack events), thus you don't need to set or change
++   any iptables rules to use that. You may need to enable kernel config option
++   CONFIG_NF_CONNTRACK_EVENTS though (if it isn't already enabled).
++   For details on how they are exported for different protocol versions see
++   below.
+ 
+ ===========
+ = OPTIONS =
+ ===========
+ 
++   protocol=5
++     - what version of NetFlow protocol to use. Default is 5.
++       You can choose from 5, 9, or 10 (where 10 is IPFIX). If you plan
++       to account IPv6 traffic you should use protocol 9 or 10 (IPFIX),
++       because NetFlow v5 isn't compatible with IPv6.
++
+    destination=127.0.0.1:2055
+      - where to export netflow, to this ip address
+        You will see this connection in netstat like this:
+        udp 0 0 127.0.0.1:32772 127.0.0.1:2055 ESTABLISHED 
+ 
+    destination=127.0.0.1:2055,192.0.0.1:2055
+-     - mirror flows to two (can be more) addresses,
+-       separate addresses with comma.
++     - mirror flows to two (can be more) addresses, separate addresses
++       with comma.
++
++   natevents=1
++     - Collect and send NAT translation events as NetFlow Event Logging (NEL)
++       for NetFlow v9/IPFIX, or as dummy flows compatible with NetFlow v5.
++       Default is 0 (don't send).
++
++       For NetFlow v5 protocol meaning of fields in dummy flows are such:
++         Src IP, Src Port  is Pre-nat source address.
++         Dst IP, Dst Port  is Post-nat destination address.
++           - These two fields made equal to data flows catched in FORWARD chain.
++	 Nexthop, Src AS  is Post-nat source address for SNAT. Or,
++	 Nexthop, Dst AS  is Pre-nat destination address for DNAT.
++	 TCP Flags is SYN+SCK for start event, RST+FIN for stop event.
++	 Pkt/Traffic size is 0 (zero), so it won't interfere with accounting.
+ 
+    inactive_timeout=15
+      - export flow after it's inactive 15 seconds. Default value is 15.
+ 
+    active_timeout=1800
+-     - export flow after it's active 1800 seconds (30 minutes). Default value is 1800.
++     - export flow after it's active 1800 seconds (30 minutes). Default valuae
++       is 1800.
++
++   refresh-rate=20
++     - for NetFlow v9 and IPFIX it's rate how frequently to re-send templates
++       (per packets). You probably don't need to change default (which is 20).
++
++   timeout-rate=30
++     - for NetFlow v9 and IPFIX it's rate when to re-send old templates (in
++       minutes). No need to change it.
+ 
+    debug=0
+      - debug level (none).
+ 
+    sndbuf=number
+-     - size of output socket buffer in bytes. Recommend you to put
++     - size of output socket buffer in bytes. I recommend you to put
+        higher value if you experience netflow packet drops (can be
+        seen in statistics as 'sock: fail' number.)
+        Default value is system default.
+ 
+    hashsize=number
+      - Hash table bucket size. Used for performance tuning.
+-       Abstractly speaking, it should be two times bigger than flows
++       Abstractly speaking, it should be minimum two times bigger than flows
+        you usually have, but not need to.
+        Default is system memory dependent small enough value.
+ 
+    maxflows=2000000
+-     - Maximum number of flows to account. It's here to prevent DOS attacks. After
+-       this limit reached new flows will not be accounted. Default is
++     - Maximum number of flows to account. It's here to prevent DOS attacks.
++       After this limit reached new flows will not be accounted. Default is
+        2000000, zero is unlimited.
+ 
+    aggregation=string..
+@@ -130,14 +263,15 @@ Troubleshooting:
+ = HOW TO READ STAT =
+ ====================
+ 
+-  Statistics is your friend to fine tune and understand netflow module performance.
++  Statistics is your friend to fine tune and understand netflow module
++  performance.
+ 
+   To see stat:
+   # cat /proc/net/stat/ipt_netflow
+ 
+   How to interpret the data:
+ 
+-> Flows: active 5187 (peak 83905 reached 0d0h1m ago, maxflows 2000000), mem 283K
++> Flows: active 5187 (peak 83905 reached 0d0h1m ago, maxflows 2000000), mem 283K, worker delay 100/1000.
+ 
+   active X: currently active flows in memory cache.
+     - for optimum CPU performance it is recommended to set hash table size to
+@@ -146,8 +280,9 @@ Troubleshooting:
+   mem XK: how much kilobytes of memory currently taken by active flows.
+     - one active flow taking 56 bytes of memory.
+     - there is system limit on cache size too.
++  worker delay X/HZ: how frequently exporter scan flows table per second.
+ 
+-> Hash: size 8192 (mem 32K), metric 1.0, 1.0, 1.0, 1.0. MemTraf: 1420 pkt, 364 K (pdu 0, 0).
++> Hash: size 8192 (mem 32K), metric 1.00, [1.00, 1.00, 1.00]. MemTraf: 1420 pkt, 364 K (pdu 0, 0).
+ 
+   Hash: size X: current hash size/limit.
+     - you can control this by sysctl net.netflow.hashsize variable.
+@@ -156,18 +291,22 @@ Troubleshooting:
+     - optimal value is twice of average of active flows.
+   mem XK: how much memory occupied by hash table.
+     - hash table is fixed size by nature, taking 4 bytes per entry.
+-  metric X, X, X, X: how optimal is your hash table being used.
++  metric X, [X, X, X]: how optimal is your hash table being used.
+     - lesser value mean more optimal hash table use, min is 1.0.
+-    - this is moving average (EWMA) of hash table access divided
+-      by match rate (searches / matches) for 4sec, and 1, 5, 15 minutes.
+-      Sort of hash table load average.
++    - last three numbers in squares is moving average (EWMA) of hash table
++      access divided by match rate (searches / matches) for 4sec, and 1, 5, and
++      15 minutes. Sort of hash table load average. First value is instantaneous.
++      You can try to increase hashsize if averages more than 1 (increase
++      certainly if >= 2).
+   MemTraf: X pkt, X K: how much traffic accounted for flows that are in memory.
+     - these flows that are residing in internal hash table.
+   pdu X, X: how much traffic in flows preparing to be exported.
+     - it is included already in aforementioned MemTraf total.
+ 
+-> Timeout: active 1800, inactive 15. Maxflows 2000000
++> Protocol version 10 (ipfix), refresh-rate 20, timeout-rate 30, (templates 2, active 2). Timeouts: active 5, inactive 15. Maxflows 2000000
+ 
++  Protocol version currently in use. Refresh-rate and timeout-rate
++      for v9 and IPFIX. Total templates generated and currently active.
+   Timeout: active X: how much seconds to wait before exporting active flow.
+     - same as sysctl net.netflow.active_timeout variable.
+   inactive X: how much seconds to wait before exporting inactive flow.
+@@ -180,20 +319,22 @@ Troubleshooting:
+ 
+   - Module throughput values for 1 second, 1 minute, and 5 minutes.
+ 
+-> cpu#  stat: <search found new, trunc frag alloc maxflows>, sock: <ok fail cberr, bytes>, traffic: <pkt, bytes>, drop: <pkt, bytes>
+-> cpu0  stat: 980540  10473 180600,    0    0    0    0, sock:   4983 928 0, 7124 K, traffic: 188765, 14 MB, drop: 27863, 1142 K
++> cpu#  stat: <search found new [metric], trunc frag alloc maxflows>, sock: <ok fail cberr, bytes>, traffic: <pkt, bytes>, drop: <pkt, bytes>
++> cpu0  stat: 980540  10473 180600 [1.03],    0    0    0    0, sock:   4983 928 0, 7124 K, traffic: 188765, 14 MB, drop: 27863, 1142 K
+ 
+   cpu#: this is Total and per CPU statistics for:
+   stat: <search found new, trunc frag alloc maxflows>: internal stat for:
+   search found new: hash table searched, found, and not found counters.
+-  trunc: how much truncated packets is ignored
++  [metric]: average hash metric since module load.
++  trunc: how much truncated packets are ignored
+     - these are that possible don't have valid IP header.
+     - accounted in drop packets counter but not in drop bytes.
+   frag: how much fragmented packets have seen.
+     - kernel always defragments INPUT/OUTPUT chains for us.
+     - these packets are not ignored but not reassembled either, so:
+-    - if there is no enough data in fragment (ex. tcp ports) it is considered zero.
+-  alloc: how much cache memory allocations is failed.
++    - if there is no enough data in fragment (ex. tcp ports) it is considered
++      zero.
++  alloc: how much cache memory allocations are failed.
+     - packets ignored and accounted in drop stat.
+     - probably increase system memory if this ever happen.
+   maxflows: how much packets ignored on maxflows (maximum active flows reached).
+@@ -203,7 +344,8 @@ Troubleshooting:
+   sock: <ok fail cberr, bytes>: table of exporting stats for:
+   ok: how much Netflow PDUs are exported (i.e. UDP packets sent by module).
+   fail: how much socket errors (i.e. packets failed to be sent).
+-    - packets dropped and their internal statistics cumulatively accounted in drop stat.
++    - packets dropped and their internal statistics cumulatively accounted in
++      drop stat.
+   cberr: how much connection refused ICMP errors we got from export target.
+     - probably you not launched collector software on destination,
+     - or specified wrong destination address.
+@@ -225,20 +367,34 @@ Troubleshooting:
+       packet is for new flow but maxflows is already reached,
+       all flows in export packets that got socket error.
+ 
+-> sock0: 10.0.0.2:2055, sndbuf 106496, filled 0, peak 106848; err: sndbuf reached 928, other 0
++> Natevents disabled, count start 0, stop 0.
++
++    - Natevents mode disabled or enabled, and how much start or stop events
++      are reported.
++
++> sock0: 10.0.0.2:2055 unconnected (1 attempts).
++
++  If socket is unconnected (for example if module loaded before interfaces is
++  up) it shows now much connection attempts was failed. It will try to connect
++  until success.
++
++> sock0: 10.0.0.2:2055, sndbuf 106496, filled 0, peak 106848; err: sndbuf reached 928, connect 0, other 0
+ 
+   sockX: per destination stats for:
+   X.X.X.X:Y: destination ip address and port.
+     - controlled by sysctl net.netflow.destination variable.
+   sndbuf X: how much data socket can hold in buffers.
+     - controlled by sysctl net.netflow.sndbuf variable.
+-    - if you have packet drops due to sndbuf reached (error -11) increase this value.
++    - if you have packet drops due to sndbuf reached (error -11) increase this
++      value.
+   filled X: how much data in socket buffers right now.
+   peak X: peak value of how much data in socket buffers was.
+     - you will be interested to keep it below sndbuf value.
+   err: how much packets are dropped due to errors.
+     - all flows from them will be accounted in drop stat.
+-  sndbuf reached X: how much packets dropped due to sndbuf being too small (error -11).
++  sndbuf reached X: how much packets dropped due to sndbuf being too small
++      (error -11).
++  connect X: how much connection attempts was failed.
+   other X: dropped due to other possible errors.
+ 
+ > aggr0: ...
+diff --git a/README.promisc b/README.promisc
+index 60ca922..31d774f 100644
+--- a/README.promisc
++++ b/README.promisc
+@@ -2,9 +2,14 @@ Hello,
+ 
+ If you wish to account with netflow module traffic mirrored on switch you may follow this example:
+ 
+-**************
+-* Solution 1 *
+-**************
++
++   Solution 1: General kernel patch.
++   Solution 2: Alternative w/o kernel patch.
++
++
++    **************
++    * Solution 1 *
++    **************
+ 
+ 1. Patch your kernel with `raw_promisc.patch' to enable raw table to see promisc traffic.
+ 
+@@ -33,17 +38,7 @@ If you wish to account with netflow module traffic mirrored on switch you may fo
+  # /sbin/vconfig add eth1 47
+  # /sbin/ifconfig eth1.47 up
+ 
+-5. Recompile ipt_netflow module with #define RAW_PROMISC_HACK uncommented:
+-
+- Find this line in ipt_NETFLOW.c (should be line 7):
+-
+-//#define RAW_PROMISC_HACK
+-
+- And remove two slashes at beginning of the line, so it become like this:
+-
+-#define RAW_PROMISC_HACK
+-
+- Re-compile module:
++5. Compile module:
+ 
+  # make clean all install
+ 
+@@ -55,13 +50,14 @@ If you wish to account with netflow module traffic mirrored on switch you may fo
+ 
+  # /sbin/iptables -A PREROUTING -t raw -i eth1.47 -j NETFLOW
+ 
+-
+ Voila.
+ 
++ps. For Debian Squeeze instructions look at raw_promisc_debian_squeeze6.patch
+ 
+-**************
+-* Solution 2 *
+-**************
++
++    **************
++    * Solution 2 *
++    **************
+ 
+ By Anonymous.
+ 
+@@ -81,4 +77,3 @@ Sometimes you may need to run:
+ 
+ for this scheme to work.
+ 
+-
+diff --git a/configure b/configure
+index 677dd7f..3f10e2a 100755
+--- a/configure
++++ b/configure
+@@ -3,7 +3,7 @@
+ PATH=$PATH:/bin:/usr/bin:/usr/sbin:/sbin:/usr/local/sbin
+ 
+ error() {
+-  echo "! Error: $@"
++  echo -e "! Error: $@"
+   exit 1
+ }
+ 
+@@ -56,19 +56,20 @@ get_lib_from_lib() {
+ }
+ 
+ iptables_inc() {
+-  echo -n "Iptables include path: "
++  echo -n "Iptables include flags: "
+   if [ "$IPTINC" ]; then
+-    echo "$IPTINC (user specified)"
+     IPTINC="-I$IPTINC"
++    echo "$IPTINC (user specified)"
++  elif [ "$PKGVER" ]; then
++    IPTINC="$PKGINC"
++    echo "$IPTINC (pkg-config)"
++  elif [ "$NOIPTSRC" ]; then
++    IPTINC=
++    echo "none (default)"
+   else
+-    if [ "$PKGINC" ]; then
+-      IPTINC="$PKGINC"
+-      echo "$IPTINC (pkg-config)"
+-    else
+-      IPTINC="$IPTSRC/include"
+-      echo "$IPTINC (from source)"
+-      IPTINC="-I$IPTINC"
+-    fi
++    IPTINC="$IPTSRC/include"
++    IPTINC="-I$IPTINC"
++    echo "$IPTINC (from source)"
+   fi
+ }
+ 
+@@ -109,7 +110,16 @@ try_dir2() {
+   test -d "$1" && try_dir `dirname $1` && return 0
+ }
+ 
+-iptables_ver() {
++check_pkg_config() {
++  test "$PKGWARN" && return 1
++  if ! which pkg-config >/dev/null 2>&1; then
++    echo "! You don't have pkg-config, it may be useful to install it."
++    PKGWARN=1
++    return 1
++  fi
++  return 0
++}
++iptables_find_version() {
+   echo -n "Iptables binary version: "
+   if [ "$IPTVER" ]; then
+     echo "$IPTVER (user specified)"
+@@ -121,6 +131,7 @@ iptables_ver() {
+     else
+       echo "no iptables binary found"
+     fi
++    check_pkg_config
+     PKGVER=`pkg-config --modversion xtables 2>/dev/null`
+     if [ "$PKGVER" ]; then
+       IPTVER="$PKGVER"
+@@ -131,44 +142,90 @@ iptables_ver() {
+   fi
+ }
+ 
+-iptables_dir() {
+-  test "$IPTINC" && return 1
+-  test "$PKGINC" && return 1
+-
+-  VER="iptables-$IPTVER"
+-  if [ "$IPTSRC" ]; then
+-    echo "User specified source directory: $IPTSRC"
+-    try_dir $IPTSRC || error "Specified directory is not iptables source.."
++compile_libitp_test() {
++  echo -n "Checking for presence of $@... "
++  echo "
++#define __EXPORTED_HEADERS__
++#include <$*>" > test.c
++  gcc -c test.c  >/dev/null 2>&1
++  RET=$?
++  if [ $RET = 0 ]; then
++    echo Yes;
+   else
+-    echo "Searching for $VER sources.."
+-    try_dir "./$VER" && return 0
+-    try_dir "../$VER" && return 0
+-    try_dir "/usr/src/$VER" && return 0
+-    try_dirg "iptables" && return 0
+-    try_dirg "../iptables" && return 0
+-    try_dirg "/usr/src/iptables" && return 0
+-    try_dir2 `locate $VER/extensions | head -1` && return 0
+-    error "Can not find iptables source directory, try setting it with --ipt-src="
++    echo No;
+   fi
++  rm -f test.c test.o
++  return $RET
+ }
+ 
+-iptables_pkg_config() {
++iptables_try_pkgconfig() {
+   if [ ! "$PKGVER" ]; then
++    check_pkg_config
++    PKGVER=`pkg-config --modversion xtables 2>/dev/null`
++    TRYPKGVER=`pkg-config --modversion xtables 2>/dev/null`
+     echo -n "pkg-config for version $IPTVER exists: "
+-    PKGVER=`pkg-config --exact-version=$IPTVER --modversion xtables 2>/dev/null`
++    pkg-config --exact-version=$IPTVER xtables 2>/dev/null
+     if [ $? = 0 ]; then
+       echo "Yes"
++      PKGVER=$TRYPKGVER
+     else
+-      echo "No (reported: $PKGVER)"
+-      unset PKGVER
++      if [ "$TRYPKGVER" ]; then
++	echo "No (reported: $TRYPKGVER)"
++      else
++	echo "No"
++      fi
+     fi
+   fi
+   if [ "$PKGVER" ]; then
++    check_pkg_config
++    PKGVER=`pkg-config --modversion xtables 2>/dev/null`
+     PKGINC=`pkg-config --cflags xtables`
+     PKGLIB=`pkg-config --variable=xtlibdir xtables`
+-    IPTCFLAGS="-DXTABLES"
+   else
+-    IPTCFLAGS="-DIPTABLES_VERSION=\\\\\"$IPTVER\\\\\""
++    # Newer versions of iptables should not have -I/kernel/include!
++    # So I assume that newer version will have correct pkg-config set up
++    # and if not, then it's older who need it.
++    IPTCFLAGS="-I$KDIR/include -DIPTABLES_VERSION=\\\\\"$IPTVER\\\\\""
++  fi
++  if compile_libitp_test xtables.h; then
++    IPTCFLAGS="-DXTABLES $IPTCFLAGS"
++  elif ! compile_libitp_test iptables.h; then
++    echo "! Iptables headers not found. You may need to specify --ipt-inc=..."
++    if [ -s /etc/debian_version ]; then
++      echo "! "
++      echo "! Under Debian simply run this:"
++      echo "!   root# apt-get install iptables-dev pkg-config"
++    elif [ -s /etc/redhat-release ]; then
++      echo "! "
++      arch=.`uname -m`
++      echo "! Under Centos simply run this:"
++      echo "!   root# yum install iptables-devel$arch pkgconfig"
++    fi
++    exit 1
++  fi
++
++}
++
++iptables_find_src() {
++  test "$IPTINC" && return 1
++  test "$PKGVER" && return 1
++
++  VER="iptables-$IPTVER"
++  if [ "$IPTSRC" ]; then
++    echo "User specified source directory: $IPTSRC"
++    try_dir $IPTSRC || error "Specified directory is not iptables source.."
++  else
++    echo "Searching for $VER sources.."
++    try_dir "./$VER" && return 0
++    try_dir "../$VER" && return 0
++    try_dir "/usr/src/$VER" && return 0
++    try_dirg "iptables" && return 0
++    try_dirg "../iptables" && return 0
++    try_dirg "/usr/src/iptables" && return 0
++    try_dir2 `locate $VER/extensions 2>/dev/null | head -1` && return 0
++    echo "! Can not find iptables source directory, you may try setting it with --ipt-src="
++    echo "! This is not fatal error, yet. Will be just using default include dir."
++    NOIPTSRC=1
+   fi
+ }
+ 
+@@ -206,18 +263,110 @@ do
+   esac
+ done
+ 
+-test "$KVERSION" || KVERSION=`uname -r`
+-echo Kernel version: $KVERSION
++kernel_find_version() {
++  KHOW=requested
++  test "$KVERSION" && return 0
++
++  if grep -q '#.*Debian' /proc/version; then
++    KHOW=proc
++    KVERSION=`sed -n 's/.*#.*Debian \([0-9\.]\+\)-.*/\1/p' /proc/version`
++    KLIBMOD=`uname -r`
++  else
++    KHOW=uname
++    KVERSION=`uname -r`
++  fi
++  test "$KDIR" || return 0
++
++  test -s $KDIR/Makefile || return 1
++  test -s $KDIR/include/config/kernel.release || return 1
++  KVERSION=`cat $KDIR/include/config/kernel.release`
++  KHOW=sources
++}
++
++kernel_check_src() {
++  if [ -s "$1/Makefile" ]; then
++    KDIR="$1"
++    return 0
++  fi
++  return 1
++}
++
++kernel_find_source() {
++  KSHOW=requested
++  test "$KDIR" && return 0
++  KSHOW=found
++  kernel_check_src /lib/modules/$KLIBMOD/build && return 0
++  kernel_check_src /lib/modules/$KVERSION/build && return 0
++  kernel_check_src /usr/src/kernels/$KVERSION && return 0
++  kernel_check_src /usr/src/linux-$KVERSION && return 0
++  echo "! Linux source not found. Don't panic. You may specify kernel source"
++  echo "! directory with --kdir=..., or try to install kernel-devel package,"
++  echo "! or just raw sources for linux-$KVERSION from kernel.org."
++  if grep -q -i centos /proc/version 2>/dev/null; then
++    echo "! "
++    arch=.`uname -m`
++    echo "! Under Centos simply run this:"
++    echo "!   root# yum install kernel-devel iptables-devel$arch pkgconfig"
++  fi
++  if grep -q -i debian /proc/version 2>/dev/null; then
++    echo "! "
++    echo "! Under Debian simply run this:"
++    echo "!   root# apt-get install module-assistant iptables-dev pkg-config"
++    echo "!   root# m-a prepare"
++  fi
++  exit 1
++}
++
++kernel_check_consistency() {
++  if test -s $KDIR/include/config/kernel.release; then
++    SRCVER=`cat $KDIR/include/config/kernel.release`
++    test "$KVERSION" != "$SRCVER" && error "$KHOW kernel version ($KVERSION) and $KSHOW version of kernel source ($SRCVER) doesn't match!\n!" \
++      "You may try to specify only kernel source tree with --kdir=$KDIR\n!" \
++      "and configure will pick up version properly."
++  else
++    test -e "$KDIR/.config" || error ".config in kernel source not found, run  make menuconfig  in $KDIR"
++    test -d "$KDIR/include/config" || error "kernel is not prepared, run  make prepare modules_prepare  in $KDIR"
++  fi
++}
++
++kconfig() {
++  KCONFIG=$KDIR/.config
++  if ! grep -q "^$1=" $KCONFIG 2>/dev/null; then
++    if [ "$KCONFIGREPORTED" != true ]; then
++      KCONFIGREPORTED=true
++      echo Kernel config file checked: $KCONFIG
++      echo
++    fi
++    echo "! Attention: $1 is undefined in your kernel configuration"
++    echo "!   Without this option enabled $2 will not work."
++    echo
++  fi
++}
++
++kernel_check_config() {
++  kconfig CONFIG_SYSCTL			"sysctl interface"
++  kconfig CONFIG_PROC_FS		"proc interface"
++  kconfig CONFIG_NF_NAT_NEEDED		"natevents"
++  kconfig CONFIG_NF_CONNTRACK_EVENTS	"natevents"
++  kconfig CONFIG_NF_CONNTRACK_MARK	"connmark tracking"
++  kconfig CONFIG_IPV6			"IPv6"
++  kconfig CONFIG_IP6_NF_IPTABLES	"ip6tables target"
++}
+ 
+-test "$KDIR" || KDIR=/lib/modules/$KVERSION/build
+-echo Kernel sources: $KDIR
++kernel_find_version	#KVERSION
++test "$KLIBMOD" || KLIBMOD=$KVERSION
++echo "Kernel version: $KVERSION ($KHOW)"
++kernel_find_source	#KDIR
++echo "Kernel sources: $KDIR ($KSHOW)"
++kernel_check_consistency
++kernel_check_config
+ 
+ test "$IPTBIN" || IPTBIN=`which iptables`
+ 
+-iptables_ver		#IPTVER
+-iptables_pkg_config
+-iptables_dir		#IPTSRC
+-iptables_src_version	#check IPTSRC match to IPTVER
++iptables_find_version	#IPTVER
++iptables_try_pkgconfig	#try to configure from pkg-config
++iptables_find_src	#IPTSRC
++iptables_src_version	#check that IPTSRC match to IPTVER
+ iptables_inc		#IPTINC
+ iptables_modules	#IPTLIB
+ 
+@@ -225,7 +374,6 @@ REPLACE="\
+ s!@KVERSION@!$KVERSION!;\
+ s!@KDIR@!$KDIR!;\
+ s!@IPTABLES_VERSION@!$IPTVER!;\
+-s!@IPTABLES_INCLUDES@!$IPTINC!;\
+ s!@IPTABLES_CFLAGS@!$IPTCFLAGS $IPTINC!;\
+ s!@IPTABLES_MODULES@!$IPTLIB!"
+ 
+diff --git a/ipt_NETFLOW.c b/ipt_NETFLOW.c
+index d4c91e1..ad974c5 100644
+--- a/ipt_NETFLOW.c
++++ b/ipt_NETFLOW.c
+@@ -1,6 +1,6 @@
+ /*
+  * This is NetFlow exporting module (NETFLOW target) for linux
+- * (c) 2008-2012 <abc@telekom.ru>
++ * (c) 2008-2013 <abc@telekom.ru>
+  *
+  *
+  *   This program is free software: you can redistribute it and/or modify
+@@ -18,8 +18,6 @@
+  *
+  */
+ 
+-//#define RAW_PROMISC_HACK
+-
+ #include <linux/module.h>
+ #include <linux/skbuff.h>
+ #include <linux/proc_fs.h>
+@@ -31,16 +29,26 @@
+ #include <linux/icmp.h>
+ #include <linux/igmp.h>
+ #include <linux/inetdevice.h>
+-#include <linux/jhash.h>
++#include <linux/hash.h>
++#include <linux/delay.h>
++#include <linux/spinlock_types.h>
+ #include <net/icmp.h>
+ #include <net/ip.h>
++#include <net/ipv6.h>
+ #include <net/tcp.h>
+ #include <net/route.h>
++#include <net/ip6_fib.h>
+ #include <net/dst.h>
+ #include <linux/netfilter_ipv4/ip_tables.h>
++#if defined(CONFIG_NF_NAT_NEEDED) || defined(CONFIG_NF_CONNTRACK_MARK)
++#include <linux/notifier.h>
++#include <net/netfilter/nf_conntrack.h>
++#include <net/netfilter/nf_conntrack_core.h>
++#endif
+ #include <linux/version.h>
+ #include <asm/unaligned.h>
+ #include "ipt_NETFLOW.h"
++#include "murmur3.h"
+ #ifdef CONFIG_BRIDGE_NETFILTER
+ #include <linux/netfilter_bridge.h>
+ #endif
+@@ -74,41 +82,66 @@
+ #define ipt_target xt_target
+ #endif
+ 
+-#define IPT_NETFLOW_VERSION "1.8"
++#define IPT_NETFLOW_VERSION "1.8.2" /* Note that if you are using git, you
++				       will see version in other format. */
++#include "version.h"
++#ifdef GITVERSION
++#undef IPT_NETFLOW_VERSION
++#define IPT_NETFLOW_VERSION GITVERSION
++#endif
+ 
+ MODULE_LICENSE("GPL");
+ MODULE_AUTHOR("<abc@telekom.ru>");
+ MODULE_DESCRIPTION("iptables NETFLOW target module");
+ MODULE_VERSION(IPT_NETFLOW_VERSION);
++MODULE_ALIAS("ip6t_NETFLOW");
+ 
+ #define DST_SIZE 256
+ static char destination_buf[DST_SIZE] = "127.0.0.1:2055";
+ static char *destination = destination_buf;
+-module_param(destination, charp, 0400);
++module_param(destination, charp, 0444);
+ MODULE_PARM_DESC(destination, "export destination ipaddress:port");
+ 
+ static int inactive_timeout = 15;
+-module_param(inactive_timeout, int, 0600);
++module_param(inactive_timeout, int, 0644);
+ MODULE_PARM_DESC(inactive_timeout, "inactive flows timeout in seconds");
+ 
+ static int active_timeout = 30 * 60;
+-module_param(active_timeout, int, 0600);
++module_param(active_timeout, int, 0644);
+ MODULE_PARM_DESC(active_timeout, "active flows timeout in seconds");
+ 
+ static int debug = 0;
+-module_param(debug, int, 0600);
++module_param(debug, int, 0644);
+ MODULE_PARM_DESC(debug, "debug verbosity level");
+ 
+ static int sndbuf;
+-module_param(sndbuf, int, 0400);
++module_param(sndbuf, int, 0444);
+ MODULE_PARM_DESC(sndbuf, "udp socket SNDBUF size");
+ 
++static int protocol = 5;
++module_param(protocol, int, 0444);
++MODULE_PARM_DESC(protocol, "netflow protocol version (5, 9, 10)");
++
++static unsigned int refresh_rate = 20;
++module_param(refresh_rate, uint, 0644);
++MODULE_PARM_DESC(refresh_rate, "NetFlow v9/IPFIX refresh rate (packets)");
++
++static unsigned int timeout_rate = 30;
++module_param(timeout_rate, uint, 0644);
++MODULE_PARM_DESC(timeout_rate, "NetFlow v9/IPFIX timeout rate (minutes)");
++
++#ifdef CONFIG_NF_NAT_NEEDED
++static int natevents = 0;
++module_param(natevents, int, 0444);
++MODULE_PARM_DESC(natevents, "send NAT Events");
++#endif
++
+ static int hashsize;
+-module_param(hashsize, int, 0400);
++module_param(hashsize, int, 0444);
+ MODULE_PARM_DESC(hashsize, "hash table size");
+ 
+ static int maxflows = 2000000;
+-module_param(maxflows, int, 0600);
++module_param(maxflows, int, 0644);
+ MODULE_PARM_DESC(maxflows, "maximum number of flows");
+ static int peakflows = 0;
+ static unsigned long peakflows_at;
+@@ -121,22 +154,52 @@ MODULE_PARM_DESC(aggregation, "aggregation ruleset");
+ 
+ static DEFINE_PER_CPU(struct ipt_netflow_stat, ipt_netflow_stat);
+ static LIST_HEAD(usock_list);
+-static DEFINE_RWLOCK(sock_lock);
++static DEFINE_MUTEX(sock_lock);
+ 
++#define LOCK_COUNT (1<<8)
++#define LOCK_COUNT_MASK (LOCK_COUNT-1)
++static spinlock_t htable_locks[LOCK_COUNT] = {
++	[0 ... LOCK_COUNT - 1] = __SPIN_LOCK_UNLOCKED(htable_locks)
++};
++static DEFINE_RWLOCK(htable_rwlock); /* global lock to protect htable_locks change */
+ static unsigned int ipt_netflow_hash_rnd;
+-struct hlist_head *ipt_netflow_hash __read_mostly; /* hash table memory */
++static struct hlist_head *ipt_netflow_hash __read_mostly; /* hash table memory */
+ static unsigned int ipt_netflow_hash_size __read_mostly = 0; /* buckets */
+ static LIST_HEAD(ipt_netflow_list); /* all flows */
++static DEFINE_SPINLOCK(hlist_lock); /* should almost always be locked w/o _bh */
+ static LIST_HEAD(aggr_n_list);
+ static LIST_HEAD(aggr_p_list);
+ static DEFINE_RWLOCK(aggr_lock);
++#ifdef CONFIG_NF_NAT_NEEDED
++static LIST_HEAD(nat_list); /* nat events */
++static DEFINE_SPINLOCK(nat_lock);
++static unsigned long nat_events_start = 0;
++static unsigned long nat_events_stop = 0;
++#endif
+ static struct kmem_cache *ipt_netflow_cachep __read_mostly; /* ipt_netflow memory */
+ static atomic_t ipt_netflow_count = ATOMIC_INIT(0);
+-static DEFINE_SPINLOCK(ipt_netflow_lock); /* hash table lock */
+ 
+-static long long pdu_packets = 0, pdu_traf = 0;
+-static struct netflow5_pdu pdu;
+-static unsigned long pdu_ts_mod;
++static long long pdu_packets = 0, pdu_traf = 0; /* how much accounted traffic in pdu */
++static unsigned int pdu_count = 0;
++static unsigned int pdu_seq = 0;
++static unsigned int pdu_data_records = 0;
++static unsigned int pdu_tpl_records = 0;
++static unsigned long pdu_ts_mod; /* ts of last flow */
++static union {
++	struct netflow5_pdu v5;
++	struct netflow9_pdu v9;
++	struct ipfix_pdu ipfix;
++} pdu;
++static int engine_id = 0; /* Observation Domain */
++static __u8 *pdu_data_used;
++static __u8 *pdu_high_wm; /* high watermark */
++static unsigned int pdu_max_size; /* sizeof pdu */
++static struct flowset_data *pdu_flowset = NULL; /* current data flowset */
++
++static void (*netflow_export_flow)(struct ipt_netflow *nf);
++static void (*netflow_export_pdu)(void); /* called on timeout */
++static void netflow_switch_version(int ver);
++
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
+ static void netflow_work_fn(void *work);
+ static DECLARE_WORK(netflow_work, netflow_work_fn, NULL);
+@@ -146,19 +209,26 @@ static DECLARE_DELAYED_WORK(netflow_work, netflow_work_fn);
+ #endif
+ static struct timer_list rate_timer;
+ 
++#define TCP_SYN_ACK 0x12
+ #define TCP_FIN_RST 0x05
+ 
+ static long long sec_prate = 0, sec_brate = 0;
+ static long long min_prate = 0, min_brate = 0;
+ static long long min5_prate = 0, min5_brate = 0;
+-static unsigned int metric = 10, min15_metric = 10, min5_metric = 10, min_metric = 10; /* hash metrics */
++static unsigned int metric = 100, min15_metric = 100, min5_metric = 100, min_metric = 100; /* hash metrics */
+ 
+ static int set_hashsize(int new_size);
+ static void destination_removeall(void);
+ static int add_destinations(char *ptr);
+ static void aggregation_remove(struct list_head *list);
+ static int add_aggregation(char *ptr);
+-static void netflow_scan_and_export(int flush);
++static int netflow_scan_and_export(int flush);
++enum {
++	DONT_FLUSH, AND_FLUSH
++};
++static int template_ids = FLOWSET_DATA_FIRST;
++static int tpl_count = 0; /* how much active templates */
++
+ 
+ static inline __be32 bits2mask(int bits) {
+ 	return (bits? 0xffffffff << (32 - bits) : 0);
+@@ -175,28 +245,46 @@ static inline int mask2bits(__be32 mask) {
+ /* under that lock worker is always stopped and not rescheduled,
+  * and we can call worker sub-functions manually */
+ static DEFINE_MUTEX(worker_lock);
+-static inline void __start_scan_worker(void)
++#define MIN_DELAY 1
++#define MAX_DELAY (HZ / 10)
++static int worker_delay = HZ / 10;
++static inline void _schedule_scan_worker(const int status)
+ {
+-	schedule_delayed_work(&netflow_work, HZ / 10);
++	/* rudimentary congestion avoidance */
++	if (status > 0)
++		worker_delay -= status;
++	else if (status < 0)
++		worker_delay /= 2;
++	else
++		worker_delay++;
++	if (worker_delay < MIN_DELAY)
++		worker_delay = MIN_DELAY;
++	else if (worker_delay > MAX_DELAY)
++		worker_delay = MAX_DELAY;
++	schedule_delayed_work(&netflow_work, worker_delay);
+ }
+ 
+-static inline void start_scan_worker(void)
++/* This is only called soon after pause_scan_worker. */
++static inline void cont_scan_worker(void)
+ {
+-	__start_scan_worker();
++	_schedule_scan_worker(0);
+ 	mutex_unlock(&worker_lock);
+ }
+ 
+-/* we always stop scanner before write_lock(&sock_lock)
+- * to let it never hold that spin lock */
+-static inline void __stop_scan_worker(void)
++static inline void _unschedule_scan_worker(void)
+ {
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
++	cancel_rearming_delayed_work(&netflow_work);
++#else
+ 	cancel_delayed_work_sync(&netflow_work);
++#endif
+ }
+ 
+-static inline void stop_scan_worker(void)
++/* This is only used for quick pause (in procctl). */
++static inline void pause_scan_worker(void)
+ {
+ 	mutex_lock(&worker_lock);
+-	__stop_scan_worker();
++	_unschedule_scan_worker();
+ }
+ 
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
+@@ -223,11 +311,14 @@ static int nf_seq_show(struct seq_file *seq, void *v)
+ 	int snum = 0;
+ 	int peak = (jiffies - peakflows_at) / HZ;
+ 
+-	seq_printf(seq, "Flows: active %u (peak %u reached %ud%uh%um ago), mem %uK\n",
++	seq_printf(seq, "ipt_NETFLOW version " IPT_NETFLOW_VERSION ", srcversion %s\n",
++	    THIS_MODULE->srcversion);
++	seq_printf(seq, "Flows: active %u (peak %u reached %ud%uh%um ago), mem %uK, worker delay %d/%d.\n",
+ 		   nr_flows,
+ 		   peakflows,
+ 		   peak / (60 * 60 * 24), (peak / (60 * 60)) % 24, (peak / 60) % 60,
+-		   (unsigned int)((nr_flows * sizeof(struct ipt_netflow)) >> 10));
++		   (unsigned int)((nr_flows * sizeof(struct ipt_netflow)) >> 10),
++		   worker_delay, HZ);
+ 
+ 	for_each_present_cpu(cpu) {
+ 		struct ipt_netflow_stat *st = &per_cpu(ipt_netflow_stat, cpu);
+@@ -252,93 +343,123 @@ static int nf_seq_show(struct seq_file *seq, void *v)
+ 	}
+ 
+ #define FFLOAT(x, prec) (int)(x) / prec, (int)(x) % prec
+-	seq_printf(seq, "Hash: size %u (mem %uK), metric %d.%d, %d.%d, %d.%d, %d.%d. MemTraf: %llu pkt, %llu K (pdu %llu, %llu).\n",
+-		   ipt_netflow_hash_size, 
+-		   (unsigned int)((ipt_netflow_hash_size * sizeof(struct hlist_head)) >> 10),
+-		   FFLOAT(metric, 10),
+-		   FFLOAT(min_metric, 10),
+-		   FFLOAT(min5_metric, 10),
+-		   FFLOAT(min15_metric, 10),
+-		   pkt_total - pkt_out + pdu_packets,
+-		   (traf_total - traf_out + pdu_traf) >> 10,
+-		   pdu_packets,
+-		   pdu_traf);
+-
+-	seq_printf(seq, "Timeout: active %d, inactive %d. Maxflows %u\n",
+-		   active_timeout,
+-		   inactive_timeout,
+-		   maxflows);
+-
+-	seq_printf(seq, "Rate: %llu bits/sec, %llu packets/sec; Avg 1 min: %llu bps, %llu pps; 5 min: %llu bps, %llu pps\n",
+-		   sec_brate, sec_prate, min_brate, min_prate, min5_brate, min5_prate);
+-
+-	seq_printf(seq, "cpu#  stat: <search found new, trunc frag alloc maxflows>, sock: <ok fail cberr, bytes>, traffic: <pkt, bytes>, drop: <pkt, bytes>\n");
+-
+-	seq_printf(seq, "Total stat: %6llu %6llu %6llu, %4u %4u %4u %4u, sock: %6u %u %u, %llu K, traffic: %llu, %llu MB, drop: %llu, %llu K\n",
+-		   (unsigned long long)searched,
+-		   (unsigned long long)found,
+-		   (unsigned long long)notfound,
+-		   truncated, frags, alloc_err, maxflows_err,
+-		   send_success, send_failed, sock_errors,
+-		   (unsigned long long)exported_size >> 10,
+-		   (unsigned long long)pkt_total, (unsigned long long)traf_total >> 20,
+-		   (unsigned long long)pkt_drop, (unsigned long long)traf_drop >> 10);
++	seq_printf(seq, "Hash: size %u (mem %uK), metric %d.%02d [%d.%02d, %d.%02d, %d.%02d]."
++	    " MemTraf: %llu pkt, %llu K (pdu %llu, %llu), Out %llu pkt, %llu K.\n",
++	    ipt_netflow_hash_size,
++	    (unsigned int)((ipt_netflow_hash_size * sizeof(struct hlist_head)) >> 10),
++	    FFLOAT(metric, 100),
++	    FFLOAT(min_metric, 100),
++	    FFLOAT(min5_metric, 100),
++	    FFLOAT(min15_metric, 100),
++	    pkt_total - pkt_out + pdu_packets,
++	    (traf_total - traf_out + pdu_traf) >> 10,
++	    pdu_packets,
++	    pdu_traf,
++	    pkt_out,
++	    traf_out >> 10);
++
++	seq_printf(seq, "Rate: %llu bits/sec, %llu packets/sec;"
++	    " Avg 1 min: %llu bps, %llu pps; 5 min: %llu bps, %llu pps\n",
++	    sec_brate, sec_prate, min_brate, min_prate, min5_brate, min5_prate);
++
++	seq_printf(seq, "cpu#  stat: <search found new [metric], trunc frag alloc maxflows>,"
++	    " sock: <ok fail cberr, bytes>, traffic: <pkt, bytes>, drop: <pkt, bytes>\n");
++
++#define SAFEDIV(x,y) ((y)? ({ u64 __tmp = x; do_div(__tmp, y); (int)__tmp; }) : 0)
++	seq_printf(seq, "Total stat: %6llu %6llu %6llu [%d.%02d], %4u %4u %4u %4u,"
++	    " sock: %6u %u %u, %llu K, traffic: %llu, %llu MB, drop: %llu, %llu K\n",
++	    searched,
++	    (unsigned long long)found,
++	    (unsigned long long)notfound,
++	    FFLOAT(SAFEDIV(100LL * (searched + found + notfound), (found + notfound)), 100),
++	    truncated, frags, alloc_err, maxflows_err,
++	    send_success, send_failed, sock_errors,
++	    (unsigned long long)exported_size >> 10,
++	    (unsigned long long)pkt_total, (unsigned long long)traf_total >> 20,
++	    (unsigned long long)pkt_drop, (unsigned long long)traf_drop >> 10);
+ 
+ 	if (num_present_cpus() > 1) {
+ 		for_each_present_cpu(cpu) {
+ 			struct ipt_netflow_stat *st;
+ 
+ 			st = &per_cpu(ipt_netflow_stat, cpu);
+-			seq_printf(seq, "cpu%u  stat: %6llu %6llu %6llu, %4u %4u %4u %4u, sock: %6u %u %u, %llu K, traffic: %llu, %llu MB, drop: %llu, %llu K\n",
+-				   cpu,
+-				   (unsigned long long)st->searched,
+-				   (unsigned long long)st->found,
+-				   (unsigned long long)st->notfound,
+-				   st->truncated, st->frags, st->alloc_err, st->maxflows_err,
+-				   st->send_success, st->send_failed, st->sock_errors,
+-				   (unsigned long long)st->exported_size >> 10,
+-				   (unsigned long long)st->pkt_total, (unsigned long long)st->traf_total >> 20,
+-				   (unsigned long long)st->pkt_drop, (unsigned long long)st->traf_drop >> 10);
++			seq_printf(seq, "cpu%u  stat: %6llu %6llu %6llu [%d.%02d], %4u %4u %4u %4u,"
++			    " sock: %6u %u %u, %llu K, traffic: %llu, %llu MB, drop: %llu, %llu K\n",
++			    cpu,
++			    (unsigned long long)st->searched,
++			    (unsigned long long)st->found,
++			    (unsigned long long)st->notfound,
++			    FFLOAT(SAFEDIV(100LL * (st->searched + st->found + st->notfound), (st->found + st->notfound)), 100),
++			    st->truncated, st->frags, st->alloc_err, st->maxflows_err,
++			    st->send_success, st->send_failed, st->sock_errors,
++			    (unsigned long long)st->exported_size >> 10,
++			    (unsigned long long)st->pkt_total, (unsigned long long)st->traf_total >> 20,
++			    (unsigned long long)st->pkt_drop, (unsigned long long)st->traf_drop >> 10);
+ 		}
+ 	}
+ 
+-	read_lock(&sock_lock);
++	seq_printf(seq, "Protocol version %d", protocol);
++	if (protocol == 10)
++		seq_printf(seq, " (ipfix)");
++	else
++		seq_printf(seq, " (netflow)");
++	if (protocol >= 9)
++		seq_printf(seq, ", refresh-rate %u, timeout-rate %u, (templates %d, active %d)",
++		    refresh_rate, timeout_rate, template_ids - FLOWSET_DATA_FIRST, tpl_count);
++
++	seq_printf(seq, ". Timeouts: active %d, inactive %d. Maxflows %u\n",
++	    active_timeout,
++	    inactive_timeout,
++	    maxflows);
++
++#ifdef CONFIG_NF_NAT_NEEDED
++	seq_printf(seq, "Natevents %s, count start %lu, stop %lu.\n", natevents? "enabled" : "disabled",
++	    nat_events_start, nat_events_stop);
++#endif
++
++	mutex_lock(&sock_lock);
+ 	list_for_each_entry(usock, &usock_list, list) {
+-		struct sock *sk = usock->sock->sk;
+-
+-		seq_printf(seq, "sock%d: %u.%u.%u.%u:%u, sndbuf %u, filled %u, peak %u; err: sndbuf reached %u, other %u\n",
+-			   snum,
+-			   usock->ipaddr >> 24,
+-			   (usock->ipaddr >> 16) & 255,
+-			   (usock->ipaddr >> 8) & 255,
+-			   usock->ipaddr & 255,
+-			   usock->port,
+-			   sk->sk_sndbuf,
+-			   atomic_read(&sk->sk_wmem_alloc),
+-			   atomic_read(&usock->wmem_peak),
+-			   atomic_read(&usock->err_full),
+-			   atomic_read(&usock->err_other));
++		seq_printf(seq, "sock%d: %u.%u.%u.%u:%u",
++		    snum,
++		    HIPQUAD(usock->ipaddr),
++		    usock->port);
++		if (usock->sock) {
++			struct sock *sk = usock->sock->sk;
++
++			seq_printf(seq, ", sndbuf %u, filled %u, peak %u;"
++			    " err: sndbuf reached %u, connect %u, other %u\n",
++			    sk->sk_sndbuf,
++			    atomic_read(&sk->sk_wmem_alloc),
++			    atomic_read(&usock->wmem_peak),
++			    atomic_read(&usock->err_full),
++			    atomic_read(&usock->err_connect),
++			    atomic_read(&usock->err_other));
++		} else
++			seq_printf(seq, " unconnected (%u attempts).\n",
++			    atomic_read(&usock->err_connect));
+ 		snum++;
+ 	}
+-	read_unlock(&sock_lock);
++	mutex_unlock(&sock_lock);
+ 
+ 	read_lock_bh(&aggr_lock);
+ 	snum = 0;
+ 	list_for_each_entry(aggr_n, &aggr_n_list, list) {
+-		seq_printf(seq, "aggr#%d net: match %u.%u.%u.%u/%d strip %d\n",
+-			   snum,
+-			   HIPQUAD(aggr_n->addr),
+-			   mask2bits(aggr_n->mask),
+-			   mask2bits(aggr_n->aggr_mask));
++		seq_printf(seq, "aggr#%d net: match %u.%u.%u.%u/%d strip %d (usage %u)\n",
++		    snum,
++		    HIPQUAD(aggr_n->addr),
++		    mask2bits(aggr_n->mask),
++		    mask2bits(aggr_n->aggr_mask),
++		    atomic_read(&aggr_n->usage));
+ 		snum++;
+ 	}
+ 	snum = 0;
+ 	list_for_each_entry(aggr_p, &aggr_p_list, list) {
+-		seq_printf(seq, "aggr#%d port: ports %u-%u replace %u\n",
+-			   snum,
+-			   aggr_p->port1,
+-			   aggr_p->port2,
+-			   aggr_p->aggr_port);
++		seq_printf(seq, "aggr#%d port: ports %u-%u replace %u (usage %u)\n",
++		    snum,
++		    aggr_p->port1,
++		    aggr_p->port2,
++		    aggr_p->aggr_port,
++		    atomic_read(&aggr_p->usage));
+ 		snum++;
+ 	}
+ 	read_unlock_bh(&aggr_lock);
+@@ -367,8 +488,13 @@ static struct file_operations nf_seq_fops = {
+ #define BEFORE2632(x,y)
+ #endif
+ 
++/* PAX need to know that we are allowed to write */
++#ifndef CONSTIFY_PLUGIN
++#define ctl_table_no_const ctl_table
++#endif
++
+ /* sysctl /proc/sys/net/netflow */
+-static int hsize_procctl(ctl_table *ctl, int write, BEFORE2632(struct file *filp,)
++static int hsize_procctl(ctl_table_no_const *ctl, int write, BEFORE2632(struct file *filp,)
+ 			 void __user *buffer, size_t *lenp, loff_t *fpos)
+ {
+ 	void *orig = ctl->data;
+@@ -386,20 +512,21 @@ static int hsize_procctl(ctl_table *ctl, int write, BEFORE2632(struct file *filp
+ 		return ret;
+ }
+ 
+-static int sndbuf_procctl(ctl_table *ctl, int write, BEFORE2632(struct file *filp,)
++static int sndbuf_procctl(ctl_table_no_const *ctl, int write, BEFORE2632(struct file *filp,)
+ 			 void __user *buffer, size_t *lenp, loff_t *fpos)
+ {
+ 	int ret;
+ 	struct ipt_netflow_sock *usock;
+-       
+-	read_lock(&sock_lock);
++
++	mutex_lock(&sock_lock);
+ 	if (list_empty(&usock_list)) {
+-		read_unlock(&sock_lock);
++		mutex_unlock(&sock_lock);
+ 		return -ENOENT;
+ 	}
+ 	usock = list_first_entry(&usock_list, struct ipt_netflow_sock, list);
+-	sndbuf = usock->sock->sk->sk_sndbuf;
+-	read_unlock(&sock_lock);
++	if (usock->sock)
++		sndbuf = usock->sock->sk->sk_sndbuf;
++	mutex_unlock(&sock_lock);
+ 
+ 	ctl->data = &sndbuf;
+ 	ret = proc_dointvec(ctl, write, BEFORE2632(filp,) buffer, lenp, fpos);
+@@ -407,13 +534,14 @@ static int sndbuf_procctl(ctl_table *ctl, int write, BEFORE2632(struct file *fil
+ 		return ret;
+ 	if (sndbuf < SOCK_MIN_SNDBUF)
+ 		sndbuf = SOCK_MIN_SNDBUF;
+-	stop_scan_worker();
+-	write_lock(&sock_lock);
++	pause_scan_worker();
++	mutex_lock(&sock_lock);
+ 	list_for_each_entry(usock, &usock_list, list) {
+-		usock->sock->sk->sk_sndbuf = sndbuf;
++		if (usock->sock)
++			usock->sock->sk->sk_sndbuf = sndbuf;
+ 	}
+-	write_unlock(&sock_lock);
+-	start_scan_worker();
++	mutex_unlock(&sock_lock);
++	cont_scan_worker();
+ 	return ret;
+ }
+ 
+@@ -424,10 +552,10 @@ static int destination_procctl(ctl_table *ctl, int write, BEFORE2632(struct file
+ 
+ 	ret = proc_dostring(ctl, write, BEFORE2632(filp,) buffer, lenp, fpos);
+ 	if (ret >= 0 && write) {
+-		stop_scan_worker();
++		pause_scan_worker();
+ 		destination_removeall();
+ 		add_destinations(destination_buf);
+-		start_scan_worker();
++		cont_scan_worker();
+ 	}
+ 	return ret;
+ }
+@@ -446,13 +574,12 @@ static int aggregation_procctl(ctl_table *ctl, int write, BEFORE2632(struct file
+ 	return ret;
+ }
+ 
+-static int flush_procctl(ctl_table *ctl, int write, BEFORE2632(struct file *filp,)
++static int flush_procctl(ctl_table_no_const *ctl, int write, BEFORE2632(struct file *filp,)
+ 			 void __user *buffer, size_t *lenp, loff_t *fpos)
+ {
+ 	int ret;
+-	int val;
++	int val = 0;
+ 
+-	val = 0;
+ 	ctl->data = &val;
+ 	ret = proc_dointvec(ctl, write, BEFORE2632(filp,) buffer, lenp, fpos);
+ 
+@@ -461,14 +588,67 @@ static int flush_procctl(ctl_table *ctl, int write, BEFORE2632(struct file *filp
+ 
+ 	if (val > 0) {
+ 		printk(KERN_INFO "ipt_NETFLOW: forced flush\n");
+-		stop_scan_worker();
+-		netflow_scan_and_export(1);
+-		start_scan_worker();
++		pause_scan_worker();
++		netflow_scan_and_export(AND_FLUSH);
++		cont_scan_worker();
++	}
++
++	return ret;
++}
++
++static int protocol_procctl(ctl_table *ctl, int write, BEFORE2632(struct file *filp,)
++			 void __user *buffer, size_t *lenp, loff_t *fpos)
++{
++	int ret;
++	int ver = protocol;
++
++	ctl->data = &ver;
++	ret = proc_dointvec(ctl, write, BEFORE2632(filp,) buffer, lenp, fpos);
++
++	if (!write)
++		return ret;
++
++	switch (ver) {
++		case 5:
++		case 9:
++		case 10:
++			printk(KERN_INFO "ipt_NETFLOW: forced flush (protocol version change)\n");
++			pause_scan_worker();
++			netflow_scan_and_export(AND_FLUSH);
++			netflow_switch_version(ver);
++			cont_scan_worker();
++			break;
++		default:
++			return -EPERM;
+ 	}
+ 
+ 	return ret;
+ }
+ 
++#ifdef CONFIG_NF_NAT_NEEDED
++static void register_ct_events(void);
++static void unregister_ct_events(void);
++static int natevents_procctl(ctl_table *ctl, int write, BEFORE2632(struct file *filp,)
++			 void __user *buffer, size_t *lenp, loff_t *fpos)
++{
++	int ret;
++	int val = natevents;
++
++	ctl->data = &val;
++	ret = proc_dointvec(ctl, write, BEFORE2632(filp,) buffer, lenp, fpos);
++
++	if (!write)
++		return ret;
++
++	if (natevents && !val)
++		unregister_ct_events();
++	else if (!natevents && val)
++		register_ct_events();
++
++	return ret;
++}
++#endif
++
+ static struct ctl_table_header *netflow_sysctl_header;
+ 
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
+@@ -547,6 +727,38 @@ static struct ctl_table netflow_sysctl_table[] = {
+ 		.maxlen		= sizeof(int),
+ 		.proc_handler	= &flush_procctl,
+ 	},
++	{
++		_CTL_NAME(10)
++		.procname	= "protocol",
++		.mode		= 0644,
++		.maxlen		= sizeof(int),
++		.proc_handler	= &protocol_procctl,
++	},
++	{
++		_CTL_NAME(11)
++		.procname	= "refresh-rate",
++		.mode		= 0644,
++		.data		= &refresh_rate,
++		.maxlen		= sizeof(int),
++		.proc_handler	= &proc_dointvec,
++	},
++	{
++		_CTL_NAME(12)
++		.procname	= "timeout-rate",
++		.mode		= 0644,
++		.data		= &timeout_rate,
++		.maxlen		= sizeof(int),
++		.proc_handler	= &proc_dointvec,
++	},
++#ifdef CONFIG_NF_NAT_NEEDED
++	{
++		_CTL_NAME(13)
++		.procname	= "natevents",
++		.mode		= 0644,
++		.maxlen		= sizeof(int),
++		.proc_handler	= &natevents_procctl,
++	},
++#endif
+ 	{ }
+ };
+ 
+@@ -588,18 +800,69 @@ static struct ctl_path netflow_sysctl_path[] = {
+ static void sk_error_report(struct sock *sk)
+ {
+ 	/* clear connection refused errors if any */
+-	write_lock_bh(&sk->sk_callback_lock);
+ 	if (debug > 1)
+-		printk(KERN_INFO "NETFLOW: socket error <%d>\n", sk->sk_err);
++		printk(KERN_INFO "ipt_NETFLOW: socket error <%d>\n", sk->sk_err);
+ 	sk->sk_err = 0;
+ 	NETFLOW_STAT_INC(sock_errors);
+-	write_unlock_bh(&sk->sk_callback_lock);
+ 	return;
+ }
+ 
++static struct socket *_usock_alloc(const __be32 ipaddr, const unsigned short port)
++{
++	struct sockaddr_in sin;
++	struct socket *sock;
++	int error;
++
++	if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) {
++		printk(KERN_ERR "ipt_NETFLOW: sock_create_kern error %d\n", -error);
++		return NULL;
++	}
++	sock->sk->sk_allocation = GFP_ATOMIC;
++	sock->sk->sk_prot->unhash(sock->sk); /* hidden from input */
++	sock->sk->sk_error_report = &sk_error_report; /* clear ECONNREFUSED */
++	if (sndbuf)
++		sock->sk->sk_sndbuf = sndbuf;
++	else
++		sndbuf = sock->sk->sk_sndbuf;
++	memset(&sin, 0, sizeof(sin));
++	sin.sin_family      = AF_INET;
++	sin.sin_addr.s_addr = htonl(ipaddr);
++	sin.sin_port        = htons(port);
++	if ((error = sock->ops->connect(sock, (struct sockaddr *)&sin,
++				  sizeof(sin), 0)) < 0) {
++		printk(KERN_ERR "ipt_NETFLOW: error connecting UDP socket %d,"
++		    " don't worry, will try reconnect later.\n", -error);
++		/* ENETUNREACH when no interfaces */
++		sock_release(sock);
++		return NULL;
++	}
++	return sock;
++}
++
++static void usock_connect(struct ipt_netflow_sock *usock, const int sendmsg)
++{
++	usock->sock = _usock_alloc(usock->ipaddr, usock->port);
++	if (usock->sock) {
++		if (sendmsg || debug)
++			printk(KERN_INFO "ipt_NETFLOW: connected %u.%u.%u.%u:%u\n",
++			    HIPQUAD(usock->ipaddr),
++			    usock->port);
++	} else {
++		atomic_inc(&usock->err_connect);
++		if (debug)
++			printk(KERN_INFO "ipt_NETFLOW: connect to %u.%u.%u.%u:%u failed%s.\n",
++			    HIPQUAD(usock->ipaddr),
++			    usock->port,
++			    (sendmsg)? " (pdu lost)" : "");
++	}
++	atomic_set(&usock->wmem_peak, 0);
++	atomic_set(&usock->err_full, 0);
++	atomic_set(&usock->err_other, 0);
++}
++
+ // return numbers of sends succeded, 0 if none
+ /* only called in scan worker path */
+-static int netflow_send_pdu(void *buffer, int len)
++static void netflow_sendmsg(void *buffer, const int len)
+ {
+ 	struct msghdr msg = { .msg_flags = MSG_DONTWAIT|MSG_NOSIGNAL };
+ 	struct kvec iov = { buffer, len };
+@@ -607,9 +870,16 @@ static int netflow_send_pdu(void *buffer, int len)
+ 	int snum = 0;
+ 	struct ipt_netflow_sock *usock;
+ 
++	mutex_lock(&sock_lock);
+ 	list_for_each_entry(usock, &usock_list, list) {
++		if (!usock->sock)
++			usock_connect(usock, 1);
++		if (!usock->sock) {
++			NETFLOW_STAT_INC_ATOMIC(send_failed);
++			continue;
++		}
+ 		if (debug)
+-			printk(KERN_INFO "netflow_send_pdu: sendmsg(%d, %d) [%u %u]\n",
++			printk(KERN_INFO "netflow_sendmsg: sendmsg(%d, %d) [%u %u]\n",
+ 			       snum,
+ 			       len,
+ 			       atomic_read(&usock->sock->sk->sk_wmem_alloc),
+@@ -624,7 +894,7 @@ static int netflow_send_pdu(void *buffer, int len)
+ 				suggestion = ": increase sndbuf!";
+ 			} else
+ 				atomic_inc(&usock->err_other);
+-			printk(KERN_ERR "netflow_send_pdu[%d]: sendmsg error %d: data loss %llu pkt, %llu bytes%s\n",
++			printk(KERN_ERR "ipt_NETFLOW: sendmsg[%d] error %d: data loss %llu pkt, %llu bytes%s\n",
+ 			       snum, ret, pdu_packets, pdu_traf, suggestion);
+ 		} else {
+ 			unsigned int wmem = atomic_read(&usock->sock->sk->sk_wmem_alloc);
+@@ -636,98 +906,67 @@ static int netflow_send_pdu(void *buffer, int len)
+ 		}
+ 		snum++;
+ 	}
+-	return retok;
++	mutex_unlock(&sock_lock);
++	if (retok == 0) {
++		/* not least one send succeded, account stat for dropped packets */
++		NETFLOW_STAT_ADD_ATOMIC(pkt_drop, pdu_packets);
++		NETFLOW_STAT_ADD_ATOMIC(traf_drop, pdu_traf);
++	}
+ }
+ 
+-static void usock_free(struct ipt_netflow_sock *usock)
++static void usock_close_free(struct ipt_netflow_sock *usock)
+ {
+-	printk(KERN_INFO "netflow: remove destination %u.%u.%u.%u:%u (%p)\n",
++	printk(KERN_INFO "ipt_NETFLOW: removed destination %u.%u.%u.%u:%u\n",
+ 	       HIPQUAD(usock->ipaddr),
+-	       usock->port,
+-	       usock->sock);
++	       usock->port);
+ 	if (usock->sock)
+ 		sock_release(usock->sock);
+ 	usock->sock = NULL;
+-	vfree(usock); 
++	vfree(usock);
+ }
+ 
+ static void destination_removeall(void)
+ {
+-	write_lock(&sock_lock);
++	mutex_lock(&sock_lock);
+ 	while (!list_empty(&usock_list)) {
+ 		struct ipt_netflow_sock *usock;
+ 
+ 		usock = list_entry(usock_list.next, struct ipt_netflow_sock, list);
+ 		list_del(&usock->list);
+-		write_unlock(&sock_lock);
+-		usock_free(usock);
+-		write_lock(&sock_lock);
++		mutex_unlock(&sock_lock);
++		usock_close_free(usock);
++		mutex_lock(&sock_lock);
+ 	}
+-	write_unlock(&sock_lock);
++	mutex_unlock(&sock_lock);
+ }
+ 
+ static void add_usock(struct ipt_netflow_sock *usock)
+ {
+ 	struct ipt_netflow_sock *sk;
+ 
+-	/* don't need empty sockets */
+-	if (!usock->sock) {
+-		usock_free(usock);
+-		return;
+-	}
+-
+-	write_lock(&sock_lock);
++	mutex_lock(&sock_lock);
+ 	/* don't need duplicated sockets */
+ 	list_for_each_entry(sk, &usock_list, list) {
+ 		if (sk->ipaddr == usock->ipaddr &&
+ 		    sk->port == usock->port) {
+-			write_unlock(&sock_lock);
+-			usock_free(usock);
++			mutex_unlock(&sock_lock);
++			usock_close_free(usock);
+ 			return;
+ 		}
+ 	}
+ 	list_add_tail(&usock->list, &usock_list);
+-	printk(KERN_INFO "netflow: added destination %u.%u.%u.%u:%u\n",
++	printk(KERN_INFO "ipt_NETFLOW: added destination %u.%u.%u.%u:%u%s\n",
+ 	       HIPQUAD(usock->ipaddr),
+-	       usock->port);
+-	write_unlock(&sock_lock);
+-}
+-
+-static struct socket *usock_alloc(__be32 ipaddr, unsigned short port)
+-{
+-	struct sockaddr_in sin;
+-	struct socket *sock;
+-	int error;
+-
+-	if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock)) < 0) {
+-		printk(KERN_ERR "netflow: sock_create_kern error %d\n", error);
+-		return NULL;
+-	}
+-	sock->sk->sk_allocation = GFP_ATOMIC;
+-	sock->sk->sk_prot->unhash(sock->sk); /* hidden from input */
+-	sock->sk->sk_error_report = &sk_error_report; /* clear ECONNREFUSED */
+-	if (sndbuf)
+-		sock->sk->sk_sndbuf = sndbuf;
+-	else
+-		sndbuf = sock->sk->sk_sndbuf;
+-	memset(&sin, 0, sizeof(sin));
+-	sin.sin_family      = AF_INET;
+-	sin.sin_addr.s_addr = htonl(ipaddr);
+-	sin.sin_port        = htons(port);
+-	if ((error = sock->ops->connect(sock, (struct sockaddr *)&sin,
+-				  sizeof(sin), 0)) < 0) {
+-		printk(KERN_ERR "netflow: error connecting UDP socket %d\n", error);
+-		sock_release(sock);
+-		return NULL;
+-	}
+-	return sock;
++	       usock->port,
++	       (!usock->sock)? " (unconnected)" : "");
++	mutex_unlock(&sock_lock);
+ }
+ 
+ #define SEPARATORS " ,;\t\n"
+ static int add_destinations(char *ptr)
+ {
+ 	while (ptr) {
+-		unsigned char ip[4]; 
++		unsigned char ip[4];
+ 		unsigned short port;
+ 
+ 		ptr += strspn(ptr, SEPARATORS);
+@@ -737,17 +976,15 @@ static int add_destinations(char *ptr)
+ 			struct ipt_netflow_sock *usock;
+ 
+ 			if (!(usock = vmalloc(sizeof(*usock)))) {
+-				printk(KERN_ERR "netflow: can't vmalloc socket\n");
++				printk(KERN_ERR "ipt_NETFLOW: can't vmalloc socket\n");
+ 				return -ENOMEM;
+ 			}
+ 
+ 			memset(usock, 0, sizeof(*usock));
++			atomic_set(&usock->err_connect, 0);
+ 			usock->ipaddr = ntohl(*(__be32 *)ip);
+ 			usock->port = port;
+-			usock->sock = usock_alloc(usock->ipaddr, port);
+-			atomic_set(&usock->wmem_peak, 0);
+-			atomic_set(&usock->err_full, 0);
+-			atomic_set(&usock->err_other, 0);
++			usock_connect(usock, 0);
+ 			add_usock(usock);
+ 		} else
+ 			break;
+@@ -781,7 +1018,7 @@ static int add_aggregation(char *ptr)
+ 	LIST_HEAD(old_aggr_list);
+ 
+ 	while (ptr && *ptr) {
+-		unsigned char ip[4]; 
++		unsigned char ip[4];
+ 		unsigned int mask;
+ 		unsigned int port1, port2;
+ 		unsigned int aggr_to;
+@@ -792,16 +1029,16 @@ static int add_aggregation(char *ptr)
+ 			   ip, ip + 1, ip + 2, ip + 3, &mask, &aggr_to) == 6) {
+ 
+ 			if (!(aggr_n = vmalloc(sizeof(*aggr_n)))) {
+-				printk(KERN_ERR "netflow: can't vmalloc aggr\n");
++				printk(KERN_ERR "ipt_NETFLOW: can't vmalloc aggr\n");
+ 				return -ENOMEM;
+ 			}
+ 			memset(aggr_n, 0, sizeof(*aggr_n));
+ 
+-			aggr_n->addr = ntohl(*(__be32 *)ip);
+ 			aggr_n->mask = bits2mask(mask);
++			aggr_n->addr = ntohl(*(__be32 *)ip) & aggr_n->mask;
+ 			aggr_n->aggr_mask = bits2mask(aggr_to);
+ 			aggr_n->prefix = mask;
+-			printk(KERN_INFO "netflow: add aggregation [%u.%u.%u.%u/%u=%u]\n",
++			printk(KERN_INFO "ipt_NETFLOW: add aggregation [%u.%u.%u.%u/%u=%u]\n",
+ 			       HIPQUAD(aggr_n->addr), mask, aggr_to);
+ 			list_add_tail(&aggr_n->list, &new_aggr_n_list);
+ 
+@@ -809,7 +1046,7 @@ static int add_aggregation(char *ptr)
+ 			   sscanf(ptr, "%u=%u", &port2, &aggr_to) == 2) {
+ 
+ 			if (!(aggr_p = vmalloc(sizeof(*aggr_p)))) {
+-				printk(KERN_ERR "netflow: can't vmalloc aggr\n");
++				printk(KERN_ERR "ipt_NETFLOW: can't vmalloc aggr\n");
+ 				return -ENOMEM;
+ 			}
+ 			memset(aggr_p, 0, sizeof(*aggr_p));
+@@ -817,11 +1054,11 @@ static int add_aggregation(char *ptr)
+ 			aggr_p->port1 = port1;
+ 			aggr_p->port2 = port2;
+ 			aggr_p->aggr_port = aggr_to;
+-			printk(KERN_INFO "netflow: add aggregation [%u-%u=%u]\n",
++			printk(KERN_INFO "ipt_NETFLOW: add aggregation [%u-%u=%u]\n",
+ 			       port1, port2, aggr_to);
+ 			list_add_tail(&aggr_p->list, &new_aggr_p_list);
+ 		} else {
+-			printk(KERN_ERR "netflow: bad aggregation rule: %s (ignoring)\n", ptr);
++			printk(KERN_ERR "ipt_NETFLOW: bad aggregation rule: %s (ignoring)\n", ptr);
+ 			break;
+ 		}
+ 
+@@ -846,17 +1083,23 @@ static int add_aggregation(char *ptr)
+ 
+ static inline u_int32_t hash_netflow(const struct ipt_netflow_tuple *tuple)
+ {
+-	/* tuple is rounded to u32s */
+-	return jhash2((u32 *)tuple, NETFLOW_TUPLE_SIZE, ipt_netflow_hash_rnd) % ipt_netflow_hash_size;
++	return murmur3(tuple, sizeof(struct ipt_netflow_tuple), ipt_netflow_hash_rnd) % ipt_netflow_hash_size;
+ }
+ 
+ static struct ipt_netflow *
+-ipt_netflow_find(const struct ipt_netflow_tuple *tuple, unsigned int hash)
++ipt_netflow_find(const struct ipt_netflow_tuple *tuple, const unsigned int hash)
+ {
+ 	struct ipt_netflow *nf;
++#if LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0)
++#define compat_hlist_for_each_entry		      hlist_for_each_entry
++#define compat_hlist_for_each_entry_safe	      hlist_for_each_entry_safe
+ 	struct hlist_node *pos;
++#else /* since 3.9.0 */
++#define compat_hlist_for_each_entry(a,pos,c,d)	      hlist_for_each_entry(a,c,d)
++#define compat_hlist_for_each_entry_safe(a,pos,c,d,e) hlist_for_each_entry_safe(a,c,d,e)
++#endif
+ 
+-	hlist_for_each_entry(nf, pos, &ipt_netflow_hash[hash], hlist) {
++	compat_hlist_for_each_entry(nf, pos, &ipt_netflow_hash[hash], hlist) {
+ 		if (ipt_netflow_tuple_equal(tuple, &nf->tuple) &&
+ 		    nf->nr_bytes < FLOW_FULL_WATERMARK) {
+ 			NETFLOW_STAT_INC(found);
+@@ -868,7 +1111,7 @@ ipt_netflow_find(const struct ipt_netflow_tuple *tuple, unsigned int hash)
+ 	return NULL;
+ }
+ 
+-static struct hlist_head *alloc_hashtable(int size)
++static struct hlist_head *alloc_hashtable(const int size)
+ {
+ 	struct hlist_head *hash;
+ 
+@@ -879,19 +1122,18 @@ static struct hlist_head *alloc_hashtable(int size)
+ 		for (i = 0; i < size; i++)
+ 			INIT_HLIST_HEAD(&hash[i]);
+ 	} else
+-		printk(KERN_ERR "netflow: unable to vmalloc hash table.\n");
++		printk(KERN_ERR "ipt_NETFLOW: unable to vmalloc hash table.\n");
+ 
+ 	return hash;
+ }
+ 
+-static int set_hashsize(int new_size)
++static int set_hashsize(const int new_size)
+ {
+ 	struct hlist_head *new_hash, *old_hash;
+-	unsigned int hash;
+ 	struct ipt_netflow *nf;
+ 	int rnd;
+ 
+-	printk(KERN_INFO "netflow: allocating new hash table %u -> %u buckets\n",
++	printk(KERN_INFO "ipt_NETFLOW: allocating new hash table %u -> %u buckets\n",
+ 	       ipt_netflow_hash_size, new_size);
+ 	new_hash = alloc_hashtable(new_size);
+ 	if (!new_hash)
+@@ -900,19 +1142,24 @@ static int set_hashsize(int new_size)
+ 	get_random_bytes(&rnd, 4);
+ 
+ 	/* rehash */
+-	spin_lock_bh(&ipt_netflow_lock);
++	write_lock_bh(&htable_rwlock);
+ 	old_hash = ipt_netflow_hash;
+ 	ipt_netflow_hash = new_hash;
+ 	ipt_netflow_hash_size = new_size;
+ 	ipt_netflow_hash_rnd = rnd;
+ 	/* hash_netflow() is dependent on ipt_netflow_hash_* values */
++	spin_lock(&hlist_lock);
+ 	list_for_each_entry(nf, &ipt_netflow_list, list) {
++		unsigned int hash;
++
+ 		hash = hash_netflow(&nf->tuple);
+ 		/* hlist_add_head overwrites hlist pointers for this node
+ 		 * so it's good */
+ 		hlist_add_head(&nf->hlist, &new_hash[hash]);
++		nf->lock = &htable_locks[hash & LOCK_COUNT_MASK];
+ 	}
+-	spin_unlock_bh(&ipt_netflow_lock);
++	spin_unlock(&hlist_lock);
++	write_unlock_bh(&htable_rwlock);
+ 
+ 	vfree(old_hash);
+ 
+@@ -920,14 +1167,14 @@ static int set_hashsize(int new_size)
+ }
+ 
+ static struct ipt_netflow *
+-ipt_netflow_alloc(struct ipt_netflow_tuple *tuple)
++ipt_netflow_alloc(const struct ipt_netflow_tuple *tuple)
+ {
+ 	struct ipt_netflow *nf;
+ 	long count;
+ 
+ 	nf = kmem_cache_alloc(ipt_netflow_cachep, GFP_ATOMIC);
+ 	if (!nf) {
+-		printk(KERN_ERR "Can't allocate netflow.\n");
++		printk(KERN_ERR "ipt_NETFLOW: Can't allocate flow.\n");
+ 		return NULL;
+ 	}
+ 
+@@ -945,13 +1192,15 @@ ipt_netflow_alloc(struct ipt_netflow_tuple *tuple)
+ 
+ static void ipt_netflow_free(struct ipt_netflow *nf)
+ {
++	if (IS_DUMMY_FLOW(nf))
++		return;
+ 	atomic_dec(&ipt_netflow_count);
+ 	kmem_cache_free(ipt_netflow_cachep, nf);
+ }
+ 
+ static struct ipt_netflow *
+-init_netflow(struct ipt_netflow_tuple *tuple,
+-	     struct sk_buff *skb, unsigned int hash)
++init_netflow(const struct ipt_netflow_tuple *tuple,
++	     const struct sk_buff *skb, const unsigned int hash)
+ {
+ 	struct ipt_netflow *nf;
+ 
+@@ -959,93 +1208,774 @@ init_netflow(struct ipt_netflow_tuple *tuple,
+ 	if (!nf)
+ 		return NULL;
+ 
++	nf->lock = &htable_locks[hash & LOCK_COUNT_MASK];
+ 	hlist_add_head(&nf->hlist, &ipt_netflow_hash[hash]);
++	spin_lock(&hlist_lock);
+ 	list_add(&nf->list, &ipt_netflow_list);
++	spin_unlock(&hlist_lock);
+ 
+ 	return nf;
+ }
+ 
+ /* cook pdu, send, and clean */
+ /* only called in scan worker path */
+-static void netflow_export_pdu(void)
++static void netflow_export_pdu_v5(void)
+ {
+ 	struct timeval tv;
+ 	int pdusize;
+ 
+-	if (!pdu.nr_records)
++	if (!pdu_data_records)
+ 		return;
+ 
+ 	if (debug > 1)
+-		printk(KERN_INFO "netflow_export_pdu with %d records\n", pdu.nr_records);
+-	do_gettimeofday(&tv);
+-
+-	pdu.version	= htons(5);
+-	pdu.ts_uptime	= htonl(jiffies_to_msecs(jiffies));
+-	pdu.ts_usecs	= htonl(tv.tv_sec);
+-	pdu.ts_unsecs	= htonl(tv.tv_usec);
+-	//pdu.eng_type	= 0;
+-	//pdu.eng_id	= 0;
+-	//pdu.padding	= 0;
++		printk(KERN_INFO "netflow_export_pdu_v5 with %d records\n", pdu_data_records);
+ 
+-	pdusize = NETFLOW5_HEADER_SIZE + sizeof(struct netflow5_record) * pdu.nr_records;
+-
+-	/* especially fix nr_records before export */
+-	pdu.nr_records	= htons(pdu.nr_records);
++	pdu.v5.version		= htons(5);
++	pdu.v5.nr_records	= htons(pdu_data_records);
++	pdu.v5.ts_uptime	= htonl(jiffies_to_msecs(jiffies));
++	do_gettimeofday(&tv);
++	pdu.v5.ts_usecs		= htonl(tv.tv_sec);
++	pdu.v5.ts_unsecs	= htonl(tv.tv_usec);
++	pdu.v5.seq		= htonl(pdu_seq);
++	//pdu.v5.eng_type	= 0;
++	pdu.v5.eng_id		= engine_id;
++	//pdu.v5.padding	= 0;
+ 
+-	if (netflow_send_pdu(&pdu, pdusize) == 0) {
+-		/* not least one send succeded, account stat for dropped packets */
+-		NETFLOW_STAT_ADD_ATOMIC(pkt_drop, pdu_packets);
+-		NETFLOW_STAT_ADD_ATOMIC(traf_drop, pdu_traf);
+-	}
++	pdusize = NETFLOW5_HEADER_SIZE + sizeof(struct netflow5_record) * pdu_data_records;
+ 
+-	pdu.seq = htonl(ntohl(pdu.seq) + ntohs(pdu.nr_records));
++	netflow_sendmsg(&pdu.v5, pdusize);
+ 
+-	pdu.nr_records	= 0;
+ 	pdu_packets = 0;
+-	pdu_traf = 0;
++	pdu_traf    = 0;
++
++	pdu_seq += pdu_data_records;
++	pdu_count++;
++	pdu_data_records = 0;
+ }
+ 
+ /* only called in scan worker path */
+-static void netflow_export_flow(struct ipt_netflow *nf)
++static void netflow_export_flow_v5(struct ipt_netflow *nf)
+ {
+ 	struct netflow5_record *rec;
+ 
+-	if (debug > 2)
+-		printk(KERN_INFO "adding flow to export (%d)\n", pdu.nr_records);
++	if (unlikely(debug > 2))
++		printk(KERN_INFO "adding flow to export (%d)\n", pdu_data_records);
+ 
+ 	pdu_packets += nf->nr_packets;
+ 	pdu_traf += nf->nr_bytes;
+ 	pdu_ts_mod = jiffies;
+-	rec = &pdu.flow[pdu.nr_records++];
++	rec = &pdu.v5.flow[pdu_data_records++];
+ 
+ 	/* make V5 flow record */
+-	rec->s_addr	= nf->tuple.s_addr;
+-	rec->d_addr	= nf->tuple.d_addr;
+-	//rec->nexthop	= 0;
++	rec->s_addr	= nf->tuple.src.ip;
++	rec->d_addr	= nf->tuple.dst.ip;
++	rec->nexthop	= nf->nh.ip;
+ 	rec->i_ifc	= htons(nf->tuple.i_ifc);
+ 	rec->o_ifc	= htons(nf->o_ifc);
+ 	rec->nr_packets = htonl(nf->nr_packets);
+ 	rec->nr_octets	= htonl(nf->nr_bytes);
+-	rec->ts_first	= htonl(jiffies_to_msecs(nf->ts_first));
+-	rec->ts_last	= htonl(jiffies_to_msecs(nf->ts_last));
++	rec->first_ms	= htonl(jiffies_to_msecs(nf->ts_first));
++	rec->last_ms	= htonl(jiffies_to_msecs(nf->ts_last));
+ 	rec->s_port	= nf->tuple.s_port;
+ 	rec->d_port	= nf->tuple.d_port;
+-	//rec->reserved	= 0;
++	//rec->reserved	= 0; /* pdu is always zeroized for v5 in netflow_switch_version */
+ 	rec->tcp_flags	= nf->tcp_flags;
+ 	rec->protocol	= nf->tuple.protocol;
+ 	rec->tos	= nf->tuple.tos;
+-	//rec->s_as	= 0;
+-	//rec->d_as	= 0;
++#ifdef CONFIG_NF_NAT_NEEDED
++	rec->s_as	= nf->s_as;
++	rec->d_as	= nf->d_as;
++#endif
+ 	rec->s_mask	= nf->s_mask;
+ 	rec->d_mask	= nf->d_mask;
+ 	//rec->padding	= 0;
+ 	ipt_netflow_free(nf);
+ 
+-	if (pdu.nr_records == NETFLOW5_RECORDS_MAX)
++	if (pdu_data_records == NETFLOW5_RECORDS_MAX)
++		netflow_export_pdu_v5();
++}
++
++/* pdu is initially blank, export current pdu, and prepare next for filling. */
++static void netflow_export_pdu_v9(void)
++{
++	struct timeval tv;
++	int pdusize;
++
++	if (pdu_data_used <= pdu.v9.data)
++		return;
++
++	if (debug > 1)
++		printk(KERN_INFO "netflow_export_pdu_v9 with %d records\n",
++		    pdu_data_records + pdu_tpl_records);
++
++	pdu.v9.version		= htons(9);
++	pdu.v9.nr_records	= htons(pdu_data_records + pdu_tpl_records);
++	pdu.v9.sys_uptime_ms	= htonl(jiffies_to_msecs(jiffies));
++	do_gettimeofday(&tv);
++	pdu.v9.export_time_s	= htonl(tv.tv_sec);
++	pdu.v9.seq		= htonl(pdu_seq);
++	pdu.v9.source_id	= engine_id;
++
++	pdusize = pdu_data_used - (unsigned char *)&pdu.v9;
++
++	netflow_sendmsg(&pdu.v9, pdusize);
++
++	pdu_packets = 0;
++	pdu_traf    = 0;
++
++	pdu_seq++;
++	pdu_count++;
++	pdu_data_records = pdu_tpl_records = 0;
++	pdu_data_used = pdu.v9.data;
++	pdu_flowset = NULL;
++}
++
++static void netflow_export_pdu_ipfix(void)
++{
++	struct timeval tv;
++	int pdusize;
++
++	if (pdu_data_used <= pdu.ipfix.data)
++		return;
++
++	if (debug > 1)
++		printk(KERN_INFO "netflow_export_pduX with %d records\n",
++		    pdu_data_records);
++
++	pdu.ipfix.version	= htons(10);
++	do_gettimeofday(&tv);
++	pdu.ipfix.export_time_s	= htonl(tv.tv_sec);
++	pdu.ipfix.seq		= htonl(pdu_seq);
++	pdu.ipfix.odomain_id	= engine_id;
++	pdusize = pdu_data_used - (unsigned char *)&pdu;
++	pdu.ipfix.length	= htons(pdusize);
++
++	netflow_sendmsg(&pdu.ipfix, pdusize);
++
++	pdu_packets = 0;
++	pdu_traf    = 0;
++
++	pdu_seq += pdu_data_records;
++	pdu_count++;
++	pdu_data_records = pdu_tpl_records = 0;
++	pdu_data_used = pdu.ipfix.data;
++	pdu_flowset = NULL;
++}
++
++static inline int pdu_have_space(const size_t size)
++{
++	return ((pdu_data_used + size) <= pdu_high_wm);
++}
++
++static inline unsigned char *pdu_grab_space(const size_t size)
++{
++	unsigned char *ptr = pdu_data_used;
++	pdu_data_used += size;
++	return ptr;
++}
++
++// allocate data space in pdu, or fail if pdu is reallocated.
++static inline unsigned char *pdu_alloc_fail(const size_t size)
++{
++	if (!pdu_have_space(size)) {
+ 		netflow_export_pdu();
++		return NULL;
++	}
++	return pdu_grab_space(size);
++}
++
++/* doesn't fail, but can provide empty pdu. */
++static unsigned char *pdu_alloc(const size_t size)
++{
++	return pdu_alloc_fail(size) ?: pdu_grab_space(size);
++}
++
++/* global table of sizes of template field types */
++static u_int8_t tpl_element_sizes[] = {
++	[IN_BYTES]	= 4,
++	[IN_PKTS]	= 4,
++	[PROTOCOL]	= 1,
++	[TOS]		= 1,
++	[TCP_FLAGS]	= 1,
++	[L4_SRC_PORT]	= 2,
++	[IPV4_SRC_ADDR]	= 4,
++	[SRC_MASK]	= 1,
++	[INPUT_SNMP]	= 2,
++	[L4_DST_PORT]	= 2,
++	[IPV4_DST_ADDR]	= 4,
++	[DST_MASK]	= 1,
++	[OUTPUT_SNMP]	= 2,
++	[IPV4_NEXT_HOP]	= 4,
++	//[SRC_AS]		= 2,
++	//[DST_AS]		= 2,
++	//[BGP_IPV4_NEXT_HOP]	= 4,
++	//[MUL_DST_PKTS]	= 4,
++	//[MUL_DST_BYTES]	= 4,
++	[LAST_SWITCHED]	= 4,
++	[FIRST_SWITCHED]= 4,
++	[IPV6_SRC_ADDR]	= 16,
++	[IPV6_DST_ADDR]	= 16,
++	[IPV6_FLOW_LABEL] = 3,
++	[ICMP_TYPE]	= 2,
++	[MUL_IGMP_TYPE]	= 1,
++	//[TOTAL_BYTES_EXP]	= 4,
++	//[TOTAL_PKTS_EXP]	= 4,
++	//[TOTAL_FLOWS_EXP]	= 4,
++	[IPV6_NEXT_HOP]			   = 16,
++	[IPV6_OPTION_HEADERS]		   = 2,
++	[commonPropertiesId]		   = 4,
++	[ipv4Options]			   = 4,
++	[tcpOptions]			   = 4,
++	[postNATSourceIPv4Address]	   = 4,
++	[postNATDestinationIPv4Address]	   = 4,
++	[postNAPTSourceTransportPort]	   = 2,
++	[postNAPTDestinationTransportPort] = 2,
++	[natEvent]			   = 1,
++	[postNATSourceIPv6Address]	   = 16,
++	[postNATDestinationIPv6Address]	   = 16,
++	[IPSecSPI]			   = 4,
++	[observationTimeMilliseconds]	   = 8,
++	[observationTimeMicroseconds]	   = 8,
++	[observationTimeNanoseconds]	   = 8,
++};
++
++#define TEMPLATES_HASH_BSIZE	8
++#define TEMPLATES_HASH_SIZE	(1<<TEMPLATES_HASH_BSIZE)
++static struct hlist_head templates_hash[TEMPLATES_HASH_SIZE];
++
++struct base_template {
++	int length; /* number of elements in template */
++	u_int16_t types[]; /* {type, size} pairs */
++};
++
++/* base templates */
++#define BTPL_BASE	0x00000001	/* base stat */
++#define BTPL_IP4	0x00000002	/* IPv4 */
++#define BTPL_MASK4	0x00000004	/* Aggregated */
++#define BTPL_PORTS	0x00000008	/* UDP&TCP */
++#define BTPL_IP6	0x00000010	/* IPv6 */
++#define BTPL_ICMP	0x00000020	/* ICMP */
++#define BTPL_IGMP	0x00000040	/* IGMP */
++#define BTPL_IPSEC	0x00000080	/* AH&ESP */
++#define BTPL_NAT4	0x00000100	/* NAT IPv4 */
++#define BTPL_MARK	0x00000400	/* connmark */
++#define BTPL_LABEL6	0x00000800	/* IPv6 flow label */
++#define BTPL_OPTIONS4	0x00001000	/* IPv4 Options */
++#define BTPL_OPTIONS6	0x00002000	/* IPv6 Options */
++#define BTPL_TCPOPTIONS	0x00004000	/* TCP Options */
++#define BTPL_MAX	32
++
++static struct base_template template_base = {
++	.types = {
++		INPUT_SNMP,
++		OUTPUT_SNMP,
++		IN_PKTS,
++		IN_BYTES,
++		FIRST_SWITCHED,
++		LAST_SWITCHED,
++		PROTOCOL,
++		TOS,
++		0
++	}
++};
++static struct base_template template_ipv4 = {
++	.types = {
++		IPV4_SRC_ADDR,
++		IPV4_DST_ADDR,
++		IPV4_NEXT_HOP,
++		0
++	}
++};
++static struct base_template template_options4 = {
++	.types = { ipv4Options, 0 }
++};
++static struct base_template template_tcpoptions = {
++	.types = { tcpOptions, 0 }
++};
++static struct base_template template_ipv6 = {
++	.types = {
++		IPV6_SRC_ADDR,
++		IPV6_DST_ADDR,
++		IPV6_NEXT_HOP,
++		0
++	}
++};
++static struct base_template template_options6 = {
++	.types = { IPV6_OPTION_HEADERS, 0 }
++};
++static struct base_template template_label6 = {
++	.types = { IPV6_FLOW_LABEL, 0 }
++};
++static struct base_template template_ipv4_mask = {
++	.types = {
++		SRC_MASK,
++		DST_MASK,
++		0
++	}
++};
++static struct base_template template_ports = {
++	.types = {
++		L4_SRC_PORT,
++		L4_DST_PORT,
++		TCP_FLAGS,
++		0
++	}
++};
++static struct base_template template_icmp = {
++	.types = { ICMP_TYPE, 0 }
++};
++static struct base_template template_igmp = {
++	.types = { MUL_IGMP_TYPE, 0 }
++};
++static struct base_template template_ipsec = {
++	.types = { IPSecSPI, 0 }
++};
++static struct base_template template_nat4 = {
++	.types = {
++		observationTimeMilliseconds,
++		IPV4_SRC_ADDR,
++		IPV4_DST_ADDR,
++		postNATSourceIPv4Address,
++		postNATDestinationIPv4Address,
++		L4_SRC_PORT,
++		L4_DST_PORT,
++		postNAPTSourceTransportPort,
++		postNAPTDestinationTransportPort,
++		PROTOCOL,
++		natEvent,
++		0
++	}
++};
++static struct base_template template_mark = {
++	.types = { commonPropertiesId, 0 }
++};
++
++struct data_template {
++	struct hlist_node hlist;
++	int tpl_mask;
++
++	int length; /* number of elements in template */
++	int tpl_size; /* summary size of template with flowset header */
++	int rec_size; /* summary size of all recods of template (w/o flowset header) */
++	int template_id_n; /* assigned from template_ids, network order. */
++	int		exported_cnt;
++	unsigned long	exported_ts; /* jiffies */
++	u_int16_t fields[]; /* {type, size} pairs */
++} __attribute__ ((packed));
++
++#define TPL_FIELD_NSIZE 4 /* one complete template field's network size */
++
++static void free_templates(void)
++{
++	int i;
++#if LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0)
++	struct hlist_node *pos;
++#endif
++	struct hlist_node *tmp;
++
++	for (i = 0; i < TEMPLATES_HASH_SIZE; i++) {
++		struct hlist_head *thead = &templates_hash[i];
++		struct data_template *tpl;
++
++		compat_hlist_for_each_entry_safe(tpl, pos, tmp, thead, hlist)
++			kfree(tpl);
++		INIT_HLIST_HEAD(thead);
++	}
++	tpl_count = 0;
++}
++
++/* create combined template from mask */
++static struct data_template *get_template(const int tmask)
++{
++	struct base_template *tlist[BTPL_MAX];
++	struct data_template *tpl;
++	int tnum;
++	int length;
++	int i, j, k;
++#if LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0)
++	struct hlist_node *pos;
++#endif
++	int hash = hash_long(tmask, TEMPLATES_HASH_BSIZE);
++
++	compat_hlist_for_each_entry(tpl, pos, &templates_hash[hash], hlist)
++		if (tpl->tpl_mask == tmask)
++			return tpl;
++
++	tnum = 0;
++	if (tmask & BTPL_IP4) {
++		tlist[tnum++] = &template_ipv4;
++		if (tmask & BTPL_OPTIONS4)
++			tlist[tnum++] = &template_options4;
++		if (tmask & BTPL_MASK4)
++			tlist[tnum++] = &template_ipv4_mask;
++	} else if (tmask & BTPL_IP6) {
++		tlist[tnum++] = &template_ipv6;
++		if (tmask & BTPL_LABEL6)
++			tlist[tnum++] = &template_label6;
++		if (tmask & BTPL_OPTIONS6)
++			tlist[tnum++] = &template_options6;
++	} else if (tmask & BTPL_NAT4)
++		tlist[tnum++] = &template_nat4;
++	if (tmask & BTPL_PORTS)
++		tlist[tnum++] = &template_ports;
++	if (tmask & BTPL_BASE)
++		tlist[tnum++] = &template_base;
++	if (tmask & BTPL_TCPOPTIONS)
++		tlist[tnum++] = &template_tcpoptions;
++	if (tmask & BTPL_ICMP)
++		tlist[tnum++] = &template_icmp;
++	if (tmask & BTPL_IGMP)
++		tlist[tnum++] = &template_igmp;
++	if (tmask & BTPL_IPSEC)
++		tlist[tnum++] = &template_ipsec;
++	if (tmask & BTPL_MARK)
++		tlist[tnum++] = &template_mark;
++
++	/* calc memory size */
++	length = 0;
++	for (i = 0; i < tnum; i++) {
++		if (!tlist[i]->length) {
++			for (k = 0; tlist[i]->types[k]; k++);
++			tlist[i]->length = k;
++		}
++		length += tlist[i]->length;
++	}
++	/* elements are pairs + one termiantor */
++	tpl = kmalloc(sizeof(struct data_template) + (length * 2 + 1) * sizeof(u_int16_t), GFP_KERNEL);
++	if (!tpl) {
++		printk(KERN_ERR "ipt_NETFLOW: unable to kmalloc template.\n");
++		return NULL;
++	}
++	tpl->tpl_mask = tmask;
++	tpl->length = length;
++	tpl->tpl_size = sizeof(struct flowset_template);
++	tpl->rec_size = 0;
++	tpl->template_id_n = htons(template_ids++);
++	tpl->exported_cnt = 0;
++	tpl->exported_ts = 0;
++
++	j = 0;
++	for (i = 0; i < tnum; i++) {
++		struct base_template *btpl = tlist[i];
++
++		for (k = 0; k < btpl->length; k++) {
++			int size;
++			int type = btpl->types[k];
++
++			tpl->fields[j++] = type;
++			size = tpl_element_sizes[type];
++			tpl->fields[j++] = size;
++			tpl->rec_size += size;
++		}
++		tpl->tpl_size += btpl->length * TPL_FIELD_NSIZE;
++	}
++	tpl->fields[j++] = 0;
++
++	hlist_add_head(&tpl->hlist, &templates_hash[hash]);
++	tpl_count++;
++
++	return tpl;
++}
++
++static void pdu_add_template(struct data_template *tpl)
++{
++	int i;
++	unsigned char *ptr;
++	struct flowset_template *ntpl;
++	__be16 *sptr;
++
++	ptr = pdu_alloc(tpl->tpl_size);
++	ntpl = (struct flowset_template *)ptr;
++	ntpl->flowset_id  = protocol == 9? htons(FLOWSET_TEMPLATE) : htons(IPFIX_TEMPLATE);
++	ntpl->length	  = htons(tpl->tpl_size);
++	ntpl->template_id = tpl->template_id_n;
++	ntpl->field_count = htons(tpl->length);
++	ptr += sizeof(struct flowset_template);
++	sptr = (__be16 *)ptr;
++	for (i = 0; ; ) {
++		int type = tpl->fields[i++];
++		if (!type)
++			break;
++		*sptr++ = htons(type);
++		*sptr++ = htons(tpl->fields[i++]);
++	}
++
++	tpl->exported_cnt = pdu_count;
++	tpl->exported_ts = jiffies;
++
++	pdu_flowset = NULL;
++	pdu_tpl_records++;
++}
++
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)
++static inline s64 portable_ktime_to_ms(const ktime_t kt)
++{
++	struct timeval tv = ktime_to_timeval(kt);
++	return (s64) tv.tv_sec * MSEC_PER_SEC + tv.tv_usec / USEC_PER_MSEC;
++}
++#define ktime_to_ms portable_ktime_to_ms
++#endif
++
++/* encode one field */
++typedef struct in6_addr in6_t;
++static inline void add_ipv4_field(__u8 *ptr, const int type, const struct ipt_netflow *nf)
++{
++	switch (type) {
++		case IN_BYTES:	     *(__be32 *)ptr = htonl(nf->nr_bytes); break;
++		case IN_PKTS:	     *(__be32 *)ptr = htonl(nf->nr_packets); break;
++		case FIRST_SWITCHED: *(__be32 *)ptr = htonl(jiffies_to_msecs(nf->ts_first)); break;
++		case LAST_SWITCHED:  *(__be32 *)ptr = htonl(jiffies_to_msecs(nf->ts_last)); break;
++		case IPV4_SRC_ADDR:  *(__be32 *)ptr = nf->tuple.src.ip; break;
++		case IPV4_DST_ADDR:  *(__be32 *)ptr = nf->tuple.dst.ip; break;
++		case IPV4_NEXT_HOP:  *(__be32 *)ptr = nf->nh.ip; break;
++		case L4_SRC_PORT:    *(__be16 *)ptr = nf->tuple.s_port; break;
++		case L4_DST_PORT:    *(__be16 *)ptr = nf->tuple.d_port; break;
++		case INPUT_SNMP:     *(__be16 *)ptr = htons(nf->tuple.i_ifc); break;
++		case OUTPUT_SNMP:    *(__be16 *)ptr = htons(nf->o_ifc); break;
++		case PROTOCOL:	               *ptr = nf->tuple.protocol; break;
++		case TCP_FLAGS:	               *ptr = nf->tcp_flags; break;
++		case TOS:	               *ptr = nf->tuple.tos; break;
++		case IPV6_SRC_ADDR:   *(in6_t *)ptr = nf->tuple.src.in6; break;
++		case IPV6_DST_ADDR:   *(in6_t *)ptr = nf->tuple.dst.in6; break;
++		case IPV6_NEXT_HOP:   *(in6_t *)ptr = nf->nh.in6; break;
++		case IPV6_FLOW_LABEL:        *ptr++ = nf->flow_label >> 16;
++				     *(__be16 *)ptr = nf->flow_label;
++				      break;
++		case tcpOptions:     *(__be32 *)ptr = htonl(nf->tcpoptions); break;
++		case ipv4Options:    *(__be32 *)ptr = htonl(nf->options); break;
++		case IPV6_OPTION_HEADERS: *(__be16 *)ptr = htons(nf->options); break;
++#ifdef CONFIG_NF_CONNTRACK_MARK
++		case commonPropertiesId:
++				     *(__be32 *)ptr = htonl(nf->mark); break;
++#endif
++		case SRC_MASK:	               *ptr = nf->s_mask; break;
++		case DST_MASK:	               *ptr = nf->d_mask; break;
++		case ICMP_TYPE:	     *(__be16 *)ptr = nf->tuple.d_port; break;
++		case MUL_IGMP_TYPE:            *ptr = nf->tuple.d_port; break;
++#ifdef CONFIG_NF_NAT_NEEDED
++		case postNATSourceIPv4Address:	       *(__be32 *)ptr = nf->nat->post.s_addr; break;
++		case postNATDestinationIPv4Address:    *(__be32 *)ptr = nf->nat->post.d_addr; break;
++		case postNAPTSourceTransportPort:      *(__be16 *)ptr = nf->nat->post.s_port; break;
++		case postNAPTDestinationTransportPort: *(__be16 *)ptr = nf->nat->post.d_port; break;
++		case natEvent:				         *ptr = nf->nat->nat_event; break;
++#endif
++		case IPSecSPI:        *(__u32 *)ptr = (nf->tuple.s_port << 16) | nf->tuple.d_port; break;
++		case observationTimeMilliseconds:
++				      *(__be64 *)ptr = cpu_to_be64(ktime_to_ms(nf->ts_obs)); break;
++		case observationTimeMicroseconds:
++				      *(__be64 *)ptr = cpu_to_be64(ktime_to_us(nf->ts_obs)); break;
++		case observationTimeNanoseconds:
++				      *(__be64 *)ptr = cpu_to_be64(ktime_to_ns(nf->ts_obs)); break;
++		default:
++					memset(ptr, 0, tpl_element_sizes[type]);
++	}
++}
++
++#define PAD_SIZE 4 /* rfc prescribes flowsets to be padded */
++
++/* cache timeout_rate in jiffies */
++static inline unsigned long timeout_rate_j(void)
++{
++	static unsigned int t_rate = 0;
++	static unsigned long t_rate_j = 0;
++
++	if (unlikely(timeout_rate != t_rate)) {
++		struct timeval tv = { .tv_sec = timeout_rate * 60, .tv_usec = 0 };
++
++		t_rate = timeout_rate;
++		t_rate_j = timeval_to_jiffies(&tv);
++	}
++	return t_rate_j;
++}
++
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
++#define IPPROTO_UDPLITE 136
++#endif
++
++#ifndef time_is_before_jiffies
++#define time_is_before_jiffies(a) time_after(jiffies, a)
++#endif
++
++static void netflow_export_flow_tpl(struct ipt_netflow *nf)
++{
++	unsigned char *ptr;
++	int i;
++	struct data_template *tpl;
++	int tpl_mask = BTPL_BASE;
++
++	if (unlikely(debug > 2))
++		printk(KERN_INFO "adding flow to export (%d)\n",
++		    pdu_data_records + pdu_tpl_records);
++
++	if (likely(nf->tuple.l3proto == AF_INET)) {
++		tpl_mask |= BTPL_IP4;
++		if (unlikely(nf->options))
++			tpl_mask |= BTPL_OPTIONS4;
++	} else {
++		tpl_mask |= BTPL_IP6;
++		if (unlikely(nf->options))
++			tpl_mask |= BTPL_OPTIONS6;
++		if (unlikely(nf->flow_label))
++			tpl_mask |= BTPL_LABEL6;
++	}
++	if (unlikely(nf->tcpoptions))
++		tpl_mask |= BTPL_TCPOPTIONS;
++	if (unlikely(nf->s_mask || nf->d_mask))
++		tpl_mask |= BTPL_MASK4;
++	if (likely(nf->tuple.protocol == IPPROTO_TCP ||
++		    nf->tuple.protocol == IPPROTO_UDP ||
++		    nf->tuple.protocol == IPPROTO_SCTP ||
++		    nf->tuple.protocol == IPPROTO_UDPLITE))
++		tpl_mask |= BTPL_PORTS;
++	else if (nf->tuple.protocol == IPPROTO_ICMP)
++		tpl_mask |= BTPL_ICMP;
++	else if (nf->tuple.protocol == IPPROTO_IGMP)
++		tpl_mask |= BTPL_IGMP;
++#ifdef CONFIG_NF_CONNTRACK_MARK
++	if (nf->mark)
++		tpl_mask |= BTPL_MARK;
++#endif
++#ifdef CONFIG_NF_NAT_NEEDED
++	if (nf->nat)
++		tpl_mask = BTPL_NAT4;
++#endif
++
++	tpl = get_template(tpl_mask);
++	if (unlikely(!tpl)) {
++		printk(KERN_INFO "ipt_NETFLOW: template allocation failed.\n");
++		NETFLOW_STAT_INC(alloc_err);
++		NETFLOW_STAT_ADD_ATOMIC(pkt_drop, nf->nr_packets);
++		NETFLOW_STAT_ADD_ATOMIC(traf_drop, nf->nr_bytes);
++		ipt_netflow_free(nf);
++		return;
++	}
++
++	if (unlikely(!pdu_flowset ||
++	    pdu_flowset->flowset_id != tpl->template_id_n ||
++	    !(ptr = pdu_alloc_fail(tpl->rec_size)))) {
++
++		/* if there was previous data template we should pad it to 4 bytes */
++		if (pdu_flowset) {
++			int padding = (PAD_SIZE - ntohs(pdu_flowset->length) % PAD_SIZE) % PAD_SIZE;
++			if (padding && (ptr = pdu_alloc_fail(padding))) {
++				pdu_flowset->length = htons(ntohs(pdu_flowset->length) + padding);
++				for (; padding; padding--)
++					*ptr++ = 0;
++			}
++		}
++
++		if (!tpl->exported_ts ||
++		    pdu_count > (tpl->exported_cnt + refresh_rate) ||
++		    time_is_before_jiffies(tpl->exported_ts + timeout_rate_j())) {
++			pdu_add_template(tpl);
++		}
++
++		ptr = pdu_alloc(sizeof(struct flowset_data) + tpl->rec_size);
++		pdu_flowset = (struct flowset_data *)ptr;
++		pdu_flowset->flowset_id = tpl->template_id_n;
++		pdu_flowset->length     = htons(sizeof(struct flowset_data));
++		ptr += sizeof(struct flowset_data);
++	}
++
++	/* encode all fields */
++	for (i = 0; ; ) {
++		int type = tpl->fields[i++];
++
++		if (!type)
++			break;
++		add_ipv4_field(ptr, type, nf);
++		ptr += tpl->fields[i++];
++	}
++
++	pdu_data_records++;
++	pdu_flowset->length = htons(ntohs(pdu_flowset->length) + tpl->rec_size);
++
++	pdu_packets += nf->nr_packets;
++	pdu_traf    += nf->nr_bytes;
++
++	ipt_netflow_free(nf);
++	pdu_ts_mod = jiffies;
++}
++
++static void netflow_switch_version(const int ver)
++{
++	protocol = ver;
++	if (protocol == 5) {
++		memset(&pdu, 0, sizeof(pdu));
++		netflow_export_flow = &netflow_export_flow_v5;
++		netflow_export_pdu = &netflow_export_pdu_v5;
++	} else if (protocol == 9) {
++		pdu_data_used = pdu.v9.data;
++		pdu_max_size = sizeof(pdu.v9);
++		pdu_high_wm = (unsigned char *)&pdu + pdu_max_size;
++		netflow_export_flow = &netflow_export_flow_tpl;
++		netflow_export_pdu = &netflow_export_pdu_v9;
++	} else { /* IPFIX */
++		pdu_data_used = pdu.ipfix.data;
++		pdu_max_size = sizeof(pdu.ipfix);
++		pdu_high_wm = (unsigned char *)&pdu + pdu_max_size;
++		netflow_export_flow = &netflow_export_flow_tpl;
++		netflow_export_pdu = &netflow_export_pdu_ipfix;
++	}
++	if (protocol != 5)
++		free_templates();
++	pdu_data_records = pdu_tpl_records = 0;
++	pdu_flowset = NULL;
++	printk(KERN_INFO "ipt_NETFLOW protocol version %d (%s) enabled.\n",
++	    protocol, protocol == 10? "IPFIX" : "NetFlow");
++}
++
++#ifdef CONFIG_NF_NAT_NEEDED
++static void export_nat_event(struct nat_event *nel)
++{
++	static struct ipt_netflow nf = { { NULL } };
++
++	nf.tuple.l3proto = AF_INET;
++	nf.tuple.protocol = nel->protocol;
++	nf.nat = nel; /* this is also flag of dummy flow */
++	nf.tcp_flags = (nel->nat_event == NAT_DESTROY)? TCP_FIN_RST : TCP_SYN_ACK;
++	if (protocol >= 9) {
++		nf.ts_obs = nel->ts_ktime;
++		nf.tuple.src.ip = nel->pre.s_addr;
++		nf.tuple.dst.ip = nel->pre.d_addr;
++		nf.tuple.s_port = nel->pre.s_port;
++		nf.tuple.d_port = nel->pre.d_port;
++		netflow_export_flow(&nf);
++	} else { /* v5 */
++		/* The weird v5 packet(s).
++		 * src and dst will be same as in data flow from the FORWARD chain
++		 * where src is pre-nat src ip and dst is post-nat dst ip.
++		 * What we lacking here is external src ip for SNAT, or
++		 * pre-nat dst ip for DNAT. We will put this into Nexthop field
++		 * with port into src/dst AS field. tcp_flags will distinguish it's
++		 * start or stop event. Two flows in case of full nat. */
++		nf.tuple.src.ip = nel->pre.s_addr;
++		nf.tuple.s_port = nel->pre.s_port;
++		nf.tuple.dst.ip = nel->post.d_addr;
++		nf.tuple.d_port = nel->post.d_port;
++
++		nf.ts_first = nel->ts_jiffies;
++		nf.ts_last = nel->ts_jiffies;
++		if (nel->pre.s_addr != nel->post.s_addr ||
++		    nel->pre.s_port != nel->post.s_port) {
++			nf.nh.ip = nel->post.s_addr;
++			nf.s_as  = nel->post.s_port;
++			nf.d_as  = 0;
++			netflow_export_flow(&nf);
++		}
++		if (nel->pre.d_addr != nel->post.d_addr ||
++		    nel->pre.d_port != nel->post.d_port) {
++			nf.nh.ip = nel->pre.d_addr;
++			nf.s_as  = 0;
++			nf.d_as  = nel->pre.d_port;
++			netflow_export_flow(&nf);
++		}
++	}
++	kfree(nel);
+ }
++#endif /* CONFIG_NF_NAT_NEEDED */
+ 
+-static inline int active_needs_export(struct ipt_netflow *nf, long a_timeout)
++static inline int active_needs_export(const struct ipt_netflow *nf, const long a_timeout)
+ {
+ 	/* active too long, finishing, or having too much bytes */
+ 	return ((jiffies - nf->ts_first) > a_timeout) ||
+@@ -1057,42 +1987,77 @@ static inline int active_needs_export(struct ipt_netflow *nf, long a_timeout)
+ 
+ /* could be called with zero to flush cache and pdu */
+ /* this function is guaranteed to be called non-concurrently */
+-static void netflow_scan_and_export(int flush)
++/* return -1 is trylockfailed, 0 if nothin gexported, >=1 if exported something */
++static int netflow_scan_and_export(const int flush)
+ {
+ 	long i_timeout = inactive_timeout * HZ;
+ 	long a_timeout = active_timeout * HZ;
++	int trylock_failed = 0;
++	int pdu_c = pdu_count;
+ 
+ 	if (flush)
+ 		i_timeout = 0;
+ 
+-	spin_lock_bh(&ipt_netflow_lock);
+-	while (!list_empty(&ipt_netflow_list)) {
++	local_bh_disable();
++	spin_lock(&hlist_lock);
++	/* This is different order of locking than elsewhere,
++	 * so we trylock&break to avoid deadlock. */
++
++	while (likely(!list_empty(&ipt_netflow_list))) {
+ 		struct ipt_netflow *nf;
+-	       
++
++		/* Last entry, which is usually oldest. */
+ 		nf = list_entry(ipt_netflow_list.prev, struct ipt_netflow, list);
++		if (!spin_trylock(nf->lock)) {
++			trylock_failed = 1;
++			break;
++		}
+ 		/* Note: i_timeout checked with >= to allow specifying zero timeout
+ 		 * to purge all flows on module unload */
+ 		if (((jiffies - nf->ts_last) >= i_timeout) ||
+ 		    active_needs_export(nf, a_timeout)) {
+ 			hlist_del(&nf->hlist);
++			spin_unlock(nf->lock);
++
+ 			list_del(&nf->list);
++			spin_unlock(&hlist_lock);
++			local_bh_enable();
++
+ 			NETFLOW_STAT_ADD(pkt_out, nf->nr_packets);
+ 			NETFLOW_STAT_ADD(traf_out, nf->nr_bytes);
+-			spin_unlock_bh(&ipt_netflow_lock);
+ 			netflow_export_flow(nf);
+-			spin_lock_bh(&ipt_netflow_lock);
++
++			local_bh_disable();
++			spin_lock(&hlist_lock);
+ 		} else {
++			spin_unlock(nf->lock);
+ 			/* all flows which need to be exported is always at the tail
+ 			 * so if no more exportable flows we can break */
+ 			break;
+ 		}
+ 	}
+-	spin_unlock_bh(&ipt_netflow_lock);
+-
++	spin_unlock(&hlist_lock);
++	local_bh_enable();
++
++#ifdef CONFIG_NF_NAT_NEEDED
++	spin_lock_bh(&nat_lock);
++	while (!list_empty(&nat_list)) {
++		struct nat_event *nel;
++
++		nel = list_entry(nat_list.next, struct nat_event, list);
++		list_del(&nel->list);
++		spin_unlock_bh(&nat_lock);
++		export_nat_event(nel);
++		spin_lock_bh(&nat_lock);
++	}
++	spin_unlock_bh(&nat_lock);
++#endif
+ 	/* flush flows stored in pdu if there no new flows for too long */
+ 	/* Note: using >= to allow flow purge on zero timeout */
+ 	if ((jiffies - pdu_ts_mod) >= i_timeout)
+ 		netflow_export_pdu();
++
++	return trylock_failed? -1 : pdu_count - pdu_c;
+ }
+ 
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
+@@ -1101,8 +2066,10 @@ static void netflow_work_fn(void *dummy)
+ static void netflow_work_fn(struct work_struct *dummy)
+ #endif
+ {
+-	netflow_scan_and_export(0);
+-	__start_scan_worker();
++	int status;
++
++	status = netflow_scan_and_export(DONT_FLUSH);
++	_schedule_scan_worker(status);
+ }
+ 
+ #define RATESHIFT 2
+@@ -1154,7 +2121,7 @@ static void rate_timer_calc(unsigned long dummy)
+ 	old_found = found;
+ 	old_notfound = notfound;
+ 	/* if there is no access to hash keep rate steady */
+-	metric = (dfnd + dnfnd)? 10 * (dsrch + dfnd + dnfnd) / (dfnd + dnfnd) : metric;
++	metric = (dfnd + dnfnd)? 100 * (dsrch + dfnd + dnfnd) / (dfnd + dnfnd) : metric;
+ 	CALC_RATE(min15_metric, (unsigned long long)metric, 15);
+ 	CALC_RATE(min5_metric, (unsigned long long)metric, 5);
+ 	CALC_RATE(min_metric, (unsigned long long)metric, 1);
+@@ -1162,6 +2129,262 @@ static void rate_timer_calc(unsigned long dummy)
+ 	mod_timer(&rate_timer, jiffies + (HZ * SAMPLERATE));
+ }
+ 
++#ifdef CONFIG_NF_NAT_NEEDED
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
++static struct nf_ct_event_notifier *saved_event_cb __read_mostly = NULL;
++static int netflow_conntrack_event(const unsigned int events, struct nf_ct_event *item)
++#else
++static int netflow_conntrack_event(struct notifier_block *this, unsigned long events, void *ptr)
++#endif
++{
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
++	struct nf_conn *ct = item->ct;
++#else
++	struct nf_conn *ct = (struct nf_conn *)ptr;
++#endif
++	struct nat_event *nel;
++	const struct nf_conntrack_tuple *t;
++	int ret = NOTIFY_DONE;
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
++	struct nf_ct_event_notifier *notifier;
++
++	/* Call netlink first. */
++	notifier = rcu_dereference(saved_event_cb);
++	if (likely(notifier))
++		ret = notifier->fcn(events, item);
++#endif
++	if (unlikely(!natevents))
++		return ret;
++
++	if (!(events & ((1 << IPCT_NEW) | (1 << IPCT_RELATED) | (1 << IPCT_DESTROY))))
++		return ret;
++
++	if (!(ct->status & IPS_NAT_MASK))
++		return ret;
++
++	if (unlikely(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num != AF_INET ||
++		    ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.l3num != AF_INET)) {
++		/* Well, there is no linux NAT for IPv6 anyway. */
++		return ret;
++	}
++
++	if (!(nel = kmalloc(sizeof(struct nat_event), GFP_ATOMIC))) {
++		printk(KERN_ERR "ipt_NETFLOW: can't kmalloc nat event\n");
++		return ret;
++	}
++	memset(nel, 0, sizeof(struct nat_event));
++	nel->ts_ktime = ktime_get_real();
++	nel->ts_jiffies = jiffies;
++	t = &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple;
++	nel->protocol = t->dst.protonum;
++	nel->pre.s_addr = t->src.u3.ip;
++	nel->pre.d_addr = t->dst.u3.ip;
++	nel->pre.s_port = t->src.u.all;
++	nel->pre.d_port = t->dst.u.all;
++	t = &ct->tuplehash[IP_CT_DIR_REPLY].tuple;
++	/* reply is reversed */
++	nel->post.s_addr = t->dst.u3.ip;
++	nel->post.d_addr = t->src.u3.ip;
++	nel->post.s_port = t->dst.u.all;
++	nel->post.d_port = t->src.u.all;
++	if (events & (1 << IPCT_DESTROY)) {
++		nel->nat_event = NAT_DESTROY;
++		nat_events_stop++;
++	} else {
++		nel->nat_event = NAT_CREATE;
++		nat_events_start++;
++	}
++
++	spin_lock_bh(&nat_lock);
++	list_add_tail(&nel->list, &nat_list);
++	spin_unlock_bh(&nat_lock);
++
++	return ret;
++}
++
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)
++static struct notifier_block ctnl_notifier = {
++	.notifier_call = netflow_conntrack_event
++};
++#else
++static struct nf_ct_event_notifier ctnl_notifier = {
++	.fcn = netflow_conntrack_event
++};
++#endif /* since 2.6.31 */
++#endif /* CONFIG_NF_NAT_NEEDED */
++
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23) && \
++    LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)
++static bool
++#else
++static int
++#endif
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
++netflow_target_check(const char *tablename, const void *entry, const struct xt_target *target,
++    void *targinfo,
++#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
++    unsigned int targinfosize,
++#endif
++    unsigned int hook_mask)
++{
++#else
++netflow_target_check(const struct xt_tgchk_param *par)
++{
++	const char *tablename = par->table;
++	const struct xt_target *target = par->target;
++#endif
++	if (strcmp("nat", tablename) == 0) {
++		/* In the nat table we only see single packet per flow, which is useless. */
++		printk(KERN_ERR "%s target: is not valid in %s table\n", target->name, tablename);
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)
++#define CHECK_FAIL	0
++#define CHECK_OK	1
++#else
++#define CHECK_FAIL	-EINVAL
++#define CHECK_OK	0
++#endif
++		return CHECK_FAIL;
++	}
++	if (target->family == AF_INET6 && protocol == 5) {
++		printk(KERN_ERR "ip6tables NETFLOW target is meaningful for protocol 9 or 10 only.\n");
++		return CHECK_FAIL;
++	}
++	return CHECK_OK;
++}
++
++#define SetXBit(x) (0x8000 >> (x)) /* Proper bit for htons later. */
++#ifndef IPPROTO_MH
++#define IPPROTO_MH	135
++#endif
++static inline __u16 observed_hdrs(const __u8 currenthdr)
++{
++	switch (currenthdr) {
++	case IPPROTO_TCP:
++	case IPPROTO_UDP:
++		/* For speed, in case switch is not optimized. */
++		return 0;
++	case IPPROTO_DSTOPTS:  return SetXBit(0);
++	case IPPROTO_HOPOPTS:  return SetXBit(1);
++	case IPPROTO_ROUTING:  return SetXBit(5);
++	case IPPROTO_MH:       return SetXBit(12);
++	case IPPROTO_ESP:      return SetXBit(13);
++	case IPPROTO_AH:       return SetXBit(14);
++	case IPPROTO_COMP:     return SetXBit(15);
++	case IPPROTO_FRAGMENT: /* Handled elsewhere. */
++		/* Next is known headers. */
++	case IPPROTO_ICMPV6:
++	case IPPROTO_UDPLITE:
++	case IPPROTO_IPIP:
++	case IPPROTO_PIM:
++	case IPPROTO_GRE:
++	case IPPROTO_SCTP:
++#ifdef IPPROTO_L2TP
++	case IPPROTO_L2TP:
++#endif
++	case IPPROTO_DCCP:
++	       return 0;
++	}
++	return SetXBit(3); /* Unknown header. */
++}
++
++/* http://www.iana.org/assignments/ip-parameters/ip-parameters.xhtml */
++static const __u8 ip4_opt_table[] = {
++	[7]	= 0,	/* RR */ /* parsed manually becasue of 0 */
++	[134]	= 1,	/* CIPSO */
++	[133]	= 2,	/* E-SEC */
++	[68]	= 3,	/* TS */
++	[131]	= 4,	/* LSR */
++	[130]	= 5,	/* SEC */
++	[1]	= 6,	/* NOP */
++	[0]	= 7,	/* EOOL */
++	[15]	= 8,	/* ENCODE */
++	[142]	= 9,	/* VISA */
++	[205]	= 10,	/* FINN */
++	[12]	= 11,	/* MTUR */
++	[11]	= 12,	/* MTUP */
++	[10]	= 13,	/* ZSU */
++	[137]	= 14,	/* SSR */
++	[136]	= 15,	/* SID */
++	[151]	= 16,	/* DPS */
++	[150]	= 17,	/* NSAPA */
++	[149]	= 18,	/* SDB */
++	[147]	= 19,	/* ADDEXT */
++	[148]	= 20,	/* RTRALT */
++	[82]	= 21,	/* TR */
++	[145]	= 22,	/* EIP */
++	[144]	= 23,	/* IMITD */
++	[30]	= 25,	/* EXP */
++	[94]	= 25,	/* EXP */
++	[158]	= 25,	/* EXP */
++	[222]	= 25,	/* EXP */
++	[25]	= 30,	/* QS */
++	[152]	= 31,	/* UMP */
++};
++/* Parse IPv4 Options array int ipv4Options IPFIX value. */
++static inline __u32 ip4_options(const u_int8_t *p, const unsigned int optsize)
++{
++	__u32 ret = 0;
++	unsigned int i;
++
++	for (i = 0; likely(i < optsize); ) {
++		u_int8_t op = p[i++];
++
++		if (op == 7) /* RR: bit 0 */
++			ret |= 1;
++		else if (likely(op < ARRAY_SIZE(ip4_opt_table))) {
++			/* Btw, IANA doc is messed up in a crazy way:
++			 *   http://www.ietf.org/mail-archive/web/ipfix/current/msg06008.html (2011)
++			 * I decided to follow IANA _text_ description from
++			 *   http://www.iana.org/assignments/ipfix/ipfix.xhtml (2013-09-18)
++			 *
++			 * Set proper bit for htonl later. */
++			if (ip4_opt_table[op])
++				ret |= 1 << (32 - ip4_opt_table[op]);
++		}
++		if (likely(i >= optsize || op == 0))
++			break;
++		else if (unlikely(op == 1))
++			continue;
++		else if (unlikely(p[i] < 2))
++			break;
++		else
++			i += p[i] - 1;
++	}
++	return ret;
++}
++
++#define TCPHDR_MAXSIZE (4 * 15)
++/* List of options: http://www.iana.org/assignments/tcp-parameters/tcp-parameters.xhtml */
++static inline __u32 tcp_options(const struct sk_buff *skb, const unsigned int ptr, const struct tcphdr *th)
++{
++	const unsigned int optsize = th->doff * 4 - sizeof(struct tcphdr);
++	__u8 _opt[TCPHDR_MAXSIZE];
++	const u_int8_t *p;
++	__u32 ret;
++	unsigned int i;
++
++	p = skb_header_pointer(skb, ptr + sizeof(struct tcphdr), optsize, _opt);
++	if (unlikely(!p))
++		return 0;
++	ret = 0;
++	for (i = 0; likely(i < optsize); ) {
++		u_int8_t opt = p[i++];
++
++		if (likely(opt < 32)) {
++			/* IANA doc is messed up, see above. */
++			ret |= 1 << (32 - opt);
++		}
++		if (likely(i >= optsize || opt == 0))
++			break;
++		else if (unlikely(opt == 1))
++			continue;
++		else if (unlikely(p[i] < 2)) /* "silly options" */
++			break;
++		else
++			i += p[i] - 1;
++	}
++	return ret;
++}
+ /* packet receiver */
+ static unsigned int netflow_target(
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
+@@ -1192,27 +2415,38 @@ static unsigned int netflow_target(
+ 		)
+ {
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
+-	struct sk_buff *skb = *pskb;
++	const struct sk_buff *skb = *pskb;
++#endif
++	union {
++		struct iphdr ip;
++		struct ipv6hdr ip6;
++	} _iph, *iph;
++	unsigned int hash;
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
++	const int family = target->family;
++#else
++	const int family = par->family;
+ #endif
+-	struct iphdr _iph, *iph;
+ 	struct ipt_netflow_tuple tuple;
+ 	struct ipt_netflow *nf;
+ 	__u8 tcp_flags;
+ 	struct netflow_aggr_n *aggr_n;
+ 	struct netflow_aggr_p *aggr_p;
+ 	__u8 s_mask, d_mask;
+-	unsigned int hash;
+-
+-	iph = skb_header_pointer(skb, 0, sizeof(_iph), &_iph); //iph = ip_hdr(skb);
+-
+-	if (iph == NULL) {
++	unsigned int ptr;
++	int fragment;
++	size_t pkt_len;
++	int options = 0;
++	int tcpoptions = 0;
++
++	iph = skb_header_pointer(skb, 0, (likely(family == AF_INET))? sizeof(_iph.ip) : sizeof(_iph.ip6), &iph);
++	if (unlikely(iph == NULL)) {
+ 		NETFLOW_STAT_INC(truncated);
+ 		NETFLOW_STAT_INC(pkt_drop);
+ 		return IPT_CONTINUE;
+ 	}
+ 
+-	tuple.s_addr	= iph->saddr;
+-	tuple.d_addr	= iph->daddr;
++	tuple.l3proto	= family;
+ 	tuple.s_port	= 0;
+ 	tuple.d_port	= 0;
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
+@@ -1220,30 +2454,118 @@ static unsigned int netflow_target(
+ #else
+ 	tuple.i_ifc	= par->in? par->in->ifindex : -1;
+ #endif
+-	tuple.protocol	= iph->protocol;
+-	tuple.tos	= iph->tos;
+ 	tcp_flags	= 0; /* Cisco sometimes have TCP ACK for non TCP packets, don't get it */
+ 	s_mask		= 0;
+ 	d_mask		= 0;
+ 
+-	if (iph->frag_off & htons(IP_OFFSET))
++	if (likely(family == AF_INET)) {
++		tuple.src	= (union nf_inet_addr){ .ip = iph->ip.saddr };
++		tuple.dst	= (union nf_inet_addr){ .ip = iph->ip.daddr };
++		tuple.tos	= iph->ip.tos;
++		tuple.protocol	= iph->ip.protocol;
++		fragment	= unlikely(iph->ip.frag_off & htons(IP_OFFSET));
++		ptr		= iph->ip.ihl * 4;
++		pkt_len		= ntohs(iph->ip.tot_len);
++
++#define IPHDR_MAXSIZE (4 * 15)
++		if (unlikely(iph->ip.ihl * 4 > sizeof(struct iphdr))) {
++			u_int8_t _opt[IPHDR_MAXSIZE - sizeof(struct iphdr)];
++			const u_int8_t *op;
++			unsigned int optsize = iph->ip.ihl * 4 - sizeof(struct iphdr);
++
++			op = skb_header_pointer(skb, sizeof(struct iphdr), optsize, _opt);
++			if (likely(op))
++				options = ip4_options(op, optsize);
++		}
++	} else {
++		__u8 currenthdr;
++
++		tuple.src.in6	= iph->ip6.saddr;
++		tuple.dst.in6	= iph->ip6.daddr;
++		tuple.tos	= iph->ip6.priority;
++		fragment	= 0;
++		ptr		= sizeof(struct ipv6hdr);
++		pkt_len		= ntohs(iph->ip6.payload_len) + sizeof(struct ipv6hdr);
++
++		currenthdr	= iph->ip6.nexthdr;
++		while (currenthdr != NEXTHDR_NONE && ipv6_ext_hdr(currenthdr)) {
++			struct ipv6_opt_hdr _hdr;
++			const struct ipv6_opt_hdr *hp;
++			unsigned int hdrlen = 0;
++
++			options |= observed_hdrs(currenthdr);
++			hp = skb_header_pointer(skb, ptr, sizeof(_hdr), &_hdr);
++			if (hp == NULL) {
++				/* We have src/dst, so must account something. */
++				tuple.protocol = currenthdr;
++				fragment = 3;
++				goto do_protocols;
++			}
++
++			switch (currenthdr) {
++			case IPPROTO_FRAGMENT: {
++				struct frag_hdr _fhdr;
++				const struct frag_hdr *fh;
++
++				fh = skb_header_pointer(skb, ptr, sizeof(_fhdr),
++						&_fhdr);
++				if (fh == NULL) {
++					tuple.protocol = currenthdr;
++					fragment = 2;
++					goto do_protocols;
++				}
++				fragment = 1;
++#define FRA0 SetXBit(4) /* Fragment header - first fragment */
++#define FRA1 SetXBit(6) /* Fragmentation header - not first fragment */
++				options |= (ntohs(fh->frag_off) & 0xFFF8)? FRA1 : FRA0;
++				hdrlen = 8;
++				break;
++			}
++			case IPPROTO_AH: {
++				struct ip_auth_hdr _hdr, *hp;
++
++				if (likely(hp = skb_header_pointer(skb, ptr, 8, &_hdr))) {
++					tuple.s_port = hp->spi >> 16;
++					tuple.d_port = hp->spi;
++				}
++				hdrlen = (hp->hdrlen + 2) << 2;
++				break;
++			}
++			default:
++				hdrlen = ipv6_optlen(hp);
++			}
++			currenthdr = hp->nexthdr;
++			ptr += hdrlen;
++		}
++		tuple.protocol	= currenthdr;
++		options |= observed_hdrs(currenthdr);
++	}
++
++do_protocols:
++	if (fragment) {
++		/* if conntrack is enabled it should defrag on pre-routing and local-out */
+ 		NETFLOW_STAT_INC(frags);
+-	else {
++	} else {
+ 		switch (tuple.protocol) {
+ 		    case IPPROTO_TCP: {
+ 			struct tcphdr _hdr, *hp;
+ 
+-			if ((hp = skb_header_pointer(skb, iph->ihl * 4, 14, &_hdr))) {
++			if (likely(hp = skb_header_pointer(skb, ptr, 14, &_hdr))) {
+ 				tuple.s_port = hp->source;
+ 				tuple.d_port = hp->dest;
+ 				tcp_flags = (u_int8_t)(ntohl(tcp_flag_word(hp)) >> 16);
++
++				if (unlikely(hp->doff * 4 > sizeof(struct tcphdr)))
++					tcpoptions = tcp_options(skb, ptr, hp);
+ 			}
+ 			break;
+ 		    }
+-		    case IPPROTO_UDP: {
++		    case IPPROTO_UDP:
++		    case IPPROTO_UDPLITE:
++		    case IPPROTO_SCTP: {
+ 			struct udphdr _hdr, *hp;
+ 
+-			if ((hp = skb_header_pointer(skb, iph->ihl * 4, 4, &_hdr))) {
++			if (likely(hp = skb_header_pointer(skb, ptr, 4, &_hdr))) {
+ 				tuple.s_port = hp->source;
+ 				tuple.d_port = hp->dest;
+ 			}
+@@ -1252,72 +2574,111 @@ static unsigned int netflow_target(
+ 		    case IPPROTO_ICMP: {
+ 			struct icmphdr _hdr, *hp;
+ 
+-			if ((hp = skb_header_pointer(skb, iph->ihl * 4, 2, &_hdr)))
+-				tuple.d_port = (hp->type << 8) | hp->code;
++			if (likely(family == AF_INET &&
++				    (hp = skb_header_pointer(skb, ptr, 2, &_hdr))))
++				tuple.d_port = htons((hp->type << 8) | hp->code);
+ 			break;
+ 		    }
++		    case IPPROTO_ICMPV6: {
++			    struct icmp6hdr _icmp6h, *ic;
++
++			    if (likely(family == AF_INET6 &&
++					(ic = skb_header_pointer(skb, ptr, 2, &_icmp6h))))
++				    tuple.d_port = htons((ic->icmp6_type << 8) | ic->icmp6_code);
++			    break;
++		    }
+ 		    case IPPROTO_IGMP: {
+-			struct igmphdr *_hdr, *hp;
++			struct igmphdr _hdr, *hp;
+ 
+-			if ((hp = skb_header_pointer(skb, iph->ihl * 4, 1, &_hdr)))
++			if (likely(hp = skb_header_pointer(skb, ptr, 1, &_hdr)))
+ 				tuple.d_port = hp->type;
+ 			}
+ 			break;
++		    case IPPROTO_AH: { /* IPSEC */
++			struct ip_auth_hdr _hdr, *hp;
++
++			if (likely(family == AF_INET && /* For IPv6 it's parsed above. */
++				    (hp = skb_header_pointer(skb, ptr, 8, &_hdr)))) {
++				tuple.s_port = hp->spi >> 16;
++				tuple.d_port = hp->spi;
++			}
++			break;
++		    }
++		    case IPPROTO_ESP: {
++			struct ip_esp_hdr _hdr, *hp;
++
++			if (likely(hp = skb_header_pointer(skb, ptr, 4, &_hdr)))
++				tuple.s_port = hp->spi >> 16;
++				tuple.d_port = hp->spi;
++			}
++			break;
+ 	       	}
+ 	} /* not fragmented */
+ 
+ 	/* aggregate networks */
+ 	read_lock_bh(&aggr_lock);
+-	list_for_each_entry(aggr_n, &aggr_n_list, list)
+-		if ((ntohl(tuple.s_addr) & aggr_n->mask) == aggr_n->addr) {
+-			tuple.s_addr &= htonl(aggr_n->aggr_mask);
+-			s_mask = aggr_n->prefix;
+-			break; 
+-		}
+-	list_for_each_entry(aggr_n, &aggr_n_list, list)
+-		if ((ntohl(tuple.d_addr) & aggr_n->mask) == aggr_n->addr) {
+-			tuple.d_addr &= htonl(aggr_n->aggr_mask);
+-			d_mask = aggr_n->prefix;
+-			break; 
+-		}
++	if (family == AF_INET) {
++		list_for_each_entry(aggr_n, &aggr_n_list, list)
++			if (unlikely((ntohl(tuple.src.ip) & aggr_n->mask) == aggr_n->addr)) {
++				tuple.src.ip &= htonl(aggr_n->aggr_mask);
++				s_mask = aggr_n->prefix;
++				atomic_inc(&aggr_n->usage);
++				break;
++			}
++		list_for_each_entry(aggr_n, &aggr_n_list, list)
++			if (unlikely((ntohl(tuple.dst.ip) & aggr_n->mask) == aggr_n->addr)) {
++				tuple.dst.ip &= htonl(aggr_n->aggr_mask);
++				d_mask = aggr_n->prefix;
++				atomic_inc(&aggr_n->usage);
++				break;
++			}
++	}
+ 
+-	/* aggregate ports */
+-	list_for_each_entry(aggr_p, &aggr_p_list, list)
+-		if (ntohs(tuple.s_port) >= aggr_p->port1 &&
+-		    ntohs(tuple.s_port) <= aggr_p->port2) {
+-			tuple.s_port = htons(aggr_p->aggr_port);
+-			break;
+-		}
++	if (tuple.protocol == IPPROTO_TCP ||
++	    tuple.protocol == IPPROTO_UDP ||
++	    tuple.protocol == IPPROTO_SCTP ||
++	    tuple.protocol == IPPROTO_UDPLITE) {
++		/* aggregate ports */
++		list_for_each_entry(aggr_p, &aggr_p_list, list)
++			if (unlikely(ntohs(tuple.s_port) >= aggr_p->port1 &&
++			    ntohs(tuple.s_port) <= aggr_p->port2)) {
++				tuple.s_port = htons(aggr_p->aggr_port);
++				atomic_inc(&aggr_p->usage);
++				break;
++			}
+ 
+-	list_for_each_entry(aggr_p, &aggr_p_list, list)
+-		if (ntohs(tuple.d_port) >= aggr_p->port1 &&
+-		    ntohs(tuple.d_port) <= aggr_p->port2) {
+-			tuple.d_port = htons(aggr_p->aggr_port);
+-			break;
+-		}
++		list_for_each_entry(aggr_p, &aggr_p_list, list)
++			if (unlikely(ntohs(tuple.d_port) >= aggr_p->port1 &&
++			    ntohs(tuple.d_port) <= aggr_p->port2)) {
++				tuple.d_port = htons(aggr_p->aggr_port);
++				atomic_inc(&aggr_p->usage);
++				break;
++			}
++	}
+ 	read_unlock_bh(&aggr_lock);
+ 
+ 	hash = hash_netflow(&tuple);
+-	spin_lock_bh(&ipt_netflow_lock);
++	read_lock_bh(&htable_rwlock);
++	spin_lock(&htable_locks[hash & LOCK_COUNT_MASK]);
+ 	/* record */
+ 	nf = ipt_netflow_find(&tuple, hash);
+-	if (!nf) {
+-		if (maxflows > 0 && atomic_read(&ipt_netflow_count) >= maxflows) {
++	if (unlikely(!nf)) {
++		struct rtable *rt;
++
++		if (unlikely(maxflows > 0 && atomic_read(&ipt_netflow_count) >= maxflows)) {
+ 			/* This is DOS attack prevention */
+ 			NETFLOW_STAT_INC(maxflows_err);
+ 			NETFLOW_STAT_INC(pkt_drop);
+-			NETFLOW_STAT_ADD(traf_drop, ntohs(iph->tot_len));
+-			spin_unlock_bh(&ipt_netflow_lock);
+-			return IPT_CONTINUE;
++			NETFLOW_STAT_ADD(traf_drop, pkt_len);
++			goto unlock_return;
+ 		}
+ 
+ 		nf = init_netflow(&tuple, skb, hash);
+-		if (!nf || IS_ERR(nf)) {
++		if (unlikely(!nf || IS_ERR(nf))) {
+ 			NETFLOW_STAT_INC(alloc_err);
+ 			NETFLOW_STAT_INC(pkt_drop);
+-			NETFLOW_STAT_ADD(traf_drop, ntohs(iph->tot_len));
+-			spin_unlock_bh(&ipt_netflow_lock);
+-			return IPT_CONTINUE;
++			NETFLOW_STAT_ADD(traf_drop, pkt_len);
++			goto unlock_return;
+ 		}
+ 
+ 		nf->ts_first = jiffies;
+@@ -1330,31 +2691,68 @@ static unsigned int netflow_target(
+ 		nf->s_mask = s_mask;
+ 		nf->d_mask = d_mask;
+ 
+-		if (debug > 2)
+-			printk(KERN_INFO "ipt_netflow: new (%u) %hd:%hd SRC=%u.%u.%u.%u:%u DST=%u.%u.%u.%u:%u\n",
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
++		rt = (struct rtable *)skb->dst;
++#else /* since 2.6.26 */
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)
++		rt = skb->rtable;
++#else /* since 2.6.31 */
++		rt = skb_rtable(skb);
++#endif
++#endif
++		if (likely(family == AF_INET)) {
++			if (rt)
++				nf->nh.ip = rt->rt_gateway;
++		} else {
++			if (rt)
++				nf->nh.in6 = ((struct rt6_info *)rt)->rt6i_gateway;
++			nf->flow_label = (iph->ip6.flow_lbl[0] << 16) |
++			       	(iph->ip6.flow_lbl[1] << 8) | (iph->ip6.flow_lbl[2]);
++		}
++#if 0
++		if (unlikely(debug > 2))
++			printk(KERN_INFO "ipt_NETFLOW: new (%u) %hd:%hd SRC=%u.%u.%u.%u:%u DST=%u.%u.%u.%u:%u\n",
+ 			       atomic_read(&ipt_netflow_count),
+ 			       tuple.i_ifc, nf->o_ifc,
+ 			       NIPQUAD(tuple.s_addr), ntohs(tuple.s_port),
+ 			       NIPQUAD(tuple.d_addr), ntohs(tuple.d_port));
++#endif
+ 	} else {
+ 		/* ipt_netflow_list is sorted by access time:
+ 		 * most recently accessed flows are at head, old flows remain at tail
+ 		 * this function bubble up flow to the head */
++		spin_lock(&hlist_lock);
+ 		list_move(&nf->list, &ipt_netflow_list);
++		spin_unlock(&hlist_lock);
+ 	}
+ 
++#ifdef CONFIG_NF_CONNTRACK_MARK
++	{
++		struct nf_conn *ct;
++		enum ip_conntrack_info ctinfo;
++		ct = nf_ct_get(skb, &ctinfo);
++		if (ct)
++			nf->mark = ct->mark;
++	}
++#endif
++
+ 	nf->nr_packets++;
+-	nf->nr_bytes += ntohs(iph->tot_len);
++	nf->nr_bytes += pkt_len;
+ 	nf->ts_last = jiffies;
+ 	nf->tcp_flags |= tcp_flags;
++	nf->options |= options;
++	if (tuple.protocol == IPPROTO_TCP)
++		nf->tcpoptions |= tcpoptions;
+ 
+ 	NETFLOW_STAT_INC(pkt_total);
+-	NETFLOW_STAT_ADD(traf_total, ntohs(iph->tot_len));
++	NETFLOW_STAT_ADD(traf_total, pkt_len);
+ 
+-	if (active_needs_export(nf, active_timeout * HZ)) {
++	if (likely(active_needs_export(nf, active_timeout * HZ))) {
+ 		/* ok, if this active flow to be exported
+ 		 * bubble it to the tail */
++		spin_lock(&hlist_lock);
+ 		list_move_tail(&nf->list, &ipt_netflow_list);
++		spin_unlock(&hlist_lock);
+ 
+ 		/* Blog: I thought about forcing timer to wake up sooner if we have
+ 		 * enough exportable flows, but in fact this doesn't have much sense,
+@@ -1363,35 +2761,194 @@ static unsigned int netflow_target(
+ 		 * limited size). But yes, this is disputable. */
+ 	}
+ 
+-	spin_unlock_bh(&ipt_netflow_lock);
++unlock_return:
++	spin_unlock(&htable_locks[hash & LOCK_COUNT_MASK]);
++	read_unlock_bh(&htable_rwlock);
+ 
+ 	return IPT_CONTINUE;
+ }
+ 
+-static struct ipt_target ipt_netflow_reg = {
+-	.name		= "NETFLOW",
+-	.target		= netflow_target,
+-	.family		= AF_INET,
+-#ifndef RAW_PROMISC_HACK
+-	.table		= "filter",
+-#ifndef NF_IP_LOCAL_IN /* 2.6.25 */
+-	.hooks		= (1 << NF_INET_LOCAL_IN) | (1 << NF_INET_FORWARD) |
+-				(1 << NF_INET_LOCAL_OUT),
+-#else
+-	.hooks		= (1 << NF_IP_LOCAL_IN) | (1 << NF_IP_FORWARD) |
+-				(1 << NF_IP_LOCAL_OUT),
+-#endif /* NF_IP_LOCAL_IN */
++#ifdef CONFIG_NF_NAT_NEEDED
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
++	/* Below 2.6.31 we don't need to handle callback chain manually. */
++
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)
++#define NET_STRUCT struct net *net
++#define NET_ARG net,
++#define nf_conntrack_event_cb net->ct.nf_conntrack_event_cb
+ #else
+-	.table          = "raw",
+-#ifndef NF_IP_LOCAL_IN
+-	.hooks          = (1 << NF_INET_LOCAL_IN) | (1 << NF_INET_FORWARD) |
+-				(1 << NF_INET_LOCAL_OUT) | (1 << NF_INET_PRE_ROUTING),
++#define NET_STRUCT void
++#define NET_ARG
++#endif
++static int set_notifier_cb(NET_STRUCT)
++{
++	struct nf_ct_event_notifier *notifier;
++
++	notifier = rcu_dereference(nf_conntrack_event_cb);
++	if (notifier == NULL) {
++		/* Polite mode. */
++		nf_conntrack_register_notifier(NET_ARG &ctnl_notifier);
++	} else if (notifier != &ctnl_notifier) {
++		if (!saved_event_cb)
++			saved_event_cb = notifier;
++		else if (saved_event_cb != notifier)
++			printk(KERN_ERR "natevents_net_init: %p != %p (report error.)\n",
++			    saved_event_cb, notifier);
++		rcu_assign_pointer(nf_conntrack_event_cb, &ctnl_notifier);
++	} else
++		printk(KERN_ERR "ipt_NETFLOW: natevents already enabled.\n");
++	return 0;
++}
++static void unset_notifier_cb(NET_STRUCT)
++{
++	struct nf_ct_event_notifier *notifier;
++
++	notifier = rcu_dereference(nf_conntrack_event_cb);
++	if (notifier == &ctnl_notifier) {
++		if (saved_event_cb == NULL)
++			nf_conntrack_unregister_notifier(NET_ARG &ctnl_notifier);
++		else
++			rcu_assign_pointer(nf_conntrack_event_cb, saved_event_cb);
++	} else
++		printk(KERN_ERR "ipt_NETFLOW: natevents already disabled.\n");
++}
++
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)
++#undef nf_conntrack_event_cb
++static struct pernet_operations natevents_net_ops = {
++	.init = set_notifier_cb,
++	.exit = unset_notifier_cb
++};
++#endif
++#endif /* since 2.6.31 */
++
++static DEFINE_MUTEX(events_lock);
++/* Both functions may be called multiple times. */
++static void register_ct_events(void)
++{
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
++#define NETLINK_M "nf_conntrack_netlink"
++	struct module *netlink_m;
++	static int referenced = 0;
++#endif
++
++	printk(KERN_INFO "ipt_NETFLOW: enable natevents.\n");
++	mutex_lock(&events_lock);
++
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
++	/* Pre-load netlink module who will be first notifier
++	 * user, and then hijack nf_conntrack_event_cb from it. */
++	if (
++#if LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0)
++	    !rcu_dereference(nf_conntrack_event_cb) ||
++#endif
++	    !(netlink_m = find_module(NETLINK_M))) {
++		printk("Loading " NETLINK_M "\n");
++		request_module(NETLINK_M);
++	}
++	/* Reference netlink module to prevent it's unsafe unload before us. */
++	if (!referenced && (netlink_m = find_module(NETLINK_M))) {
++		referenced++;
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)
++#define use_module ref_module
++#endif
++		use_module(THIS_MODULE, netlink_m);
++	}
++
++	/* Register ct events callback. */
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)
++	register_pernet_subsys(&natevents_net_ops);
+ #else
+-	.hooks          = (1 << NF_IP_LOCAL_IN) | (1 << NF_IP_FORWARD) |
+-				(1 << NF_IP_LOCAL_OUT) | (1 << NF_IP_PRE_ROUTING),
+-#endif /* NF_IP_LOCAL_IN */
+-#endif /* !RAW_PROMISC_HACK */
+-	.me		= THIS_MODULE
++	set_notifier_cb();
++#endif
++#else /* below v2.6.31 */
++	if (!natevents && nf_conntrack_register_notifier(&ctnl_notifier) < 0)
++		printk(KERN_ERR "Can't register conntrack notifier, natevents disabled.\n");
++	else
++#endif
++	natevents = 1;
++	mutex_unlock(&events_lock);
++}
++
++static void unregister_ct_events(void)
++{
++	printk(KERN_INFO "ipt_NETFLOW: disable natevents.\n");
++	mutex_lock(&events_lock);
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)
++	unregister_pernet_subsys(&natevents_net_ops);
++#else /* < v3.2 */
++	unset_notifier_cb();
++#endif /* v3.2 */
++	rcu_assign_pointer(saved_event_cb, NULL);
++#else /* < v2.6.31 */
++	nf_conntrack_unregister_notifier(&ctnl_notifier);
++#endif
++	natevents = 0;
++	mutex_unlock(&events_lock);
++}
++#endif /* CONFIG_NF_NAT_NEEDED */
++
++#ifndef NF_IP_LOCAL_IN /* 2.6.25 */
++#define NF_IP_PRE_ROUTING	NF_INET_PRE_ROUTING
++#define NF_IP_LOCAL_IN		NF_INET_LOCAL_IN
++#define NF_IP_FORWARD		NF_INET_FORWARD
++#define NF_IP_LOCAL_OUT		NF_INET_LOCAL_OUT
++#define NF_IP_POST_ROUTING	NF_INET_POST_ROUTING
++#endif
++
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
++/* net/netfilter/x_tables.c */
++static void xt_unregister_targets(struct xt_target *target, unsigned int n)
++{
++	unsigned int i;
++
++	for (i = 0; i < n; i++)
++		xt_unregister_target(&target[i]);
++}
++static int xt_register_targets(struct xt_target *target, unsigned int n)
++{
++	unsigned int i;
++
++	int err = 0;
++	for (i = 0; i < n; i++)
++		if ((err = xt_register_target(&target[i])))
++			goto err;
++	return err;
++err:
++	if (i > 0)
++		xt_unregister_targets(target, i);
++	return err;
++}
++#endif
++
++static struct ipt_target ipt_netflow_reg[] __read_mostly = {
++	{
++		.name		= "NETFLOW",
++		.target		= netflow_target,
++		.checkentry	= netflow_target_check,
++		.family		= AF_INET,
++		.hooks		=
++		       	(1 << NF_IP_PRE_ROUTING) |
++		       	(1 << NF_IP_LOCAL_IN) |
++		       	(1 << NF_IP_FORWARD) |
++			(1 << NF_IP_LOCAL_OUT) |
++			(1 << NF_IP_POST_ROUTING),
++		.me		= THIS_MODULE
++	},
++	{
++		.name		= "NETFLOW",
++		.target		= netflow_target,
++		.checkentry	= netflow_target_check,
++		.family		= AF_INET6,
++		.hooks		=
++		       	(1 << NF_IP_PRE_ROUTING) |
++		       	(1 << NF_IP_LOCAL_IN) |
++		       	(1 << NF_IP_FORWARD) |
++			(1 << NF_IP_LOCAL_OUT) |
++			(1 << NF_IP_POST_ROUTING),
++		.me		= THIS_MODULE
++	},
+ };
+ 
+ static int __init ipt_netflow_init(void)
+@@ -1399,11 +2956,16 @@ static int __init ipt_netflow_init(void)
+ #ifdef CONFIG_PROC_FS
+ 	struct proc_dir_entry *proc_stat;
+ #endif
++	printk(KERN_INFO "ipt_NETFLOW version %s, srcversion %s\n",
++		IPT_NETFLOW_VERSION, THIS_MODULE->srcversion);
+ 
+ 	get_random_bytes(&ipt_netflow_hash_rnd, 4);
+ 
+ 	/* determine hash size (idea from nf_conntrack_core.c) */
+ 	if (!hashsize) {
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0)
++#define num_physpages totalram_pages
++#endif
+ 		hashsize = (((num_physpages << PAGE_SHIFT) / 16384)
+ 					 / sizeof(struct hlist_head));
+ 		if (num_physpages > (1024 * 1024 * 1024 / PAGE_SIZE))
+@@ -1411,8 +2973,7 @@ static int __init ipt_netflow_init(void)
+ 	}
+ 	if (hashsize < 16)
+ 		hashsize = 16;
+-	printk(KERN_INFO "ipt_netflow version %s (%u buckets)\n",
+-		IPT_NETFLOW_VERSION, hashsize);
++	printk(KERN_INFO "ipt_NETFLOW: hashsize %u\n", hashsize);
+ 
+ 	ipt_netflow_hash_size = hashsize;
+ 	ipt_netflow_hash = alloc_hashtable(ipt_netflow_hash_size);
+@@ -1434,12 +2995,18 @@ static int __init ipt_netflow_init(void)
+ 	}
+ 
+ #ifdef CONFIG_PROC_FS
++#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
+ 	proc_stat = create_proc_entry("ipt_netflow", S_IRUGO, INIT_NET(proc_net_stat));
++#else
++	proc_stat = proc_create("ipt_netflow", S_IRUGO, INIT_NET(proc_net_stat), &nf_seq_fops);
++#endif
+ 	if (!proc_stat) {
+ 		printk(KERN_ERR "Unable to create /proc/net/stat/ipt_netflow entry\n");
+ 		goto err_free_netflow_slab;
+ 	}
++#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
+ 	proc_stat->proc_fops = &nf_seq_fops;
++#endif
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
+ 	proc_stat->owner = THIS_MODULE;
+ #endif
+@@ -1480,21 +3047,28 @@ static int __init ipt_netflow_init(void)
+ 	}
+ 	add_aggregation(aggregation);
+ 
+-	__start_scan_worker();
++	netflow_switch_version(protocol);
++	_schedule_scan_worker(0);
+ 	setup_timer(&rate_timer, rate_timer_calc, 0);
+ 	mod_timer(&rate_timer, jiffies + (HZ * SAMPLERATE));
+ 
+-	if (xt_register_target(&ipt_netflow_reg))
++	peakflows_at = jiffies;
++	if (xt_register_targets(ipt_netflow_reg, ARRAY_SIZE(ipt_netflow_reg)))
+ 		goto err_stop_timer;
+ 
+-	peakflows_at = jiffies;
++#ifdef CONFIG_NF_NAT_NEEDED
++	if (natevents)
++		register_ct_events();
++#endif
+ 
+-	printk(KERN_INFO "ipt_netflow loaded.\n");
++	printk(KERN_INFO "ipt_NETFLOW is loaded.\n");
+ 	return 0;
+ 
+ err_stop_timer:
+-	__stop_scan_worker();
++	_unschedule_scan_worker();
++	netflow_scan_and_export(AND_FLUSH);
+ 	del_timer_sync(&rate_timer);
++	free_templates();
+ 	destination_removeall();
+ 	aggregation_remove(&aggr_n_list);
+ 	aggregation_remove(&aggr_p_list);
+@@ -1506,17 +3080,18 @@ err_free_proc_stat:
+ #ifdef CONFIG_PROC_FS
+ 	remove_proc_entry("ipt_netflow", INIT_NET(proc_net_stat));
+ err_free_netflow_slab:
+-#endif  
++#endif
+ 	kmem_cache_destroy(ipt_netflow_cachep);
+ err_free_hash:
+ 	vfree(ipt_netflow_hash);
+ err:
++	printk(KERN_INFO "ipt_NETFLOW is not loaded.\n");
+ 	return -ENOMEM;
+ }
+ 
+ static void __exit ipt_netflow_fini(void)
+ {
+-	printk(KERN_INFO "ipt_netflow unloading..\n");
++	printk(KERN_INFO "ipt_NETFLOW unloading..\n");
+ 
+ #ifdef CONFIG_SYSCTL
+ 	unregister_sysctl_table(netflow_sysctl_header);
+@@ -1524,14 +3099,18 @@ static void __exit ipt_netflow_fini(void)
+ #ifdef CONFIG_PROC_FS
+ 	remove_proc_entry("ipt_netflow", INIT_NET(proc_net_stat));
+ #endif
+-
+-	xt_unregister_target(&ipt_netflow_reg);
+-	__stop_scan_worker();
+-	netflow_scan_and_export(1);
++	xt_unregister_targets(ipt_netflow_reg, ARRAY_SIZE(ipt_netflow_reg));
++#ifdef CONFIG_NF_NAT_NEEDED
++	if (natevents)
++		unregister_ct_events();
++#endif
++	_unschedule_scan_worker();
++	netflow_scan_and_export(AND_FLUSH);
+ 	del_timer_sync(&rate_timer);
+ 
+ 	synchronize_sched();
+ 
++	free_templates();
+ 	destination_removeall();
+ 	aggregation_remove(&aggr_n_list);
+ 	aggregation_remove(&aggr_p_list);
+@@ -1539,7 +3118,7 @@ static void __exit ipt_netflow_fini(void)
+ 	kmem_cache_destroy(ipt_netflow_cachep);
+ 	vfree(ipt_netflow_hash);
+ 
+-	printk(KERN_INFO "ipt_netflow unloaded.\n");
++	printk(KERN_INFO "ipt_NETFLOW unloaded.\n");
+ }
+ 
+ module_init(ipt_netflow_init);
+diff --git a/ipt_NETFLOW.h b/ipt_NETFLOW.h
+index 4a7b645..749f985 100644
+--- a/ipt_NETFLOW.h
++++ b/ipt_NETFLOW.h
+@@ -35,8 +35,8 @@ struct netflow5_record {
+ 	__be16		o_ifc;
+ 	__be32		nr_packets;
+ 	__be32		nr_octets;
+-	__be32		ts_first;
+-	__be32		ts_last;
++	__be32		first_ms;
++	__be32		last_ms;
+ 	__be16		s_port;
+ 	__be16		d_port;
+ 	__u8		reserved;
+@@ -54,9 +54,9 @@ struct netflow5_record {
+ struct netflow5_pdu {
+ 	__be16			version;
+ 	__be16			nr_records;
+-	__be32			ts_uptime;
+-	__be32			ts_usecs;
+-	__be32			ts_unsecs;
++	__be32			ts_uptime; /* ms */
++	__be32			ts_usecs;  /* s  */
++	__be32			ts_unsecs; /* ns */
+ 	__be32			seq;
+ 	__u8			eng_type;
+ 	__u8			eng_id;
+@@ -65,42 +65,185 @@ struct netflow5_pdu {
+ } __attribute__ ((packed));
+ #define NETFLOW5_HEADER_SIZE (sizeof(struct netflow5_pdu) - NETFLOW5_RECORDS_MAX * sizeof(struct netflow5_record))
+ 
++/* NetFlow v9 RFC http://www.ietf.org/rfc/rfc3954.txt */
++enum {
++	IN_BYTES = 1,
++	IN_PKTS = 2,
++	PROTOCOL = 4,
++	TOS = 5,
++	TCP_FLAGS = 6,
++	L4_SRC_PORT = 7,
++	IPV4_SRC_ADDR = 8,
++	SRC_MASK = 9,
++	INPUT_SNMP = 10,
++	L4_DST_PORT = 11,
++	IPV4_DST_ADDR = 12,
++	DST_MASK = 13,
++	OUTPUT_SNMP = 14,
++	IPV4_NEXT_HOP = 15,
++	//SRC_AS = 16,
++	//DST_AS = 17,
++	//BGP_IPV4_NEXT_HOP = 18,
++	//MUL_DST_PKTS = 19,
++	//MUL_DST_BYTES = 20,
++	LAST_SWITCHED = 21,
++	FIRST_SWITCHED = 22,
++	IPV6_SRC_ADDR = 27,
++	IPV6_DST_ADDR = 28,
++	IPV6_FLOW_LABEL = 31,
++	ICMP_TYPE = 32,
++	MUL_IGMP_TYPE = 33,
++	//TOTAL_BYTES_EXP = 40,
++	//TOTAL_PKTS_EXP = 41,
++	//TOTAL_FLOWS_EXP = 42,
++	IPV6_NEXT_HOP = 62,
++	IPV6_OPTION_HEADERS = 64,
++	commonPropertiesId = 137, /* for MARK */
++	ipv4Options = 208,
++	tcpOptions = 209,
++	postNATSourceIPv4Address = 225,
++	postNATDestinationIPv4Address = 226,
++	postNAPTSourceTransportPort = 227,
++	postNAPTDestinationTransportPort = 228,
++	natEvent = 230,
++	postNATSourceIPv6Address = 281,
++	postNATDestinationIPv6Address = 282,
++	IPSecSPI = 295,
++	observationTimeMilliseconds = 323,
++	observationTimeMicroseconds = 324,
++	observationTimeNanoseconds = 325,
++};
++
++enum {
++	FLOWSET_TEMPLATE = 0,
++	FLOWSET_OPTIONS = 1,
++	IPFIX_TEMPLATE = 2,
++	IPFIX_OPTIONS = 3,
++	FLOWSET_DATA_FIRST = 256,
++};
++
++struct flowset_template {
++	__be16	flowset_id;
++	__be16	length;
++	__be16	template_id;
++	__be16	field_count;
++} __attribute__ ((packed));
++
++struct flowset_data {
++	__be16	flowset_id;
++	__be16	length;
++} __attribute__ ((packed));
++
++/* NetFlow v9 packet. */
++struct netflow9_pdu {
++	__be16		version;
++	__be16		nr_records;
++	__be32		sys_uptime_ms;
++	__be32		export_time_s;
++	__be32		seq;
++	__be32		source_id; /* Exporter Observation Domain */
++	__u8		data[1400];
++} __attribute__ ((packed));
++
++/* IPFIX packet. */
++struct ipfix_pdu {
++	__be16		version;
++	__be16		length;
++	__be32		export_time_s;
++	__be32		seq;
++	__be32		odomain_id; /* Observation Domain ID */
++	__u8		data[1400];
++} __attribute__ ((packed));
++
++/* Maximum bytes flow can have, after it's reached flow will become
++ * not searchable and will be exported soon. */
++#define FLOW_FULL_WATERMARK 0xffefffff
++
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
++union nf_inet_addr {
++	__be32          ip;
++	__be32          ip6[4];
++	struct in_addr  in;
++	struct in6_addr in6;
++};
++#endif
++
+ /* hashed data which identify unique flow */
++/* 16+16 + 2+2 + 2+1+1+1 = 41 */
+ struct ipt_netflow_tuple {
+-	__be32		s_addr;	// Network byte order
+-	__be32		d_addr; // -"-
+-	__be16		s_port; // -"-
++	union nf_inet_addr src;
++	union nf_inet_addr dst;
++	__be16		s_port; // Network byte order
+ 	__be16		d_port; // -"-
+-	__be16		i_ifc;	// Local byte order
++	__u16		i_ifc;	// Host byte order
+ 	__u8		protocol;
+ 	__u8		tos;
++	__u8		l3proto;
+ };
+-/* tuple size is rounded to u32s */
+-#define NETFLOW_TUPLE_SIZE (sizeof(struct ipt_netflow_tuple) / 4)
+-
+-/* maximum bytes flow can have, after it reached flow become not searchable and will be exported soon */
+-#define FLOW_FULL_WATERMARK 0xffefffff
+ 
+-/* flow entry */
++/* hlist[2] + tuple[]: 8+8 + 41 = 57 (less than usual cache line, 64) */
+ struct ipt_netflow {
+ 	struct hlist_node hlist; // hashtable search chain
+-	struct list_head list; // all flows chain
+ 
+ 	/* unique per flow data (hashed, NETFLOW_TUPLE_SIZE) */
+ 	struct ipt_netflow_tuple tuple;
+ 
+ 	/* volatile data */
+-	__be16		o_ifc;
++	union nf_inet_addr nh;
++	__u16		o_ifc;
+ 	__u8		s_mask;
+ 	__u8		d_mask;
++	__u8		tcp_flags; /* `OR' of all tcp flags */
+ 
+ 	/* flow statistics */
+ 	u_int32_t	nr_packets;
+ 	u_int32_t	nr_bytes;
+-	unsigned long	ts_first;
+-	unsigned long	ts_last;
+-	__u8		tcp_flags; /* `OR' of all tcp flags */
++	union {
++		struct {
++			unsigned long first;
++			unsigned long last;
++		} ts;
++		ktime_t	ts_obs;
++	} _ts_un;
++#define ts_first _ts_un.ts.first
++#define ts_last  _ts_un.ts.last
++#define ts_obs   _ts_un.ts_obs
++	u_int32_t	flow_label; /* IPv6 */
++	u_int32_t	options; /* IPv4(16) & IPv6(32) Options */
++	u_int32_t	tcpoptions;
++#ifdef CONFIG_NF_CONNTRACK_MARK
++	u_int32_t	mark; /* Exported as commonPropertiesId */
++#endif
++#ifdef CONFIG_NF_NAT_NEEDED
++	__be32		s_as;
++	__be32		d_as;
++	struct nat_event *nat;
++#endif
++	struct list_head list; // all flows chain
++	spinlock_t	*lock;
++};
++
++#ifdef CONFIG_NF_NAT_NEEDED
++enum {
++	NAT_CREATE, NAT_DESTROY, NAT_POOLEXHAUSTED
+ };
++struct nat_event {
++	struct list_head list;
++	struct {
++		__be32	s_addr;
++		__be32	d_addr;
++		__be16	s_port;
++		__be16	d_port;
++	} pre, post;
++	ktime_t		ts_ktime;
++	unsigned long	ts_jiffies;
++	__u8	protocol;
++	__u8	nat_event;
++};
++#define IS_DUMMY_FLOW(nf) (nf->nat)
++#else
++#define IS_DUMMY_FLOW(nf) 0
++#endif
+ 
+ static inline int ipt_netflow_tuple_equal(const struct ipt_netflow_tuple *t1,
+ 				    const struct ipt_netflow_tuple *t2)
+@@ -115,11 +258,13 @@ struct ipt_netflow_sock {
+ 	unsigned short port;
+ 	atomic_t wmem_peak;	// sk_wmem_alloc peak value
+ 	atomic_t err_full;	// socket filled error
++	atomic_t err_connect;	// connect errors
+ 	atomic_t err_other;	// other socket errors
+ };
+ 
+ struct netflow_aggr_n {
+ 	struct list_head list;
++	atomic_t usage;
+ 	__u32 mask;
+ 	__u32 addr;
+ 	__u32 aggr_mask;
+@@ -128,6 +273,7 @@ struct netflow_aggr_n {
+ 
+ struct netflow_aggr_p {
+ 	struct list_head list;
++	atomic_t usage;
+ 	__u16 port1;
+ 	__u16 port2;
+ 	__u16 aggr_port;
+diff --git a/libipt_NETFLOW.c b/libipt_NETFLOW.c
+index d85b6d9..a0f9e5d 100644
+--- a/libipt_NETFLOW.c
++++ b/libipt_NETFLOW.c
+@@ -58,24 +58,24 @@
+ #define _IPT_IP struct ipt_ip
+ #endif
+ 
++#ifndef IPTABLES_VERSION
++#define IPTABLES_VERSION XTABLES_VERSION
++#endif
++
+ static struct option opts[] = {
+-  {0}
++  { 0 }
+ };
+ 
+ static void help(void)
+ {
+-	printf( "NETFLOW target\n");
++	printf("NETFLOW target\n");
+ }
+ 
+-//static int parse(int c, char **argv, int invert, unsigned int *flags,
+-//      const _IPT_ENTRY *entry,
+-//      struct ipt_entry_target **target)
+ static int parse(int c, char **argv, int invert, unsigned int *flags,
+ 	     const _IPT_ENTRY  *entry,
+ 	     struct ipt_entry_target **targetinfo)
+ 
+ {
+-
+ 	return 1;
+ }
+ 
+@@ -95,16 +95,9 @@ static void print(const _IPT_IP *ip,
+ }
+ 
+ static struct iptables_target netflow = { 
+-#ifdef MOD140
+-	.family		= AF_INET,
+-#endif
+ 	.next		= NULL,
+ 	.name		= "NETFLOW",
+-#ifdef XTABLES_VERSION
+-	.version	= XTABLES_VERSION,
+-#else
+ 	.version	= IPTABLES_VERSION,
+-#endif
+ 	.size           = IPT_ALIGN(0),
+ 	.userspacesize  = IPT_ALIGN(0),
+ 	.help		= &help,
+diff --git a/murmur3.h b/murmur3.h
+new file mode 100644
+index 0000000..57a6006
+--- /dev/null
++++ b/murmur3.h
+@@ -0,0 +1,42 @@
++/* MurmurHash3, based on https://code.google.com/p/smhasher of Austin Appleby. */
++
++static __always_inline uint32_t rotl32(const uint32_t x, const int8_t r)
++{
++	return (x << r) | (x >> (32 - r));
++}
++
++static __always_inline uint32_t fmix32(register uint32_t h)
++{
++	h ^= h >> 16;
++	h *= 0x85ebca6b;
++	h ^= h >> 13;
++	h *= 0xc2b2ae35;
++	h ^= h >> 16;
++	return h;
++}
++
++static inline uint32_t murmur3(const void *key, const uint32_t len, const uint32_t seed)
++{
++	const uint32_t c1 = 0xcc9e2d51;
++	const uint32_t c2 = 0x1b873593;
++	const uint32_t *blocks;
++	const uint8_t *tail;
++	register uint32_t h1 = seed;
++	uint32_t k1 = 0;
++	uint32_t i;
++
++	blocks = (const uint32_t *)key;
++	for (i = len / 4; i; --i) {
++		h1 ^= rotl32(*blocks++ * c1, 15) * c2;
++		h1 = rotl32(h1, 13) * 5 + 0xe6546b64;
++	}
++	tail = (const uint8_t*)blocks;
++	switch (len & 3) {
++		case 3: k1 ^= tail[2] << 16;
++		case 2: k1 ^= tail[1] << 8;
++		case 1: k1 ^= tail[0];
++			h1 ^= rotl32(k1 * c1, 15) * c2;
++	}
++	return fmix32(h1^ len);
++}
++
+diff --git a/raw_promisc_debian_squeeze6.patch b/raw_promisc_debian_squeeze6.patch
+new file mode 100644
+index 0000000..69d0d35
+--- /dev/null
++++ b/raw_promisc_debian_squeeze6.patch
+@@ -0,0 +1,37 @@
++
++ Short manual and patch for Debian Squeeze
++ suggested by Pavel Odintsov:
++
++On Thu, Dec 27, 2012 at 07:46:30PM +0400, Pavel Odintsov wrote:
++>
++> краткий мануал для патчинга Debian Squeeze ядра патчем promisc.
++> 
++> cd /usr/src
++> apt-get install -y dpkg-dev
++> apt-get build-dep  linux-image-2.6.32-5-amd64
++> cd linux-2.6-2.6.32/
++> apt-get source  linux-image-2.6.32-5-amd64
++> 
++> wget .... /root/raw_promisc_debian_squeeze6.patch
++> patch -p1 < raw_promisc_debian_squeeze6.patch
++> Накладываем патчи дебияна:
++> debian/rules source
++> 
++> Запускаем сборку:
++> debian/rules binary
++> 
++
++diff -rupN linux-2.6-2.6.32/net/ipv4/ip_input.c linux-2.6-2.6.32_promisc_raw//net/ipv4/ip_input.c
++--- linux-2.6-2.6.32/net/ipv4/ip_input.c	2009-12-03 04:51:21.000000000 +0100
+++++ linux-2.6-2.6.32_promisc_raw//net/ipv4/ip_input.c	2012-06-25 19:13:49.000000000 +0200
++@@ -383,8 +383,8 @@ int ip_rcv(struct sk_buff *skb, struct n
++ 	/* When the interface is in promisc. mode, drop all the crap
++ 	 * that it receives, do not try to analyse it.
++ 	 */
++-	if (skb->pkt_type == PACKET_OTHERHOST)
++-		goto drop;
+++	//if (skb->pkt_type == PACKET_OTHERHOST)
+++	//	goto drop;
++ 
++ 
++ 	IP_UPD_PO_STATS_BH(dev_net(dev), IPSTATS_MIB_IN, skb->len);
diff --git a/testing/ipt-netflow/kernel-vs-userspace.patch b/testing/ipt-netflow/kernel-vs-userspace.patch
new file mode 100644
index 0000000000..8f9857fa8b
--- /dev/null
+++ b/testing/ipt-netflow/kernel-vs-userspace.patch
@@ -0,0 +1,56 @@
+diff --git a/configure b/configure
+index 3f10e2a..b43f024 100755
+--- a/configure
++++ b/configure
+@@ -256,6 +256,8 @@ do
+     --ipt-inc=*) IPTINC="$ac_optarg" ;;
+     --kver=*)  KVERSION="$ac_optarg" ;;
+     --kdir=*)      KDIR="$ac_optarg" ;;
++    --disable-kernel) NOKERNEL=1;;
++    --disable-ipt) NOIPT=1;;
+     --make) echo called from make ;;
+     --help) show_help ;;
+     -*) echo Invalid option: $ac_option; exit 1 ;;
+@@ -353,22 +355,26 @@ kernel_check_config() {
+   kconfig CONFIG_IP6_NF_IPTABLES	"ip6tables target"
+ }
+ 
+-kernel_find_version	#KVERSION
+-test "$KLIBMOD" || KLIBMOD=$KVERSION
+-echo "Kernel version: $KVERSION ($KHOW)"
+-kernel_find_source	#KDIR
+-echo "Kernel sources: $KDIR ($KSHOW)"
+-kernel_check_consistency
+-kernel_check_config
+-
+-test "$IPTBIN" || IPTBIN=`which iptables`
+-
+-iptables_find_version	#IPTVER
+-iptables_try_pkgconfig	#try to configure from pkg-config
+-iptables_find_src	#IPTSRC
+-iptables_src_version	#check that IPTSRC match to IPTVER
+-iptables_inc		#IPTINC
+-iptables_modules	#IPTLIB
++if ! test "$NOKERNEL"; then
++	kernel_find_version	#KVERSION
++	test "$KLIBMOD" || KLIBMOD=$KVERSION
++	echo "Kernel version: $KVERSION ($KHOW)"
++	kernel_find_source	#KDIR
++	echo "Kernel sources: $KDIR ($KSHOW)"
++	kernel_check_consistency
++	kernel_check_config
++fi
++
++if ! test "$NOIPT"; then
++	test "$IPTBIN" || IPTBIN=`which iptables`
++
++	iptables_find_version	#IPTVER
++	iptables_try_pkgconfig	#try to configure from pkg-config
++	iptables_find_src	#IPTSRC
++	iptables_src_version	#check that IPTSRC match to IPTVER
++	iptables_inc		#IPTINC
++	iptables_modules	#IPTLIB
++fi
+ 
+ REPLACE="\
+ s!@KVERSION@!$KVERSION!;\