Adding PROX(Packet pROcessing eXecution engine) VNF to sampleVNF

JIRA: SAMPLEVNF-55

PROX is a DPDK-based application implementing Telco use-cases such as
a simplified BRAS/BNG, light-weight AFTR... It also allows configuring
finer grained network functions like QoS, Routing, load-balancing...

(We are moving PROX version v039 to sampleVNF
https://01.org/intel-data-plane-performance-demonstrators/prox-overview)

Change-Id: Ia3cb02cf0e49ac5596e922c197ff7e010293d033
Signed-off-by: Deepak S <deepak.s@linux.intel.com>

363 files changed, 64275 insertions, 1 deletions

diff --git a/Makefile b/Makefile
index 7c14693f..bfe85c59 100644
--- a/Makefile
+++ b/Makefile
@@ -25,8 +25,9 @@ ACL          := $(VNF_DIR)/vACL
 FW           := $(VNF_DIR)/vFW
 CGNAPT       := $(VNF_DIR)/vCGNAPT
 UDP_Replay   := $(VNF_DIR)/UDP_Replay
+PROX         := $(VNF_DIR)/DPPD-PROX
 
-subdirs      := $(ACL) $(CGNAPT) $(FW) $(UDP_Replay)
+subdirs      := $(ACL) $(CGNAPT) $(FW) $(UDP_Replay) ${PROX}
 
 .PHONY: $(TARGETS) $(subdirs)
 
diff --git a/VNFs/DPPD-PROX/LICENSE.ALv2 b/VNFs/DPPD-PROX/LICENSE.ALv2
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/VNFs/DPPD-PROX/LICENSE.ALv2
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/VNFs/DPPD-PROX/Makefile b/VNFs/DPPD-PROX/Makefile
new file mode 100644
index 00000000..0288181c
--- /dev/null
+++ b/VNFs/DPPD-PROX/Makefile
@@ -0,0 +1,204 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+ifeq ($(RTE_SDK),)
+$(error "Please define RTE_SDK environment variable")
+endif
+
+# Default target, can be overriden by command line or environment
+RTE_TARGET ?= x86_64-native-linuxapp-gcc
+
+rte_version_h := $(RTE_SDK)/$(RTE_TARGET)/include/rte_version.h
+rte_ver_part = $(shell sed -n -e 's/^\#define\s*$1\s*\(.*\)$$/\1/p' $(rte_version_h))
+rte_ver_eval = $(shell printf '%u' $$(printf '0x%02x%02x%02x%02x' $1 $2 $3 $4))
+rte_ver_MMLR = $(call rte_ver_eval,$(call \
+	rte_ver_part,RTE_VER_MAJOR),$(call \
+	rte_ver_part,RTE_VER_MINOR),$(call \
+	rte_ver_part,RTE_VER_PATCH_LEVEL),$(call \
+	rte_ver_part,RTE_VER_PATCH_RELEASE))
+rte_ver_YMMR = $(call rte_ver_eval,$(call \
+	rte_ver_part,RTE_VER_YEAR),$(call \
+	rte_ver_part,RTE_VER_MONTH),$(call \
+	rte_ver_part,RTE_VER_MINOR),$(call \
+	rte_ver_part,RTE_VER_RELEASE))
+rte_ver_dpdk := $(if $(call rte_ver_part,RTE_VER_MAJOR),$(rte_ver_MMLR),$(rte_ver_YMMR))
+rte_ver_comp = $(shell test $(rte_ver_dpdk) $5 $(call rte_ver_eval,$1,$2,$3,$4) && echo 'y')
+rte_ver_EQ = $(call rte_ver_comp,$1,$2,$3,$4,-eq)
+rte_ver_NE = $(call rte_ver_comp,$1,$2,$3,$4,-ne)
+rte_ver_GT = $(call rte_ver_comp,$1,$2,$3,$4,-gt)
+rte_ver_LT = $(call rte_ver_comp,$1,$2,$3,$4,-lt)
+rte_ver_GE = $(call rte_ver_comp,$1,$2,$3,$4,-ge)
+rte_ver_LE = $(call rte_ver_comp,$1,$2,$3,$4,-le)
+
+include $(RTE_SDK)/mk/rte.vars.mk
+
+# binary name
+APP = prox
+CFLAGS += -DPROGRAM_NAME=\"$(APP)\"
+
+CFLAGS += -O2 -g
+CFLAGS += -fno-stack-protector -Wno-deprecated-declarations
+
+ifeq ($(BNG_QINQ),)
+CFLAGS += -DUSE_QINQ
+else ifeq ($(BNG_QINQ),y)
+CFLAGS += -DUSE_QINQ
+endif
+
+ifeq ($(MPLS_ROUTING),)
+CFLAGS += -DMPLS_ROUTING
+else ifeq ($(MPLS_ROUTING),y)
+CFLAGS += -DMPLS_ROUTING
+endif
+
+LD_LUA  = $(shell pkg-config --silence-errors --libs-only-l lua)
+CFLAGS += $(shell pkg-config --silence-errors --cflags lua)
+ifeq ($(LD_LUA),)
+LD_LUA  = $(shell pkg-config --silence-errors --libs-only-l lua5.2)
+CFLAGS += $(shell pkg-config --silence-errors --cflags lua5.2)
+ifeq ($(LD_LUA),)
+LD_LUA  = $(shell pkg-config --silence-errors --libs-only-l lua5.3)
+CFLAGS += $(shell pkg-config --silence-errors --cflags lua5.3)
+ifeq ($(LD_LUA),)
+LD_LUA =-llua
+endif
+endif
+endif
+
+LD_TINFO = $(shell pkg-config --silence-errors --libs-only-l tinfo)
+LDFLAGS += -lpcap $(LD_TINFO) $(LD_LUA)
+LDFLAGS += -lncurses -lncursesw -ledit
+
+PROX_STATS ?= y
+ifeq ($(PROX_STATS),y)
+CFLAGS += -DPROX_STATS
+endif
+
+ifeq ($(DPI_STATS),y)
+CFLAGS += -DDPI_STATS
+endif
+
+ifeq ($(HW_DIRECT_STATS),y)
+CFLAGS += -DPROX_HW_DIRECT_STATS
+endif
+
+ifeq ($(dbg),y)
+EXTRA_CFLAGS += -ggdb
+endif
+
+ifeq ($(log),)
+CFLAGS += -DPROX_MAX_LOG_LVL=2
+else
+CFLAGS += -DPROX_MAX_LOG_LVL=$(log)
+endif
+
+# override any use-case/enviroment specific choices regarding crc and
+# always use the sw implementation
+ifeq ($(crc),soft)
+CFLAGS += -DSOFT_CRC
+endif
+
+CFLAGS += -DPROX_PREFETCH_OFFSET=2
+#CFLAGS += -DBRAS_RX_BULK
+#CFLAGS += -DASSERT
+#CFLAGS += -DENABLE_EXTRA_USER_STATISTICS
+CFLAGS += -DLATENCY_PER_PACKET
+CFLAGS += -DLATENCY_DETAILS
+CFLAGS += -DGRE_TP
+CFLAGS += -std=gnu99
+CFLAGS += -D_GNU_SOURCE                # for PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+CFLAGS += $(WERROR_FLAGS)
+CFLAGS += -Wno-unused
+CFLAGS += -Wno-unused-parameter
+CFLAGS += -Wno-unused-result
+
+# all source are stored in SRCS-y
+
+SRCS-y := task_init.c
+
+SRCS-y += handle_aggregator.c
+SRCS-y += handle_nop.c
+SRCS-y += handle_irq.c
+SRCS-y += handle_arp.c
+SRCS-y += handle_impair.c
+SRCS-y += handle_lat.c
+SRCS-y += handle_qos.c
+SRCS-y += handle_qinq_decap4.c
+SRCS-y += handle_routing.c
+SRCS-y += handle_untag.c
+SRCS-y += handle_mplstag.c
+SRCS-y += handle_qinq_decap6.c
+
+# support for GRE encap/decap dropped in latest DPDK versions
+SRCS-$(call rte_ver_LT,2,1,0,0) += handle_gre_decap_encap.c
+
+SRCS-y += rw_reg.c
+SRCS-y += handle_lb_qinq.c
+SRCS-y += handle_lb_pos.c
+SRCS-y += handle_lb_net.c
+SRCS-y += handle_qinq_encap4.c
+SRCS-y += handle_qinq_encap6.c
+SRCS-y += handle_classify.c
+SRCS-y += handle_l2fwd.c
+SRCS-y += handle_swap.c
+SRCS-y += handle_police.c
+SRCS-y += handle_acl.c
+SRCS-y += handle_gen.c
+SRCS-y += handle_mirror.c
+SRCS-y += handle_genl4.c
+SRCS-y += handle_ipv6_tunnel.c
+SRCS-y += handle_read.c
+SRCS-y += handle_cgnat.c
+SRCS-y += handle_nat.c
+SRCS-y += handle_dump.c
+SRCS-y += handle_tsc.c
+SRCS-y += handle_fm.c
+SRCS-$(call rte_ver_GE,1,8,0,16) += handle_nsh.c
+SRCS-y += handle_lb_5tuple.c
+SRCS-y += handle_blockudp.c
+SRCS-y += toeplitz.c
+SRCS-$(CONFIG_RTE_LIBRTE_PIPELINE) += handle_pf_acl.c
+
+SRCS-y += thread_nop.c
+SRCS-y += thread_generic.c
+SRCS-$(CONFIG_RTE_LIBRTE_PIPELINE) += thread_pipeline.c
+
+SRCS-y += prox_args.c prox_cfg.c prox_cksum.c prox_port_cfg.c
+
+SRCS-y += cfgfile.c clock.c commands.c cqm.c msr.c defaults.c
+SRCS-y += display.c display_latency.c display_mempools.c
+SRCS-y += display_ports.c display_rings.c display_priority.c display_pkt_len.c display_l4gen.c display_tasks.c
+SRCS-y += log.c hash_utils.c main.c parse_utils.c file_utils.c
+SRCS-y += run.c input_conn.c input_curses.c
+SRCS-y += rx_pkt.c lconf.c tx_pkt.c expire_cpe.c ip_subnet.c
+SRCS-y += stats_port.c stats_mempool.c stats_ring.c stats_l4gen.c
+SRCS-y += stats_latency.c stats_global.c stats_core.c stats_task.c stats_prio.c
+SRCS-y += cmd_parser.c input.c prox_shared.c prox_lua_types.c
+SRCS-y += genl4_bundle.c heap.c genl4_stream_tcp.c genl4_stream_udp.c cdf.c
+SRCS-y += stats.c stats_cons_log.c stats_cons_cli.c stats_parser.c hash_set.c prox_lua.c prox_malloc.c
+
+ifeq ($(FIRST_PROX_MAKE),)
+MAKEFLAGS += --no-print-directory
+FIRST_PROX_MAKE = 1
+export FIRST_PROX_MAKE
+all:
+	@./helper-scripts/trailing.sh
+	@$(MAKE) $@
+%::
+	@$(MAKE) $@
+else
+include $(RTE_SDK)/mk/rte.extapp.mk
+endif
diff --git a/VNFs/DPPD-PROX/README b/VNFs/DPPD-PROX/README
new file mode 100644
index 00000000..a09873cd
--- /dev/null
+++ b/VNFs/DPPD-PROX/README
@@ -0,0 +1,117 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+Description
+-----------
+This is PROX, the Packet pROcessing eXecution engine, part of Intel(R)
+Data Plane Performance Demonstrators, and formerly known as DPPD-BNG.
+PROX is a DPDK-based application implementing Telco use-cases such as
+a simplified BRAS/BNG, light-weight AFTR... It also allows configuring
+finer grained network functions like QoS, Routing, load-balancing...
+
+Compiling and running this application
+--------------------------------------
+This application supports DPDK 16.04, 16.11, 16.11.1, 17.02 and 17.05.
+The following commands assume that the following variables have been set:
+
+export RTE_SDK=/path/to/dpdk
+export RTE_TARGET=x86_64-native-linuxapp-gcc
+
+Example: DPDK 17.05 installation
+--------------------------------
+git clone http://dpdk.org/git/dpdk
+cd dpdk
+git checkout v17.05
+make install T=$RTE_TARGET
+
+PROX compilation
+----------------
+The Makefile with this application expects RTE_SDK to point to the
+root directory of DPDK (e.g. export RTE_SDK=/root/dpdk). If RTE_TARGET
+has not been set, x86_64-native-linuxapp-gcc will be assumed.
+
+Running PROX
+------------
+After DPDK has been set up, run make from the directory where you have
+extracted this application. A build directory will be created
+containing the PROX executable. The usage of the application is shown
+below. Note that this application assumes that all required ports have
+been bound to the DPDK provided igb_uio driver. Refer to the "Getting
+Started Guide - DPDK" document for more details.
+
+Usage: ./build/prox [-f CONFIG_FILE] [-l LOG_FILE] [-p] [-o DISPLAY] [-v] [-a|-e] \
+		[-m|-s|-i] [-n] [-w DEF] [-q] [-k] [-d] [-z] [-r VAL] [-u] [-t]
+        -f CONFIG_FILE : configuration file to load, ./prox.cfg by default
+        -l LOG_FILE : log file name, ./prox.log by default
+        -p : include PID in log file name if default log file is used
+        -o DISPLAY: Set display to use, can be 'curses' (default), 'cli' or 'none'
+        -v verbosity : initial logging verbosity
+        -a : autostart all cores (by default)
+        -e : don't autostart
+        -n : Create NULL devices instead of using PCI devices, useful together with -i
+        -m : list supported task modes and exit
+        -s : check configuration file syntax and exit
+        -i : check initialization sequence and exit
+        -u : Listen on UDS /tmp/prox.sock
+        -t : Listen on TCP port 8474
+        -q : Pass argument to Lua interpreter, useful to define variables
+        -w : define variable using syntax varname=value
+             takes precedence over variables defined in CONFIG_FILE
+        -k : Log statistics to file "stats_dump" in current directory
+        -d : Run as daemon, the parent process will block until PROX is not initialized
+        -z : Ignore CPU topology, implies -i
+        -r : Change initial screen refresh rate. If set to a lower than 0.001 seconds,
+                  screen refreshing will be disabled
+
+While applications using DPDK typically rely on the core mask and the
+number of channels to be specified on the command line, this
+application is configured using a .cfg file. The core mask and number
+of channels is derived from this config. For example, to run the
+application from the source directory execute:
+
+  user@target:~$ ./build/prox -f ./config/nop.cfg
+
+Provided example configurations
+-------------------------------
+PROX can be configured either as the SUT (System Under Test) or as the
+Traffic Generator. Some example configuration files are provided, both
+in the config directory to run PROX as a SUT, and in the gen directory
+to run it as a Traffic Generator.
+A quick description of these example configurations is provided below.
+Additional details are provided in the example configuration files.
+
+Basic configurations, mostly used as sanity check:
+- config/nop.cfg
+- config/nop-rings.cfg
+- gen/nop-gen.cfg
+
+Simplified BNG (Border Network Gateway) configurations, using different
+number of ports, with and without QoS, running on the host or in a VM:
+- config/bng-4ports.cfg
+- config/bng-8ports.cfg
+- config/bng-qos-4ports.cfg
+- config/bng-qos-8ports.cfg
+- config/bng-1q-4ports.cfg
+- config/bng-ovs-usv-4ports.cfg
+- config/bng-no-cpu-topology-4ports.cfg
+- gen/bng-4ports-gen.cfg
+- gen/bng-8ports-gen.cfg
+- gen/bng-ovs-usv-4ports-gen.cfg
+
+Light-weight AFTR configurations:
+- config/lw_aftr.cfg
+- gen/lw_aftr-gen.cfg
+
diff --git a/VNFs/DPPD-PROX/acl_field_def.h b/VNFs/DPPD-PROX/acl_field_def.h
new file mode 100644
index 00000000..ede5bea7
--- /dev/null
+++ b/VNFs/DPPD-PROX/acl_field_def.h
@@ -0,0 +1,152 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _ACL_FIELD_DEF_H_
+#define _ACL_FIELD_DEF_H_
+
+#include <rte_ether.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#include "qinq.h"
+
+struct pkt_eth_ipv4_udp {
+	struct ether_hdr ether_hdr;
+	struct ipv4_hdr ipv4_hdr;
+	struct udp_hdr udp_hdr;
+} __attribute__((packed));
+
+static struct rte_acl_field_def pkt_eth_ipv4_udp_defs[] = {
+	/* first input field - always one byte long. */
+	{
+		.type = RTE_ACL_FIELD_TYPE_BITMASK,
+		.size = sizeof (uint8_t),
+		.field_index = 0,
+		.input_index = 0,
+		.offset = offsetof (struct pkt_eth_ipv4_udp, ipv4_hdr.next_proto_id),
+	},
+	/* IPv4 source address. */
+	{
+		.type = RTE_ACL_FIELD_TYPE_MASK,
+		.size = sizeof (uint32_t),
+		.field_index = 1,
+		.input_index = 1,
+		.offset = offsetof (struct pkt_eth_ipv4_udp, ipv4_hdr.src_addr),
+	},
+	/* IPv4 destination address */
+	{
+		.type = RTE_ACL_FIELD_TYPE_MASK,
+		.size = sizeof (uint32_t),
+		.field_index = 2,
+		.input_index = 2,
+		.offset = offsetof (struct pkt_eth_ipv4_udp, ipv4_hdr.dst_addr),
+	},
+	/* (L4 src/dst port) - 4 consecutive bytes. */
+	{
+		.type = RTE_ACL_FIELD_TYPE_RANGE,
+		.size = sizeof (uint16_t),
+		.field_index = 3,
+		.input_index = 3,
+		.offset = offsetof (struct pkt_eth_ipv4_udp, udp_hdr.src_port),
+	},
+	{
+		.type = RTE_ACL_FIELD_TYPE_RANGE,
+		.size = sizeof (uint16_t),
+		.field_index = 4,
+		.input_index = 3,
+		.offset = offsetof (struct pkt_eth_ipv4_udp, udp_hdr.dst_port),
+	},
+};
+
+struct pkt_qinq_ipv4_udp {
+	struct qinq_hdr qinq_hdr;
+	struct ipv4_hdr ipv4_hdr;
+	struct udp_hdr udp_hdr;
+};
+
+static struct rte_acl_field_def pkt_qinq_ipv4_udp_defs[] = {
+	/* first input field - always one byte long. */
+	{
+		.type = RTE_ACL_FIELD_TYPE_BITMASK,
+		.size = sizeof (uint8_t),
+		.field_index = 0,
+		.input_index = 0,
+		.offset = offsetof (struct pkt_qinq_ipv4_udp, ipv4_hdr.next_proto_id),
+	},
+	/* IPv4 source address. */
+	{
+		.type = RTE_ACL_FIELD_TYPE_MASK,
+		.size = sizeof (uint32_t),
+		.field_index = 1,
+		.input_index = 1,
+		.offset = offsetof (struct pkt_qinq_ipv4_udp, ipv4_hdr.src_addr),
+	},
+	/* IPv4 destination address */
+	{
+		.type = RTE_ACL_FIELD_TYPE_MASK,
+		.size = sizeof (uint32_t),
+		.field_index = 2,
+		.input_index = 2,
+		.offset = offsetof (struct pkt_qinq_ipv4_udp, ipv4_hdr.dst_addr),
+	},
+	/* (L4 src/dst port) - 4 consecutive bytes. */
+	{
+		.type = RTE_ACL_FIELD_TYPE_RANGE,
+		.size = sizeof (uint16_t),
+		.field_index = 3,
+		.input_index = 3,
+		.offset = offsetof (struct pkt_qinq_ipv4_udp, udp_hdr.src_port),
+	},
+	{
+		.type = RTE_ACL_FIELD_TYPE_RANGE,
+		.size = sizeof (uint16_t),
+		.field_index = 4,
+		.input_index = 3,
+		.offset = offsetof (struct pkt_qinq_ipv4_udp, udp_hdr.dst_port),
+	},
+	/* (SVLAN id + eth type) - 4 consecutive bytes. */
+	{
+		.type = RTE_ACL_FIELD_TYPE_BITMASK,
+		.size = sizeof(uint16_t),
+		.field_index = 5,
+		.input_index = 4,
+		.offset = offsetof (struct pkt_qinq_ipv4_udp, qinq_hdr.svlan.eth_proto),
+	},
+	{
+		.type = RTE_ACL_FIELD_TYPE_BITMASK,
+		.size = sizeof(uint16_t),
+		.field_index = 6,
+		.input_index = 4,
+		.offset = offsetof (struct pkt_qinq_ipv4_udp, qinq_hdr.svlan.vlan_tci),
+	},
+	/* (CVLAN id + eth type) - 4 consecutive byates. */
+	{
+		.type = RTE_ACL_FIELD_TYPE_BITMASK,
+		.size = sizeof(uint16_t),
+		.field_index = 7,
+		.input_index = 5,
+		.offset = offsetof (struct pkt_qinq_ipv4_udp, qinq_hdr.cvlan.eth_proto),
+	},
+	{
+		.type = RTE_ACL_FIELD_TYPE_BITMASK,
+		.size = sizeof(uint16_t),
+		.field_index = 8,
+		.input_index = 5,
+		.offset = offsetof (struct pkt_qinq_ipv4_udp, qinq_hdr.cvlan.vlan_tci),
+	},
+};
+
+#endif /* _ACL_FIELD_DEF_H_ */
diff --git a/VNFs/DPPD-PROX/arp.h b/VNFs/DPPD-PROX/arp.h
new file mode 100644
index 00000000..279bdada
--- /dev/null
+++ b/VNFs/DPPD-PROX/arp.h
@@ -0,0 +1,72 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _ARP_H_
+#define _ARP_H_
+
+#include <rte_ether.h>
+
+#define ARP_REQUEST	0x100
+#define ARP_REPLY	0x200
+
+struct _arp_ipv4 {
+	struct ether_addr sha; /* Sender hardware address */
+	uint32_t spa;          /* Sender protocol address */
+	struct ether_addr tha; /* Target hardware address */
+	uint32_t tpa;          /* Target protocol address */
+} __attribute__((__packed__));
+typedef struct _arp_ipv4 arp_ipv4_t;
+
+struct my_arp_t {
+	uint16_t   htype;
+	uint16_t   ptype;
+	uint8_t    hlen;
+	uint8_t    plen;
+	uint16_t   oper;
+	arp_ipv4_t data;
+} __attribute__((__packed__));
+
+struct ether_hdr_arp {
+	struct ether_hdr ether_hdr;
+	struct my_arp_t arp;
+};
+
+static int arp_is_gratuitous(struct ether_hdr_arp *hdr)
+{
+	return hdr->arp.data.spa == hdr->arp.data.tpa;
+}
+
+static inline void prepare_arp_reply(struct ether_hdr_arp *hdr_arp, struct ether_addr *s_addr)
+{
+	uint32_t ip_source = hdr_arp->arp.data.spa;
+
+	hdr_arp->arp.data.spa = hdr_arp->arp.data.tpa;
+	hdr_arp->arp.data.tpa = ip_source;
+	hdr_arp->arp.oper = 0x200;
+	memcpy(&hdr_arp->arp.data.tha, &hdr_arp->arp.data.sha, sizeof(struct ether_addr));
+	memcpy(&hdr_arp->arp.data.sha, s_addr, sizeof(struct ether_addr));
+}
+
+static void create_mac(struct ether_hdr_arp *hdr, struct ether_addr *addr)
+{
+        addr->addr_bytes[0] = 0x2;
+        addr->addr_bytes[1] = 0;
+        // Instead of sending a completely random MAC address, create the following MAC:
+        // 02:00:x1:x2:x3:x4 where x1:x2:x3:x4 is the IP address
+        memcpy(addr->addr_bytes + 2, (uint32_t *)&hdr->arp.data.tpa, 4);
+}
+
+#endif /* _ARP_H_ */
diff --git a/VNFs/DPPD-PROX/bng_pkts.h b/VNFs/DPPD-PROX/bng_pkts.h
new file mode 100644
index 00000000..82e6199c
--- /dev/null
+++ b/VNFs/DPPD-PROX/bng_pkts.h
@@ -0,0 +1,114 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _BNG_PKTS_H_
+#define _BNG_PKTS_H_
+
+#include <rte_ether.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+#include <rte_byteorder.h>
+
+#include "gre.h"
+#include "mpls.h"
+#include "qinq.h"
+#include "arp.h"
+#include "hash_entry_types.h"
+
+struct cpe_pkt {
+#ifdef USE_QINQ
+	struct qinq_hdr qinq_hdr;
+#else
+	struct ether_hdr ether_hdr;
+#endif
+	struct ipv4_hdr ipv4_hdr;
+	struct udp_hdr udp_hdr;
+} __attribute__((packed));
+
+struct cpe_packet_arp {
+	struct qinq_hdr qinq_hdr;
+	struct my_arp_t arp;
+} __attribute__((packed));
+
+/* Struct used for setting all the values a packet
+   going to the core netwerk. Payload may follow
+   after the headers, but no need to touch that. */
+struct core_net_pkt_m {
+	struct ether_hdr ether_hdr;
+#ifdef MPLS_ROUTING
+	union {
+		struct mpls_hdr mpls;
+		uint32_t mpls_bytes;
+	};
+#endif
+	struct ipv4_hdr tunnel_ip_hdr;
+	struct gre_hdr gre_hdr;
+	struct ipv4_hdr ip_hdr;
+	struct udp_hdr udp_hdr;
+} __attribute__((packed));
+
+struct core_net_pkt {
+	struct ether_hdr ether_hdr;
+	struct ipv4_hdr tunnel_ip_hdr;
+	struct gre_hdr gre_hdr;
+	struct ipv4_hdr ip_hdr;
+	struct udp_hdr udp_hdr;
+} __attribute__((packed));
+
+#define UPSTREAM_DELTA   ((uint32_t)(sizeof(struct core_net_pkt) - sizeof(struct cpe_pkt)))
+#define DOWNSTREAM_DELTA ((uint32_t)(sizeof(struct core_net_pkt_m) - sizeof(struct cpe_pkt)))
+
+struct cpe_pkt_delta {
+	uint8_t encap[DOWNSTREAM_DELTA];
+	struct cpe_pkt pkt;
+} __attribute__((packed));
+
+static inline void extract_key_cpe(struct rte_mbuf *mbuf, uint64_t* key)
+{
+	uint8_t* packet = rte_pktmbuf_mtod(mbuf, uint8_t*);
+#ifdef USE_QINQ
+	*key = (*(uint64_t *)(packet + 12)) & 0xFF0FFFFFFF0FFFFF;
+#else
+	*key = rte_bswap32(*(uint32_t *)(packet + 26)) & 0x00FFFFFF;
+#endif
+}
+
+static inline void key_core(struct gre_hdr* gre, __attribute__((unused)) struct ipv4_hdr* ip, uint64_t* key)
+{
+	struct cpe_key *cpe_key = (struct cpe_key*)key;
+
+	cpe_key->gre_id = rte_be_to_cpu_32(gre->gre_id) & 0xFFFFFFF;
+
+#ifdef USE_QINQ
+	cpe_key->ip = ip->dst_addr;
+#else
+	cpe_key->ip = 0;
+#endif
+}
+
+static inline void extract_key_core(struct rte_mbuf *mbuf, uint64_t* key)
+{
+	struct core_net_pkt *packet = rte_pktmbuf_mtod(mbuf, struct core_net_pkt *);
+	key_core(&packet->gre_hdr, &packet->ip_hdr, key);
+}
+
+static inline void extract_key_core_m(struct rte_mbuf *mbuf, uint64_t* key)
+{
+	struct core_net_pkt_m *packet = rte_pktmbuf_mtod(mbuf, struct core_net_pkt_m *);
+	key_core(&packet->gre_hdr, &packet->ip_hdr, key);
+}
+
+#endif /* _BNG_PKTS_H_ */
diff --git a/VNFs/DPPD-PROX/cdf.c b/VNFs/DPPD-PROX/cdf.c
new file mode 100644
index 00000000..1de40314
--- /dev/null
+++ b/VNFs/DPPD-PROX/cdf.c
@@ -0,0 +1,148 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <stdlib.h>
+#include <inttypes.h>
+
+#include <rte_cycles.h>
+
+#include "prox_malloc.h"
+#include "cdf.h"
+
+static uint32_t round_pow2(uint32_t val)
+{
+	uint32_t ret;
+	uint32_t s = 1 << 31;
+
+	while ((s & val) == 0)
+		s = s >> 1;
+	if (s == 1U << 31 && s != val)
+		return 0;
+
+	ret = val;
+	if (s != ret)
+		ret = (s << 1);
+
+	return ret;
+}
+
+static uint32_t get_r_max(struct cdf *cdf, uint32_t cur)
+{
+	uint32_t right_child = cur;
+
+	do {
+		cur = right_child;
+		right_child = cur * 2 + 1;
+	} while (right_child < cdf->elems[0]);
+
+	return cdf->elems[cur];
+}
+
+struct cdf *cdf_create(uint32_t n_vals, int socket_id)
+{
+	struct cdf *ret;
+	size_t mem_size = 0;
+	uint32_t n_vals_round = round_pow2(n_vals);
+
+	if (0 == n_vals_round)
+		return NULL;
+
+	mem_size += sizeof(struct cdf);
+	mem_size += sizeof(((struct cdf *)(0))->elems[0]) * n_vals_round * 2;
+	ret = prox_zmalloc(mem_size, socket_id);
+	ret->elems[0] = n_vals;
+
+	/* leafs are [n_vals, 2 * n_vals[. During cdf_add() and
+	   cdf_setup(), rand_max refers to the index of the next leaf
+	   to be added.  */
+	ret->rand_max = n_vals_round;
+	ret->first_child = n_vals_round;
+	ret->seed = rte_rdtsc();
+
+	return ret;
+}
+
+void cdf_add(struct cdf *cdf, uint32_t len)
+{
+	cdf->elems[cdf->rand_max++] = len;
+}
+
+int cdf_setup(struct cdf *cdf)
+{
+	uint32_t last_leaf, first_leaf;
+	uint32_t first_parent, last_parent;
+	uint32_t total, multiplier, cur, end;
+
+	if (cdf->elems[0] == 1) {
+		cdf->rand_max = RAND_MAX;
+		cdf->elems[1] = RAND_MAX;
+		cdf->elems[0] = 2;
+		return 0;
+	}
+
+	last_leaf  = cdf->rand_max;
+	first_leaf = round_pow2(cdf->elems[0]);
+	/* Failed to add all elements through cdf_add() */
+	if (last_leaf - first_leaf != cdf->elems[0])
+		return -1;
+
+	total = 0;
+	for (uint32_t i = first_leaf; i < last_leaf; ++i) {
+		total += cdf->elems[i];
+	}
+
+	multiplier = RAND_MAX / total;
+	if (multiplier * total == RAND_MAX)
+		multiplier--;
+	cdf->rand_max = multiplier * total;
+	total = 0;
+	for (uint32_t i = first_leaf; i < last_leaf; ++i) {
+		uint32_t cur = cdf->elems[i];
+
+		/* Each element represents the range between previous
+		   total (non-inclusive) and new total (inclusive). */
+		total += cur * multiplier - 1;
+		cdf->elems[i] = total;
+		total += 1;
+	}
+	end = round_pow2(first_leaf) << 1;
+	for (uint32_t i = last_leaf; i < end; ++i) {
+		cdf->elems[i] = RAND_MAX;
+	}
+	cdf->first_child = first_leaf;
+	cdf->elems[0] = end;
+
+	/* Build the binary tree used at run-time. */
+	last_leaf = end - 1;
+	do {
+		first_parent = first_leaf/2;
+		last_parent  = last_leaf/2;
+
+		for (uint32_t i = first_parent; i <= last_parent; ++i) {
+			/* The current nodes value should be the
+			   biggest value accessible through its left
+			   child. This value is stored in the right
+			   most child of the left child. The left most
+			   child of the right child is the first value
+			   that can not be accessed through the left
+			   child.  */
+			cdf->elems[i] = get_r_max(cdf, i * 2);
+		}
+		first_leaf = first_parent;
+		last_leaf = last_parent;
+	} while (first_parent != last_parent);
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/cdf.h b/VNFs/DPPD-PROX/cdf.h
new file mode 100644
index 00000000..821c71bf
--- /dev/null
+++ b/VNFs/DPPD-PROX/cdf.h
@@ -0,0 +1,49 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+struct cdf {
+	uint32_t rand_max;
+	uint32_t seed;
+	uint32_t first_child;
+	uint32_t elems[0];
+};
+
+struct cdf *cdf_create(uint32_t n_vals, int socket_id);
+void cdf_add(struct cdf *cdf, uint32_t len);
+int cdf_setup(struct cdf *cdf);
+
+static uint32_t cdf_sample(struct cdf *cdf)
+{
+	uint32_t left_child, right_child;
+	uint32_t rand;
+
+	do {
+		rand = rand_r(&cdf->seed);
+	} while (rand > cdf->rand_max);
+
+	uint32_t cur = 1;
+
+	while (1) {
+		left_child = cur * 2;
+		right_child = cur * 2 + 1;
+		if (right_child < cdf->elems[0])
+			cur = rand > cdf->elems[cur]? right_child : left_child;
+		else if (left_child < cdf->elems[0])
+			cur = left_child;
+		else
+			return cur - cdf->first_child;
+	}
+}
diff --git a/VNFs/DPPD-PROX/cfgfile.c b/VNFs/DPPD-PROX/cfgfile.c
new file mode 100644
index 00000000..80a90937
--- /dev/null
+++ b/VNFs/DPPD-PROX/cfgfile.c
@@ -0,0 +1,339 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "cfgfile.h"
+
+#include <rte_string_fns.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include "parse_utils.h"
+#include "log.h"
+#include "quit.h"
+
+#define UINT32_MAX_STR "4294967295"
+
+/*
+ * Allocate cfg_file structure.
+ * Returns pointer to the allocated structure, NULL otherwise.
+ */
+struct cfg_file *cfg_open(const char *cfg_name)
+{
+	if (cfg_name == NULL) {
+		plog_err("\tNo config file name provided\n");
+		return NULL;
+	}
+	if (access(cfg_name, F_OK)) {
+                plog_err("\tError opening config file '%s': %s\n", cfg_name, strerror(errno));
+		return NULL;
+	}
+
+	FILE *pf = fopen(cfg_name, "rb");
+	if (pf == NULL) {
+		plog_err("\tError opening config file '%s'\n", cfg_name);
+		return NULL;
+	}
+
+	struct cfg_file *pcfg = calloc(1, sizeof(struct cfg_file));
+
+	if (pcfg == NULL) {
+		fclose(pf);
+		plog_err("\tCouldn't allocate memory for config file struct\n");
+		return NULL;
+	}
+
+	pcfg->pfile = pf;
+	pcfg->name = strdup(cfg_name);
+
+	return pcfg;
+}
+
+/* Free memory allocated for cfg_file structure.
+ * Returns 0 on success, -1 if the pointer to the pcfg is invalid */
+int cfg_close(struct cfg_file *pcfg)
+{
+	if (pcfg == NULL) {
+		return -1;
+	}
+
+	if (pcfg->name != NULL) {
+		free(pcfg->name);
+	}
+	if (pcfg->err_section != NULL) {
+		free(pcfg->err_section);
+	}
+	if (pcfg->pfile != NULL) {
+		fclose(pcfg->pfile);
+	}
+
+	free(pcfg);
+	return 0;
+}
+
+static int cfg_get_pos(struct cfg_file *pcfg, fpos_t *pos)
+{
+	pcfg->index_line = pcfg->line;
+	return fgetpos(pcfg->pfile, pos);
+}
+
+static int cfg_set_pos(struct cfg_file *pcfg, fpos_t *pos)
+{
+	pcfg->line = pcfg->index_line;
+	return fsetpos(pcfg->pfile, pos);
+}
+
+/*
+ * Read a line from the configuration file.
+ * Returns: on success length of the line read from the file is returned,
+ *          0 to indicate End of File,
+ *         -1 in case of wrong function parameters
+ */
+static int cfg_get_line(struct cfg_file *pcfg, char *buffer, unsigned len, int raw_lines)
+{
+	char *ptr;
+
+	if (pcfg == NULL || pcfg->pfile == NULL || buffer == NULL || len == 0) {
+		return -1;
+	}
+
+	do {
+		ptr = fgets(buffer, len, pcfg->pfile);
+		if (ptr == NULL) {
+			return 0; /* end of file */
+		}
+		++pcfg->line;
+
+		if (raw_lines) {
+			break;
+		}
+
+		/* remove comments */
+		ptr = strchr(buffer, ';');
+		if (ptr != NULL) {
+			*ptr = '\0';
+		}
+		else {
+			ptr = strchr(buffer, '\0');
+		}
+
+		/* remove trailing spaces */
+		if (ptr != buffer) {
+			ptr--;
+			while (isspace(*ptr)) {
+				*ptr = '\0';
+				ptr--;
+			}
+		}
+
+		ptr = buffer;
+		/* remove leading spaces */
+		while (*ptr && isspace(*ptr)) {
+			++ptr;
+		}
+		if (ptr != buffer) {
+			strcpy(buffer, ptr);
+			ptr = buffer;
+		}
+	}
+	while (*ptr == '\0'); /* skip empty strings */
+
+	return strlen(buffer);
+}
+
+/*
+ * Checks if buffer contains section name specified by the cfg_section pointer.
+ * Returns NULL if section name does not match, cfg_section pointer otherwise
+ */
+static struct cfg_section *cfg_check_section(char *buffer, struct cfg_section *psec)
+{
+	char *pend;
+	unsigned len;
+	static const char *valid = "0123456789,hs- \t";
+
+	pend = strchr(buffer, ']');
+	if (pend == NULL) {
+		return NULL; /* ']' not found: invalid section name */
+	}
+
+	*pend = '\0';
+
+	/* check if section is indexed */
+	pend = strchr(psec->name, '#');
+	if (pend == NULL) {
+		return (strcmp(buffer, psec->name) == 0) ? psec : NULL;
+	}
+
+	/* get section index */
+	len = pend - psec->name;
+	if (strncmp(buffer, psec->name, len) != 0) {
+		return NULL;
+	}
+	pend = buffer + len;
+	if (*pend == '\0') {
+		return NULL;
+	}
+	/* only numeric characters are valid for section index
+	   (currently, variables not checked!) */
+	if (pend[0] != '$') {
+		for (len = 0; pend[len] != '\0'; ++len) {
+			if (strchr(valid, pend[len]) == NULL) {
+				return NULL;
+			}
+		}
+	}
+
+	psec->nbindex = parse_list_set(psec->indexp, pend, MAX_INDEX);
+	PROX_PANIC(psec->nbindex == -1, "\t\tError in cfg_check_section('%s'): %s\n", buffer, get_parse_err());
+
+	for (int i = 0; i < psec->nbindex; ++i) {
+		psec->indexp[i] |= CFG_INDEXED;
+	}
+
+	return psec;
+}
+
+static char *cfg_get_section_name(struct cfg_section *psec)
+{
+	char *name;
+
+	if (!(psec->indexp[0] & CFG_INDEXED)) {
+		return strdup(psec->name);
+	}
+
+	name = malloc(strlen(psec->name) + strlen(UINT32_MAX_STR));
+	if (name != NULL) {
+		strcpy(name, psec->name);
+		char *pidx = strchr(name, '#');
+		if (pidx != NULL) {
+			sprintf(pidx, "%u", psec->indexp[0] & ~CFG_INDEXED);
+		}
+	}
+	return name;
+}
+
+/*
+ * Reads configuration file and parses section specified by psec pointer.
+ * Returns 0 on success, -1 otherwise
+ */
+int cfg_parse(struct cfg_file *pcfg, struct cfg_section *psec)
+{
+	int error;
+	unsigned entry = 0;
+	fpos_t pos;
+	int index_count = 0;
+	struct cfg_section *section = NULL;
+	char buffer[sizeof(pcfg->cur_line)] = {0};
+
+	if (pcfg == NULL || psec == NULL) {
+		return -1;
+	}
+
+	pcfg->line = 0;
+	fseek(pcfg->pfile, 0, SEEK_SET);
+
+	/* read configuration file and parse section specified by psec pointer */
+	while (1) {
+		if (psec->raw_lines) {
+			/* skip until section starts */
+			char *lines = pcfg->cur_line;
+			size_t max_len = sizeof(pcfg->cur_line);
+			char *ret;
+
+			do {
+				ret = fgets(lines, max_len, pcfg->pfile);
+				if (ret && *ret == '[') {
+					section = cfg_check_section(lines + 1, psec);
+				}
+			} while (!section && ret);
+
+			if (!ret)
+				return 0;
+
+			do {
+
+				ret = fgets(buffer, sizeof(buffer), pcfg->pfile);
+				if (ret && *ret != '[') {
+					size_t l = strlen(buffer);
+					strncpy(lines, buffer, max_len);
+					max_len -= l;
+					lines += l;
+				}
+			} while ((ret && *ret != '['));
+
+			if (section != NULL) {
+				error = section->parser(section->indexp[index_count], pcfg->cur_line, section->data);
+				if (error != 0) {
+					section->error = error;
+					/* log only the very first error */
+					if (!pcfg->err_section) {
+						pcfg->err_line = pcfg->line;
+						pcfg->err_entry = entry;
+						pcfg->err_section = cfg_get_section_name(section);
+					}
+					return 0;
+				}
+				++entry;
+			}
+			return 0;
+		}
+
+		while (cfg_get_line(pcfg, buffer, MAX_CFG_STRING_LEN, psec->raw_lines) > 0) {
+			strncpy(pcfg->cur_line, buffer, sizeof(pcfg->cur_line));
+			if (*buffer == '[') {
+				if (index_count + 1 < psec->nbindex) {
+					// Need to loop - go back to recorded postion in file
+					cfg_set_pos(pcfg, &pos);
+					++index_count;
+					continue;
+				}
+				else {
+					section = cfg_check_section(buffer + 1, psec);
+					entry = 0;
+					index_count = 0;
+					cfg_get_pos(pcfg, &pos);
+					continue;
+				}
+			}
+			/* call parser procedure for each line in the section */
+			if (section != NULL) {
+				error = section->parser(section->indexp[index_count], buffer, section->data);
+				if (error != 0) {
+					section->error = error;
+					/* log only the very first error */
+					if (!pcfg->err_section) {
+						pcfg->err_line = pcfg->line;
+						pcfg->err_entry = entry;
+						pcfg->err_section = cfg_get_section_name(section);
+					}
+					return 0;
+				}
+				++entry;
+			}
+		}
+		if (index_count + 1 < psec->nbindex) {
+			// Last core config contained multiple cores - loop back
+			cfg_set_pos(pcfg, &pos);
+			++index_count;
+		}
+		else {
+			break;
+		}
+	}
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/cfgfile.h b/VNFs/DPPD-PROX/cfgfile.h
new file mode 100644
index 00000000..41b474ee
--- /dev/null
+++ b/VNFs/DPPD-PROX/cfgfile.h
@@ -0,0 +1,60 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _CFG_FILE_H_
+#define _CFG_FILE_H_
+
+#include <stdio.h>
+
+#define DEFAULT_CONFIG_FILE	"./prox.cfg"
+
+/* configuration file line parser procedure */
+typedef int (*cfg_parser)(unsigned sindex, char *str, void *data);
+
+#define CFG_INDEXED	0x80000000	/* section contains index [name #] */
+#define MAX_INDEX	64
+
+struct cfg_section {
+	const char	*name;	/* section name without [] */
+	cfg_parser	parser;	/* section parser function */
+	void		*data;	/* data to be passed to the parser */
+	/* set by parsing procedure */
+	unsigned	indexp[MAX_INDEX];
+	int             raw_lines; /* if set, do not remove text after ';' */
+	int		nbindex;
+	int		error;
+};
+
+#define MAX_CFG_STRING_LEN 8192
+#define STRING_TERMINATOR_LEN 4
+
+struct cfg_file {
+	char		*name;
+	FILE		*pfile;
+	unsigned	line;
+	unsigned	index_line;
+	/* set in case of any error */
+	unsigned	err_line;
+	char		*err_section;
+	unsigned	err_entry;
+	char		cur_line[MAX_CFG_STRING_LEN + STRING_TERMINATOR_LEN];
+};
+
+struct cfg_file *cfg_open(const char *cfg_name);
+int cfg_parse(struct cfg_file *pcfg, struct cfg_section *psec);
+int cfg_close(struct cfg_file *pcfg);
+
+#endif /* _CFGFILE_H_ */
diff --git a/VNFs/DPPD-PROX/clock.c b/VNFs/DPPD-PROX/clock.c
new file mode 100644
index 00000000..6e057101
--- /dev/null
+++ b/VNFs/DPPD-PROX/clock.c
@@ -0,0 +1,261 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "clock.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <rte_cycles.h>
+
+/* Calibrate TSC overhead by reading NB_READ times and take the smallest value.
+   Bigger values are caused by external influence and can be discarded. The best
+   estimate is the smallest read value. */
+#define NB_READ 10000
+
+uint32_t rdtsc_overhead;
+uint32_t rdtsc_overhead_stats;
+
+uint64_t thresh;
+uint64_t tsc_hz;
+
+/* calculate how much overhead is involved with calling rdtsc. This value has
+   to be taken into account where the time spent running a small piece of code
+   is measured */
+static void init_tsc_overhead(void)
+{
+	volatile uint32_t min_without_overhead = UINT32_MAX;
+	volatile uint32_t min_with_overhead = UINT32_MAX;
+	volatile uint32_t min_stats_overhead = UINT32_MAX;
+	volatile uint64_t start1, end1;
+	volatile uint64_t start2, end2;
+
+	for (uint32_t i = 0; i < NB_READ; ++i) {
+		start1 = rte_rdtsc();
+		end1   = rte_rdtsc();
+
+		start2 = rte_rdtsc();
+		end2   = rte_rdtsc();
+		end2   = rte_rdtsc();
+
+		if (min_without_overhead > end1 - start1) {
+			min_without_overhead = end1 - start1;
+		}
+
+		if (min_with_overhead > end2 - start2) {
+			min_with_overhead = end2 - start2;
+		}
+	}
+
+	rdtsc_overhead = min_with_overhead - min_without_overhead;
+
+	start1 = rte_rdtsc();
+	end1   = rte_rdtsc();
+	/* forbid the compiler to optimize this dummy variable */
+	volatile int dummy = 0;
+	for (uint32_t i = 0; i < NB_READ; ++i) {
+		start1 = rte_rdtsc();
+		dummy += 32;
+		end1   = rte_rdtsc();
+
+		if (min_stats_overhead > end2 - start2) {
+			min_stats_overhead = end1 - start1;
+		}
+	}
+
+	rdtsc_overhead_stats = rdtsc_overhead + min_stats_overhead - min_without_overhead;
+}
+
+void clock_init(void)
+{
+	init_tsc_overhead();
+	tsc_hz = rte_get_tsc_hz();
+	thresh = UINT64_MAX/tsc_hz;
+}
+
+uint64_t str_to_tsc(const char *from)
+{
+	const uint64_t hz = rte_get_tsc_hz();
+	uint64_t ret;
+	char str[16];
+
+	strncpy(str, from, sizeof(str));
+
+	char *frac = strchr(str, '.');
+
+	if (frac) {
+		*frac = 0;
+		frac++;
+	}
+
+	ret = hz * atoi(str);
+
+	if (!frac)
+		return ret;
+
+	uint64_t nsec = 0;
+	uint64_t multiplier = 100000000;
+
+	for (size_t i = 0; i < strlen(frac); ++i) {
+		nsec += (frac[i] - '0') * multiplier;
+		multiplier /= 10;
+	}
+
+	/* Wont overflow until CPU freq is ~18.44 GHz */
+	ret += hz * nsec/1000000000;
+
+	return ret;
+}
+
+uint64_t sec_to_tsc(uint64_t sec)
+{
+	if (sec < UINT64_MAX/rte_get_tsc_hz())
+		return sec * rte_get_tsc_hz();
+	else
+		return UINT64_MAX;
+}
+
+uint64_t msec_to_tsc(uint64_t msec)
+{
+	if (msec < UINT64_MAX/rte_get_tsc_hz())
+		return msec * rte_get_tsc_hz() / 1000;
+	else
+		return msec / 1000 * rte_get_tsc_hz();
+}
+
+uint64_t usec_to_tsc(uint64_t usec)
+{
+	if (usec < UINT64_MAX/rte_get_tsc_hz())
+		return usec * rte_get_tsc_hz() / 1000000;
+	else
+		return usec / 1000000 * rte_get_tsc_hz();
+}
+
+uint64_t nsec_to_tsc(uint64_t nsec)
+{
+	if (nsec < UINT64_MAX/rte_get_tsc_hz())
+		return nsec * rte_get_tsc_hz() / 1000000000;
+	else
+		return nsec / 1000000000 * rte_get_tsc_hz();
+}
+
+uint64_t tsc_to_msec(uint64_t tsc)
+{
+	if (tsc < UINT64_MAX / 1000) {
+		return tsc * 1000 / rte_get_tsc_hz();
+	} else {
+		return tsc / (rte_get_tsc_hz() / 1000);
+	}
+}
+
+uint64_t tsc_to_usec(uint64_t tsc)
+{
+	if (tsc < UINT64_MAX / 1000000) {
+		return tsc * 1000000 / rte_get_tsc_hz();
+	} else {
+		return tsc / (rte_get_tsc_hz() / 1000000);
+	}
+}
+
+uint64_t tsc_to_nsec(uint64_t tsc)
+{
+	if (tsc < UINT64_MAX / 1000000000) {
+		return tsc * 1000000000 / rte_get_tsc_hz();
+	} else {
+		return tsc / (rte_get_tsc_hz() / 1000000000);
+	}
+}
+
+uint64_t tsc_to_sec(uint64_t tsc)
+{
+	return tsc / rte_get_tsc_hz();
+}
+
+struct time_unit tsc_to_time_unit(uint64_t tsc)
+{
+	struct time_unit ret;
+	uint64_t hz = rte_get_tsc_hz();
+
+	ret.sec = tsc/hz;
+	ret.nsec = (tsc - ret.sec*hz)*1000000000/hz;
+
+	return ret;
+}
+
+uint64_t time_unit_to_usec(struct time_unit *time_unit)
+{
+	return time_unit->sec * 1000000 + time_unit->nsec/1000;
+}
+
+uint64_t time_unit_to_nsec(struct time_unit *time_unit)
+{
+	return time_unit->sec * 1000000000 + time_unit->nsec;
+}
+
+int time_unit_cmp(struct time_unit *left, struct time_unit *right)
+{
+	if (left->sec < right->sec)
+		return -1;
+	if (left->sec > right->sec)
+		return 1;
+
+	if (left->nsec < right->nsec)
+		return -1;
+	if (left->nsec > right->nsec)
+		return -1;
+	return 0;
+}
+
+uint64_t freq_to_tsc(uint64_t times_per_sec)
+{
+	return rte_get_tsc_hz()/times_per_sec;
+}
+
+void tsc_to_tv(struct timeval *tv, const uint64_t tsc)
+{
+	uint64_t hz = rte_get_tsc_hz();
+	uint64_t sec = tsc/hz;
+
+	tv->tv_sec = sec;
+	tv->tv_usec = ((tsc - sec * hz) * 1000000) / hz;
+}
+
+void tv_to_tsc(const struct timeval *tv, uint64_t *tsc)
+{
+	uint64_t hz = rte_get_tsc_hz();
+	*tsc = tv->tv_sec * hz;
+	*tsc += tv->tv_usec * hz / 1000000;
+}
+
+struct timeval tv_diff(const struct timeval *cur, const struct timeval *next)
+{
+	uint64_t sec, usec;
+
+	sec = next->tv_sec - cur->tv_sec;
+	if (next->tv_usec < cur->tv_usec) {
+		usec = next->tv_usec + 1000000 - cur->tv_usec;
+		sec -= 1;
+	}
+	else
+		usec = next->tv_usec - cur->tv_usec;
+
+	struct timeval ret = {
+		.tv_sec  = sec,
+		.tv_usec = usec,
+	};
+
+	return ret;
+}
diff --git a/VNFs/DPPD-PROX/clock.h b/VNFs/DPPD-PROX/clock.h
new file mode 100644
index 00000000..719968ab
--- /dev/null
+++ b/VNFs/DPPD-PROX/clock.h
@@ -0,0 +1,76 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _CLOCK_H_
+#define _CLOCK_H_
+
+#include <inttypes.h>
+
+extern uint32_t rdtsc_overhead;
+extern uint32_t rdtsc_overhead_stats;
+
+void clock_init(void);
+
+struct time_unit {
+	uint64_t sec;
+	uint64_t nsec;
+};
+
+struct time_unit_err {
+	struct time_unit time;
+	struct time_unit error;
+};
+
+extern uint64_t thresh;
+extern uint64_t tsc_hz;
+
+static uint64_t val_to_rate(uint64_t val, uint64_t delta_t)
+{
+	if (val < thresh) {
+		return val * tsc_hz / delta_t;
+	} else if (val >> 2 < thresh) {
+		/* bytes per sec malls into this category ... */
+		return ((val >> 2) * tsc_hz) / (delta_t >> 2);
+	} else {
+		if (delta_t < tsc_hz)
+			return UINT64_MAX;
+		else
+			return val / (delta_t/tsc_hz);
+	}
+}
+
+/* The precision of the conversion is nano-second. */
+uint64_t str_to_tsc(const char *from);
+uint64_t sec_to_tsc(uint64_t sec);
+uint64_t msec_to_tsc(uint64_t msec);
+uint64_t usec_to_tsc(uint64_t usec);
+uint64_t nsec_to_tsc(uint64_t nsec);
+uint64_t freq_to_tsc(uint64_t times_per_sec);
+uint64_t tsc_to_msec(uint64_t tsc);
+uint64_t tsc_to_usec(uint64_t tsc);
+uint64_t tsc_to_nsec(uint64_t tsc);
+uint64_t tsc_to_sec(uint64_t tsc);
+struct time_unit tsc_to_time_unit(uint64_t tsc);
+uint64_t time_unit_to_usec(struct time_unit *time_unit);
+uint64_t time_unit_to_nsec(struct time_unit *time_unit);
+int time_unit_cmp(struct time_unit *left, struct time_unit *right);
+
+struct timeval;
+void tsc_to_tv(struct timeval *tv, const uint64_t tsc);
+void tv_to_tsc(const struct timeval *tv, uint64_t *tsc);
+struct timeval tv_diff(const struct timeval *tv1, const struct timeval * tv2);
+
+#endif /* _CLOCK_H_ */
diff --git a/VNFs/DPPD-PROX/cmd_parser.c b/VNFs/DPPD-PROX/cmd_parser.c
new file mode 100644
index 00000000..95688477
--- /dev/null
+++ b/VNFs/DPPD-PROX/cmd_parser.c
@@ -0,0 +1,2031 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <rte_cycles.h>
+#include <rte_version.h>
+
+#include "input.h"
+#include "cmd_parser.h"
+#include "commands.h"
+#include "run.h"
+#include "display.h"
+#include "log.h"
+#include "prox_cfg.h"
+#include "prox_port_cfg.h"
+#include "task_base.h"
+#include "lconf.h"
+#include "main.h"
+#include "parse_utils.h"
+#include "stats_parser.h"
+#include "stats_port.h"
+#include "stats_latency.h"
+#include "stats_global.h"
+#include "stats_prio_task.h"
+
+#include "handle_routing.h"
+#include "handle_qinq_decap4.h"
+#include "handle_lat.h"
+#include "handle_arp.h"
+#include "handle_gen.h"
+#include "handle_acl.h"
+#include "handle_irq.h"
+#include "defines.h"
+#include "prox_cfg.h"
+#include "version.h"
+#include "stats_latency.h"
+#include "handle_cgnat.h"
+#include "handle_impair.h"
+
+static int core_task_is_valid(int lcore_id, int task_id)
+{
+	if (lcore_id >= RTE_MAX_LCORE) {
+		plog_err("Invalid core id %u (lcore ID above %d)\n", lcore_id, RTE_MAX_LCORE);
+		return 0;
+	}
+	else if (!prox_core_active(lcore_id, 0)) {
+		plog_err("Invalid core id %u (lcore is not active)\n", lcore_id);
+		return 0;
+	}
+	else if (task_id >= lcore_cfg[lcore_id].n_tasks_all) {
+		plog_err("Invalid task id (valid task IDs for core %u are below %u)\n",
+			 lcore_id, lcore_cfg[lcore_id].n_tasks_all);
+		return 0;
+	}
+	return 1;
+}
+
+static int cores_task_are_valid(unsigned int *lcores, int task_id, unsigned int nb_cores)
+{
+	unsigned int lcore_id;
+	for (unsigned int i = 0; i < nb_cores; i++) {
+		lcore_id = lcores[i];
+		if (lcore_id >= RTE_MAX_LCORE) {
+			plog_err("Invalid core id %u (lcore ID above %d)\n", lcore_id, RTE_MAX_LCORE);
+			return 0;
+		}
+		else if (!prox_core_active(lcore_id, 0)) {
+			plog_err("Invalid core id %u (lcore is not active)\n", lcore_id);
+			return 0;
+		}
+		else if (task_id >= lcore_cfg[lcore_id].n_tasks_all) {
+			plog_err("Invalid task id (valid task IDs for core %u are below %u)\n",
+			 	lcore_id, lcore_cfg[lcore_id].n_tasks_all);
+			return 0;
+		}
+	}
+	return 1;
+}
+
+static int parse_core_task(const char *str, uint32_t *lcore_id, uint32_t *task_id, unsigned int *nb_cores)
+{
+	char str_lcore_id[128];
+	int ret;
+
+	if (2 != sscanf(str, "%s %u", str_lcore_id, task_id))
+		return -1;
+
+	if ((ret = parse_list_set(lcore_id, str_lcore_id, RTE_MAX_LCORE)) <= 0) {
+		plog_err("Invalid core while parsing command (%s)\n", get_parse_err());
+		return -1;
+	}
+	*nb_cores = ret;
+
+	return 0;
+}
+
+static const char *strchr_skip_twice(const char *str, int chr)
+{
+	str = strchr(str, chr);
+	if (!str)
+		return NULL;
+	str = str + 1;
+
+	str = strchr(str, chr);
+	if (!str)
+		return NULL;
+	return str + 1;
+}
+
+static int parse_cmd_quit(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	quit();
+	return 0;
+}
+
+static int parse_cmd_quit_force(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	abort();
+}
+
+static int parse_cmd_history(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	if (input->history) {
+		input->history(input);
+		return 0;
+	}
+	plog_err("Invalid history comand ");
+	return -1;
+}
+
+static int parse_cmd_echo(const char *str, struct input *input)
+{
+	if (strcmp(str, "") == 0) {
+		return -1;
+	}
+
+	char resolved[2048];
+
+	if (parse_vars(resolved, sizeof(resolved), str)) {
+		return 0;
+	}
+
+	if (input->reply) {
+		if (strlen(resolved) + 2 < sizeof(resolved)) {
+			resolved[strlen(resolved) + 1] = 0;
+			resolved[strlen(resolved)] = '\n';
+		}
+		else
+			return 0;
+
+		input->reply(input, resolved, strlen(resolved));
+	} else
+		plog_info("%s\n", resolved);
+
+	return 0;
+}
+
+static int parse_cmd_reset_stats(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	stats_reset();
+	return 0;
+}
+
+static int parse_cmd_reset_lat_stats(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	stats_latency_reset();
+	return 0;
+}
+
+static int parse_cmd_trace(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], task_id, nb_packets, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%u", &nb_packets) != 1)
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			cmd_trace(lcores[i], task_id, nb_packets);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_dump_rx(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], task_id, nb_packets, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%u", &nb_packets) != 1) {
+		return -1;
+	}
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			cmd_dump(lcores[i], task_id, nb_packets, input, 1, 0);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_pps_unit(const char *str, struct input *input)
+{
+	uint32_t val;
+
+	if (sscanf(str, "%u", &val) != 1) {
+		return -1;
+	}
+	display_set_pps_unit(val);
+	return 0;
+}
+
+static int parse_cmd_dump_tx(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], task_id, nb_packets, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%u", &nb_packets) != 1) {
+		return -1;
+	}
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			cmd_dump(lcores[i], task_id, nb_packets, input, 0, 1);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_rate(const char *str, struct input *input)
+{
+	unsigned queue, port, rate;
+
+	if (sscanf(str, "%u %u %u", &queue, &port, &rate) != 3) {
+		return -1;
+	}
+
+	if (port > PROX_MAX_PORTS) {
+		plog_err("Max port id allowed is %u (specified %u)\n", PROX_MAX_PORTS, port);
+	}
+	else if (!prox_port_cfg[port].active) {
+		plog_err("Port %u not active\n", port);
+	}
+	else if (queue >= prox_port_cfg[port].n_txq) {
+		plog_err("Number of active queues is %u\n",
+			 prox_port_cfg[port].n_txq);
+	}
+	else if (rate > prox_port_cfg[port].link_speed) {
+		plog_err("Max rate allowed on port %u queue %u is %u Mbps\n",
+			 port, queue, prox_port_cfg[port].link_speed);
+	}
+	else {
+		if (rate == 0) {
+			plog_info("Disabling rate limiting on port %u queue %u\n",
+				  port, queue);
+		}
+		else {
+			plog_info("Setting rate limiting to %u Mbps on port %u queue %u\n",
+				  rate, port, queue);
+		}
+		rte_eth_set_queue_rate_limit(port, queue, rate);
+	}
+	return 0;
+}
+
+int task_is_mode(uint32_t lcore_id, uint32_t task_id, const char *mode, const char *sub_mode)
+{
+	struct task_init *t = lcore_cfg[lcore_id].targs[task_id].task_init;
+
+	return !strcmp(t->mode_str, mode) && !strcmp(t->sub_mode_str, sub_mode);
+}
+
+int task_is_sub_mode(uint32_t lcore_id, uint32_t task_id, const char *sub_mode)
+{
+	struct task_init *t = lcore_cfg[lcore_id].targs[task_id].task_init;
+
+	return !strcmp(t->sub_mode_str, sub_mode);
+}
+
+static void log_pkt_count(uint32_t count, uint32_t lcore_id, uint32_t task_id)
+{
+	if (count == UINT32_MAX)
+		plog_info("Core %u task %u will keep sending packets\n", lcore_id, task_id);
+	else if (count == 0)
+		plog_info("Core %u task %u waits for next count command\n", lcore_id, task_id);
+	else
+		plog_info("Core %u task %u stopping after %u packets\n", lcore_id, task_id, count);
+}
+
+static int parse_cmd_count(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, count, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%u", &count) != 1)
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if ((!task_is_mode(lcore_id, task_id, "gen", "")) && (!task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+				plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
+			}
+			else {
+				struct task_base *task = lcore_cfg[lcore_id].tasks_all[task_id];
+
+				log_pkt_count(count, lcore_id, task_id);
+				task_gen_set_pkt_count(task, count);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_set_probability(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+	float probability;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%f", &probability) != 1)
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if (!task_is_mode(lcore_id, task_id, "impair", "")) {
+				plog_err("Core %u task %u is not impairing packets\n", lcore_id, task_id);
+			}
+			struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+			task_impair_set_proba(tbase, probability);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_delay_us(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, delay_us, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%d", &delay_us) != 1)
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if (!task_is_mode(lcore_id, task_id, "impair", "")) {
+				plog_err("Core %u task %u is not impairing packets\n", lcore_id, task_id);
+			}
+			struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+			task_impair_set_delay_us(tbase, delay_us, 0);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_random_delay_us(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, delay_us, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%d", &delay_us) != 1)
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if (!task_is_mode(lcore_id, task_id, "impair", "")) {
+				plog_err("Core %u task %u is not impairing packets\n", lcore_id, task_id);
+			}
+			struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+			task_impair_set_delay_us(tbase, 0, delay_us);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_bypass(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, pkt_size, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if ((prox_cfg.flags & DSF_ENABLE_BYPASS) == 0) {
+		plog_err("enable bypass not set => command not supported\n");
+		return -1;
+	}
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if (bypass_task(lcore_id, task_id) != 0)
+				return -1;
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_reconnect(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, pkt_size, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if (reconnect_task(lcore_id, task_id) != 0)
+				return -1;
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_pkt_size(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, pkt_size, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%d", &pkt_size) != 1)
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if ((!task_is_mode(lcore_id, task_id, "gen", "")) && (!task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+				plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
+			}
+			struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+
+			if (task_gen_set_pkt_size(tbase, pkt_size) != 0)
+				return -1;
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_speed(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], task_id, lcore_id, nb_cores;
+	float speed;
+	unsigned i;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%f", &speed) != 1) {
+		return -1;
+	}
+
+	if (!cores_task_are_valid(lcores, task_id, nb_cores)) {
+		return 0;
+	}
+
+	for (i = 0; i < nb_cores; i++) {
+		lcore_id = lcores[i];
+		if ((!task_is_mode(lcore_id, task_id, "gen", "")) && (!task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+			plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
+		}
+		else if (speed > 400.0f || speed < 0.0f) {
+			plog_err("Speed out of range (must be betweeen 0%% and 100%%)\n");
+		}
+		else {
+			struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+			uint64_t bps = speed * 12500000;
+
+			plog_info("Setting rate to %"PRIu64" Bps\n", bps);
+
+			task_gen_set_rate(tbase, bps);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_speed_byte(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+	uint64_t bps;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%"PRIu64"", &bps) != 1)
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+
+			if ((!task_is_mode(lcore_id, task_id, "gen", "")) && (!task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+				plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
+			}
+			else if (bps > 1250000000) {
+				plog_err("Speed out of range (must be <= 1250000000)\n");
+			}
+			else {
+				struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+
+				plog_info("Setting rate to %"PRIu64" Bps\n", bps);
+				task_gen_set_rate(tbase, bps);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_reset_randoms_all(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	unsigned task_id, lcore_id = -1;
+	while (prox_core_next(&lcore_id, 0) == 0) {
+		for (task_id = 0; task_id < lcore_cfg[lcore_id].n_tasks_all; task_id++) {
+			if ((task_is_mode(lcore_id, task_id, "gen", "")) || (task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+				struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+				uint32_t n_rands = task_gen_get_n_randoms(tbase);
+
+				plog_info("Resetting randoms on core %d task %d from %d randoms\n", lcore_id, task_id, n_rands);
+				task_gen_reset_randoms(tbase);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_reset_values_all(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	unsigned task_id, lcore_id = -1;
+	while (prox_core_next(&lcore_id, 0) == 0) {
+		for (task_id = 0; task_id < lcore_cfg[lcore_id].n_tasks_all; task_id++) {
+			if ((task_is_mode(lcore_id, task_id, "gen", "")) || (task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+				struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+
+				plog_info("Resetting values on core %d task %d\n", lcore_id, task_id);
+				task_gen_reset_values(tbase);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_reset_values(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if ((!task_is_mode(lcore_id, task_id, "gen", "")) && (!task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+				plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
+			}
+			else {
+				struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+
+				plog_info("Resetting values on core %d task %d\n", lcore_id, task_id);
+				task_gen_reset_values(tbase);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_set_value(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, value, nb_cores;
+	unsigned short offset;
+	uint8_t value_len;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%hu %u %hhu", &offset, &value, &value_len) != 3) {
+		return -1;
+	}
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if ((!task_is_mode(lcore_id, task_id, "gen", "")) && (!task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+				plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
+			}
+			else if (offset > ETHER_MAX_LEN) {
+				plog_err("Offset out of range (must be less then %u)\n", ETHER_MAX_LEN);
+			}
+			else if (value_len > 4) {
+				plog_err("Length out of range (must be less then 4)\n");
+			}
+			else {
+				struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+
+				if (task_gen_set_value(tbase, value, offset, value_len))
+					plog_info("Unable to set Byte %"PRIu16" to %"PRIu8" - too many value set\n", offset, value);
+				else
+					plog_info("Setting Byte %"PRIu16" to %"PRIu32"\n", offset, value);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_set_random(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+	unsigned short offset;
+	uint8_t value_len;
+	char rand_str[64];
+	int16_t rand_id = -1;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%hu %32s %hhu", &offset, rand_str, &value_len) != 3) {
+		return -1;
+	}
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if ((!task_is_mode(lcore_id, task_id, "gen", "")) && (!task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+				plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
+			}
+			else if (offset > ETHER_MAX_LEN) {
+				plog_err("Offset out of range (must be less then %u)\n", ETHER_MAX_LEN);
+			}
+			else if (value_len > 4) {
+				plog_err("Length out of range (must be less then 4)\n");
+			} else {
+				struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+
+				if (task_gen_add_rand(tbase, rand_str, offset, rand_id)) {
+					plog_warn("Random not added on core %u task %u\n", lcore_id, task_id);
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_thread_info(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	for (unsigned int i = 0; i < nb_cores; i++) {
+		cmd_thread_info(lcores[i], task_id);
+	}
+	return 0;
+}
+
+static int parse_cmd_verbose(const char *str, struct input *input)
+{
+	unsigned id;
+
+	if (sscanf(str, "%u", &id) != 1) {
+		return -1;
+	}
+
+	if (plog_set_lvl(id) != 0) {
+		plog_err("Cannot set log level to %u\n", id);
+	}
+	return 0;
+}
+
+static int parse_cmd_arp_add(const char *str, struct input *input)
+{
+	struct arp_msg amsg;
+	struct arp_msg *pmsg = &amsg;
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+	struct rte_ring *ring;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (strcmp(str, ""))
+		return -1;
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		if (str_to_arp_msg(&amsg, str) == 0) {
+			for (unsigned int i = 0; i < nb_cores; i++) {
+				lcore_id = lcores[i];
+				ring = ctrl_rings[lcore_id*MAX_TASKS_PER_CORE + task_id];
+				if (!ring) {
+					plog_err("No ring for control messages to core %u task %u\n", lcore_id, task_id);
+				}
+				else {
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+					while (rte_ring_sp_enqueue_bulk(ring, (void *const *)&pmsg, 1));
+#else
+					while (rte_ring_sp_enqueue_bulk(ring, (void *const *)&pmsg, 1, NULL) == 0);
+#endif
+					while (!rte_ring_empty(ring));
+				}
+			}
+			return 0;
+		}
+	}
+	return -1;
+}
+
+static int parse_cmd_rule_add(const char *str, struct input *input)
+{
+	struct rte_ring *ring;
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (strcmp(str, ""))
+		return -1;
+	char *fields[9];
+	char str_cpy[255];
+	strncpy(str_cpy, str, 255);
+	// example add rule command: rule add 15 0 1&0x0fff 1&0x0fff 0&0 128.0.0.0/1 128.0.0.0/1 5000-5000 5000-5000 allow
+	int ret = rte_strsplit(str_cpy, 255, fields, 9, ' ');
+	if (ret != 8) {
+		return -1;
+	}
+
+	struct acl4_rule rule;
+	struct acl4_rule *prule = &rule;
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		if (str_to_rule(&rule, fields, -1, 1) == 0) {
+			for (unsigned int i = 0; i < nb_cores; i++) {
+				lcore_id = lcores[i];
+				ring = ctrl_rings[lcore_id*MAX_TASKS_PER_CORE + task_id];
+				if (!ring) {
+					plog_err("No ring for control messages to core %u task %u\n", lcore_id, task_id);
+				}
+				else {
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+					while (rte_ring_sp_enqueue_bulk(ring, (void *const *)&prule, 1));
+#else
+					while (rte_ring_sp_enqueue_bulk(ring, (void *const *)&prule, 1, NULL) == 0);
+#endif
+					while (!rte_ring_empty(ring));
+				}
+			}
+			return 0;
+		}
+	}
+	return -1;
+}
+
+static int parse_cmd_gateway_ip(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, ip[4], nb_cores, i;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (!strcmp(str, ""))
+		return -1;
+	if (sscanf(str, "%u.%u.%u.%u", ip, ip + 1, ip + 2, ip + 3) != 4) {
+		return -1;
+	}
+	for (i = 0; i < nb_cores; i++) {
+		lcore_id = lcores[i];
+		if ((!task_is_mode(lcore_id, task_id, "gen", "")) && (!task_is_mode(lcore_id, task_id, "gen", "l3"))) {
+			plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
+		}
+		else {
+			uint32_t gateway_ip = ((ip[3] & 0xFF) << 24) | ((ip[2] & 0xFF) << 16) | ((ip[1] & 0xFF) << 8) | ((ip[0] & 0xFF) << 0);
+			struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+			plog_info("Setting gateway ip to %s\n", str);
+			task_gen_set_gateway_ip(tbase, gateway_ip);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_local_ip(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, ip[4], nb_cores, i;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (!strcmp(str, ""))
+		return -1;
+	if (sscanf(str, "%u.%u.%u.%u", ip, ip + 1, ip + 2, ip + 3) != 4) {
+		return -1;
+	}
+	for (i = 0; i < nb_cores; i++) {
+		lcore_id = lcores[i];
+		if (!task_is_mode(lcore_id, task_id, "arp", "local")) {
+			plog_err("Core %u task %u is not in arp mode\n", lcore_id, task_id);
+		}
+		else {
+			uint32_t local_ip = ((ip[3] & 0xFF) << 24) | ((ip[2] & 0xFF) << 16) | ((ip[1] & 0xFF) << 8) | ((ip[0] & 0xFF) << 0);
+			struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+			plog_info("Setting local ip to %s\n", str);
+			task_arp_set_local_ip(tbase, local_ip);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_route_add(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, prefix, next_hop_idx, ip[4], nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (strcmp(str, ""))
+		return -1;
+	if (sscanf(str, "%u.%u.%u.%u/%u %u", ip, ip + 1, ip + 2, ip + 3,
+		   &prefix, &next_hop_idx) != 8) {
+		return -1;
+	}
+	struct rte_ring *ring;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			ring = ctrl_rings[lcore_id*MAX_TASKS_PER_CORE + task_id];
+			if (!ring) {
+				plog_err("No ring for control messages to core %u task %u\n", lcore_id, task_id);
+			}
+			else {
+				struct route_msg rmsg;
+				struct route_msg *pmsg = &rmsg;
+
+				rmsg.ip_bytes[0] = ip[0];
+				rmsg.ip_bytes[1] = ip[1];
+				rmsg.ip_bytes[2] = ip[2];
+				rmsg.ip_bytes[3] = ip[3];
+				rmsg.prefix = prefix;
+				rmsg.nh = next_hop_idx;
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+				while (rte_ring_sp_enqueue_bulk(ring, (void *const *)&pmsg, 1));
+#else
+				while (rte_ring_sp_enqueue_bulk(ring, (void *const *)&pmsg, 1, NULL) == 0);
+#endif
+				while (!rte_ring_empty(ring));
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_start(const char *str, struct input *input)
+{
+	int task_id = -1;
+
+	if (strncmp(str, "all", 3) == 0) {
+		str += 3;
+		sscanf(str, "%d", &task_id);
+
+		start_core_all(task_id);
+		req_refresh();
+		return 0;
+	}
+
+	uint32_t cores[64] = {0};
+	int ret;
+	ret = parse_list_set(cores, str, 64);
+	if (ret < 0) {
+		return -1;
+	}
+	str = strchr(str, ' ');
+
+	if (str) {
+		sscanf(str, "%d", &task_id);
+	}
+	start_cores(cores, ret, task_id);
+	req_refresh();
+	return 0;
+}
+
+static int parse_cmd_stop(const char *str, struct input *input)
+{
+	int task_id = -1;
+
+	if (strncmp(str, "all", 3) == 0) {
+		str += 3;
+		sscanf(str, "%d", &task_id);
+		stop_core_all(task_id);
+		req_refresh();
+		return 0;
+	}
+
+	uint32_t cores[64] = {0};
+	int ret;
+	ret = parse_list_set(cores, str, 64);
+	if (ret < 0) {
+		return -1;
+	}
+	str = strchr(str, ' ');
+
+	if (str) {
+		sscanf(str, "%d", &task_id);
+	}
+	stop_cores(cores, ret, task_id);
+	req_refresh();
+
+	return 0;
+}
+
+static int parse_cmd_rx_distr_start(const char *str, struct input *input)
+{
+	unsigned lcore_id[RTE_MAX_LCORE];
+
+	int nb_cores;
+
+	nb_cores = parse_list_set(lcore_id, str, sizeof(lcore_id)/sizeof(lcore_id[0]));
+
+	if (nb_cores <= 0) {
+		return -1;
+	}
+
+	for (int i = 0; i < nb_cores; ++i)
+		cmd_rx_distr_start(lcore_id[i]);
+	return 0;
+}
+
+static int parse_cmd_tx_distr_start(const char *str, struct input *input)
+{
+	unsigned lcore_id[RTE_MAX_LCORE];
+
+	int nb_cores;
+
+	nb_cores = parse_list_set(lcore_id, str, sizeof(lcore_id)/sizeof(lcore_id[0]));
+
+	if (nb_cores <= 0) {
+		return -1;
+	}
+
+	for (int i = 0; i < nb_cores; ++i)
+		cmd_tx_distr_start(lcore_id[i]);
+	return 0;
+}
+
+static int parse_cmd_rx_distr_stop(const char *str, struct input *input)
+{
+	unsigned lcore_id[RTE_MAX_LCORE];
+
+	int nb_cores;
+
+	nb_cores = parse_list_set(lcore_id, str, sizeof(lcore_id)/sizeof(lcore_id[0]));
+
+	if (nb_cores <= 0) {
+		return -1;
+	}
+
+	for (int i = 0; i < nb_cores; ++i)
+		cmd_rx_distr_stop(lcore_id[i]);
+	return 0;
+}
+
+static int parse_cmd_tx_distr_stop(const char *str, struct input *input)
+{
+	unsigned lcore_id[RTE_MAX_LCORE];
+
+	int nb_cores;
+
+	nb_cores = parse_list_set(lcore_id, str, sizeof(lcore_id)/sizeof(lcore_id[0]));
+
+	if (nb_cores <= 0) {
+		return -1;
+	}
+
+	for (int i = 0; i < nb_cores; ++i)
+		cmd_tx_distr_stop(lcore_id[i]);
+	return 0;
+}
+
+static int parse_cmd_rx_distr_reset(const char *str, struct input *input)
+{
+	unsigned lcore_id[RTE_MAX_LCORE];
+
+	int nb_cores;
+
+	nb_cores = parse_list_set(lcore_id, str, sizeof(lcore_id)/sizeof(lcore_id[0]));
+
+	if (nb_cores <= 0) {
+		return -1;
+	}
+
+	for (int i = 0; i < nb_cores; ++i)
+		cmd_rx_distr_rst(lcore_id[i]);
+	return 0;
+}
+
+static int parse_cmd_tx_distr_reset(const char *str, struct input *input)
+{
+	unsigned lcore_id[RTE_MAX_LCORE];
+
+	int nb_cores;
+
+	nb_cores = parse_list_set(lcore_id, str, sizeof(lcore_id)/sizeof(lcore_id[0]));
+
+	if (nb_cores <= 0) {
+		return -1;
+	}
+
+	for (int i = 0; i < nb_cores; ++i)
+		cmd_tx_distr_rst(lcore_id[i]);
+	return 0;
+}
+
+static int parse_cmd_rx_distr_show(const char *str, struct input *input)
+{
+	unsigned lcore_id[RTE_MAX_LCORE];
+
+	int nb_cores;
+
+	nb_cores = parse_list_set(lcore_id, str, sizeof(lcore_id)/sizeof(lcore_id[0]));
+
+	if (nb_cores <= 0) {
+		return -1;
+	}
+
+	for (int i = 0; i < nb_cores; ++i)
+		cmd_rx_distr_show(lcore_id[i]);
+	return 0;
+}
+
+static int parse_cmd_tx_distr_show(const char *str, struct input *input)
+{
+	unsigned lcore_id[RTE_MAX_LCORE];
+
+	int nb_cores;
+
+	nb_cores = parse_list_set(lcore_id, str, sizeof(lcore_id)/sizeof(lcore_id[0]));
+
+	if (nb_cores <= 0) {
+		return -1;
+	}
+
+	for (int i = 0; i < nb_cores; ++i)
+		cmd_tx_distr_show(lcore_id[i]);
+	return 0;
+}
+
+static int parse_cmd_tot_stats(const char *str, struct input *input)
+{
+	if (strcmp("", str) != 0) {
+		return -1;
+	}
+
+	struct global_stats_sample *gsl = stats_get_global_stats(1);
+	uint64_t tot_rx = gsl->host_rx_packets;
+	uint64_t tot_tx = gsl->host_tx_packets;
+	uint64_t last_tsc = gsl->tsc;
+
+	if (input->reply) {
+		char buf[128];
+		snprintf(buf, sizeof(buf), "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64"\n",
+			 tot_rx, tot_tx, last_tsc, rte_get_tsc_hz());
+		input->reply(input, buf, strlen(buf));
+	}
+	else {
+		plog_info("RX: %"PRIu64", TX: %"PRIu64"\n", tot_rx, tot_tx);
+	}
+	return 0;
+}
+
+static int parse_cmd_update_interval(const char *str, struct input *input)
+{
+	unsigned val;
+
+	if (sscanf(str, "%u", &val) != 1) {
+		return -1;
+	}
+
+	if (val == 0) {
+		plog_err("Minimum update interval is 1 ms\n");
+	}
+	else {
+		plog_info("Setting update interval to %d ms\n", val);
+		set_update_interval(val);
+	}
+	return 0;
+}
+
+static int parse_cmd_mem_info(const char *str, struct input *input)
+{
+	if (strcmp("", str) != 0) {
+		return -1;
+	}
+
+	cmd_mem_stats();
+	cmd_mem_layout();
+	return 0;
+}
+
+static int parse_cmd_tot_ierrors_tot(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	struct global_stats_sample *gsl = stats_get_global_stats(1);
+	uint64_t tot = gsl->nics_ierrors;
+	uint64_t last_tsc = gsl->tsc;
+
+	if (input->reply) {
+		char buf[128];
+		snprintf(buf, sizeof(buf),
+			 "%"PRIu64",%"PRIu64",%"PRIu64"\n",
+			 tot, last_tsc, rte_get_tsc_hz());
+		input->reply(input, buf, strlen(buf));
+	}
+	else {
+		plog_info("ierrors: %"PRIu64"\n", tot);
+	}
+	return 0;
+}
+
+static int parse_cmd_tot_imissed_tot(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	struct global_stats_sample *gsl = stats_get_global_stats(1);
+	uint64_t tot = gsl->nics_imissed;
+	uint64_t last_tsc = gsl->tsc;
+
+	if (input->reply) {
+		char buf[128];
+		snprintf(buf, sizeof(buf),
+			 "%"PRIu64",%"PRIu64",%"PRIu64"\n",
+			 tot, last_tsc, rte_get_tsc_hz());
+		input->reply(input, buf, strlen(buf));
+	}
+	else {
+		plog_info("imissed: %"PRIu64"\n", tot);
+	}
+	return 0;
+}
+
+static int parse_cmd_reset_port(const char *str, struct input *input)
+{
+	uint32_t port_id;
+
+	if (sscanf(str, "%u", &port_id ) != 1) {
+                return -1;
+        }
+
+	cmd_reset_port(port_id);
+	return 0;
+}
+
+static int parse_cmd_write_reg(const char *str, struct input *input)
+{
+	uint32_t port_id;
+	uint32_t id, val;
+
+	if (sscanf(str, "%u %x %u", &port_id, &id, &val) != 3) {
+                return -1;
+        }
+
+	cmd_write_reg(port_id, id, val);
+	return 0;
+}
+
+static int parse_cmd_read_reg(const char *str, struct input *input)
+{
+	uint32_t port_id;
+	uint32_t id;
+
+	if (sscanf(str, "%u %x", &port_id, &id) != 2) {
+                return -1;
+        }
+
+	cmd_read_reg(port_id, id);
+	return 0;
+}
+
+static int parse_cmd_cache_reset(const char *str, struct input *input)
+{
+	cmd_cache_reset();
+	return 0;
+}
+
+static int parse_cmd_set_cache_class_mask(const char *str, struct input *input)
+{
+	uint32_t lcore_id;
+	uint32_t set;
+	uint32_t val;
+
+	if (sscanf(str, "%u %u %u", &lcore_id, &set, &val) != 3) {
+                return -1;
+        }
+
+	cmd_set_cache_class_mask(lcore_id, set, val);
+	return 0;
+}
+
+static int parse_cmd_set_cache_class(const char *str, struct input *input)
+{
+	uint32_t lcore_id;
+	uint32_t set;
+
+	if (sscanf(str, "%u %u", &lcore_id, &set) != 2) {
+                return -1;
+        }
+
+	cmd_set_cache_class(lcore_id, set);
+	return 0;
+}
+
+static int parse_cmd_get_cache_class_mask(const char *str, struct input *input)
+{
+	uint32_t lcore_id;
+	uint32_t set;
+	uint32_t val = 0;
+
+	if (sscanf(str, "%u %u", &lcore_id, &set) != 2) {
+                return -1;
+        }
+
+	cmd_get_cache_class_mask(lcore_id, set, &val);
+	if (input->reply) {
+		char buf[128];
+		snprintf(buf, sizeof(buf), "%d, %d, %x\n", lcore_id, set, val);
+		input->reply(input, buf, strlen(buf));
+	} else {
+		plog_info("core=%d, set=%d, mask=%x\n", lcore_id, set, val);
+	}
+	return 0;
+}
+
+static int parse_cmd_get_cache_class(const char *str, struct input *input)
+{
+	uint32_t lcore_id;
+	uint32_t set;
+	uint32_t val;
+
+	if (sscanf(str, "%u", &lcore_id) != 1) {
+                return -1;
+        }
+
+	cmd_get_cache_class(lcore_id, &set);
+	if (input->reply) {
+		char buf[128];
+		snprintf(buf, sizeof(buf), "%d, %d\n", lcore_id, set);
+		input->reply(input, buf, strlen(buf));
+	} else {
+		plog_info("core=%d, cos=%d\n", lcore_id, set);
+	}
+	return 0;
+}
+
+static int parse_cmd_get_cache_mask(const char *str, struct input *input)
+{
+	uint32_t lcore_id;
+	uint32_t set;
+	uint32_t mask;
+
+	if (sscanf(str, "%u", &lcore_id) != 1) {
+                return -1;
+        }
+
+	cmd_get_cache_class(lcore_id, &set);
+	cmd_get_cache_class_mask(lcore_id, set, &mask);
+	if (input->reply) {
+		char buf[128];
+		snprintf(buf, sizeof(buf), "%d, %x\n", lcore_id, mask);
+		input->reply(input, buf, strlen(buf));
+	} else {
+		plog_info("core=%d, mask=%x\n", lcore_id, mask);
+	}
+	return 0;
+}
+
+static int parse_cmd_set_vlan_offload(const char *str, struct input *input)
+{
+	uint32_t port_id;
+	uint32_t val;
+
+	if (sscanf(str, "%u %u", &port_id, &val) != 2) {
+                return -1;
+        }
+
+	cmd_set_vlan_offload(port_id, val);
+	return 0;
+}
+
+static int parse_cmd_set_vlan_filter(const char *str, struct input *input)
+{
+	uint32_t port_id;
+	uint32_t id, val;
+
+	if (sscanf(str, "%u %d %u", &port_id, &id, &val) != 3) {
+                return -1;
+        }
+
+	cmd_set_vlan_filter(port_id, id, val);
+	return 0;
+}
+
+static int parse_cmd_ring_info_all(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+	cmd_ringinfo_all();
+	return 0;
+}
+
+static int parse_cmd_port_up(const char *str, struct input *input)
+{
+	unsigned val;
+
+	if (sscanf(str, "%u", &val) != 1) {
+		return -1;
+	}
+
+	cmd_port_up(val);
+	return 0;
+}
+
+static int parse_cmd_port_down(const char *str, struct input *input)
+{
+	unsigned val;
+
+	if (sscanf(str, "%u", &val) != 1) {
+		return -1;
+	}
+
+	cmd_port_down(val);
+	return 0;
+}
+
+static int parse_cmd_port_link_state(const char *str, struct input *input)
+{
+	unsigned val;
+
+	if (sscanf(str, "%u", &val) != 1) {
+		return -1;
+	}
+
+	if (!port_is_active(val))
+		return -1;
+
+	int active = prox_port_cfg[val].link_up;
+	const char *state = active? "up\n" : "down\n";
+
+	if (input->reply)
+		input->reply(input, state, strlen(state));
+	else
+		plog_info("%s", state);
+
+	return 0;
+}
+
+static int parse_cmd_xstats(const char *str, struct input *input)
+{
+	unsigned val;
+
+	if (sscanf(str, "%u", &val) != 1) {
+		return -1;
+	}
+
+	cmd_xstats(val);
+	return 0;
+}
+
+static int parse_cmd_stats(const char *str, struct input *input)
+{
+	if (strcmp(str, "") == 0)
+		return -1;
+
+	char buf[32768];
+	char ret2[32768];
+	char *ret = ret2;
+	int list = 0;
+
+	strncpy(buf, str, sizeof(buf) - 1);
+	char *tok;
+	uint64_t stat_val;
+
+	while ((tok = strchr(str, ','))) {
+		*tok = 0;
+		stat_val = stats_parser_get(str);
+
+		ret += sprintf(ret, "%s%"PRIu64"", list? "," :"", stat_val);
+		list = 1;
+		str = tok + 1;
+	}
+
+	stat_val = stats_parser_get(str);
+	ret += sprintf(ret, "%s%"PRIu64"", list? "," :"", stat_val);
+
+	sprintf(ret, "\n");
+
+	if (input->reply)
+		input->reply(input, ret2, strlen(ret2));
+	else
+		plog_info("%s", ret2);
+	return 0;
+}
+
+static void replace_char(char *str, char to_replace, char by)
+{
+	for (size_t i = 0; str[i] != '\0'; ++i) {
+		if (str[i] == to_replace)
+			str[i] = by;
+	}
+}
+
+static int parse_cmd_port_info(const char *str, struct input *input)
+{
+	int val;
+
+	if (strcmp(str, "all") == 0) {
+		val = -1;
+	}
+	else if (sscanf(str, "%d", &val) != 1) {
+		return -1;
+	}
+
+	char port_info[2048];
+
+	cmd_portinfo(val, port_info, sizeof(port_info));
+
+	if (input->reply) {
+		replace_char(port_info, '\n', ',');
+		port_info[strlen(port_info) - 1] = '\n';
+		input->reply(input, port_info, strlen(port_info));
+	} else
+		plog_info("%s", port_info);
+
+	return 0;
+}
+
+static int parse_cmd_ring_info(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], task_id, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			cmd_ringinfo(lcores[i], task_id);
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_port_stats(const char *str, struct input *input)
+{
+	unsigned val;
+
+	if (sscanf(str, "%u", &val) != 1) {
+		return -1;
+	}
+
+	struct get_port_stats s;
+	if (stats_port(val, &s)) {
+		plog_err("Invalid port %u\n", val);
+		return 0;
+	}
+	char buf[256];
+	snprintf(buf, sizeof(buf),
+		 "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64","
+		 "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64","
+		 "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64"\n",
+		 s.no_mbufs_diff, s.ierrors_diff + s.imissed_diff,
+		 s.rx_bytes_diff, s.tx_bytes_diff,
+		 s.rx_pkts_diff, s.tx_pkts_diff,
+		 s.rx_tot, s.tx_tot,
+		 s.no_mbufs_tot, s.ierrors_tot + s.imissed_tot,
+		 s.last_tsc, s.prev_tsc);
+	plog_info("%s", buf);
+	if (input->reply)
+		input->reply(input, buf, strlen(buf));
+	return 0;
+}
+
+static int parse_cmd_core_stats(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			uint64_t tot_rx = stats_core_task_tot_rx(lcore_id, task_id);
+			uint64_t tot_tx = stats_core_task_tot_tx(lcore_id, task_id);
+			uint64_t tot_drop = stats_core_task_tot_drop(lcore_id, task_id);
+			uint64_t last_tsc = stats_core_task_last_tsc(lcore_id, task_id);
+
+			if (input->reply) {
+				char buf[128];
+				snprintf(buf, sizeof(buf),
+				 	"%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64"\n",
+				 	tot_rx, tot_tx, tot_drop, last_tsc, rte_get_tsc_hz());
+				input->reply(input, buf, strlen(buf));
+			}
+			else {
+				plog_info("RX: %"PRIu64", TX: %"PRIu64", DROP: %"PRIu64"\n",
+				  	tot_rx, tot_tx, tot_drop);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_lat_stats(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if (!task_is_mode(lcore_id, task_id, "lat", "")) {
+				plog_err("Core %u task %u is not measuring latency\n", lcore_id, task_id);
+			}
+			else {
+				struct stats_latency *stats = stats_latency_find(lcore_id, task_id);
+				struct stats_latency *tot = stats_latency_tot_find(lcore_id, task_id);
+
+				uint64_t last_tsc = stats_core_task_last_tsc(lcore_id, task_id);
+				uint64_t lat_min_usec = time_unit_to_usec(&stats->min.time);
+				uint64_t lat_max_usec = time_unit_to_usec(&stats->max.time);
+				uint64_t tot_lat_min_usec = time_unit_to_usec(&tot->min.time);
+				uint64_t tot_lat_max_usec = time_unit_to_usec(&tot->max.time);
+				uint64_t lat_avg_usec = time_unit_to_usec(&stats->avg.time);
+
+				if (input->reply) {
+					char buf[128];
+					snprintf(buf, sizeof(buf),
+					 	"%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64"\n",
+						 lat_min_usec,
+						 lat_max_usec,
+						 lat_avg_usec,
+						 tot_lat_min_usec,
+						 tot_lat_max_usec,
+						 last_tsc,
+						 rte_get_tsc_hz());
+					input->reply(input, buf, strlen(buf));
+				}
+				else {
+					plog_info("min: %"PRIu64", max: %"PRIu64", avg: %"PRIu64", min since reset: %"PRIu64", max since reset: %"PRIu64"\n",
+						  lat_min_usec,
+						  lat_max_usec,
+						  lat_avg_usec,
+						  tot_lat_min_usec,
+						  tot_lat_max_usec);
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_irq(const char *str, struct input *input)
+{
+	unsigned int i, c;
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (c = 0; c < nb_cores; c++) {
+			lcore_id = lcores[c];
+			if (!task_is_mode(lcore_id, task_id, "irq", "")) {
+				plog_err("Core %u task %u is not in irq mode\n", lcore_id, task_id);
+			} else {
+				struct task_irq *task_irq = (struct task_irq *)(lcore_cfg[lcore_id].tasks_all[task_id]);
+
+				task_irq_show_stats(task_irq, input);
+			}
+		}
+	}
+	return 0;
+}
+
+static void task_lat_show_latency_histogram(uint8_t lcore_id, uint8_t task_id, struct input *input)
+{
+#ifdef LATENCY_HISTOGRAM
+	uint64_t *buckets;
+
+	stats_core_lat_histogram(lcore_id, task_id, &buckets);
+
+	if (buckets == NULL)
+		return;
+
+	if (input->reply) {
+		char buf[4096] = {0};
+		for (size_t i = 0; i < 128; i++)
+			sprintf(buf+strlen(buf), "Bucket [%zu]: %"PRIu64"\n", i, buckets[i]);
+		input->reply(input, buf, strlen(buf));
+	}
+	else {
+		for (size_t i = 0; i < 128; i++)
+			if (buckets[i])
+				plog_info("Bucket [%zu]: %"PRIu64"\n", i, buckets[i]);
+	}
+#else
+	plog_info("LATENCY_DETAILS disabled\n");
+#endif
+}
+
+static int parse_cmd_lat_packets(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+			if (!task_is_mode(lcore_id, task_id, "lat", "")) {
+				plog_err("Core %u task %u is not measuring latency\n", lcore_id, task_id);
+			}
+			else {
+				task_lat_show_latency_histogram(lcore_id, task_id, input);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_cgnat_public_hash(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+
+			if (!task_is_mode(lcore_id, task_id, "cgnat", "")) {
+				plog_err("Core %u task %u is not cgnat\n", lcore_id, task_id);
+			}
+			else {
+				struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+				task_cgnat_dump_public_hash((struct task_nat *)tbase);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_cgnat_private_hash(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+	uint32_t val;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+
+			if (!task_is_mode(lcore_id, task_id, "cgnat", "")) {
+				plog_err("Core %u task %u is not cgnat\n", lcore_id, task_id);
+			}
+			else {
+				struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+				task_cgnat_dump_private_hash((struct task_nat *)tbase);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_accuracy(const char *str, struct input *input)
+{
+	unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
+	uint32_t val;
+
+	if (parse_core_task(str, lcores, &task_id, &nb_cores))
+		return -1;
+	if (!(str = strchr_skip_twice(str, ' ')))
+		return -1;
+	if (sscanf(str, "%"PRIu32"", &val) != 1)
+		return -1;
+
+	if (cores_task_are_valid(lcores, task_id, nb_cores)) {
+		for (unsigned int i = 0; i < nb_cores; i++) {
+			lcore_id = lcores[i];
+
+			if (!task_is_mode(lcore_id, task_id, "lat", "")) {
+				plog_err("Core %u task %u is not measuring latency\n", lcore_id, task_id);
+			}
+			else {
+				struct task_base *tbase = lcore_cfg[lcore_id].tasks_all[task_id];
+
+				task_lat_set_accuracy_limit((struct task_lat *)tbase, val);
+			}
+		}
+	}
+	return 0;
+}
+
+static int parse_cmd_rx_tx_info(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	cmd_rx_tx_info();
+	return 0;
+}
+
+static int parse_cmd_version(const char *str, struct input *input)
+{
+	if (strcmp(str, "") != 0) {
+		return -1;
+	}
+
+	if (input->reply) {
+		uint64_t version =
+			((uint64_t)VERSION_MAJOR) << 24 |
+			((uint64_t)VERSION_MINOR) << 16 |
+			((uint64_t)VERSION_REV) << 8;
+
+		char buf[128];
+		snprintf(buf, sizeof(buf), "%"PRIu64",%"PRIu64"\n", version, (uint64_t)RTE_VERSION);
+		input->reply(input, buf, strlen(buf));
+	}
+	else {
+		plog_info("prox version: %d.%d, DPDK version: %s\n",
+			  VERSION_MAJOR, VERSION_MINOR,
+			  rte_version() + sizeof(RTE_VER_PREFIX));
+	}
+	return 0;
+}
+
+struct cmd_str {
+	const char *cmd;
+	const char *args;
+	const char *help;
+	int (*parse)(const char *args, struct input *input);
+};
+
+static int parse_cmd_help(const char *str, struct input *input);
+
+static struct cmd_str cmd_strings[] = {
+	{"history", "", "Print command history", parse_cmd_history},
+	{"echo", "", "echo parameter, useful to resolving variables", parse_cmd_echo},
+	{"quit", "", "Stop all cores and quit", parse_cmd_quit},
+	{"quit_force", "", "Quit without waiting on cores to stop", parse_cmd_quit_force},
+	{"help", "<substr>", "Show list of commands that have <substr> as a substring. If no substring is provided, all commands are shown.", parse_cmd_help},
+	{"verbose", "<level>", "Set verbosity level", parse_cmd_verbose},
+	{"thread info", "<core_id> <task_id>", "", parse_cmd_thread_info},
+	{"mem info", "", "Show information about system memory (number of huge pages and addresses of these huge pages)", parse_cmd_mem_info},
+	{"update interval", "<value>", "Update statistics refresh rate, in msec (must be >=10). Default is 1 second", parse_cmd_update_interval},
+	{"rx tx info", "", "Print connections between tasks on all cores", parse_cmd_rx_tx_info},
+	{"start", "<core list>|all <task_id>", "Start core <core_id> or all cores", parse_cmd_start},
+	{"stop", "<core list>|all <task_id>", "Stop core <core id> or all cores", parse_cmd_stop},
+
+	{"dump", "<core id> <task id> <nb packets>", "Create a hex dump of <nb_packets> from <task_id> on <core_id> showing how packets have changed between RX and TX.", parse_cmd_trace},
+	{"dump_rx", "<core id> <task id> <nb packets>", "Create a hex dump of <nb_packets> from <task_id> on <core_id> at RX", parse_cmd_dump_rx},
+	{"dump_tx", "<core id> <task id> <nb packets>", "Create a hex dump of <nb_packets> from <task_id> on <core_id> at TX", parse_cmd_dump_tx},
+	{"rx distr start", "", "Start gathering statistical distribution of received packets", parse_cmd_rx_distr_start},
+	{"rx distr stop", "", "Stop gathering statistical distribution of received packets", parse_cmd_rx_distr_stop},
+	{"rx distr reset", "", "Reset gathered statistical distribution of received packets", parse_cmd_rx_distr_reset},
+	{"rx distr show", "", "Display gathered statistical distribution of received packets", parse_cmd_rx_distr_show},
+	{"tx distr start", "", "Start gathering statistical distribution of xmitted packets", parse_cmd_tx_distr_start},
+	{"tx distr stop", "", "Stop gathering statistical distribution of xmitted packets", parse_cmd_tx_distr_stop},
+	{"tx distr reset", "", "Reset gathered statistical distribution of xmitted packets", parse_cmd_tx_distr_reset},
+	{"tx distr show", "", "Display gathered statistical distribution of xmitted packets", parse_cmd_tx_distr_show},
+
+	{"rate", "<port id> <queue id> <rate>", "rate does not include preamble, SFD and IFG", parse_cmd_rate},
+	{"count","<core id> <task id> <count>", "Generate <count> packets", parse_cmd_count},
+	{"bypass", "<core_id> <task_id>", "Bypass task", parse_cmd_bypass},
+	{"reconnect", "<core_id> <task_id>", "Reconnect task", parse_cmd_reconnect},
+	{"pkt_size", "<core_id> <task_id> <pkt_size>", "Set the packet size to <pkt_size>", parse_cmd_pkt_size},
+	{"speed", "<core_id> <task_id> <speed percentage>", "Change the speed to <speed percentage> at which packets are being generated on core <core_id> in task <task_id>.", parse_cmd_speed},
+	{"speed_byte", "<core_id> <task_id> <speed>", "Change speed to <speed>. The speed is specified in units of bytes per second.", parse_cmd_speed_byte},
+	{"set value", "<core_id> <task_id> <offset> <value> <value_len>", "Set <value_len> bytes to <value> at offset <offset> in packets generated on <core_id> <task_id>", parse_cmd_set_value},
+	{"set random", "<core_id> <task_id> <offset> <random_str> <value_len>", "Set <value_len> bytes to <rand_str> at offset <offset> in packets generated on <core_id> <task_id>", parse_cmd_set_random},
+	{"reset values all", "", "Undo all \"set value\" commands on all cores/tasks", parse_cmd_reset_values_all},
+	{"reset randoms all", "", "Undo all \"set random\" commands on all cores/tasks", parse_cmd_reset_randoms_all},
+	{"reset values", "<core id> <task id>", "Undo all \"set value\" commands on specified core/task", parse_cmd_reset_values},
+
+	{"arp add", "<core id> <task id> <port id> <gre id> <svlan> <cvlan> <ip addr> <mac addr> <user>", "Add a single ARP entry into a CPE table on <core id>/<task id>.", parse_cmd_arp_add},
+	{"rule add", "<core id> <task id> svlan_id&mask cvlan_id&mask ip_proto&mask source_ip/prefix destination_ip/prefix range dport_range action", "Add a rule to the ACL table on <core id>/<task id>", parse_cmd_rule_add},
+	{"route add", "<core id> <task id> <ip/prefix> <next hop id>", "Add a route to the routing table on core <core id> <task id>. Example: route add 10.0.16.0/24 9", parse_cmd_route_add},
+	{"gateway ip", "<core id> <task id> <ip>", "Define/Change IP address of destination gateway on core <core id> <task id>.", parse_cmd_gateway_ip},
+	{"local ip", "<core id> <task id> <ip>", "Define/Change IP address of destination gateway on core <core id> <task id>.", parse_cmd_local_ip},
+
+	{"pps unit", "", "Change core stats pps unit", parse_cmd_pps_unit},
+	{"reset stats", "", "Reset all statistics", parse_cmd_reset_stats},
+	{"reset lat stats", "", "Reset all latency statistics", parse_cmd_reset_lat_stats},
+	{"tot stats", "", "Print total RX and TX packets", parse_cmd_tot_stats},
+	{"tot ierrors tot", "", "Print total number of ierrors since reset", parse_cmd_tot_ierrors_tot},
+	{"tot imissed tot", "", "Print total number of imissed since reset", parse_cmd_tot_imissed_tot},
+	{"lat stats", "<core id> <task id>", "Print min,max,avg latency as measured during last sampling interval", parse_cmd_lat_stats},
+	{"irq stats", "<core id> <task id>", "Print irq related infos", parse_cmd_irq},
+	{"lat packets", "<core id> <task id>", "Print the latency for each of the last set of packets", parse_cmd_lat_packets},
+	{"accuracy limit", "<core id> <task id> <nsec>", "Only consider latency of packets that were measured with an error no more than <nsec>", parse_cmd_accuracy},
+	{"core stats", "<core id> <task id>", "Print rx/tx/drop for task <task id> running on core <core id>", parse_cmd_core_stats},
+	{"port_stats", "<port id>", "Print rate for no_mbufs, ierrors + imissed, rx_bytes, tx_bytes, rx_pkts, tx_pkts; totals for RX, TX, no_mbufs, ierrors + imissed for port <port id>", parse_cmd_port_stats},
+	{"read reg", "", "Read register", parse_cmd_read_reg},
+	{"write reg", "", "Read register", parse_cmd_write_reg},
+	{"set vlan offload", "", "Set Vlan offload", parse_cmd_set_vlan_offload},
+	{"set vlan filter", "", "Set Vlan filter", parse_cmd_set_vlan_filter},
+	{"reset cache", "", "Reset cache", parse_cmd_cache_reset},
+	{"set cache class mask", "<core id> <class> <mask>", "Set cache class mask for <core id>", parse_cmd_set_cache_class_mask},
+	{"get cache class mask", "<core id> <class>", "Get cache class mask", parse_cmd_get_cache_class_mask},
+	{"set cache class", "<core id> <class>", "Set cache class", parse_cmd_set_cache_class},
+	{"get cache class", "<core id>", "Get cache class", parse_cmd_get_cache_class},
+	{"get cache mask", "<core id>", "Get cache mask", parse_cmd_get_cache_mask},
+	{"reset port", "", "Reset port", parse_cmd_reset_port},
+	{"ring info all", "", "Get information about ring, such as ring size and number of elements in the ring", parse_cmd_ring_info_all},
+	{"ring info", "<core id> <task id>", "Get information about ring on core <core id> in task <task id>, such as ring size and number of elements in the ring", parse_cmd_ring_info},
+	{"port info", "<port id> [brief?]", "Get port related information, such as MAC address, socket, number of descriptors..., . Adding \"brief\" after command prints short version of output.", parse_cmd_port_info},
+	{"port up", "<port id>", "Set the port up", parse_cmd_port_up},
+	{"port down", "<port id>", "Set the port down", parse_cmd_port_down},
+	{"port link state", "<port id>", "Get link state (up or down) for port", parse_cmd_port_link_state},
+	{"port xstats", "<port id>", "Get extra statistics for the port", parse_cmd_xstats},
+	{"stats", "<stats_path>", "Get stats as sepcified by <stats_path>. A comma-separated list of <stats_path> can be supplied", parse_cmd_stats},
+	{"cgnat dump public hash", "<core id> <task id>", "Dump cgnat public hash table", parse_cmd_cgnat_public_hash},
+	{"cgnat dump private hash", "<core id> <task id>", "Dump cgnat private hash table", parse_cmd_cgnat_private_hash},
+	{"delay_us", "<core_id> <task_id> <delay_us>", "Set the delay in usec for the impair mode to <delay_us>", parse_cmd_delay_us},
+	{"random delay_us", "<core_id> <task_id> <random delay_us>", "Set the delay in usec for the impair mode to <random delay_us>", parse_cmd_random_delay_us},
+	{"probability", "<core_id> <task_id> <probability>", "Set the percent of forwarded packets for the impair mode", parse_cmd_set_probability},
+	{"version", "", "Show version", parse_cmd_version},
+	{0,0,0,0},
+};
+
+static int parse_cmd_help(const char *str, struct input *input)
+{
+	/* str contains the arguments, all commands that have str as a
+	   substring will be shown. */
+	size_t len, len2, longest_cmd = 0;
+	for (size_t i = 0; i < cmd_parser_n_cmd(); ++i) {
+		if (longest_cmd <strlen(cmd_strings[i].cmd))
+			longest_cmd = strlen(cmd_strings[i].cmd);
+	}
+	/* A single call to log will be executed after the help string
+	   has been built. The reason for this is to make use of the
+	   built-in pager. */
+	char buf[32768] = {0};
+
+	for (size_t i = 0; i < cmd_parser_n_cmd(); ++i) {
+		int is_substr = 0;
+		const size_t cmd_len = strlen(cmd_strings[i].cmd);
+		for (size_t j = 0; j < cmd_len; ++j) {
+			is_substr = 1;
+			for (size_t k = 0; k < strlen(str); ++k) {
+				if (str[k] != (cmd_strings[i].cmd + j)[k]) {
+					is_substr = 0;
+					break;
+				}
+			}
+			if (is_substr)
+				break;
+		}
+		if (!is_substr)
+			continue;
+
+		snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%s", cmd_strings[i].cmd);
+		len = strlen(cmd_strings[i].cmd);
+		while (len < longest_cmd) {
+			len++;
+			snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " ");
+		}
+
+		if (strlen(cmd_strings[i].args)) {
+			char tmp[256] = {0};
+			strncpy(tmp, cmd_strings[i].args, 128);
+			snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "Arguments: %s\n", tmp);
+			len2 = len;
+			if (strlen(cmd_strings[i].help)) {
+				while (len2) {
+					len2--;
+			snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " ");
+				}
+			}
+		}
+
+		if (strlen(cmd_strings[i].help)) {
+			int add = 0;
+			const char *h = cmd_strings[i].help;
+			do {
+				if (add) {
+					len2 = len;
+					while (len2) {
+						len2--;
+						snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " ");
+					}
+				}
+				char tmp[128] = {0};
+				const size_t max_len = strlen(h) > 80? 80 : strlen(h);
+				size_t len3 = max_len;
+				if (len3 == 80) {
+					while (len3 && h[len3] != ' ')
+						len3--;
+					if (len3 == 0)
+						len3 = max_len;
+				}
+
+				strncpy(tmp, h, len3);
+				h += len3;
+				while (h[0] == ' ' && strlen(h))
+					h++;
+
+				snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%s\n", tmp);
+				add = 1;
+			} while(strlen(h));
+		}
+		if (strlen(cmd_strings[i].help) == 0&& strlen(cmd_strings[i].args) == 0) {
+			snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "\n");
+		}
+	}
+	plog_info("%s", buf);
+
+	return 0;
+}
+
+const char *cmd_parser_cmd(size_t i)
+{
+	i = i < cmd_parser_n_cmd()? i: cmd_parser_n_cmd();
+	return cmd_strings[i].cmd;
+}
+
+size_t cmd_parser_n_cmd(void)
+{
+	return sizeof(cmd_strings)/sizeof(cmd_strings[0]) - 1;
+}
+
+void cmd_parser_parse(const char *str, struct input *input)
+{
+	size_t skip;
+
+	for (size_t i = 0; i < cmd_parser_n_cmd(); ++i) {
+		skip = strlen(cmd_strings[i].cmd);
+		if (strncmp(cmd_strings[i].cmd, str, skip) == 0 &&
+		    (str[skip] == ' ' || str[skip] == 0)) {
+			while (str[skip] == ' ')
+				skip++;
+
+			if (cmd_strings[i].parse(str + skip, input) != 0) {
+				plog_warn("Invalid syntax for command '%s': %s %s\n",
+					  cmd_strings[i].cmd, cmd_strings[i].args, cmd_strings[i].help);
+			}
+			return ;
+		}
+	}
+
+	plog_err("Unknown command: '%s'\n", str);
+}
diff --git a/VNFs/DPPD-PROX/cmd_parser.h b/VNFs/DPPD-PROX/cmd_parser.h
new file mode 100644
index 00000000..05284bb7
--- /dev/null
+++ b/VNFs/DPPD-PROX/cmd_parser.h
@@ -0,0 +1,29 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _CMD_PARSER_H_
+#define _CMD_PARSER_H_
+
+#include <stddef.h>
+
+struct input;
+void cmd_parser_parse(const char *str, struct input *input);
+const char *cmd_parser_cmd(size_t i);
+size_t cmd_parser_n_cmd(void);
+int task_is_mode(uint32_t lcore_id, uint32_t task_id, const char *mode, const char *sub_mode);
+int task_is_sub_mode(uint32_t lcore_id, uint32_t task_id, const char *sub_mode);
+
+#endif /* _CMD_PARSER_H_ */
diff --git a/VNFs/DPPD-PROX/commands.c b/VNFs/DPPD-PROX/commands.c
new file mode 100644
index 00000000..93acc62a
--- /dev/null
+++ b/VNFs/DPPD-PROX/commands.c
@@ -0,0 +1,1016 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <rte_table_hash.h>
+#include <rte_version.h>
+#include <rte_malloc.h>
+
+#include "prox_malloc.h"
+#include "display.h"
+#include "commands.h"
+#include "log.h"
+#include "run.h"
+#include "lconf.h"
+#include "hash_utils.h"
+#include "prox_cfg.h"
+#include "prox_port_cfg.h"
+#include "defines.h"
+#include "handle_qos.h"
+#include "handle_qinq_encap4.h"
+#include "quit.h"
+#include "input.h"
+#include "rw_reg.h"
+#include "cqm.h"
+#include "stats_core.h"
+
+void start_core_all(int task_id)
+{
+	uint32_t cores[RTE_MAX_LCORE];
+	uint32_t lcore_id;
+	char tmp[256];
+	int cnt = 0;
+
+	prox_core_to_str(tmp, sizeof(tmp), 0);
+	plog_info("Starting cores: %s\n", tmp);
+
+	lcore_id = -1;
+	while (prox_core_next(&lcore_id, 0) == 0) {
+		cores[cnt++] = lcore_id;
+	}
+	start_cores(cores, cnt, task_id);
+}
+
+void stop_core_all(int task_id)
+{
+	uint32_t cores[RTE_MAX_LCORE];
+	uint32_t lcore_id;
+	char tmp[256];
+	int cnt = 0;
+
+	prox_core_to_str(tmp, sizeof(tmp), 0);
+	plog_info("Stopping cores: %s\n", tmp);
+
+	lcore_id = -1;
+	while (prox_core_next(&lcore_id, 0) == 0) {
+		cores[cnt++] = lcore_id;
+	}
+
+	stop_cores(cores, cnt, task_id);
+}
+
+static void warn_inactive_cores(uint32_t *cores, int count, const char *prefix)
+{
+	for (int i = 0; i < count; ++i) {
+		if (!prox_core_active(cores[i], 0)) {
+			plog_warn("%s %u: core is not active\n", prefix, cores[i]);
+		}
+	}
+}
+
+static inline int wait_command_handled(struct lcore_cfg *lconf)
+{
+	uint64_t t1 = rte_rdtsc(), t2;
+	while (lconf_is_req(lconf)) {
+		t2 = rte_rdtsc();
+		if (t2 - t1 > 5 * rte_get_tsc_hz()) {
+			// Failed to handle command ...
+			for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+				struct task_args *targs = &lconf->targs[task_id];
+				if (!(targs->flags & TASK_ARG_DROP)) {
+					plogx_err("Failed to handle command - task is in NO_DROP and might be stuck...\n");
+					return - 1;
+				}
+			}
+			plogx_err("Failed to handle command\n");
+			return -1;
+		}
+	}
+	return 0;
+}
+void start_cores(uint32_t *cores, int count, int task_id)
+{
+	int n_started_cores = 0;
+	uint32_t started_cores[RTE_MAX_LCORE];
+
+	warn_inactive_cores(cores, count, "Can't start core");
+
+	for (int i = 0; i < count; ++i) {
+		struct lcore_cfg *lconf = &lcore_cfg[cores[i]];
+
+		if (lconf->n_tasks_run != lconf->n_tasks_all) {
+
+			lconf->msg.type = LCONF_MSG_START;
+			lconf->msg.task_id = task_id;
+			lconf_set_req(lconf);
+			if (task_id == -1)
+				plog_info("Starting core %u (all tasks)\n", cores[i]);
+			else
+				plog_info("Starting core %u task %u\n", cores[i], task_id);
+			started_cores[n_started_cores++] = cores[i];
+			lconf->flags |= LCONF_FLAG_RUNNING;
+			rte_eal_remote_launch(lconf_run, NULL, cores[i]);
+		}
+		else {
+			plog_warn("Core %u is already running all its tasks\n", cores[i]);
+		}
+	}
+
+	/* This function is blocking, so detect when each core has
+	   consumed the message. */
+	for (int i = 0; i < n_started_cores; ++i) {
+		struct lcore_cfg *lconf = &lcore_cfg[started_cores[i]];
+		plog_info("Waiting for core %u to start...", started_cores[i]);
+		if (wait_command_handled(lconf) == -1) return;
+		plog_info(" OK\n");
+	}
+}
+
+void stop_cores(uint32_t *cores, int count, int task_id)
+{
+	int n_stopped_cores = 0;
+	uint32_t stopped_cores[RTE_MAX_LCORE];
+	uint32_t c;
+
+	warn_inactive_cores(cores, count, "Can't stop core");
+
+	for (int i = 0; i < count; ++i) {
+		struct lcore_cfg *lconf = &lcore_cfg[cores[i]];
+		if (lconf->n_tasks_run) {
+			if (wait_command_handled(lconf) == -1) return;
+
+			lconf->msg.type = LCONF_MSG_STOP;
+			lconf->msg.task_id = task_id;
+			lconf_set_req(lconf);
+			stopped_cores[n_stopped_cores++] = cores[i];
+		}
+	}
+
+	for (int i = 0; i < n_stopped_cores; ++i) {
+		c = stopped_cores[i];
+		struct lcore_cfg *lconf = &lcore_cfg[c];
+		if (wait_command_handled(lconf) == -1) return;
+
+		if (lconf->n_tasks_run == 0) {
+			plog_info("All tasks stopped on core %u, waiting for core to stop...", c);
+			rte_eal_wait_lcore(c);
+			plog_info(" OK\n");
+			lconf->flags &= ~LCONF_FLAG_RUNNING;
+		}
+		else {
+			plog_info("Stopped task %u on core %u\n", task_id, c);
+		}
+	}
+}
+
+struct size_unit {
+	uint64_t val;
+	uint64_t frac;
+	char     unit[8];
+};
+
+static struct size_unit to_size_unit(uint64_t bytes)
+{
+	struct size_unit ret;
+
+	if (bytes > 1 << 30) {
+		ret.val = bytes >> 30;
+		ret.frac = ((bytes - (ret.val << 30)) * 1000) / (1 << 30);
+		strcpy(ret.unit, "GB");
+	}
+	else if (bytes > 1 << 20) {
+		ret.val = bytes >> 20;
+		ret.frac = ((bytes - (ret.val << 20)) * 1000) / (1 << 20);
+		strcpy(ret.unit, "MB");
+	}
+	else if (bytes > 1 << 10) {
+		ret.val = bytes >> 10;
+		ret.frac = (bytes - (ret.val << 10)) * 1000 / (1 << 10);
+		strcpy(ret.unit, "KB");
+	}
+	else {
+		ret.val = bytes;
+		ret.frac = 0;
+		strcpy(ret.unit, "B");
+	}
+
+	return ret;
+}
+
+void cmd_mem_stats(void)
+{
+	struct rte_malloc_socket_stats sock_stats;
+	uint64_t v;
+	struct size_unit su;
+
+	for (uint32_t i = 0; i < RTE_MAX_NUMA_NODES; ++i) {
+		if (rte_malloc_get_socket_stats(i, &sock_stats) < 0 || sock_stats.heap_totalsz_bytes == 0)
+			continue;
+
+		plogx_info("Socket %u memory stats:\n", i);
+		su = to_size_unit(sock_stats.heap_totalsz_bytes);
+		plogx_info("\tHeap_size: %zu.%03zu %s\n", su.val, su.frac, su.unit);
+		su = to_size_unit(sock_stats.heap_freesz_bytes);
+		plogx_info("\tFree_size: %zu.%03zu %s\n", su.val, su.frac, su.unit);
+		su = to_size_unit(sock_stats.heap_allocsz_bytes);
+		plogx_info("\tAlloc_size: %zu.%03zu %s\n", su.val, su.frac, su.unit);
+		su = to_size_unit(sock_stats.greatest_free_size);
+		plogx_info("\tGreatest_free_size: %zu %s\n", su.val, su.unit);
+		plogx_info("\tAlloc_count: %u\n", sock_stats.alloc_count);
+		plogx_info("\tFree_count: %u\n", sock_stats.free_count);
+	}
+}
+
+void cmd_mem_layout(void)
+{
+	const struct rte_memseg* memseg = rte_eal_get_physmem_layout();
+
+	plog_info("Memory layout:\n");
+	for (uint32_t i = 0; i < RTE_MAX_MEMSEG; i++) {
+		if (memseg[i].addr == NULL)
+			break;
+
+		const char *sz_str;
+		switch (memseg[i].hugepage_sz >> 20) {
+		case 2:
+			sz_str = "2MB";
+			break;
+		case 1024:
+			sz_str = "1GB";
+			break;
+		default:
+			sz_str = "??";
+		}
+
+		plog_info("Segment %u: [%#lx-%#lx] at %p using %zu pages of %s\n",
+			  i,
+			  memseg[i].phys_addr,
+			  memseg[i].phys_addr + memseg[i].len,
+			  memseg[i].addr,
+			  memseg[i].len/memseg[i].hugepage_sz, sz_str);
+	}
+}
+
+void cmd_dump(uint8_t lcore_id, uint8_t task_id, uint32_t nb_packets, struct input *input, int rx, int tx)
+{
+	plog_info("dump %u %u %u\n", lcore_id, task_id, nb_packets);
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	}
+	else if (task_id >= lcore_cfg[lcore_id].n_tasks_all) {
+		plog_warn("task_id too high, should be in [0, %u]\n", lcore_cfg[lcore_id].n_tasks_all - 1);
+	}
+	else {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		lconf->tasks_all[task_id]->aux->task_rt_dump.input = input;
+
+		if (wait_command_handled(lconf) == -1) return;
+		if (rx && tx)
+			lconf->msg.type = LCONF_MSG_DUMP;
+		else if (rx)
+			lconf->msg.type = LCONF_MSG_DUMP_RX;
+		else if (tx)
+			lconf->msg.type = LCONF_MSG_DUMP_TX;
+
+		if (rx || tx) {
+			lconf->msg.task_id = task_id;
+			lconf->msg.val  = nb_packets;
+			lconf_set_req(lconf);
+		}
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_trace(uint8_t lcore_id, uint8_t task_id, uint32_t nb_packets)
+{
+	plog_info("trace %u %u %u\n", lcore_id, task_id, nb_packets);
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	}
+	else if (task_id >= lcore_cfg[lcore_id].n_tasks_all) {
+		plog_warn("task_id too high, should be in [0, %u]\n", lcore_cfg[lcore_id].n_tasks_all - 1);
+	}
+	else {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+
+		lconf->msg.type = LCONF_MSG_TRACE;
+		lconf->msg.task_id = task_id;
+		lconf->msg.val  = nb_packets;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_rx_bw_start(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else if (lcore_cfg[lcore_id].flags & LCONF_FLAG_RX_BW_ACTIVE) {
+		plog_warn("rx bandwidt already on core %u\n", lcore_id);
+	} else {
+
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_RX_BW_START;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_tx_bw_start(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else if (lcore_cfg[lcore_id].flags & LCONF_FLAG_TX_BW_ACTIVE) {
+		plog_warn("tx bandwidth already running on core %u\n", lcore_id);
+	} else {
+
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_TX_BW_START;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_rx_bw_stop(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else if (!(lcore_cfg[lcore_id].flags & LCONF_FLAG_RX_BW_ACTIVE)) {
+		plog_warn("rx bandwidth not running on core %u\n", lcore_id);
+	} else {
+
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_RX_BW_STOP;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_tx_bw_stop(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else if (!(lcore_cfg[lcore_id].flags & LCONF_FLAG_TX_BW_ACTIVE)) {
+		plog_warn("tx bandwidth not running on core %u\n", lcore_id);
+	} else {
+
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_TX_BW_STOP;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+void cmd_rx_distr_start(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else if (lcore_cfg[lcore_id].flags & LCONF_FLAG_RX_DISTR_ACTIVE) {
+		plog_warn("rx distribution already xrunning on core %u\n", lcore_id);
+	} else {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_RX_DISTR_START;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_tx_distr_start(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else if (lcore_cfg[lcore_id].flags & LCONF_FLAG_TX_DISTR_ACTIVE) {
+		plog_warn("tx distribution already xrunning on core %u\n", lcore_id);
+	} else {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_TX_DISTR_START;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_rx_distr_stop(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else if ((lcore_cfg[lcore_id].flags & LCONF_FLAG_RX_DISTR_ACTIVE) == 0) {
+		plog_warn("rx distribution not running on core %u\n", lcore_id);
+	} else {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_RX_DISTR_STOP;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_tx_distr_stop(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else if ((lcore_cfg[lcore_id].flags & LCONF_FLAG_TX_DISTR_ACTIVE) == 0) {
+		plog_warn("tx distribution not running on core %u\n", lcore_id);
+	} else {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_TX_DISTR_STOP;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_rx_distr_rst(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_RX_DISTR_RESET;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_tx_distr_rst(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (wait_command_handled(lconf) == -1) return;
+		lconf->msg.type = LCONF_MSG_TX_DISTR_RESET;
+		lconf_set_req(lconf);
+
+		if (lconf->n_tasks_run == 0) {
+			lconf_do_flags(lconf);
+		}
+	}
+}
+
+void cmd_rx_distr_show(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else {
+		for (uint32_t i = 0; i < lcore_cfg[lcore_id].n_tasks_all; ++i) {
+			struct task_base *t = lcore_cfg[lcore_id].tasks_all[i];
+			plog_info("t[%u]: ", i);
+			for (uint32_t j = 0; j < sizeof(t->aux->rx_bucket)/sizeof(t->aux->rx_bucket[0]); ++j) {
+				plog_info("%u ", t->aux->rx_bucket[j]);
+			}
+			plog_info("\n");
+		}
+	}
+}
+void cmd_tx_distr_show(uint32_t lcore_id)
+{
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	} else {
+		for (uint32_t i = 0; i < lcore_cfg[lcore_id].n_tasks_all; ++i) {
+			struct task_base *t = lcore_cfg[lcore_id].tasks_all[i];
+			uint64_t tot = 0, avg = 0;
+			for (uint32_t j = 0; j < sizeof(t->aux->tx_bucket)/sizeof(t->aux->tx_bucket[0]); ++j) {
+				tot += t->aux->tx_bucket[j];
+				avg += j * t->aux->tx_bucket[j];
+			}
+			if (tot) {
+				avg = avg / tot;
+			}
+			plog_info("t[%u]: %lu: ", i, avg);
+			for (uint32_t j = 0; j < sizeof(t->aux->tx_bucket)/sizeof(t->aux->tx_bucket[0]); ++j) {
+				plog_info("%u ", t->aux->tx_bucket[j]);
+			}
+			plog_info("\n");
+		}
+	}
+}
+
+void cmd_ringinfo_all(void)
+{
+	struct lcore_cfg *lconf;
+	uint32_t lcore_id = -1;
+
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			cmd_ringinfo(lcore_id, task_id);
+		}
+	}
+}
+
+void cmd_ringinfo(uint8_t lcore_id, uint8_t task_id)
+{
+	struct lcore_cfg *lconf;
+	struct rte_ring *ring;
+	struct task_args* targ;
+	uint32_t count;
+
+	if (!prox_core_active(lcore_id, 0)) {
+		plog_info("lcore %u is not active\n", lcore_id);
+		return;
+	}
+	lconf = &lcore_cfg[lcore_id];
+	if (task_id >= lconf->n_tasks_all) {
+		plog_warn("Invalid task index %u: lcore %u has %u tasks\n", task_id, lcore_id, lconf->n_tasks_all);
+		return;
+	}
+
+	targ = &lconf->targs[task_id];
+	plog_info("Core %u task %u: %u rings\n", lcore_id, task_id, targ->nb_rxrings);
+	for (uint8_t i = 0; i < targ->nb_rxrings; ++i) {
+		ring = targ->rx_rings[i];
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+		count = ring->prod.mask + 1;
+#else
+		count = ring->mask + 1;
+#endif
+		plog_info("\tRing %u:\n", i);
+		plog_info("\t\tFlags: %s,%s\n", ring->flags & RING_F_SP_ENQ? "sp":"mp", ring->flags & RING_F_SC_DEQ? "sc":"mc");
+		plog_info("\t\tMemory size: %zu bytes\n", rte_ring_get_memsize(count));
+		plog_info("\t\tOccupied: %u/%u\n", rte_ring_count(ring), count);
+	}
+}
+
+void cmd_port_up(uint8_t port_id)
+{
+	int err;
+
+	if (!port_is_active(port_id)) {
+		return ;
+	}
+
+	if ((err = rte_eth_dev_set_link_up(port_id)) == 0) {
+		plog_info("Bringing port %d up\n", port_id);
+	}
+	else {
+		plog_warn("Failed to bring port %d up with error %d\n", port_id, err);
+	}
+}
+
+void cmd_port_down(uint8_t port_id)
+{
+	int err;
+
+	if (!port_is_active(port_id)) {
+		return ;
+	}
+
+	if ((err = rte_eth_dev_set_link_down(port_id)) == 0) {
+		plog_info("Bringing port %d down\n", port_id);
+	}
+	else {
+		plog_warn("Failed to bring port %d down with error %d\n", port_id, err);
+	}
+}
+
+void cmd_xstats(uint8_t port_id)
+{
+#if RTE_VERSION >= RTE_VERSION_NUM(16,7,0,0)
+	int n_xstats;
+	struct rte_eth_xstat *eth_xstat = NULL;	// id and value
+	struct rte_eth_xstat_name *eth_xstat_name = NULL;	// only names
+	struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
+	int rc;
+
+	n_xstats = rte_eth_xstats_get(port_id, NULL, 0);
+	eth_xstat_name = prox_zmalloc(n_xstats * sizeof(*eth_xstat_name), port_cfg->socket);
+	PROX_ASSERT(eth_xstat_name);
+	rc = rte_eth_xstats_get_names(port_id, eth_xstat_name, n_xstats);
+	if ((rc < 0) || (rc > n_xstats)) {
+		if (rc < 0) {
+			plog_warn("Failed to get xstats_names on port %d with error %d\n", port_id, rc);
+		} else if (rc > n_xstats) {
+			plog_warn("Failed to get xstats_names on port %d: too many xstats (%d)\n", port_id, rc);
+		}
+	}
+
+	eth_xstat = prox_zmalloc(n_xstats * sizeof(*eth_xstat), port_cfg->socket);
+	PROX_ASSERT(eth_xstat);
+	rc = rte_eth_xstats_get(port_id, eth_xstat, n_xstats);
+	if ((rc < 0) || (rc > n_xstats)) {
+		if (rc < 0) {
+			plog_warn("Failed to get xstats on port %d with error %d\n", port_id, rc);
+		} else if (rc > n_xstats) {
+			plog_warn("Failed to get xstats on port %d: too many xstats (%d)\n", port_id, rc);
+		}
+	} else {
+		for (int i=0;i<rc;i++) {
+			plog_info("%s: %ld\n", eth_xstat_name[i].name, eth_xstat[i].value);
+		}
+	}
+	if (eth_xstat_name)
+		prox_free(eth_xstat_name);
+	if (eth_xstat)
+		prox_free(eth_xstat);
+#else
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
+	int n_xstats;
+	struct rte_eth_xstats *eth_xstats;
+	struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
+	int rc;
+
+	n_xstats = rte_eth_xstats_get(port_id, NULL, 0);
+	eth_xstats = prox_zmalloc(n_xstats * sizeof(*eth_xstats), port_cfg->socket);
+	PROX_ASSERT(eth_xstats);
+	rc = rte_eth_xstats_get(port_id, eth_xstats, n_xstats);
+	if ((rc < 0) || (rc > n_xstats)) {
+		if (rc < 0) {
+			plog_warn("Failed to get xstats on port %d with error %d\n", port_id, rc);
+		} else if (rc > n_xstats) {
+			plog_warn("Failed to get xstats on port %d: too many xstats (%d)\n", port_id, rc);
+		}
+	} else {
+		for (int i=0;i<rc;i++) {
+			plog_info("%s: %ld\n", eth_xstats[i].name, eth_xstats[i].value);
+		}
+	}
+	if (eth_xstats)
+		prox_free(eth_xstats);
+#else
+	plog_warn("Failed to get xstats, xstats are not supported in this version of dpdk\n");
+#endif
+#endif
+}
+
+void cmd_portinfo(int port_id, char *dst, size_t max_len)
+{
+	char *end = dst + max_len;
+
+	*dst = 0;
+	if (port_id == -1) {
+		uint8_t max_port_idx = prox_last_port_active() + 1;
+
+		for (uint8_t port_id = 0; port_id < max_port_idx; ++port_id) {
+			if (!prox_port_cfg[port_id].active) {
+				continue;
+			}
+			struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
+
+			dst += snprintf(dst, end - dst,
+					"%2d:%10s; "MAC_BYTES_FMT"; %s\n",
+					port_id,
+					port_cfg->name,
+					MAC_BYTES(port_cfg->eth_addr.addr_bytes),
+					port_cfg->pci_addr);
+		}
+		return;
+	}
+
+	if (!port_is_active(port_id)) {
+		return ;
+	}
+
+	struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
+
+	dst += snprintf(dst, end - dst, "Port info for port %u\n", port_id);
+	dst += snprintf(dst, end - dst, "\tName: %s\n", port_cfg->name);
+	dst += snprintf(dst, end - dst, "\tDriver: %s\n", port_cfg->driver_name);
+	dst += snprintf(dst, end - dst, "\tMac address: "MAC_BYTES_FMT"\n", MAC_BYTES(port_cfg->eth_addr.addr_bytes));
+	dst += snprintf(dst, end - dst, "\tLink speed: %u Mbps\n", port_cfg->link_speed);
+	dst += snprintf(dst, end - dst, "\tLink status: %s\n", port_cfg->link_up? "up" : "down");
+	dst += snprintf(dst, end - dst, "\tSocket: %u\n", port_cfg->socket);
+	dst += snprintf(dst, end - dst, "\tPCI address: %s\n", port_cfg->pci_addr);
+	dst += snprintf(dst, end - dst, "\tPromiscuous: %s\n", port_cfg->promiscuous? "yes" : "no");
+	dst += snprintf(dst, end - dst, "\tNumber of RX/TX descriptors: %u/%u\n", port_cfg->n_rxd, port_cfg->n_txd);
+	dst += snprintf(dst, end - dst, "\tNumber of RX/TX queues: %u/%u (max: %u/%u)\n", port_cfg->n_rxq, port_cfg->n_txq, port_cfg->max_rxq, port_cfg->max_txq);
+	dst += snprintf(dst, end - dst, "\tMemory pools:\n");
+
+	for (uint8_t i = 0; i < 32; ++i) {
+		if (port_cfg->pool[i]) {
+			dst += snprintf(dst, end - dst, "\t\tname: %s (%p)\n",
+					port_cfg->pool[i]->name, port_cfg->pool[i]);
+		}
+	}
+}
+
+void cmd_read_reg(uint8_t port_id, unsigned int id)
+{
+	unsigned int val, rc;
+	if (!port_is_active(port_id)) {
+		return ;
+	}
+	rc = read_reg(port_id, id, &val);
+	if (rc) {
+		plog_warn("Failed to read register %d on port %d\n", id, port_id);
+	}
+	else {
+		plog_info("Register 0x%08X : %08X \n", id, val);
+	}
+}
+
+void cmd_reset_port(uint8_t portid)
+{
+	unsigned int rc;
+	if (!prox_port_cfg[portid].active) {
+		plog_info("port not active \n");
+		return;
+	}
+	rte_eth_dev_stop(portid);
+	rc = rte_eth_dev_start(portid);
+	if (rc) {
+		plog_warn("Failed to restart port %d\n", portid);
+	}
+}
+void cmd_write_reg(uint8_t port_id, unsigned int id, unsigned int val)
+{
+	if (!port_is_active(port_id)) {
+		return ;
+	}
+
+	plog_info("writing 0x%08X %08X\n", id, val);
+	write_reg(port_id, id, val);
+}
+
+void cmd_set_vlan_offload(uint8_t port_id, unsigned int val)
+{
+	if (!port_is_active(port_id)) {
+		return ;
+	}
+
+	plog_info("setting vlan offload to %d\n", val);
+	if (val & ~(ETH_VLAN_STRIP_OFFLOAD | ETH_VLAN_FILTER_OFFLOAD | ETH_VLAN_EXTEND_OFFLOAD)) {
+		plog_info("wrong vlan offload value\n");
+	}
+	int ret = rte_eth_dev_set_vlan_offload(port_id, val);
+	plog_info("rte_eth_dev_set_vlan_offload return %d\n", ret);
+}
+
+void cmd_set_vlan_filter(uint8_t port_id, unsigned int id, unsigned int val)
+{
+	if (!port_is_active(port_id)) {
+		return ;
+	}
+
+	plog_info("setting vln filter for vlan %d to %d\n", id, val);
+	int ret = rte_eth_dev_vlan_filter(port_id, id, val);
+	plog_info("rte_eth_dev_vlan_filter return %d\n", ret);
+}
+
+void cmd_thread_info(uint8_t lcore_id, uint8_t task_id)
+{
+	plog_info("thread_info %u %u \n", lcore_id, task_id);
+	if (lcore_id > RTE_MAX_LCORE) {
+		plog_warn("core_id too high, maximum allowed is: %u\n", RTE_MAX_LCORE);
+	}
+	if (!prox_core_active(lcore_id, 0)) {
+		plog_warn("lcore %u is not active\n", lcore_id);
+		return;
+	}
+	if (task_id >= lcore_cfg[lcore_id].n_tasks_all) {
+		plog_warn("task_id too high, should be in [0, %u]\n", lcore_cfg[lcore_id].n_tasks_all - 1);
+		return;
+	}
+	if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "qos") == 0) {
+		struct task_base *task;
+
+		task = lcore_cfg[lcore_id].tasks_all[task_id];
+		plog_info("core %d, task %d: %d mbufs stored in QoS\n", lcore_id, task_id,
+			  task_qos_n_pkts_buffered(task));
+
+#ifdef ENABLE_EXTRA_USER_STATISTICS
+	}
+	else if (lcore_cfg[lcore_id].targs[task_id].mode == QINQ_ENCAP4) {
+		struct task_qinq_encap4 *task;
+		task = (struct task_qinq_encap4 *)(lcore_cfg[lcore_id].tasks_all[task_id]);
+		for (int i=0;i<task->n_users;i++) {
+			if (task->stats_per_user[i])
+				plog_info("User %d: %d packets\n", i, task->stats_per_user[i]);
+		}
+#endif
+	}
+	else {
+		// Only QoS thread info so far
+		plog_err("core %d, task %d: not a qos core (%p)\n", lcore_id, task_id, lcore_cfg[lcore_id].thread_x);
+	}
+}
+
+void cmd_rx_tx_info(void)
+{
+	uint32_t lcore_id = -1;
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		for (uint8_t task_id = 0; task_id < lcore_cfg[lcore_id].n_tasks_all; ++task_id) {
+			struct task_args *targ = &lcore_cfg[lcore_id].targs[task_id];
+
+			plog_info("Core %u:", lcore_id);
+			if (targ->rx_port_queue[0].port != OUT_DISCARD) {
+				for (int i = 0; i < targ->nb_rxports; i++) {
+					plog_info(" RX port %u (queue %u)", targ->rx_port_queue[i].port, targ->rx_port_queue[i].queue);
+				}
+			}
+			else {
+				for (uint8_t j = 0; j < targ->nb_rxrings; ++j) {
+					plog_info(" RX ring[%u,%u] %p", task_id, j, targ->rx_rings[j]);
+				}
+			}
+			plog_info(" ==>");
+			for (uint8_t j = 0; j < targ->nb_txports; ++j) {
+				plog_info(" TX port %u (queue %u)", targ->tx_port_queue[j].port,
+					  targ->tx_port_queue[j].queue);
+			}
+
+			for (uint8_t j = 0; j < targ->nb_txrings; ++j) {
+				plog_info(" TX ring %p", targ->tx_rings[j]);
+			}
+
+			plog_info("\n");
+		}
+	}
+}
+void cmd_get_cache_class(uint32_t lcore_id, uint32_t *set)
+{
+	uint64_t tmp_rmid = 0;
+	cqm_assoc_read(lcore_id, &tmp_rmid);
+	*set = (uint32_t)(tmp_rmid >> 32);
+}
+
+void cmd_get_cache_class_mask(uint32_t lcore_id, uint32_t set, uint32_t *val)
+{
+	cat_get_class_mask(lcore_id, set, val);
+}
+
+void cmd_set_cache_class_mask(uint32_t lcore_id, uint32_t set, uint32_t val)
+{
+	cat_set_class_mask(lcore_id, set, val);
+	lcore_cfg[lcore_id].cache_set = set;
+	uint32_t id = -1;
+	while(prox_core_next(&id, 0) == 0) {
+		if ((lcore_cfg[id].cache_set == set) && (rte_lcore_to_socket_id(id) == rte_lcore_to_socket_id(lcore_id))) {
+			plog_info("Updating mask for core %d to %d\n", id, set);
+			stats_update_cache_mask(id, val);
+		}
+	}
+}
+
+void cmd_set_cache_class(uint32_t lcore_id, uint32_t set)
+{
+	uint64_t tmp_rmid = 0;
+	uint32_t val = 0;
+	cqm_assoc_read(lcore_id, &tmp_rmid);
+	cqm_assoc(lcore_id, (tmp_rmid & 0xffffffff) | ((set * 1L) << 32));
+	cat_get_class_mask(lcore_id, set, &val);
+	stats_update_cache_mask(lcore_id, val);
+}
+
+void cmd_cache_reset(void)
+{
+	uint8_t sockets[MAX_SOCKETS] = {0};
+	uint8_t cores[MAX_SOCKETS] = {0};
+	uint32_t mask = (1 << cat_get_num_ways()) - 1;
+	uint32_t lcore_id = -1, socket_id;
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		cqm_assoc(lcore_id, 0);
+		socket_id = rte_lcore_to_socket_id(lcore_id);
+		if (socket_id < MAX_SOCKETS) {
+			sockets[socket_id] = 1;
+			cores[socket_id] = lcore_id;
+		}
+		stats_update_cache_mask(lcore_id, mask);
+		plog_info("Setting core %d to cache mask %x\n", lcore_id, mask);
+		lcore_cfg[lcore_id].cache_set = 0;
+	}
+	for (uint32_t s = 0; s < MAX_SOCKETS; s++) {
+		if (sockets[s])
+			cat_reset_cache(cores[s]);
+	}
+	stats_lcore_assoc_rmid();
+}
+
+int bypass_task(uint32_t lcore_id, uint32_t task_id)
+{
+	struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+	struct task_args *targ, *starg, *dtarg;
+	struct rte_ring *ring = NULL;
+
+	if (task_id >= lconf->n_tasks_all)
+		return -1;
+
+	targ = &lconf->targs[task_id];
+	if (targ->nb_txrings == 1) {
+		plog_info("Task has %d receive and 1 transmmit ring and can be bypassed, %d precedent tasks\n", targ->nb_rxrings, targ->n_prev_tasks);
+		// Find source task
+		for (unsigned int i = 0; i < targ->n_prev_tasks; i++) {
+			starg = targ->prev_tasks[i];
+			for (unsigned int j = 0; j < starg->nb_txrings; j++) {
+				for (unsigned int k = 0; k < targ->nb_rxrings; k++) {
+					if (starg->tx_rings[j] == targ->rx_rings[k]) {
+						plog_info("bypassing ring %p and connecting it to %p\n", starg->tx_rings[j], targ->tx_rings[0]);
+						starg->tx_rings[j] = targ->tx_rings[0];
+						struct task_base *tbase = starg->tbase;
+						tbase->tx_params_sw.tx_rings[j] = starg->tx_rings[j];
+					}
+				}
+			}
+		}
+	} else {
+		plog_info("Task has %d receive and %d transmit ring and cannot be bypassed\n", targ->nb_rxrings, targ->nb_txrings);
+		return -1;
+	}
+
+	return 0;
+}
+
+int reconnect_task(uint32_t lcore_id, uint32_t task_id)
+{
+	struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+	struct task_args *targ, *starg, *dtarg = NULL;
+	struct rte_ring *ring = NULL;
+
+	if (task_id >= lconf->n_tasks_all)
+		return -1;
+
+	targ = &lconf->targs[task_id];
+	if (targ->nb_txrings == 1) {
+		// Find source task
+		for (unsigned int i = 0; i < targ->n_prev_tasks; i++) {
+			starg = targ->prev_tasks[i];
+			for (unsigned int j = 0; j < starg->nb_txrings; j++) {
+				if (starg->tx_rings[j] == targ->tx_rings[0]) {
+					if (targ->n_prev_tasks == targ->nb_rxrings) {
+						starg->tx_rings[j] = targ->rx_rings[i];
+						struct task_base *tbase = starg->tbase;
+						tbase->tx_params_sw.tx_rings[j] = starg->tx_rings[j];
+						plog_info("Task has %d receive and 1 transmmit ring and can be reconnected, %d precedent tasks\n", targ->nb_rxrings, targ->n_prev_tasks);
+					} else if (targ->nb_rxrings == 1) {
+						starg->tx_rings[j] = targ->rx_rings[0];
+						struct task_base *tbase = starg->tbase;
+						tbase->tx_params_sw.tx_rings[j] = starg->tx_rings[j];
+						plog_info("Task has %d receive and 1 transmmit ring and ring %p can be reconnected, %d precedent tasks\n", targ->nb_rxrings, starg->tx_rings[j], targ->n_prev_tasks);
+					} else {
+						plog_err("Unexpected configuration: %d precedent tasks, %d rx rings\n", targ->n_prev_tasks, targ->nb_rxrings);
+					}
+				}
+			}
+		}
+	} else {
+		plog_info("Task has %d receive and %d transmit ring and cannot be bypassed\n", targ->nb_rxrings, targ->nb_txrings);
+		return -1;
+	}
+
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/commands.h b/VNFs/DPPD-PROX/commands.h
new file mode 100644
index 00000000..6c4a29a3
--- /dev/null
+++ b/VNFs/DPPD-PROX/commands.h
@@ -0,0 +1,70 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _COMMANDS_H_
+#define _COMMANDS_H_
+
+#include <inttypes.h>
+
+struct input;
+
+/* command functions */
+void start_core_all(int task_id);
+void stop_core_all(int task_id);
+void start_cores(uint32_t *cores, int count, int task_id);
+void stop_cores(uint32_t *cores, int count, int task_id);
+
+void cmd_trace(uint8_t lcore_id, uint8_t task_id, uint32_t nb_packets);
+void cmd_dump(uint8_t lcore_id, uint8_t task_id, uint32_t nb_packets, struct input *input, int rx, int tx);
+void cmd_mem_stats(void);
+void cmd_mem_layout(void);
+void cmd_hashdump(uint8_t lcore_id, uint8_t task_id, uint32_t table_id);
+void cmd_rx_distr_start(uint32_t lcore_id);
+void cmd_rx_distr_stop(uint32_t lcore_id);
+void cmd_rx_distr_rst(uint32_t lcore_id);
+void cmd_rx_distr_show(uint32_t lcore_id);
+void cmd_tx_distr_start(uint32_t lcore_id);
+void cmd_tx_distr_stop(uint32_t lcore_id);
+void cmd_tx_distr_rst(uint32_t lcore_id);
+void cmd_tx_distr_show(uint32_t lcore_id);
+void cmd_rx_bw_start(uint32_t lcore_id);
+void cmd_tx_bw_start(uint32_t lcore_id);
+void cmd_rx_bw_stop(uint32_t lcore_id);
+void cmd_tx_bw_stop(uint32_t lcore_id);
+
+void cmd_portinfo(int port_id, char *dst, size_t max_len);
+void cmd_port_up(uint8_t port_id);
+void cmd_port_down(uint8_t port_id);
+void cmd_xstats(uint8_t port_id);
+void cmd_thread_info(uint8_t lcore_id, uint8_t task_id);
+void cmd_ringinfo(uint8_t lcore_id, uint8_t task_id);
+void cmd_ringinfo_all(void);
+void cmd_rx_tx_info(void);
+void cmd_read_reg(uint8_t port_id, uint32_t id);
+void cmd_write_reg(uint8_t port_id, unsigned int id, unsigned int val);
+void cmd_set_vlan_filter(uint8_t port_id, unsigned int id, unsigned int val);
+void cmd_set_vlan_offload(uint8_t port_id, unsigned int val);
+void cmd_get_cache_class(uint32_t lcore_id, uint32_t *set);
+void cmd_get_cache_class_mask(uint32_t lcore_id, uint32_t set, uint32_t *val);
+void cmd_set_cache_class_mask(uint32_t lcore_id, uint32_t set, uint32_t val);
+void cmd_set_cache_class(uint32_t lcore_id, uint32_t set);
+void cmd_cache_reset(void);
+
+void cmd_reset_port(uint8_t port_id);
+int reconnect_task(uint32_t lcore_id, uint32_t task_id);
+int bypass_task(uint32_t lcore_id, uint32_t task_id);
+
+#endif /* _COMMANDS_H_ */
diff --git a/VNFs/DPPD-PROX/config/acl_table.lua b/VNFs/DPPD-PROX/config/acl_table.lua
new file mode 100644
index 00000000..cebe3b77
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/acl_table.lua
@@ -0,0 +1,36 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+five_tuple = function(ip_proto, src, dst, sport, dport, action)
+   return {
+      ip_proto = ip_proto,
+      src_cidr = src,
+      dst_cidr = dst,
+      sport    = sport,
+      dport    = dport,
+      action   = action,
+   }
+end
+
+return {
+   five_tuple(val_mask(17, 0xff), cidr("192.168.0.0/18"), cidr("10.10.0.0/16"), val_range(0,65535), val_range(0,65535), "allow"),
+   five_tuple(val_mask(17, 0xff), cidr("10.10.0.0/18"), cidr("192.168.0.0/16"), val_range(0,65535), val_range(0,65535), "allow"),
+   five_tuple(val_mask(17, 0xff), cidr("192.168.0.0/18"), cidr("74.0.0.0/7"), val_range(0,65535), val_range(0,65535), "allow"),
+   five_tuple(val_mask(17, 0xff), cidr("1.1.1.0/24"), cidr("1.2.3.0/24"), val_range(0,65535), val_range(0,65535), "allow"),
+   five_tuple(val_mask(17, 0xff), cidr("192.168.1.0/24"), cidr("192.168.1.0/24"), val_range(0,65535), val_range(0,65535), "allow"),
+   five_tuple(val_mask(6, 0xf), cidr("10.0.0.0/18"), cidr("192.168.0.0/16"), val_range(0,65535), val_range(0,65535), "allow"),
+   five_tuple(val_mask(6, 0xf), cidr("192.168.0.0/18"), cidr("10.0.0.0/16"), val_range(0,65535), val_range(0,65535), "allow"),
+}
diff --git a/VNFs/DPPD-PROX/config/bng-1q-4ports.cfg b/VNFs/DPPD-PROX/config/bng-1q-4ports.cfg
new file mode 100644
index 00000000..661d4aa0
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-1q-4ports.cfg
@@ -0,0 +1,130 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration sets up a system that handles the same workload as
+; config/bng-4ports.cfg. The difference is that on each of the interfaces, only
+; one queue is used. Use-cases for this configuration include running in a
+; virtualized environment using SRIOV.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=hardware
+[port 1]
+name=inet0
+mac=hardware
+[port 2]
+name=cpe1
+mac=hardware
+[port 3]
+name=inet1
+mac=hardware
+[variables]
+;$wk=3s0,3s0h; 2 workers
+;$wk=3s0-4s0,3s0h-4s0h; 4 workers
+;$wk=3s0-5s0,3s0h-5s0h; 6 workers
+$wk=5s0-8s0,5s0h-8s0h; 8 workers
+;$wk=3s0-7s0,3s0h-7s0h; 10 workers
+;$wk=3s0-8s0,3s0h-8s0h; 12 workers
+[lua]
+lpm4 = dofile("ipv4.lua")
+user_table = dofile("user_table-65K-bng.lua")
+[defaults]
+mempool size=16K
+
+[global]
+start time=20
+name=BNG (1Q)
+
+[core 0s0]
+mode=master
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s0]
+name=LB-cpe
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe0
+task=1
+mode=lbqinq
+rx port=cpe0
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+
+[core 2s0]
+name=LB-inet
+task=0
+mode=nop
+rx ring=yes
+tx port=inet0
+task=1
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+
+[core 3s0]
+name=LB-cpe
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe1
+task=1
+mode=lbqinq
+rx port=cpe1
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+
+[core 4s0]
+name=LB-inet
+task=0
+mode=nop
+rx ring=yes
+tx port=inet1
+task=1
+mode=lbnetwork
+untag mpls=yes
+rx port=inet1
+tx cores=(${wk})t1 proto=ipv4
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx cores from routing table=2s0,4s0
+route table=lpm4
+local ipv4=21.22.23.24
+user table=user_table
+handle arp=yes
+
+task=1
+mode=qinqencapv4
+rx ring=yes
+user table=user_table
+tx cores from cpe table=1s0,3s0 remap=cpe0,cpe1
diff --git a/VNFs/DPPD-PROX/config/bng-4ports.cfg b/VNFs/DPPD-PROX/config/bng-4ports.cfg
new file mode 100644
index 00000000..6ef195ae
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-4ports.cfg
@@ -0,0 +1,125 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration sets up a simplified Border Network Gateway (BNG) on the
+; first socket (socket 0). Four load balancers (two physical cores, four logical
+; cores) and eight workers (four physical cores, eight logical cores) are set
+; up. The number of workers can be changed by uncommenting one of the lines in
+; the [variables] section. If this configuration is to be used on a system with
+; few cores, the number of workers need to be reduced.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=hardware
+[port 1]
+name=inet0
+mac=hardware
+[port 2]
+name=cpe1
+mac=hardware
+[port 3]
+name=inet1
+mac=hardware
+
+[lua]
+lpm4 = dofile("ipv4.lua")
+user_table = dofile("user_table-65K-bng.lua")
+[variables]
+;uncomment one of the following to change the number of workers
+;$wk=3s0,3s0h; 2 workers
+;$wk=3s0-4s0,3s0h-4s0h; 4 workers
+;$wk=3s0-5s0,3s0h-5s0h; 6 workers
+$wk=3s0-6s0,3s0h-6s0h; 8 workers
+;$wk=3s0-7s0,3s0h-7s0h; 10 workers
+;$wk=3s0-8s0,3s0h-8s0h; 12 workers
+
+[defaults]
+mempool size=16K
+qinq tag=0x0081
+[global]
+start time=20
+name=BNG
+[core 0s0]
+mode=master
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe0
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0 proto=arp
+drop=no
+
+[core 1s0h]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=no
+
+[core 2s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe1
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0 proto=arp
+drop=no
+
+[core 2s0h]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet1
+tx cores=(${wk})t1 proto=ipv4
+drop=no
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx ports from routing table=inet0,inet1
+route table=lpm4
+local ipv4=21.22.23.24
+handle arp=yes
+user table=user_table
+drop=no
+fast path handle arp=yes
+
+task=1
+mode=qinqencapv4
+rx ring=yes ; gre received from internal queue
+tx ports from cpe table=cpe0,cpe1
+user table=user_table
+drop=no
diff --git a/VNFs/DPPD-PROX/config/bng-8ports-17cores.cfg b/VNFs/DPPD-PROX/config/bng-8ports-17cores.cfg
new file mode 100644
index 00000000..295aa131
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-8ports-17cores.cfg
@@ -0,0 +1,222 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration sets up a system that handles the same workload as
+; config/bng-qos-4ports.cfg, but on 8 ports instead of 4 and on CPU socket 1
+; instead of socket 0.
+;;
+
+[eal options]
+-n=6 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:01:00:00:01
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 1]
+name=inet0
+mac=00:00:01:00:00:02
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 2]
+name=cpe1
+mac=00:00:01:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 3]
+name=inet1
+mac=00:00:01:00:00:04
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 4]
+name=cpe2
+mac=00:00:02:00:00:01
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 5]
+name=inet2
+mac=00:00:02:00:00:02
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 6]
+name=cpe3
+mac=00:00:02:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 7]
+name=inet3
+mac=00:00:02:00:00:04
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[variables]
+$wk=9s0-16s0,9s0h-16s0h
+$lb_drop=no
+$wt_drop=no
+$rxd=256
+$txd=256
+$promiscuous=yes
+$mcs=128
+$rs=1024
+
+[defaults]
+mempool size=16K
+qinq tag=0xa888
+
+[lua]
+lpm4 = dofile("ipv4-4ports.lua")
+user_table = dofile("user_table-131K-bng.lua")
+[global]
+start time=20
+name=BNG + QoS
+unique mempool per socket=yes
+mp rings=yes
+
+[core 0s0]
+mode=master
+
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe0
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe1
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 3s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe2
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 4s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe3
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 5s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 6s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet1
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 7s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet2
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 8s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet3
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx ports from routing table=inet0,inet1,inet2,inet3
+route table=lpm4
+local ipv4=21.22.23.24
+drop=$wt_drop
+handle arp=yes
+cpe table timeout ms=15000000
+ctrl path polling frequency=10000
+user table=user_table
+
+task=1
+mode=qinqencapv4
+rx ring=yes
+tx ports from cpe table=cpe0,cpe1,cpe2,cpe3
+drop=$wt_drop
+ctrl path polling frequency=10000
+user table=user_table
+ring size=$rs
diff --git a/VNFs/DPPD-PROX/config/bng-8ports-25cores.cfg b/VNFs/DPPD-PROX/config/bng-8ports-25cores.cfg
new file mode 100644
index 00000000..602e0a3c
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-8ports-25cores.cfg
@@ -0,0 +1,222 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration sets up a system that handles the same workload as
+; config/bng-qos-4ports.cfg, but on 8 ports instead of 4 and on CPU socket 1
+; instead of socket 0.
+;;
+
+[eal options]
+-n=6 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:01:00:00:01
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 1]
+name=inet0
+mac=00:00:01:00:00:02
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 2]
+name=cpe1
+mac=00:00:01:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 3]
+name=inet1
+mac=00:00:01:00:00:04
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 4]
+name=cpe2
+mac=00:00:02:00:00:01
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 5]
+name=inet2
+mac=00:00:02:00:00:02
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 6]
+name=cpe3
+mac=00:00:02:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 7]
+name=inet3
+mac=00:00:02:00:00:04
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[variables]
+$wk=9s0-24s0,9s0h-24s0h
+$lb_drop=no
+$wt_drop=no
+$rxd=256
+$txd=256
+$promiscuous=yes
+$mcs=128
+$rs=1024
+
+[defaults]
+mempool size=16K
+qinq tag=0xa888
+
+[lua]
+lpm4 = dofile("ipv4-4ports.lua")
+user_table = dofile("user_table-131K-bng.lua")
+[global]
+start time=20
+name=BNG + QoS
+unique mempool per socket=yes
+mp rings=yes
+
+[core 0s0]
+mode=master
+
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe0
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe1
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 3s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe2
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 4s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe3
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 5s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 6s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet1
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 7s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet2
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 8s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet3
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx ports from routing table=inet0,inet1,inet2,inet3
+route table=lpm4
+local ipv4=21.22.23.24
+drop=$wt_drop
+handle arp=yes
+cpe table timeout ms=15000000
+ctrl path polling frequency=10000
+user table=user_table
+
+task=1
+mode=qinqencapv4
+rx ring=yes
+tx ports from cpe table=cpe0,cpe1,cpe2,cpe3
+drop=$wt_drop
+ctrl path polling frequency=10000
+user table=user_table
+ring size=$rs
diff --git a/VNFs/DPPD-PROX/config/bng-8ports.cfg b/VNFs/DPPD-PROX/config/bng-8ports.cfg
new file mode 100644
index 00000000..07d31cbd
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-8ports.cfg
@@ -0,0 +1,231 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration sets up a system that handles the same workload as
+; config/bng-4ports.cfg, but on 8 ports instead of 4 and on CPU socket 1
+; instead of socket 0.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[variables]
+;uncomment one of the following to change the number of worker threads
+$lb_drop=yes
+$wk_drop=yes
+$rxd=128
+$txd=128
+$promiscuous=yes
+$mp=16K
+$mcs=512
+$rs=128
+
+[port 0]
+name=cpe0
+mac=00:00:01:00:00:01
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 1]
+name=inet0
+mac=00:00:01:00:00:02
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 2]
+name=cpe1
+mac=00:00:01:00:00:03
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 3]
+name=inet1
+mac=00:00:01:00:00:04
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 4]
+name=cpe2
+mac=00:00:01:00:00:01
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 5]
+name=inet2
+mac=00:00:01:00:00:02
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 6]
+name=cpe3
+mac=00:00:01:00:00:03
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 7]
+name=inet3
+mac=00:00:01:00:00:04
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+[lua]
+lpm4 = dofile("ipv4-4ports.lua")
+dscp_table = dofile("dscp.lua")
+user_table = dofile("user_table-131K-bng.lua")
+
+wk="5s1-9s1,5s1h-9s1h"
+name="BNG (" .. task_count(wk) .. " workers)"
+
+[defaults]
+mempool size=$mp
+qinq tag=0xa888
+
+[global]
+start time=10
+duration time=0
+name=$name
+unique mempool per socket=yes
+shuffle=yes
+
+[core 0s1]
+task=0
+mode=master
+tx cores=(${wk})t0m
+
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s1]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 1s1h]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet1
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s1]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet2
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s1h]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet3
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 3s1]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe0
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 3s1h]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe1
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 4s1]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe2
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 4s1h]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe3
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+;*****************************************************************************************
+;#### Worker Threads receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=WK
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx ports from routing table=inet0,inet1,inet2,inet3
+route table=lpm4
+local ipv4=21.22.23.24
+drop=$wk_drop
+handle arp=yes
+cpe table timeout ms=15000
+user table=user_table
+
+task=1
+mode=qinqencapv4
+rx ring=yes ; gre received from internal queue
+tx ports from cpe table=cpe0,cpe1,cpe2,cpe3
+drop=$wk_drop
+user table=user_table
diff --git a/VNFs/DPPD-PROX/config/bng-no-cpu-topology-4ports.cfg b/VNFs/DPPD-PROX/config/bng-no-cpu-topology-4ports.cfg
new file mode 100644
index 00000000..02598098
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-no-cpu-topology-4ports.cfg
@@ -0,0 +1,102 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:00:00:00:01
+[port 1]
+name=inet0
+mac=00:00:00:00:00:03
+[port 2]
+name=cpe1
+mac=00:00:00:00:00:02
+[port 3]
+name=inet1
+mac=00:00:00:00:00:04
+[variables]
+$wk=3-6,9-12
+
+[defaults]
+mempool size=16K
+[lua]
+lpm4 = dofile("ipv4.lua")
+user_table = dofile("user_table-65K-bng.lua")
+[global]
+start time=20
+name=vBNG
+
+[core 0]
+mode=master
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe0
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+
+[core 7]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+
+[core 2]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx port=cpe1
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+
+[core 8]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet1
+tx cores=(${wk})t1 proto=ipv4
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx ports from routing table=inet0,inet1
+route table=lpm4
+local ipv4=21.22.23.24
+handle arp=yes
+user table=user_table
+
+task=1
+mode=qinqencapv4
+rx ring=yes
+tx ports from cpe table=cpe0,cpe1
+user table=user_table
diff --git a/VNFs/DPPD-PROX/config/bng-ovs-usv-4ports.cfg b/VNFs/DPPD-PROX/config/bng-ovs-usv-4ports.cfg
new file mode 100644
index 00000000..48321c0d
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-ovs-usv-4ports.cfg
@@ -0,0 +1,137 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration is provided for virtualized environments running on top of
+; a soft-switch. Specifically, ingredients are Open vSwitch (openvswitch.org)
+; and Qemu version 1.6.2. Note that since the currently supported version of
+; Open vSwitch does not handle all the protocols that are used in the full BNG,
+; PROX has to be recompiled to use different packet processing paths as a
+; workaround. DPDK version 1.8.0 should be used with this configuration and it
+; has to be compiled with COMBINE_LIBS enabled:
+;   make install T=$RTE_TARGET CONFIG_RTE_BUILD_COMBINE_LIBS=y CONFIG_RTE_LIBRTE_VHOST=y
+; The following commands demonstrate how to set up Open vSwitch:
+;   git clone https://github.com/openvswitch/ovs.git
+;   cd ovs
+;   git checkout 5c62a855c7bb24424cbe7ec48ecf2f128db8b102
+;   ./boot.sh && ./configure --with-dpdk=$RTE_SDK/$RTE_TARGET --disable-ssl && make
+; This configuration is intended to be used in a VM with 4 virtual ports. This
+; means that 4 virtual ports (with type dpdkvhost) and 4 physical ports (with
+; type dpdk) will need to be added and connected through open-flow commands in
+; Open vSwitch. After Open vSwitch has been set up on the host, PROX needs to be
+; recompiled in the VM as follows before running it with this configuration:
+;   make BNG_QINQ=n MPLS_ROUTING=n
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:00:00:00:01
+[port 1]
+name=inet0
+mac=00:00:00:00:00:03
+[port 2]
+name=cpe1
+mac=00:00:00:00:00:02
+[port 3]
+name=inet1
+mac=00:00:00:00:00:04
+[variables]
+$wk=5s0,6s0
+
+[defaults]
+mempool size=16K
+[lua]
+lpm4 = dofile("ipv4.lua")
+user_table =dofile("user_table-65K-bng.lua")
+[global]
+start time=20
+name=BNG (OVS)
+
+[core 0s0]
+mode=master
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s0]
+name=LB-cpe
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe0
+task=1
+mode=lbqinq
+rx port=cpe0
+tx cores=(${wk})t0 proto=ipv4
+
+[core 2s0]
+name=LB-inet
+task=0
+mode=nop
+rx ring=yes
+tx port=inet0
+task=1
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+
+[core 3s0]
+name=LB-cpe
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe1
+task=1
+mode=lbqinq
+rx port=cpe1
+tx cores=(${wk})t0 proto=ipv4
+
+[core 4s0]
+name=LB-inet
+task=0
+mode=nop
+rx ring=yes
+tx port=inet1
+task=1
+mode=lbnetwork
+untag mpls=yes
+rx port=inet1
+tx cores=(${wk})t1 proto=ipv4
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: Upstream traffic
+;#### Task 1: Downstream traffic
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx cores from routing table=2s0,4s0
+route table=lpm4
+local ipv4=21.22.23.24
+handle arp=no
+user table=user_table
+
+task=1
+mode=qinqencapv4
+rx ring=yes
+tx cores from cpe table=1s0,3s0 remap=cpe0,cpe1
+user table=user_table
diff --git a/VNFs/DPPD-PROX/config/bng-qos-4ports.cfg b/VNFs/DPPD-PROX/config/bng-qos-4ports.cfg
new file mode 100644
index 00000000..cd26fd5b
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-qos-4ports.cfg
@@ -0,0 +1,209 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; Compared to config/bng-4ports.cfg, this configuration sets up a BNG with QoS
+; functionality. In total, an extra eight cores (four physical cores) are needed
+; to run this configuration. Four cores are used for QoS, two cores are assigned
+; with the task of classifying upstream packets and two cores are assigned with
+; transmitting downstream packets.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=hardware
+[port 1]
+name=inet0
+mac=hardware
+[port 2]
+name=cpe1
+mac=hardware
+[port 3]
+name=inet1
+mac=hardware
+[variables]
+;uncomment one of the following to change the number of workers
+;$wk=7s0,7s0h; 2 workers
+;$wk=7s0-8s0,7s0h-8s0h; 4 workers
+$wk=7s0-9s0,7s0h-9s0h; 6 workers
+;$wk=7s0-10s0,7s0h-10s0h; 8 workers
+
+[defaults]
+mempool size=128K
+qinq tag=0xa888;0x0081
+[lua]
+lpm4 = dofile("ipv4.lua")
+dscp_table = dofile("dscp.lua")
+user_table = dofile("user_table-65K-bng.lua")
+[global]
+start time=20
+name=BNG + QoS
+
+[core 0s0]
+mode=master
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=no
+
+[core 1s0h]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+
+[core 2s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=no
+
+[core 2s0h]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet1
+tx cores=(${wk})t1 proto=ipv4
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx ports from routing table=inet0,inet1
+route table=lpm4
+local ipv4=21.22.23.24
+handle arp=yes
+drop=no
+user table=user_table
+
+task=1
+mode=qinqencapv4
+rx ring=yes
+tx cores from cpe table=3s0,4s0 remap=cpe0,cpe1 ;map packets going to cpe0 to 3s0 and cpe1 to 4s0
+classify=yes
+dscp=dscp_table
+user table=user_table
+
+;*****************************************************************************************
+;#### Downstream QoS receiving from workers
+;#### classification done by workers
+;#### Downstream QoS = QoS core and TX core
+[core 3s0]
+name=txqos0
+task=0
+mode=qos
+rx ring=yes
+tx cores=3s0ht0
+drop=no
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 3s0h]
+name=txnop0
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe0
+drop=no
+
+[core 4s0]
+name=txqos1
+task=0
+mode=qos
+rx ring=yes
+tx cores=4s0ht0
+drop=no
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 4s0h]
+name=txnop1
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe1
+drop=no
+
+;*****************************************************************************************
+;#### upstream QoS receiving from CPE
+;#### classification done by RX, QoS core
+;#### upstream QoS = RX core (classify) + QoS core
+[core 5s0h]
+name=rxcl0
+task=0
+mode=classify
+rx port=cpe0
+tx cores=5s0t0
+dscp=dscp_table
+drop=no
+user table=user_table
+
+[core 5s0]
+name=rxqos0
+task=0
+mode=qos
+rx ring=yes
+tx cores=1s0t0
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+
+[core 6s0h]
+name=rxcl1
+task=0
+mode=classify
+rx port=cpe1
+tx cores=6s0t0
+dscp=dscp_table
+drop=no
+user table=user_table
+
+[core 6s0]
+name=rxqos1
+task=0
+mode=qos
+rx ring=yes
+tx cores=2s0t0
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
diff --git a/VNFs/DPPD-PROX/config/bng-qos-8ports.cfg b/VNFs/DPPD-PROX/config/bng-qos-8ports.cfg
new file mode 100644
index 00000000..c191a22e
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-qos-8ports.cfg
@@ -0,0 +1,323 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration sets up a system that handles the same workload as
+; config/bng-qos-4ports.cfg, but on 8 ports instead of 4 and on CPU socket 1
+; instead of socket 0.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+;mac=00:00:01:00:00:01
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 1]
+name=inet0
+;mac=00:00:01:00:00:02
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 2]
+name=cpe1
+;mac=00:00:01:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 3]
+name=inet1
+;mac=00:00:01:00:00:04
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 4]
+name=cpe2
+;mac=00:00:01:00:00:01
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 5]
+name=inet2
+;mac=00:00:01:00:00:02
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 6]
+name=cpe3
+;mac=00:00:01:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 7]
+name=inet3
+;mac=00:00:01:00:00:04
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[variables]
+$wk=9s1,5s1h-9s1h; 6 workers
+$lb_drop=no
+$wt_drop=no
+$rxd=256
+$txd=256
+$promiscuous=yes
+$mp=6K
+$mcs=128
+$rs=256
+
+[defaults]
+mempool size=128K
+qinq tag=0xa888
+
+[lua]
+lpm4 = dofile("ipv4-4ports.lua")
+dscp_table = dofile("dscp.lua")
+user_table = dofile("user_table-131K-bng.lua")
+[global]
+start time=20
+name=BNG + QoS
+unique mempool per socket=no
+
+[core 0s1]
+mode=master
+
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s1]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+task=1
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 1s1h]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+task=1
+mode=lbnetwork
+rx port=inet2
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s1]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+task=1
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s1h]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet1
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+task=1
+mode=lbnetwork
+untag mpls=yes
+rx port=inet3
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx ports from routing table=inet0,inet1,inet2,inet3
+route table=lpm4
+local ipv4=21.22.23.24
+drop=$wt_drop
+handle arp=yes
+cpe table timeout ms=15000000
+ctrl path polling frequency=10000
+user table=user_table
+
+task=1
+mode=qinqencapv4
+rx ring=yes
+tx cores from cpe table=3s1,3s1h,4s1,4s1h remap=cpe0,cpe1,cpe2,cpe3 ;map packets going to cpe0 to 3s1 and cpe1 to 4s1
+classify=yes
+drop=$wt_drop
+ctrl path polling frequency=10000
+user table=user_table
+dscp=dscp_table
+
+;*****************************************************************************************
+;#### Downstream QoS receiving from workers
+;#### classification done by workers
+;#### Downstream QoS = QoS core and TX core
+[core 3s1]
+name=txqos0
+task=0
+mode=qos
+rx ring=yes
+tx port=cpe0
+drop=no
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 3s1h]
+name=txqos1
+task=0
+mode=qos
+rx ring=yes
+tx port=cpe1
+drop=no
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 4s1]
+name=txqos2
+task=0
+mode=qos
+rx ring=yes
+tx port=cpe2
+drop=no
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 4s1h]
+name=txqos3
+task=0
+mode=qos
+rx ring=yes
+drop=no
+tx port=cpe3
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+;*****************************************************************************************
+;#### upstream QoS receiving from CPE
+;#### classification done by RX, QoS core
+;#### upstream QoS = RX core (classify) + QoS core
+[core 5s1]
+name=rxqos0
+task=0
+mode=qos
+rx port=cpe0
+tx cores=1s1t0
+classify=yes
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 6s1]
+name=rxqos1
+task=0
+mode=qos
+rx port=cpe1
+classify=yes
+dscp=dscp_table
+tx cores=1s1t1
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 7s1]
+name=rxqos1
+task=0
+mode=qos
+rx port=cpe2
+tx cores=2s1t0
+classify=yes
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 8s1]
+task=0
+mode=qos
+rx port=cpe3
+tx cores=2s1t1
+classify=yes
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
diff --git a/VNFs/DPPD-PROX/config/bng-qos-8ports_17cores.cfg b/VNFs/DPPD-PROX/config/bng-qos-8ports_17cores.cfg
new file mode 100644
index 00000000..74c45872
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-qos-8ports_17cores.cfg
@@ -0,0 +1,411 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration sets up a system that handles the same workload as
+; config/bng-qos-4ports.cfg, but on 8 ports instead of 4 and on CPU socket 1
+; instead of socket 0.
+;;
+
+[eal options]
+-n=6 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:01:00:00:01
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 1]
+name=inet0
+mac=00:00:01:00:00:02
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 2]
+name=cpe1
+mac=00:00:01:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 3]
+name=inet1
+mac=00:00:01:00:00:04
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 4]
+name=cpe2
+mac=00:00:02:00:00:01
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 5]
+name=inet2
+mac=00:00:02:00:00:02
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 6]
+name=cpe3
+mac=00:00:02:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 7]
+name=inet3
+mac=00:00:02:00:00:04
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[variables]
+$wk=0s0h,13s0-16s0,13s0h-16s0h,4s0,4s0h
+$lb_drop=no
+$wt_drop=no
+$rxd=256
+$txd=256
+$promiscuous=yes
+$mcs=128
+$rs=1024
+
+[defaults]
+mempool size=256K
+qinq tag=0xa888
+
+[lua]
+lpm4 = dofile("ipv4-4ports.lua")
+dscp_table = dofile("dscp.lua")
+user_table = dofile("user_table-131K-bng.lua")
+[global]
+start time=20
+name=BNG + QoS
+unique mempool per socket=no
+mp rings=yes
+enable bypass=yes
+
+[core 0s0]
+mode=master
+
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+name=LB-cpe
+task=1
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 1s0h]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+name=LB-cpe
+task=1
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+name=LB-inet
+task=1
+mode=lbnetwork
+rx port=inet1
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s0h]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet2
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+name=LB-inet
+task=1
+mode=lbnetwork
+untag mpls=yes
+rx port=inet3
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 3s0]
+name=classify1
+task=0
+mode=classify
+rx port=cpe0
+tx cores=9s0
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+name=classify2
+task=1
+mode=classify
+rx port=cpe1
+tx cores=10s0
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 3s0h]
+name=classify3
+task=0
+mode=classify
+rx port=cpe2
+tx cores=11s0
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+name=classify4
+task=1
+mode=classify
+rx port=cpe3
+tx cores=12s0
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx ports from routing table=inet0,inet1,inet2,inet3
+route table=lpm4
+local ipv4=21.22.23.24
+drop=$wt_drop
+handle arp=yes
+cpe table timeout ms=15000000
+ctrl path polling frequency=10000
+user table=user_table
+
+task=1
+mode=qinqencapv4
+rx ring=yes
+tx cores from cpe table=5s0t1,6s0t1,7s0t1,8s0t1 remap=cpe0,cpe1,cpe2,cpe3 ;map packets going to cpe0 to 3s0 and cpe1 to 4s0
+classify=yes
+drop=$wt_drop
+ctrl path polling frequency=10000
+user table=user_table
+dscp=dscp_table
+ring size=$rs
+
+;*****************************************************************************************
+;#### Downstream QoS receiving from workers
+;#### classification done by workers
+;#### Downstream QoS = QoS core and TX core
+[core 5s0]
+name=txqos0
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe0
+drop=no
+
+task=1
+mode=qos
+rx ring=yes
+tx cores=5s0t0
+drop=yes
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 6s0]
+name=txqos1
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe1
+drop=no
+
+task=1
+mode=qos
+rx ring=yes
+;tx port=cpe1
+tx cores=6s0t0
+drop=yes
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 7s0]
+name=txqos2
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe2
+drop=no
+
+task=1
+mode=qos
+rx ring=yes
+;tx port=cpe2
+tx cores=7s0t0
+drop=yes
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 8s0]
+name=txqos3
+task=0
+mode=nop
+rx ring=yes
+tx port=cpe3
+drop=no
+
+task=1
+mode=qos
+rx ring=yes
+drop=yes
+;tx port=cpe3
+tx cores=8s0t0
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+;*****************************************************************************************
+;#### upstream QoS receiving from CPE
+;#### classification done by RX, QoS core
+;#### upstream QoS = RX core (classify) + QoS core
+[core 9s0]
+name=rxqos0
+task=0
+mode=qos
+;rx port=cpe0
+rx ring=yes
+tx cores=1s0
+;classify=yes
+;dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 10s0]
+name=rxqos0
+task=0
+mode=qos
+;rx port=cpe1
+rx ring=yes
+;classify=yes
+;dscp=dscp_table
+tx cores=1s0t1
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 11s0]
+name=rxqos2
+task=0
+mode=qos
+;rx port=cpe2
+rx ring=yes
+tx cores=1s0h
+;classify=yes
+;dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 12s0]
+name=rxqos3
+task=0
+mode=qos
+;rx port=cpe3
+rx ring=yes
+tx cores=1s0ht1
+;classify=yes
+;dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
diff --git a/VNFs/DPPD-PROX/config/bng-qos-8ports_25cores.cfg b/VNFs/DPPD-PROX/config/bng-qos-8ports_25cores.cfg
new file mode 100644
index 00000000..cfb58bac
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/bng-qos-8ports_25cores.cfg
@@ -0,0 +1,438 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration sets up a system that handles the same workload as
+; config/bng-qos-4ports.cfg, but on 8 ports instead of 4 and on CPU socket 1
+; instead of socket 0.
+;;
+
+[eal options]
+-n=6 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:01:00:00:01
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 1]
+name=inet0
+mac=00:00:01:00:00:02
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 2]
+name=cpe1
+mac=00:00:01:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 3]
+name=inet1
+mac=00:00:01:00:00:04
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 4]
+name=cpe2
+mac=00:00:02:00:00:01
+tx desc=$txd
+rx desc=$rxd
+promiscuous=$promiscuous
+
+[port 5]
+name=inet2
+mac=00:00:02:00:00:02
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 6]
+name=cpe3
+mac=00:00:02:00:00:03
+tx desc=$txd
+promiscuous=$promiscuous
+
+[port 7]
+name=inet3
+mac=00:00:02:00:00:04
+rx desc=$rxd
+tx desc=$txd
+promiscuous=$promiscuous
+
+[variables]
+$wk=0s0h,15s0-20s0,7s0h-20s0h
+$lb_drop=no
+$wt_drop=no
+$rxd=256
+$txd=256
+$promiscuous=yes
+$mcs=128
+$rs=1024
+$tx1=21s0
+$tx2=22s0
+$tx3=23s0
+$tx4=24s0
+
+[defaults]
+mempool size=256K
+qinq tag=0xa888
+
+[lua]
+lpm4 = dofile("ipv4-4ports.lua")
+dscp_table = dofile("dscp.lua")
+user_table = dofile("user_table-131K-bng.lua")
+[global]
+start time=20
+name=BNG + QoS
+unique mempool per socket=yes
+mp rings=yes
+enable bypass=yes
+
+[core 0s0]
+mode=master
+
+; IPv4
+;*****************************************************************************************
+;##### Load Balancing receiving from CPE and from Internet ####
+[core 1s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 1s0h]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s0]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 2s0h]
+name=LB-cpe
+task=0
+mode=lbqinq
+rx ring=yes
+tx cores=(${wk})t0 proto=ipv4
+tx cores=(${wk})t0p proto=arp
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 3s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 3s0h]
+name=LB-inet
+task=0
+mode=lbnetwork
+rx port=inet1
+untag mpls=yes
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 4s0]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet2
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 4s0h]
+name=LB-inet
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet3
+tx cores=(${wk})t1 proto=ipv4
+drop=$lb_drop
+memcache size=$mcs
+ring size=$rs
+
+[core 5s0]
+name=classify1
+task=0
+mode=classify
+rx port=cpe0
+tx cores=11s0
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+memcache size=$mcs
+
+[core 5s0h]
+name=classify2
+task=0
+mode=classify
+rx port=cpe1
+tx cores=12s0
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+memcache size=$mcs
+
+[core 6s0]
+name=classify3
+task=0
+mode=classify
+rx port=cpe2
+tx cores=13s0
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+memcache size=$mcs
+
+[core 6s0h]
+name=classify4
+task=0
+mode=classify
+rx port=cpe3
+tx cores=14s0
+dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+memcache size=$mcs
+
+;*****************************************************************************************
+;#### Workers receiving from LB
+;#### Task 0: QinQ decapsulation + gre encapsulation + routing
+;#### Task 1: ARP
+;#### Task 2: GRE depcapsulation + QinQ encapsulation + use learned mac
+[core $wk]
+name=Worker
+task=0
+mode=qinqdecapv4
+rx ring=yes
+tx ports from routing table=inet0,inet1,inet2,inet3
+route table=lpm4
+local ipv4=21.22.23.24
+drop=$wt_drop
+handle arp=yes
+cpe table timeout ms=15000000
+ctrl path polling frequency=10000
+user table=user_table
+
+task=1
+mode=qinqencapv4
+rx ring=yes
+tx cores from cpe table=7s0,8s0,9s0,10s0 remap=cpe0,cpe1,cpe2,cpe3 ;map packets going to cpe0 to 3s0 and cpe1 to 4s0
+classify=yes
+drop=$wt_drop
+ctrl path polling frequency=10000
+user table=user_table
+dscp=dscp_table
+ring size=$rs
+
+;*****************************************************************************************
+;#### Downstream QoS receiving from workers
+;#### classification done by workers
+;#### Downstream QoS = QoS core and TX core
+[core 7s0]
+name=txqos0
+task=0
+mode=qos
+rx ring=yes
+;tx port=cpe0
+tx cores=$tx1
+drop=no
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 8s0]
+name=txqos0
+task=0
+mode=qos
+rx ring=yes
+;tx port=cpe1
+tx cores=$tx2
+drop=no
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 9s0]
+name=txqos2
+task=0
+mode=qos
+rx ring=yes
+;tx port=cpe2
+tx cores=$tx3
+drop=no
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+[core 10s0]
+name=txqos3
+task=0
+mode=qos
+rx ring=yes
+drop=no
+;tx port=cpe3
+tx cores=$tx4
+pipe tc rate=125000
+pipe tb rate=125000
+user table=user_table
+
+;*****************************************************************************************
+;#### upstream QoS receiving from CPE
+;#### classification done by RX, QoS core
+;#### upstream QoS = RX core (classify) + QoS core
+[core 11s0]
+name=rxqos0
+task=0
+mode=qos
+;rx port=cpe0
+rx ring=yes
+tx cores=1s0
+;classify=yes
+;dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 12s0]
+name=rxqos0
+task=0
+mode=qos
+;rx port=cpe1
+rx ring=yes
+;classify=yes
+;dscp=dscp_table
+tx cores=1s0h
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 13s0]
+name=rxqos2
+task=0
+mode=qos
+;rx port=cpe2
+rx ring=yes
+tx cores=2s0
+;classify=yes
+;dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core 14s0]
+name=rxqos3
+task=0
+mode=qos
+;rx port=cpe3
+rx ring=yes
+tx cores=2s0h
+;classify=yes
+;dscp=dscp_table
+pipe tc rate=125000
+pipe tb rate=125000
+drop=no
+user table=user_table
+dscp=dscp_table
+
+[core $tx1]
+name=tx1
+task=0
+mode=read
+rx ring=yes
+tx port=cpe0
+ring size=$rs
+drop=no
+
+[core $tx2]
+name=tx2
+task=0
+mode=read
+rx ring=yes
+tx port=cpe1
+ring size=$rs
+drop=no
+
+[core $tx3]
+name=tx3
+task=0
+mode=read
+rx ring=yes
+tx port=cpe2
+ring size=$rs
+drop=no
+
+[core $tx4]
+name=tx4
+task=0
+mode=read
+rx ring=yes
+tx port=cpe3
+ring size=$rs
+drop=no
diff --git a/VNFs/DPPD-PROX/config/cgnat.cfg b/VNFs/DPPD-PROX/config/cgnat.cfg
new file mode 100644
index 00000000..4015d3ab
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/cgnat.cfg
@@ -0,0 +1,58 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=if0
+mac=hardware
+[port 1]
+name=if1
+mac=hardware
+
+[lua]
+nat_table = dofile("cgnat_table.lua")
+lpm4 = dofile("ipv4_1port.lua")
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=CGNAT
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=nat
+task=0
+mode=cgnat
+private=yes
+nat table=nat_table
+route table=lpm4
+rx port=if0
+tx ports from routing table=if1
+
+task=1
+mode=cgnat
+private=no
+nat table=nat_table
+route table=lpm4
+rx port=if1
+tx port=if0
diff --git a/VNFs/DPPD-PROX/config/cgnat_table.lua b/VNFs/DPPD-PROX/config/cgnat_table.lua
new file mode 100644
index 00000000..26ae9c7a
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/cgnat_table.lua
@@ -0,0 +1,38 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+local cgnat = {}
+cgnat.dynamic = {
+   {public_ip_range_start = ip("20.0.1.0"),public_ip_range_stop = ip("20.0.1.15"), public_port = val_range(0,65535)},
+   {public_ip_range_start = ip("20.0.1.16"),public_ip_range_stop = ip("20.0.1.31"), public_port = val_range(0,65535)},
+}
+cgnat.static_ip_port = {
+   {src_ip = ip("192.168.2.1"), src_port = 68, dst_ip = ip("20.0.2.1"), dst_port = 68},
+   {src_ip = ip("192.168.2.1"), src_port = 168, dst_ip = ip("20.0.2.1"), dst_port = 5000},
+   {src_ip = ip("192.168.2.1"), src_port = 268, dst_ip = ip("20.0.2.1"), dst_port = 5001},
+   {src_ip = ip("192.168.2.1"), src_port = 368, dst_ip = ip("20.0.2.1"), dst_port = 5002},
+}
+cgnat.static_ip = {
+   {src_ip = ip("192.168.3.1"), dst_ip = ip("20.0.3.1")},
+   {src_ip = ip("192.168.3.2"), dst_ip = ip("20.0.3.2")},
+   {src_ip = ip("192.168.3.3"), dst_ip = ip("20.0.3.3")},
+   {src_ip = ip("192.168.3.4"), dst_ip = ip("20.0.3.4")},
+   {src_ip = ip("192.168.3.5"), dst_ip = ip("20.0.3.5")},
+   {src_ip = ip("192.168.3.6"), dst_ip = ip("20.0.3.6")},
+   {src_ip = ip("192.168.3.7"), dst_ip = ip("20.0.3.7")},
+   {src_ip = ip("192.168.3.8"), dst_ip = ip("20.0.3.8")},
+}
+return cgnat
diff --git a/VNFs/DPPD-PROX/config/cpe_table.lua b/VNFs/DPPD-PROX/config/cpe_table.lua
new file mode 100644
index 00000000..305e14f2
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/cpe_table.lua
@@ -0,0 +1,2066 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+return {
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=0, cidr = cidr("192.168.0.0/29"), mac = mac("00:00:01:00:00:00"), user_id=0},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=0, cidr = cidr("192.168.0.8/29"), mac = mac("00:00:01:00:00:00"), user_id=0},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=1, cidr = cidr("192.168.0.16/29"), mac = mac("00:00:01:00:00:01"), user_id=1},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=1, cidr = cidr("192.168.0.24/29"), mac = mac("00:00:01:00:00:01"), user_id=1},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=2, cidr = cidr("192.168.0.32/29"), mac = mac("00:00:01:00:00:02"), user_id=2},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=2, cidr = cidr("192.168.0.40/29"), mac = mac("00:00:01:00:00:02"), user_id=2},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=3, cidr = cidr("192.168.0.48/29"), mac = mac("00:00:01:00:00:03"), user_id=3},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=3, cidr = cidr("192.168.0.56/29"), mac = mac("00:00:01:00:00:03"), user_id=3},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=4, cidr = cidr("192.168.0.64/29"), mac = mac("00:00:01:00:00:04"), user_id=4},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=4, cidr = cidr("192.168.0.72/29"), mac = mac("00:00:01:00:00:04"), user_id=4},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=5, cidr = cidr("192.168.0.80/29"), mac = mac("00:00:01:00:00:05"), user_id=5},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=5, cidr = cidr("192.168.0.88/29"), mac = mac("00:00:01:00:00:05"), user_id=5},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=6, cidr = cidr("192.168.0.96/29"), mac = mac("00:00:01:00:00:06"), user_id=6},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=6, cidr = cidr("192.168.0.104/29"), mac = mac("00:00:01:00:00:06"), user_id=6},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=7, cidr = cidr("192.168.0.112/29"), mac = mac("00:00:01:00:00:07"), user_id=7},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=7, cidr = cidr("192.168.0.120/29"), mac = mac("00:00:01:00:00:07"), user_id=7},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=8, cidr = cidr("192.168.0.128/29"), mac = mac("00:00:01:00:00:08"), user_id=8},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=8, cidr = cidr("192.168.0.136/29"), mac = mac("00:00:01:00:00:08"), user_id=8},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=9, cidr = cidr("192.168.0.144/29"), mac = mac("00:00:01:00:00:09"), user_id=9},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=9, cidr = cidr("192.168.0.152/29"), mac = mac("00:00:01:00:00:09"), user_id=9},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=10, cidr = cidr("192.168.0.160/29"), mac = mac("00:00:01:00:00:0a"), user_id=10},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=10, cidr = cidr("192.168.0.168/29"), mac = mac("00:00:01:00:00:0a"), user_id=10},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=11, cidr = cidr("192.168.0.176/29"), mac = mac("00:00:01:00:00:0b"), user_id=11},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=11, cidr = cidr("192.168.0.184/29"), mac = mac("00:00:01:00:00:0b"), user_id=11},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=12, cidr = cidr("192.168.0.192/29"), mac = mac("00:00:01:00:00:0c"), user_id=12},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=12, cidr = cidr("192.168.0.200/29"), mac = mac("00:00:01:00:00:0c"), user_id=12},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=13, cidr = cidr("192.168.0.208/29"), mac = mac("00:00:01:00:00:0d"), user_id=13},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=13, cidr = cidr("192.168.0.216/29"), mac = mac("00:00:01:00:00:0d"), user_id=13},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=14, cidr = cidr("192.168.0.224/29"), mac = mac("00:00:01:00:00:0e"), user_id=14},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=14, cidr = cidr("192.168.0.232/29"), mac = mac("00:00:01:00:00:0e"), user_id=14},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=15, cidr = cidr("192.168.0.240/29"), mac = mac("00:00:01:00:00:0f"), user_id=15},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=15, cidr = cidr("192.168.0.248/29"), mac = mac("00:00:01:00:00:0f"), user_id=15},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=16, cidr = cidr("192.168.1.0/29"), mac = mac("00:00:01:00:00:10"), user_id=16},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=16, cidr = cidr("192.168.1.8/29"), mac = mac("00:00:01:00:00:10"), user_id=16},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=17, cidr = cidr("192.168.1.16/29"), mac = mac("00:00:01:00:00:11"), user_id=17},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=17, cidr = cidr("192.168.1.24/29"), mac = mac("00:00:01:00:00:11"), user_id=17},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=18, cidr = cidr("192.168.1.32/29"), mac = mac("00:00:01:00:00:12"), user_id=18},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=18, cidr = cidr("192.168.1.40/29"), mac = mac("00:00:01:00:00:12"), user_id=18},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=19, cidr = cidr("192.168.1.48/29"), mac = mac("00:00:01:00:00:13"), user_id=19},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=19, cidr = cidr("192.168.1.56/29"), mac = mac("00:00:01:00:00:13"), user_id=19},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=20, cidr = cidr("192.168.1.64/29"), mac = mac("00:00:01:00:00:14"), user_id=20},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=20, cidr = cidr("192.168.1.72/29"), mac = mac("00:00:01:00:00:14"), user_id=20},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=21, cidr = cidr("192.168.1.80/29"), mac = mac("00:00:01:00:00:15"), user_id=21},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=21, cidr = cidr("192.168.1.88/29"), mac = mac("00:00:01:00:00:15"), user_id=21},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=22, cidr = cidr("192.168.1.96/29"), mac = mac("00:00:01:00:00:16"), user_id=22},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=22, cidr = cidr("192.168.1.104/29"), mac = mac("00:00:01:00:00:16"), user_id=22},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=23, cidr = cidr("192.168.1.112/29"), mac = mac("00:00:01:00:00:17"), user_id=23},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=23, cidr = cidr("192.168.1.120/29"), mac = mac("00:00:01:00:00:17"), user_id=23},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=24, cidr = cidr("192.168.1.128/29"), mac = mac("00:00:01:00:00:18"), user_id=24},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=24, cidr = cidr("192.168.1.136/29"), mac = mac("00:00:01:00:00:18"), user_id=24},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=25, cidr = cidr("192.168.1.144/29"), mac = mac("00:00:01:00:00:19"), user_id=25},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=25, cidr = cidr("192.168.1.152/29"), mac = mac("00:00:01:00:00:19"), user_id=25},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=26, cidr = cidr("192.168.1.160/29"), mac = mac("00:00:01:00:00:1a"), user_id=26},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=26, cidr = cidr("192.168.1.168/29"), mac = mac("00:00:01:00:00:1a"), user_id=26},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=27, cidr = cidr("192.168.1.176/29"), mac = mac("00:00:01:00:00:1b"), user_id=27},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=27, cidr = cidr("192.168.1.184/29"), mac = mac("00:00:01:00:00:1b"), user_id=27},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=28, cidr = cidr("192.168.1.192/29"), mac = mac("00:00:01:00:00:1c"), user_id=28},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=28, cidr = cidr("192.168.1.200/29"), mac = mac("00:00:01:00:00:1c"), user_id=28},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=29, cidr = cidr("192.168.1.208/29"), mac = mac("00:00:01:00:00:1d"), user_id=29},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=29, cidr = cidr("192.168.1.216/29"), mac = mac("00:00:01:00:00:1d"), user_id=29},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=30, cidr = cidr("192.168.1.224/29"), mac = mac("00:00:01:00:00:1e"), user_id=30},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=30, cidr = cidr("192.168.1.232/29"), mac = mac("00:00:01:00:00:1e"), user_id=30},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=31, cidr = cidr("192.168.1.240/29"), mac = mac("00:00:01:00:00:1f"), user_id=31},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=31, cidr = cidr("192.168.1.248/29"), mac = mac("00:00:01:00:00:1f"), user_id=31},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=32, cidr = cidr("192.168.2.0/29"), mac = mac("00:00:01:00:00:20"), user_id=32},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=32, cidr = cidr("192.168.2.8/29"), mac = mac("00:00:01:00:00:20"), user_id=32},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=33, cidr = cidr("192.168.2.16/29"), mac = mac("00:00:01:00:00:21"), user_id=33},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=33, cidr = cidr("192.168.2.24/29"), mac = mac("00:00:01:00:00:21"), user_id=33},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=34, cidr = cidr("192.168.2.32/29"), mac = mac("00:00:01:00:00:22"), user_id=34},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=34, cidr = cidr("192.168.2.40/29"), mac = mac("00:00:01:00:00:22"), user_id=34},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=35, cidr = cidr("192.168.2.48/29"), mac = mac("00:00:01:00:00:23"), user_id=35},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=35, cidr = cidr("192.168.2.56/29"), mac = mac("00:00:01:00:00:23"), user_id=35},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=36, cidr = cidr("192.168.2.64/29"), mac = mac("00:00:01:00:00:24"), user_id=36},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=36, cidr = cidr("192.168.2.72/29"), mac = mac("00:00:01:00:00:24"), user_id=36},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=37, cidr = cidr("192.168.2.80/29"), mac = mac("00:00:01:00:00:25"), user_id=37},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=37, cidr = cidr("192.168.2.88/29"), mac = mac("00:00:01:00:00:25"), user_id=37},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=38, cidr = cidr("192.168.2.96/29"), mac = mac("00:00:01:00:00:26"), user_id=38},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=38, cidr = cidr("192.168.2.104/29"), mac = mac("00:00:01:00:00:26"), user_id=38},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=39, cidr = cidr("192.168.2.112/29"), mac = mac("00:00:01:00:00:27"), user_id=39},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=39, cidr = cidr("192.168.2.120/29"), mac = mac("00:00:01:00:00:27"), user_id=39},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=40, cidr = cidr("192.168.2.128/29"), mac = mac("00:00:01:00:00:28"), user_id=40},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=40, cidr = cidr("192.168.2.136/29"), mac = mac("00:00:01:00:00:28"), user_id=40},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=41, cidr = cidr("192.168.2.144/29"), mac = mac("00:00:01:00:00:29"), user_id=41},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=41, cidr = cidr("192.168.2.152/29"), mac = mac("00:00:01:00:00:29"), user_id=41},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=42, cidr = cidr("192.168.2.160/29"), mac = mac("00:00:01:00:00:2a"), user_id=42},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=42, cidr = cidr("192.168.2.168/29"), mac = mac("00:00:01:00:00:2a"), user_id=42},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=43, cidr = cidr("192.168.2.176/29"), mac = mac("00:00:01:00:00:2b"), user_id=43},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=43, cidr = cidr("192.168.2.184/29"), mac = mac("00:00:01:00:00:2b"), user_id=43},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=44, cidr = cidr("192.168.2.192/29"), mac = mac("00:00:01:00:00:2c"), user_id=44},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=44, cidr = cidr("192.168.2.200/29"), mac = mac("00:00:01:00:00:2c"), user_id=44},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=45, cidr = cidr("192.168.2.208/29"), mac = mac("00:00:01:00:00:2d"), user_id=45},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=45, cidr = cidr("192.168.2.216/29"), mac = mac("00:00:01:00:00:2d"), user_id=45},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=46, cidr = cidr("192.168.2.224/29"), mac = mac("00:00:01:00:00:2e"), user_id=46},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=46, cidr = cidr("192.168.2.232/29"), mac = mac("00:00:01:00:00:2e"), user_id=46},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=47, cidr = cidr("192.168.2.240/29"), mac = mac("00:00:01:00:00:2f"), user_id=47},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=47, cidr = cidr("192.168.2.248/29"), mac = mac("00:00:01:00:00:2f"), user_id=47},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=48, cidr = cidr("192.168.3.0/29"), mac = mac("00:00:01:00:00:30"), user_id=48},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=48, cidr = cidr("192.168.3.8/29"), mac = mac("00:00:01:00:00:30"), user_id=48},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=49, cidr = cidr("192.168.3.16/29"), mac = mac("00:00:01:00:00:31"), user_id=49},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=49, cidr = cidr("192.168.3.24/29"), mac = mac("00:00:01:00:00:31"), user_id=49},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=50, cidr = cidr("192.168.3.32/29"), mac = mac("00:00:01:00:00:32"), user_id=50},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=50, cidr = cidr("192.168.3.40/29"), mac = mac("00:00:01:00:00:32"), user_id=50},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=51, cidr = cidr("192.168.3.48/29"), mac = mac("00:00:01:00:00:33"), user_id=51},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=51, cidr = cidr("192.168.3.56/29"), mac = mac("00:00:01:00:00:33"), user_id=51},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=52, cidr = cidr("192.168.3.64/29"), mac = mac("00:00:01:00:00:34"), user_id=52},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=52, cidr = cidr("192.168.3.72/29"), mac = mac("00:00:01:00:00:34"), user_id=52},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=53, cidr = cidr("192.168.3.80/29"), mac = mac("00:00:01:00:00:35"), user_id=53},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=53, cidr = cidr("192.168.3.88/29"), mac = mac("00:00:01:00:00:35"), user_id=53},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=54, cidr = cidr("192.168.3.96/29"), mac = mac("00:00:01:00:00:36"), user_id=54},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=54, cidr = cidr("192.168.3.104/29"), mac = mac("00:00:01:00:00:36"), user_id=54},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=55, cidr = cidr("192.168.3.112/29"), mac = mac("00:00:01:00:00:37"), user_id=55},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=55, cidr = cidr("192.168.3.120/29"), mac = mac("00:00:01:00:00:37"), user_id=55},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=56, cidr = cidr("192.168.3.128/29"), mac = mac("00:00:01:00:00:38"), user_id=56},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=56, cidr = cidr("192.168.3.136/29"), mac = mac("00:00:01:00:00:38"), user_id=56},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=57, cidr = cidr("192.168.3.144/29"), mac = mac("00:00:01:00:00:39"), user_id=57},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=57, cidr = cidr("192.168.3.152/29"), mac = mac("00:00:01:00:00:39"), user_id=57},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=58, cidr = cidr("192.168.3.160/29"), mac = mac("00:00:01:00:00:3a"), user_id=58},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=58, cidr = cidr("192.168.3.168/29"), mac = mac("00:00:01:00:00:3a"), user_id=58},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=59, cidr = cidr("192.168.3.176/29"), mac = mac("00:00:01:00:00:3b"), user_id=59},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=59, cidr = cidr("192.168.3.184/29"), mac = mac("00:00:01:00:00:3b"), user_id=59},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=60, cidr = cidr("192.168.3.192/29"), mac = mac("00:00:01:00:00:3c"), user_id=60},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=60, cidr = cidr("192.168.3.200/29"), mac = mac("00:00:01:00:00:3c"), user_id=60},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=61, cidr = cidr("192.168.3.208/29"), mac = mac("00:00:01:00:00:3d"), user_id=61},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=61, cidr = cidr("192.168.3.216/29"), mac = mac("00:00:01:00:00:3d"), user_id=61},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=62, cidr = cidr("192.168.3.224/29"), mac = mac("00:00:01:00:00:3e"), user_id=62},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=62, cidr = cidr("192.168.3.232/29"), mac = mac("00:00:01:00:00:3e"), user_id=62},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=63, cidr = cidr("192.168.3.240/29"), mac = mac("00:00:01:00:00:3f"), user_id=63},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=63, cidr = cidr("192.168.3.248/29"), mac = mac("00:00:01:00:00:3f"), user_id=63},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=64, cidr = cidr("192.168.4.0/29"), mac = mac("00:00:01:00:00:40"), user_id=64},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=64, cidr = cidr("192.168.4.8/29"), mac = mac("00:00:01:00:00:40"), user_id=64},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=65, cidr = cidr("192.168.4.16/29"), mac = mac("00:00:01:00:00:41"), user_id=65},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=65, cidr = cidr("192.168.4.24/29"), mac = mac("00:00:01:00:00:41"), user_id=65},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=66, cidr = cidr("192.168.4.32/29"), mac = mac("00:00:01:00:00:42"), user_id=66},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=66, cidr = cidr("192.168.4.40/29"), mac = mac("00:00:01:00:00:42"), user_id=66},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=67, cidr = cidr("192.168.4.48/29"), mac = mac("00:00:01:00:00:43"), user_id=67},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=67, cidr = cidr("192.168.4.56/29"), mac = mac("00:00:01:00:00:43"), user_id=67},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=68, cidr = cidr("192.168.4.64/29"), mac = mac("00:00:01:00:00:44"), user_id=68},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=68, cidr = cidr("192.168.4.72/29"), mac = mac("00:00:01:00:00:44"), user_id=68},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=69, cidr = cidr("192.168.4.80/29"), mac = mac("00:00:01:00:00:45"), user_id=69},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=69, cidr = cidr("192.168.4.88/29"), mac = mac("00:00:01:00:00:45"), user_id=69},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=70, cidr = cidr("192.168.4.96/29"), mac = mac("00:00:01:00:00:46"), user_id=70},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=70, cidr = cidr("192.168.4.104/29"), mac = mac("00:00:01:00:00:46"), user_id=70},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=71, cidr = cidr("192.168.4.112/29"), mac = mac("00:00:01:00:00:47"), user_id=71},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=71, cidr = cidr("192.168.4.120/29"), mac = mac("00:00:01:00:00:47"), user_id=71},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=72, cidr = cidr("192.168.4.128/29"), mac = mac("00:00:01:00:00:48"), user_id=72},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=72, cidr = cidr("192.168.4.136/29"), mac = mac("00:00:01:00:00:48"), user_id=72},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=73, cidr = cidr("192.168.4.144/29"), mac = mac("00:00:01:00:00:49"), user_id=73},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=73, cidr = cidr("192.168.4.152/29"), mac = mac("00:00:01:00:00:49"), user_id=73},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=74, cidr = cidr("192.168.4.160/29"), mac = mac("00:00:01:00:00:4a"), user_id=74},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=74, cidr = cidr("192.168.4.168/29"), mac = mac("00:00:01:00:00:4a"), user_id=74},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=75, cidr = cidr("192.168.4.176/29"), mac = mac("00:00:01:00:00:4b"), user_id=75},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=75, cidr = cidr("192.168.4.184/29"), mac = mac("00:00:01:00:00:4b"), user_id=75},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=76, cidr = cidr("192.168.4.192/29"), mac = mac("00:00:01:00:00:4c"), user_id=76},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=76, cidr = cidr("192.168.4.200/29"), mac = mac("00:00:01:00:00:4c"), user_id=76},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=77, cidr = cidr("192.168.4.208/29"), mac = mac("00:00:01:00:00:4d"), user_id=77},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=77, cidr = cidr("192.168.4.216/29"), mac = mac("00:00:01:00:00:4d"), user_id=77},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=78, cidr = cidr("192.168.4.224/29"), mac = mac("00:00:01:00:00:4e"), user_id=78},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=78, cidr = cidr("192.168.4.232/29"), mac = mac("00:00:01:00:00:4e"), user_id=78},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=79, cidr = cidr("192.168.4.240/29"), mac = mac("00:00:01:00:00:4f"), user_id=79},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=79, cidr = cidr("192.168.4.248/29"), mac = mac("00:00:01:00:00:4f"), user_id=79},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=80, cidr = cidr("192.168.5.0/29"), mac = mac("00:00:01:00:00:50"), user_id=80},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=80, cidr = cidr("192.168.5.8/29"), mac = mac("00:00:01:00:00:50"), user_id=80},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=81, cidr = cidr("192.168.5.16/29"), mac = mac("00:00:01:00:00:51"), user_id=81},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=81, cidr = cidr("192.168.5.24/29"), mac = mac("00:00:01:00:00:51"), user_id=81},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=82, cidr = cidr("192.168.5.32/29"), mac = mac("00:00:01:00:00:52"), user_id=82},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=82, cidr = cidr("192.168.5.40/29"), mac = mac("00:00:01:00:00:52"), user_id=82},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=83, cidr = cidr("192.168.5.48/29"), mac = mac("00:00:01:00:00:53"), user_id=83},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=83, cidr = cidr("192.168.5.56/29"), mac = mac("00:00:01:00:00:53"), user_id=83},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=84, cidr = cidr("192.168.5.64/29"), mac = mac("00:00:01:00:00:54"), user_id=84},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=84, cidr = cidr("192.168.5.72/29"), mac = mac("00:00:01:00:00:54"), user_id=84},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=85, cidr = cidr("192.168.5.80/29"), mac = mac("00:00:01:00:00:55"), user_id=85},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=85, cidr = cidr("192.168.5.88/29"), mac = mac("00:00:01:00:00:55"), user_id=85},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=86, cidr = cidr("192.168.5.96/29"), mac = mac("00:00:01:00:00:56"), user_id=86},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=86, cidr = cidr("192.168.5.104/29"), mac = mac("00:00:01:00:00:56"), user_id=86},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=87, cidr = cidr("192.168.5.112/29"), mac = mac("00:00:01:00:00:57"), user_id=87},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=87, cidr = cidr("192.168.5.120/29"), mac = mac("00:00:01:00:00:57"), user_id=87},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=88, cidr = cidr("192.168.5.128/29"), mac = mac("00:00:01:00:00:58"), user_id=88},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=88, cidr = cidr("192.168.5.136/29"), mac = mac("00:00:01:00:00:58"), user_id=88},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=89, cidr = cidr("192.168.5.144/29"), mac = mac("00:00:01:00:00:59"), user_id=89},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=89, cidr = cidr("192.168.5.152/29"), mac = mac("00:00:01:00:00:59"), user_id=89},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=90, cidr = cidr("192.168.5.160/29"), mac = mac("00:00:01:00:00:5a"), user_id=90},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=90, cidr = cidr("192.168.5.168/29"), mac = mac("00:00:01:00:00:5a"), user_id=90},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=91, cidr = cidr("192.168.5.176/29"), mac = mac("00:00:01:00:00:5b"), user_id=91},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=91, cidr = cidr("192.168.5.184/29"), mac = mac("00:00:01:00:00:5b"), user_id=91},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=92, cidr = cidr("192.168.5.192/29"), mac = mac("00:00:01:00:00:5c"), user_id=92},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=92, cidr = cidr("192.168.5.200/29"), mac = mac("00:00:01:00:00:5c"), user_id=92},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=93, cidr = cidr("192.168.5.208/29"), mac = mac("00:00:01:00:00:5d"), user_id=93},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=93, cidr = cidr("192.168.5.216/29"), mac = mac("00:00:01:00:00:5d"), user_id=93},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=94, cidr = cidr("192.168.5.224/29"), mac = mac("00:00:01:00:00:5e"), user_id=94},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=94, cidr = cidr("192.168.5.232/29"), mac = mac("00:00:01:00:00:5e"), user_id=94},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=95, cidr = cidr("192.168.5.240/29"), mac = mac("00:00:01:00:00:5f"), user_id=95},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=95, cidr = cidr("192.168.5.248/29"), mac = mac("00:00:01:00:00:5f"), user_id=95},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=96, cidr = cidr("192.168.6.0/29"), mac = mac("00:00:01:00:00:60"), user_id=96},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=96, cidr = cidr("192.168.6.8/29"), mac = mac("00:00:01:00:00:60"), user_id=96},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=97, cidr = cidr("192.168.6.16/29"), mac = mac("00:00:01:00:00:61"), user_id=97},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=97, cidr = cidr("192.168.6.24/29"), mac = mac("00:00:01:00:00:61"), user_id=97},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=98, cidr = cidr("192.168.6.32/29"), mac = mac("00:00:01:00:00:62"), user_id=98},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=98, cidr = cidr("192.168.6.40/29"), mac = mac("00:00:01:00:00:62"), user_id=98},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=99, cidr = cidr("192.168.6.48/29"), mac = mac("00:00:01:00:00:63"), user_id=99},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=99, cidr = cidr("192.168.6.56/29"), mac = mac("00:00:01:00:00:63"), user_id=99},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=100, cidr = cidr("192.168.6.64/29"), mac = mac("00:00:01:00:00:64"), user_id=100},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=100, cidr = cidr("192.168.6.72/29"), mac = mac("00:00:01:00:00:64"), user_id=100},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=101, cidr = cidr("192.168.6.80/29"), mac = mac("00:00:01:00:00:65"), user_id=101},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=101, cidr = cidr("192.168.6.88/29"), mac = mac("00:00:01:00:00:65"), user_id=101},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=102, cidr = cidr("192.168.6.96/29"), mac = mac("00:00:01:00:00:66"), user_id=102},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=102, cidr = cidr("192.168.6.104/29"), mac = mac("00:00:01:00:00:66"), user_id=102},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=103, cidr = cidr("192.168.6.112/29"), mac = mac("00:00:01:00:00:67"), user_id=103},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=103, cidr = cidr("192.168.6.120/29"), mac = mac("00:00:01:00:00:67"), user_id=103},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=104, cidr = cidr("192.168.6.128/29"), mac = mac("00:00:01:00:00:68"), user_id=104},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=104, cidr = cidr("192.168.6.136/29"), mac = mac("00:00:01:00:00:68"), user_id=104},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=105, cidr = cidr("192.168.6.144/29"), mac = mac("00:00:01:00:00:69"), user_id=105},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=105, cidr = cidr("192.168.6.152/29"), mac = mac("00:00:01:00:00:69"), user_id=105},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=106, cidr = cidr("192.168.6.160/29"), mac = mac("00:00:01:00:00:6a"), user_id=106},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=106, cidr = cidr("192.168.6.168/29"), mac = mac("00:00:01:00:00:6a"), user_id=106},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=107, cidr = cidr("192.168.6.176/29"), mac = mac("00:00:01:00:00:6b"), user_id=107},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=107, cidr = cidr("192.168.6.184/29"), mac = mac("00:00:01:00:00:6b"), user_id=107},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=108, cidr = cidr("192.168.6.192/29"), mac = mac("00:00:01:00:00:6c"), user_id=108},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=108, cidr = cidr("192.168.6.200/29"), mac = mac("00:00:01:00:00:6c"), user_id=108},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=109, cidr = cidr("192.168.6.208/29"), mac = mac("00:00:01:00:00:6d"), user_id=109},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=109, cidr = cidr("192.168.6.216/29"), mac = mac("00:00:01:00:00:6d"), user_id=109},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=110, cidr = cidr("192.168.6.224/29"), mac = mac("00:00:01:00:00:6e"), user_id=110},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=110, cidr = cidr("192.168.6.232/29"), mac = mac("00:00:01:00:00:6e"), user_id=110},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=111, cidr = cidr("192.168.6.240/29"), mac = mac("00:00:01:00:00:6f"), user_id=111},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=111, cidr = cidr("192.168.6.248/29"), mac = mac("00:00:01:00:00:6f"), user_id=111},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=112, cidr = cidr("192.168.7.0/29"), mac = mac("00:00:01:00:00:70"), user_id=112},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=112, cidr = cidr("192.168.7.8/29"), mac = mac("00:00:01:00:00:70"), user_id=112},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=113, cidr = cidr("192.168.7.16/29"), mac = mac("00:00:01:00:00:71"), user_id=113},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=113, cidr = cidr("192.168.7.24/29"), mac = mac("00:00:01:00:00:71"), user_id=113},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=114, cidr = cidr("192.168.7.32/29"), mac = mac("00:00:01:00:00:72"), user_id=114},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=114, cidr = cidr("192.168.7.40/29"), mac = mac("00:00:01:00:00:72"), user_id=114},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=115, cidr = cidr("192.168.7.48/29"), mac = mac("00:00:01:00:00:73"), user_id=115},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=115, cidr = cidr("192.168.7.56/29"), mac = mac("00:00:01:00:00:73"), user_id=115},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=116, cidr = cidr("192.168.7.64/29"), mac = mac("00:00:01:00:00:74"), user_id=116},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=116, cidr = cidr("192.168.7.72/29"), mac = mac("00:00:01:00:00:74"), user_id=116},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=117, cidr = cidr("192.168.7.80/29"), mac = mac("00:00:01:00:00:75"), user_id=117},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=117, cidr = cidr("192.168.7.88/29"), mac = mac("00:00:01:00:00:75"), user_id=117},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=118, cidr = cidr("192.168.7.96/29"), mac = mac("00:00:01:00:00:76"), user_id=118},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=118, cidr = cidr("192.168.7.104/29"), mac = mac("00:00:01:00:00:76"), user_id=118},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=119, cidr = cidr("192.168.7.112/29"), mac = mac("00:00:01:00:00:77"), user_id=119},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=119, cidr = cidr("192.168.7.120/29"), mac = mac("00:00:01:00:00:77"), user_id=119},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=120, cidr = cidr("192.168.7.128/29"), mac = mac("00:00:01:00:00:78"), user_id=120},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=120, cidr = cidr("192.168.7.136/29"), mac = mac("00:00:01:00:00:78"), user_id=120},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=121, cidr = cidr("192.168.7.144/29"), mac = mac("00:00:01:00:00:79"), user_id=121},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=121, cidr = cidr("192.168.7.152/29"), mac = mac("00:00:01:00:00:79"), user_id=121},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=122, cidr = cidr("192.168.7.160/29"), mac = mac("00:00:01:00:00:7a"), user_id=122},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=122, cidr = cidr("192.168.7.168/29"), mac = mac("00:00:01:00:00:7a"), user_id=122},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=123, cidr = cidr("192.168.7.176/29"), mac = mac("00:00:01:00:00:7b"), user_id=123},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=123, cidr = cidr("192.168.7.184/29"), mac = mac("00:00:01:00:00:7b"), user_id=123},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=124, cidr = cidr("192.168.7.192/29"), mac = mac("00:00:01:00:00:7c"), user_id=124},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=124, cidr = cidr("192.168.7.200/29"), mac = mac("00:00:01:00:00:7c"), user_id=124},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=125, cidr = cidr("192.168.7.208/29"), mac = mac("00:00:01:00:00:7d"), user_id=125},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=125, cidr = cidr("192.168.7.216/29"), mac = mac("00:00:01:00:00:7d"), user_id=125},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=126, cidr = cidr("192.168.7.224/29"), mac = mac("00:00:01:00:00:7e"), user_id=126},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=126, cidr = cidr("192.168.7.232/29"), mac = mac("00:00:01:00:00:7e"), user_id=126},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=127, cidr = cidr("192.168.7.240/29"), mac = mac("00:00:01:00:00:7f"), user_id=127},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=127, cidr = cidr("192.168.7.248/29"), mac = mac("00:00:01:00:00:7f"), user_id=127},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=128, cidr = cidr("192.168.8.0/29"), mac = mac("00:00:01:00:00:80"), user_id=128},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=128, cidr = cidr("192.168.8.8/29"), mac = mac("00:00:01:00:00:80"), user_id=128},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=129, cidr = cidr("192.168.8.16/29"), mac = mac("00:00:01:00:00:81"), user_id=129},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=129, cidr = cidr("192.168.8.24/29"), mac = mac("00:00:01:00:00:81"), user_id=129},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=130, cidr = cidr("192.168.8.32/29"), mac = mac("00:00:01:00:00:82"), user_id=130},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=130, cidr = cidr("192.168.8.40/29"), mac = mac("00:00:01:00:00:82"), user_id=130},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=131, cidr = cidr("192.168.8.48/29"), mac = mac("00:00:01:00:00:83"), user_id=131},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=131, cidr = cidr("192.168.8.56/29"), mac = mac("00:00:01:00:00:83"), user_id=131},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=132, cidr = cidr("192.168.8.64/29"), mac = mac("00:00:01:00:00:84"), user_id=132},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=132, cidr = cidr("192.168.8.72/29"), mac = mac("00:00:01:00:00:84"), user_id=132},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=133, cidr = cidr("192.168.8.80/29"), mac = mac("00:00:01:00:00:85"), user_id=133},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=133, cidr = cidr("192.168.8.88/29"), mac = mac("00:00:01:00:00:85"), user_id=133},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=134, cidr = cidr("192.168.8.96/29"), mac = mac("00:00:01:00:00:86"), user_id=134},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=134, cidr = cidr("192.168.8.104/29"), mac = mac("00:00:01:00:00:86"), user_id=134},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=135, cidr = cidr("192.168.8.112/29"), mac = mac("00:00:01:00:00:87"), user_id=135},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=135, cidr = cidr("192.168.8.120/29"), mac = mac("00:00:01:00:00:87"), user_id=135},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=136, cidr = cidr("192.168.8.128/29"), mac = mac("00:00:01:00:00:88"), user_id=136},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=136, cidr = cidr("192.168.8.136/29"), mac = mac("00:00:01:00:00:88"), user_id=136},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=137, cidr = cidr("192.168.8.144/29"), mac = mac("00:00:01:00:00:89"), user_id=137},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=137, cidr = cidr("192.168.8.152/29"), mac = mac("00:00:01:00:00:89"), user_id=137},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=138, cidr = cidr("192.168.8.160/29"), mac = mac("00:00:01:00:00:8a"), user_id=138},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=138, cidr = cidr("192.168.8.168/29"), mac = mac("00:00:01:00:00:8a"), user_id=138},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=139, cidr = cidr("192.168.8.176/29"), mac = mac("00:00:01:00:00:8b"), user_id=139},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=139, cidr = cidr("192.168.8.184/29"), mac = mac("00:00:01:00:00:8b"), user_id=139},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=140, cidr = cidr("192.168.8.192/29"), mac = mac("00:00:01:00:00:8c"), user_id=140},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=140, cidr = cidr("192.168.8.200/29"), mac = mac("00:00:01:00:00:8c"), user_id=140},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=141, cidr = cidr("192.168.8.208/29"), mac = mac("00:00:01:00:00:8d"), user_id=141},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=141, cidr = cidr("192.168.8.216/29"), mac = mac("00:00:01:00:00:8d"), user_id=141},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=142, cidr = cidr("192.168.8.224/29"), mac = mac("00:00:01:00:00:8e"), user_id=142},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=142, cidr = cidr("192.168.8.232/29"), mac = mac("00:00:01:00:00:8e"), user_id=142},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=143, cidr = cidr("192.168.8.240/29"), mac = mac("00:00:01:00:00:8f"), user_id=143},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=143, cidr = cidr("192.168.8.248/29"), mac = mac("00:00:01:00:00:8f"), user_id=143},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=144, cidr = cidr("192.168.9.0/29"), mac = mac("00:00:01:00:00:90"), user_id=144},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=144, cidr = cidr("192.168.9.8/29"), mac = mac("00:00:01:00:00:90"), user_id=144},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=145, cidr = cidr("192.168.9.16/29"), mac = mac("00:00:01:00:00:91"), user_id=145},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=145, cidr = cidr("192.168.9.24/29"), mac = mac("00:00:01:00:00:91"), user_id=145},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=146, cidr = cidr("192.168.9.32/29"), mac = mac("00:00:01:00:00:92"), user_id=146},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=146, cidr = cidr("192.168.9.40/29"), mac = mac("00:00:01:00:00:92"), user_id=146},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=147, cidr = cidr("192.168.9.48/29"), mac = mac("00:00:01:00:00:93"), user_id=147},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=147, cidr = cidr("192.168.9.56/29"), mac = mac("00:00:01:00:00:93"), user_id=147},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=148, cidr = cidr("192.168.9.64/29"), mac = mac("00:00:01:00:00:94"), user_id=148},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=148, cidr = cidr("192.168.9.72/29"), mac = mac("00:00:01:00:00:94"), user_id=148},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=149, cidr = cidr("192.168.9.80/29"), mac = mac("00:00:01:00:00:95"), user_id=149},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=149, cidr = cidr("192.168.9.88/29"), mac = mac("00:00:01:00:00:95"), user_id=149},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=150, cidr = cidr("192.168.9.96/29"), mac = mac("00:00:01:00:00:96"), user_id=150},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=150, cidr = cidr("192.168.9.104/29"), mac = mac("00:00:01:00:00:96"), user_id=150},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=151, cidr = cidr("192.168.9.112/29"), mac = mac("00:00:01:00:00:97"), user_id=151},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=151, cidr = cidr("192.168.9.120/29"), mac = mac("00:00:01:00:00:97"), user_id=151},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=152, cidr = cidr("192.168.9.128/29"), mac = mac("00:00:01:00:00:98"), user_id=152},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=152, cidr = cidr("192.168.9.136/29"), mac = mac("00:00:01:00:00:98"), user_id=152},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=153, cidr = cidr("192.168.9.144/29"), mac = mac("00:00:01:00:00:99"), user_id=153},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=153, cidr = cidr("192.168.9.152/29"), mac = mac("00:00:01:00:00:99"), user_id=153},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=154, cidr = cidr("192.168.9.160/29"), mac = mac("00:00:01:00:00:9a"), user_id=154},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=154, cidr = cidr("192.168.9.168/29"), mac = mac("00:00:01:00:00:9a"), user_id=154},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=155, cidr = cidr("192.168.9.176/29"), mac = mac("00:00:01:00:00:9b"), user_id=155},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=155, cidr = cidr("192.168.9.184/29"), mac = mac("00:00:01:00:00:9b"), user_id=155},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=156, cidr = cidr("192.168.9.192/29"), mac = mac("00:00:01:00:00:9c"), user_id=156},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=156, cidr = cidr("192.168.9.200/29"), mac = mac("00:00:01:00:00:9c"), user_id=156},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=157, cidr = cidr("192.168.9.208/29"), mac = mac("00:00:01:00:00:9d"), user_id=157},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=157, cidr = cidr("192.168.9.216/29"), mac = mac("00:00:01:00:00:9d"), user_id=157},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=158, cidr = cidr("192.168.9.224/29"), mac = mac("00:00:01:00:00:9e"), user_id=158},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=158, cidr = cidr("192.168.9.232/29"), mac = mac("00:00:01:00:00:9e"), user_id=158},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=159, cidr = cidr("192.168.9.240/29"), mac = mac("00:00:01:00:00:9f"), user_id=159},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=159, cidr = cidr("192.168.9.248/29"), mac = mac("00:00:01:00:00:9f"), user_id=159},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=160, cidr = cidr("192.168.10.0/29"), mac = mac("00:00:01:00:00:a0"), user_id=160},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=160, cidr = cidr("192.168.10.8/29"), mac = mac("00:00:01:00:00:a0"), user_id=160},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=161, cidr = cidr("192.168.10.16/29"), mac = mac("00:00:01:00:00:a1"), user_id=161},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=161, cidr = cidr("192.168.10.24/29"), mac = mac("00:00:01:00:00:a1"), user_id=161},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=162, cidr = cidr("192.168.10.32/29"), mac = mac("00:00:01:00:00:a2"), user_id=162},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=162, cidr = cidr("192.168.10.40/29"), mac = mac("00:00:01:00:00:a2"), user_id=162},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=163, cidr = cidr("192.168.10.48/29"), mac = mac("00:00:01:00:00:a3"), user_id=163},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=163, cidr = cidr("192.168.10.56/29"), mac = mac("00:00:01:00:00:a3"), user_id=163},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=164, cidr = cidr("192.168.10.64/29"), mac = mac("00:00:01:00:00:a4"), user_id=164},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=164, cidr = cidr("192.168.10.72/29"), mac = mac("00:00:01:00:00:a4"), user_id=164},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=165, cidr = cidr("192.168.10.80/29"), mac = mac("00:00:01:00:00:a5"), user_id=165},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=165, cidr = cidr("192.168.10.88/29"), mac = mac("00:00:01:00:00:a5"), user_id=165},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=166, cidr = cidr("192.168.10.96/29"), mac = mac("00:00:01:00:00:a6"), user_id=166},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=166, cidr = cidr("192.168.10.104/29"), mac = mac("00:00:01:00:00:a6"), user_id=166},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=167, cidr = cidr("192.168.10.112/29"), mac = mac("00:00:01:00:00:a7"), user_id=167},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=167, cidr = cidr("192.168.10.120/29"), mac = mac("00:00:01:00:00:a7"), user_id=167},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=168, cidr = cidr("192.168.10.128/29"), mac = mac("00:00:01:00:00:a8"), user_id=168},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=168, cidr = cidr("192.168.10.136/29"), mac = mac("00:00:01:00:00:a8"), user_id=168},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=169, cidr = cidr("192.168.10.144/29"), mac = mac("00:00:01:00:00:a9"), user_id=169},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=169, cidr = cidr("192.168.10.152/29"), mac = mac("00:00:01:00:00:a9"), user_id=169},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=170, cidr = cidr("192.168.10.160/29"), mac = mac("00:00:01:00:00:aa"), user_id=170},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=170, cidr = cidr("192.168.10.168/29"), mac = mac("00:00:01:00:00:aa"), user_id=170},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=171, cidr = cidr("192.168.10.176/29"), mac = mac("00:00:01:00:00:ab"), user_id=171},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=171, cidr = cidr("192.168.10.184/29"), mac = mac("00:00:01:00:00:ab"), user_id=171},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=172, cidr = cidr("192.168.10.192/29"), mac = mac("00:00:01:00:00:ac"), user_id=172},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=172, cidr = cidr("192.168.10.200/29"), mac = mac("00:00:01:00:00:ac"), user_id=172},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=173, cidr = cidr("192.168.10.208/29"), mac = mac("00:00:01:00:00:ad"), user_id=173},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=173, cidr = cidr("192.168.10.216/29"), mac = mac("00:00:01:00:00:ad"), user_id=173},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=174, cidr = cidr("192.168.10.224/29"), mac = mac("00:00:01:00:00:ae"), user_id=174},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=174, cidr = cidr("192.168.10.232/29"), mac = mac("00:00:01:00:00:ae"), user_id=174},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=175, cidr = cidr("192.168.10.240/29"), mac = mac("00:00:01:00:00:af"), user_id=175},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=175, cidr = cidr("192.168.10.248/29"), mac = mac("00:00:01:00:00:af"), user_id=175},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=176, cidr = cidr("192.168.11.0/29"), mac = mac("00:00:01:00:00:b0"), user_id=176},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=176, cidr = cidr("192.168.11.8/29"), mac = mac("00:00:01:00:00:b0"), user_id=176},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=177, cidr = cidr("192.168.11.16/29"), mac = mac("00:00:01:00:00:b1"), user_id=177},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=177, cidr = cidr("192.168.11.24/29"), mac = mac("00:00:01:00:00:b1"), user_id=177},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=178, cidr = cidr("192.168.11.32/29"), mac = mac("00:00:01:00:00:b2"), user_id=178},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=178, cidr = cidr("192.168.11.40/29"), mac = mac("00:00:01:00:00:b2"), user_id=178},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=179, cidr = cidr("192.168.11.48/29"), mac = mac("00:00:01:00:00:b3"), user_id=179},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=179, cidr = cidr("192.168.11.56/29"), mac = mac("00:00:01:00:00:b3"), user_id=179},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=180, cidr = cidr("192.168.11.64/29"), mac = mac("00:00:01:00:00:b4"), user_id=180},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=180, cidr = cidr("192.168.11.72/29"), mac = mac("00:00:01:00:00:b4"), user_id=180},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=181, cidr = cidr("192.168.11.80/29"), mac = mac("00:00:01:00:00:b5"), user_id=181},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=181, cidr = cidr("192.168.11.88/29"), mac = mac("00:00:01:00:00:b5"), user_id=181},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=182, cidr = cidr("192.168.11.96/29"), mac = mac("00:00:01:00:00:b6"), user_id=182},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=182, cidr = cidr("192.168.11.104/29"), mac = mac("00:00:01:00:00:b6"), user_id=182},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=183, cidr = cidr("192.168.11.112/29"), mac = mac("00:00:01:00:00:b7"), user_id=183},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=183, cidr = cidr("192.168.11.120/29"), mac = mac("00:00:01:00:00:b7"), user_id=183},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=184, cidr = cidr("192.168.11.128/29"), mac = mac("00:00:01:00:00:b8"), user_id=184},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=184, cidr = cidr("192.168.11.136/29"), mac = mac("00:00:01:00:00:b8"), user_id=184},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=185, cidr = cidr("192.168.11.144/29"), mac = mac("00:00:01:00:00:b9"), user_id=185},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=185, cidr = cidr("192.168.11.152/29"), mac = mac("00:00:01:00:00:b9"), user_id=185},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=186, cidr = cidr("192.168.11.160/29"), mac = mac("00:00:01:00:00:ba"), user_id=186},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=186, cidr = cidr("192.168.11.168/29"), mac = mac("00:00:01:00:00:ba"), user_id=186},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=187, cidr = cidr("192.168.11.176/29"), mac = mac("00:00:01:00:00:bb"), user_id=187},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=187, cidr = cidr("192.168.11.184/29"), mac = mac("00:00:01:00:00:bb"), user_id=187},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=188, cidr = cidr("192.168.11.192/29"), mac = mac("00:00:01:00:00:bc"), user_id=188},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=188, cidr = cidr("192.168.11.200/29"), mac = mac("00:00:01:00:00:bc"), user_id=188},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=189, cidr = cidr("192.168.11.208/29"), mac = mac("00:00:01:00:00:bd"), user_id=189},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=189, cidr = cidr("192.168.11.216/29"), mac = mac("00:00:01:00:00:bd"), user_id=189},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=190, cidr = cidr("192.168.11.224/29"), mac = mac("00:00:01:00:00:be"), user_id=190},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=190, cidr = cidr("192.168.11.232/29"), mac = mac("00:00:01:00:00:be"), user_id=190},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=191, cidr = cidr("192.168.11.240/29"), mac = mac("00:00:01:00:00:bf"), user_id=191},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=191, cidr = cidr("192.168.11.248/29"), mac = mac("00:00:01:00:00:bf"), user_id=191},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=192, cidr = cidr("192.168.12.0/29"), mac = mac("00:00:01:00:00:c0"), user_id=192},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=192, cidr = cidr("192.168.12.8/29"), mac = mac("00:00:01:00:00:c0"), user_id=192},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=193, cidr = cidr("192.168.12.16/29"), mac = mac("00:00:01:00:00:c1"), user_id=193},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=193, cidr = cidr("192.168.12.24/29"), mac = mac("00:00:01:00:00:c1"), user_id=193},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=194, cidr = cidr("192.168.12.32/29"), mac = mac("00:00:01:00:00:c2"), user_id=194},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=194, cidr = cidr("192.168.12.40/29"), mac = mac("00:00:01:00:00:c2"), user_id=194},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=195, cidr = cidr("192.168.12.48/29"), mac = mac("00:00:01:00:00:c3"), user_id=195},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=195, cidr = cidr("192.168.12.56/29"), mac = mac("00:00:01:00:00:c3"), user_id=195},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=196, cidr = cidr("192.168.12.64/29"), mac = mac("00:00:01:00:00:c4"), user_id=196},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=196, cidr = cidr("192.168.12.72/29"), mac = mac("00:00:01:00:00:c4"), user_id=196},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=197, cidr = cidr("192.168.12.80/29"), mac = mac("00:00:01:00:00:c5"), user_id=197},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=197, cidr = cidr("192.168.12.88/29"), mac = mac("00:00:01:00:00:c5"), user_id=197},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=198, cidr = cidr("192.168.12.96/29"), mac = mac("00:00:01:00:00:c6"), user_id=198},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=198, cidr = cidr("192.168.12.104/29"), mac = mac("00:00:01:00:00:c6"), user_id=198},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=199, cidr = cidr("192.168.12.112/29"), mac = mac("00:00:01:00:00:c7"), user_id=199},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=199, cidr = cidr("192.168.12.120/29"), mac = mac("00:00:01:00:00:c7"), user_id=199},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=200, cidr = cidr("192.168.12.128/29"), mac = mac("00:00:01:00:00:c8"), user_id=200},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=200, cidr = cidr("192.168.12.136/29"), mac = mac("00:00:01:00:00:c8"), user_id=200},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=201, cidr = cidr("192.168.12.144/29"), mac = mac("00:00:01:00:00:c9"), user_id=201},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=201, cidr = cidr("192.168.12.152/29"), mac = mac("00:00:01:00:00:c9"), user_id=201},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=202, cidr = cidr("192.168.12.160/29"), mac = mac("00:00:01:00:00:ca"), user_id=202},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=202, cidr = cidr("192.168.12.168/29"), mac = mac("00:00:01:00:00:ca"), user_id=202},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=203, cidr = cidr("192.168.12.176/29"), mac = mac("00:00:01:00:00:cb"), user_id=203},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=203, cidr = cidr("192.168.12.184/29"), mac = mac("00:00:01:00:00:cb"), user_id=203},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=204, cidr = cidr("192.168.12.192/29"), mac = mac("00:00:01:00:00:cc"), user_id=204},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=204, cidr = cidr("192.168.12.200/29"), mac = mac("00:00:01:00:00:cc"), user_id=204},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=205, cidr = cidr("192.168.12.208/29"), mac = mac("00:00:01:00:00:cd"), user_id=205},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=205, cidr = cidr("192.168.12.216/29"), mac = mac("00:00:01:00:00:cd"), user_id=205},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=206, cidr = cidr("192.168.12.224/29"), mac = mac("00:00:01:00:00:ce"), user_id=206},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=206, cidr = cidr("192.168.12.232/29"), mac = mac("00:00:01:00:00:ce"), user_id=206},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=207, cidr = cidr("192.168.12.240/29"), mac = mac("00:00:01:00:00:cf"), user_id=207},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=207, cidr = cidr("192.168.12.248/29"), mac = mac("00:00:01:00:00:cf"), user_id=207},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=208, cidr = cidr("192.168.13.0/29"), mac = mac("00:00:01:00:00:d0"), user_id=208},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=208, cidr = cidr("192.168.13.8/29"), mac = mac("00:00:01:00:00:d0"), user_id=208},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=209, cidr = cidr("192.168.13.16/29"), mac = mac("00:00:01:00:00:d1"), user_id=209},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=209, cidr = cidr("192.168.13.24/29"), mac = mac("00:00:01:00:00:d1"), user_id=209},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=210, cidr = cidr("192.168.13.32/29"), mac = mac("00:00:01:00:00:d2"), user_id=210},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=210, cidr = cidr("192.168.13.40/29"), mac = mac("00:00:01:00:00:d2"), user_id=210},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=211, cidr = cidr("192.168.13.48/29"), mac = mac("00:00:01:00:00:d3"), user_id=211},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=211, cidr = cidr("192.168.13.56/29"), mac = mac("00:00:01:00:00:d3"), user_id=211},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=212, cidr = cidr("192.168.13.64/29"), mac = mac("00:00:01:00:00:d4"), user_id=212},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=212, cidr = cidr("192.168.13.72/29"), mac = mac("00:00:01:00:00:d4"), user_id=212},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=213, cidr = cidr("192.168.13.80/29"), mac = mac("00:00:01:00:00:d5"), user_id=213},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=213, cidr = cidr("192.168.13.88/29"), mac = mac("00:00:01:00:00:d5"), user_id=213},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=214, cidr = cidr("192.168.13.96/29"), mac = mac("00:00:01:00:00:d6"), user_id=214},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=214, cidr = cidr("192.168.13.104/29"), mac = mac("00:00:01:00:00:d6"), user_id=214},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=215, cidr = cidr("192.168.13.112/29"), mac = mac("00:00:01:00:00:d7"), user_id=215},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=215, cidr = cidr("192.168.13.120/29"), mac = mac("00:00:01:00:00:d7"), user_id=215},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=216, cidr = cidr("192.168.13.128/29"), mac = mac("00:00:01:00:00:d8"), user_id=216},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=216, cidr = cidr("192.168.13.136/29"), mac = mac("00:00:01:00:00:d8"), user_id=216},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=217, cidr = cidr("192.168.13.144/29"), mac = mac("00:00:01:00:00:d9"), user_id=217},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=217, cidr = cidr("192.168.13.152/29"), mac = mac("00:00:01:00:00:d9"), user_id=217},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=218, cidr = cidr("192.168.13.160/29"), mac = mac("00:00:01:00:00:da"), user_id=218},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=218, cidr = cidr("192.168.13.168/29"), mac = mac("00:00:01:00:00:da"), user_id=218},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=219, cidr = cidr("192.168.13.176/29"), mac = mac("00:00:01:00:00:db"), user_id=219},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=219, cidr = cidr("192.168.13.184/29"), mac = mac("00:00:01:00:00:db"), user_id=219},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=220, cidr = cidr("192.168.13.192/29"), mac = mac("00:00:01:00:00:dc"), user_id=220},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=220, cidr = cidr("192.168.13.200/29"), mac = mac("00:00:01:00:00:dc"), user_id=220},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=221, cidr = cidr("192.168.13.208/29"), mac = mac("00:00:01:00:00:dd"), user_id=221},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=221, cidr = cidr("192.168.13.216/29"), mac = mac("00:00:01:00:00:dd"), user_id=221},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=222, cidr = cidr("192.168.13.224/29"), mac = mac("00:00:01:00:00:de"), user_id=222},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=222, cidr = cidr("192.168.13.232/29"), mac = mac("00:00:01:00:00:de"), user_id=222},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=223, cidr = cidr("192.168.13.240/29"), mac = mac("00:00:01:00:00:df"), user_id=223},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=223, cidr = cidr("192.168.13.248/29"), mac = mac("00:00:01:00:00:df"), user_id=223},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=224, cidr = cidr("192.168.14.0/29"), mac = mac("00:00:01:00:00:e0"), user_id=224},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=224, cidr = cidr("192.168.14.8/29"), mac = mac("00:00:01:00:00:e0"), user_id=224},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=225, cidr = cidr("192.168.14.16/29"), mac = mac("00:00:01:00:00:e1"), user_id=225},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=225, cidr = cidr("192.168.14.24/29"), mac = mac("00:00:01:00:00:e1"), user_id=225},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=226, cidr = cidr("192.168.14.32/29"), mac = mac("00:00:01:00:00:e2"), user_id=226},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=226, cidr = cidr("192.168.14.40/29"), mac = mac("00:00:01:00:00:e2"), user_id=226},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=227, cidr = cidr("192.168.14.48/29"), mac = mac("00:00:01:00:00:e3"), user_id=227},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=227, cidr = cidr("192.168.14.56/29"), mac = mac("00:00:01:00:00:e3"), user_id=227},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=228, cidr = cidr("192.168.14.64/29"), mac = mac("00:00:01:00:00:e4"), user_id=228},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=228, cidr = cidr("192.168.14.72/29"), mac = mac("00:00:01:00:00:e4"), user_id=228},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=229, cidr = cidr("192.168.14.80/29"), mac = mac("00:00:01:00:00:e5"), user_id=229},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=229, cidr = cidr("192.168.14.88/29"), mac = mac("00:00:01:00:00:e5"), user_id=229},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=230, cidr = cidr("192.168.14.96/29"), mac = mac("00:00:01:00:00:e6"), user_id=230},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=230, cidr = cidr("192.168.14.104/29"), mac = mac("00:00:01:00:00:e6"), user_id=230},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=231, cidr = cidr("192.168.14.112/29"), mac = mac("00:00:01:00:00:e7"), user_id=231},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=231, cidr = cidr("192.168.14.120/29"), mac = mac("00:00:01:00:00:e7"), user_id=231},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=232, cidr = cidr("192.168.14.128/29"), mac = mac("00:00:01:00:00:e8"), user_id=232},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=232, cidr = cidr("192.168.14.136/29"), mac = mac("00:00:01:00:00:e8"), user_id=232},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=233, cidr = cidr("192.168.14.144/29"), mac = mac("00:00:01:00:00:e9"), user_id=233},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=233, cidr = cidr("192.168.14.152/29"), mac = mac("00:00:01:00:00:e9"), user_id=233},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=234, cidr = cidr("192.168.14.160/29"), mac = mac("00:00:01:00:00:ea"), user_id=234},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=234, cidr = cidr("192.168.14.168/29"), mac = mac("00:00:01:00:00:ea"), user_id=234},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=235, cidr = cidr("192.168.14.176/29"), mac = mac("00:00:01:00:00:eb"), user_id=235},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=235, cidr = cidr("192.168.14.184/29"), mac = mac("00:00:01:00:00:eb"), user_id=235},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=236, cidr = cidr("192.168.14.192/29"), mac = mac("00:00:01:00:00:ec"), user_id=236},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=236, cidr = cidr("192.168.14.200/29"), mac = mac("00:00:01:00:00:ec"), user_id=236},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=237, cidr = cidr("192.168.14.208/29"), mac = mac("00:00:01:00:00:ed"), user_id=237},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=237, cidr = cidr("192.168.14.216/29"), mac = mac("00:00:01:00:00:ed"), user_id=237},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=238, cidr = cidr("192.168.14.224/29"), mac = mac("00:00:01:00:00:ee"), user_id=238},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=238, cidr = cidr("192.168.14.232/29"), mac = mac("00:00:01:00:00:ee"), user_id=238},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=239, cidr = cidr("192.168.14.240/29"), mac = mac("00:00:01:00:00:ef"), user_id=239},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=239, cidr = cidr("192.168.14.248/29"), mac = mac("00:00:01:00:00:ef"), user_id=239},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=240, cidr = cidr("192.168.15.0/29"), mac = mac("00:00:01:00:00:f0"), user_id=240},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=240, cidr = cidr("192.168.15.8/29"), mac = mac("00:00:01:00:00:f0"), user_id=240},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=241, cidr = cidr("192.168.15.16/29"), mac = mac("00:00:01:00:00:f1"), user_id=241},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=241, cidr = cidr("192.168.15.24/29"), mac = mac("00:00:01:00:00:f1"), user_id=241},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=242, cidr = cidr("192.168.15.32/29"), mac = mac("00:00:01:00:00:f2"), user_id=242},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=242, cidr = cidr("192.168.15.40/29"), mac = mac("00:00:01:00:00:f2"), user_id=242},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=243, cidr = cidr("192.168.15.48/29"), mac = mac("00:00:01:00:00:f3"), user_id=243},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=243, cidr = cidr("192.168.15.56/29"), mac = mac("00:00:01:00:00:f3"), user_id=243},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=244, cidr = cidr("192.168.15.64/29"), mac = mac("00:00:01:00:00:f4"), user_id=244},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=244, cidr = cidr("192.168.15.72/29"), mac = mac("00:00:01:00:00:f4"), user_id=244},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=245, cidr = cidr("192.168.15.80/29"), mac = mac("00:00:01:00:00:f5"), user_id=245},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=245, cidr = cidr("192.168.15.88/29"), mac = mac("00:00:01:00:00:f5"), user_id=245},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=246, cidr = cidr("192.168.15.96/29"), mac = mac("00:00:01:00:00:f6"), user_id=246},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=246, cidr = cidr("192.168.15.104/29"), mac = mac("00:00:01:00:00:f6"), user_id=246},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=247, cidr = cidr("192.168.15.112/29"), mac = mac("00:00:01:00:00:f7"), user_id=247},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=247, cidr = cidr("192.168.15.120/29"), mac = mac("00:00:01:00:00:f7"), user_id=247},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=248, cidr = cidr("192.168.15.128/29"), mac = mac("00:00:01:00:00:f8"), user_id=248},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=248, cidr = cidr("192.168.15.136/29"), mac = mac("00:00:01:00:00:f8"), user_id=248},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=249, cidr = cidr("192.168.15.144/29"), mac = mac("00:00:01:00:00:f9"), user_id=249},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=249, cidr = cidr("192.168.15.152/29"), mac = mac("00:00:01:00:00:f9"), user_id=249},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=250, cidr = cidr("192.168.15.160/29"), mac = mac("00:00:01:00:00:fa"), user_id=250},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=250, cidr = cidr("192.168.15.168/29"), mac = mac("00:00:01:00:00:fa"), user_id=250},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=251, cidr = cidr("192.168.15.176/29"), mac = mac("00:00:01:00:00:fb"), user_id=251},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=251, cidr = cidr("192.168.15.184/29"), mac = mac("00:00:01:00:00:fb"), user_id=251},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=252, cidr = cidr("192.168.15.192/29"), mac = mac("00:00:01:00:00:fc"), user_id=252},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=252, cidr = cidr("192.168.15.200/29"), mac = mac("00:00:01:00:00:fc"), user_id=252},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=253, cidr = cidr("192.168.15.208/29"), mac = mac("00:00:01:00:00:fd"), user_id=253},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=253, cidr = cidr("192.168.15.216/29"), mac = mac("00:00:01:00:00:fd"), user_id=253},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=254, cidr = cidr("192.168.15.224/29"), mac = mac("00:00:01:00:00:fe"), user_id=254},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=254, cidr = cidr("192.168.15.232/29"), mac = mac("00:00:01:00:00:fe"), user_id=254},
+   {dest_id=0, gre_id=0, svlan_id=0, cvlan_id=255, cidr = cidr("192.168.15.240/29"), mac = mac("00:00:01:00:00:ff"), user_id=255},
+   {dest_id=0, gre_id=0, svlan_id=1, cvlan_id=255, cidr = cidr("192.168.15.248/29"), mac = mac("00:00:01:00:00:ff"), user_id=255},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=0, cidr = cidr("192.168.16.0/29"), mac = mac("00:00:01:00:00:00"), user_id=0},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=0, cidr = cidr("192.168.16.8/29"), mac = mac("00:00:01:00:00:00"), user_id=0},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=1, cidr = cidr("192.168.16.16/29"), mac = mac("00:00:01:00:00:01"), user_id=1},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=1, cidr = cidr("192.168.16.24/29"), mac = mac("00:00:01:00:00:01"), user_id=1},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=2, cidr = cidr("192.168.16.32/29"), mac = mac("00:00:01:00:00:02"), user_id=2},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=2, cidr = cidr("192.168.16.40/29"), mac = mac("00:00:01:00:00:02"), user_id=2},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=3, cidr = cidr("192.168.16.48/29"), mac = mac("00:00:01:00:00:03"), user_id=3},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=3, cidr = cidr("192.168.16.56/29"), mac = mac("00:00:01:00:00:03"), user_id=3},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=4, cidr = cidr("192.168.16.64/29"), mac = mac("00:00:01:00:00:04"), user_id=4},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=4, cidr = cidr("192.168.16.72/29"), mac = mac("00:00:01:00:00:04"), user_id=4},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=5, cidr = cidr("192.168.16.80/29"), mac = mac("00:00:01:00:00:05"), user_id=5},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=5, cidr = cidr("192.168.16.88/29"), mac = mac("00:00:01:00:00:05"), user_id=5},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=6, cidr = cidr("192.168.16.96/29"), mac = mac("00:00:01:00:00:06"), user_id=6},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=6, cidr = cidr("192.168.16.104/29"), mac = mac("00:00:01:00:00:06"), user_id=6},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=7, cidr = cidr("192.168.16.112/29"), mac = mac("00:00:01:00:00:07"), user_id=7},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=7, cidr = cidr("192.168.16.120/29"), mac = mac("00:00:01:00:00:07"), user_id=7},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=8, cidr = cidr("192.168.16.128/29"), mac = mac("00:00:01:00:00:08"), user_id=8},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=8, cidr = cidr("192.168.16.136/29"), mac = mac("00:00:01:00:00:08"), user_id=8},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=9, cidr = cidr("192.168.16.144/29"), mac = mac("00:00:01:00:00:09"), user_id=9},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=9, cidr = cidr("192.168.16.152/29"), mac = mac("00:00:01:00:00:09"), user_id=9},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=10, cidr = cidr("192.168.16.160/29"), mac = mac("00:00:01:00:00:0a"), user_id=10},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=10, cidr = cidr("192.168.16.168/29"), mac = mac("00:00:01:00:00:0a"), user_id=10},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=11, cidr = cidr("192.168.16.176/29"), mac = mac("00:00:01:00:00:0b"), user_id=11},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=11, cidr = cidr("192.168.16.184/29"), mac = mac("00:00:01:00:00:0b"), user_id=11},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=12, cidr = cidr("192.168.16.192/29"), mac = mac("00:00:01:00:00:0c"), user_id=12},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=12, cidr = cidr("192.168.16.200/29"), mac = mac("00:00:01:00:00:0c"), user_id=12},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=13, cidr = cidr("192.168.16.208/29"), mac = mac("00:00:01:00:00:0d"), user_id=13},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=13, cidr = cidr("192.168.16.216/29"), mac = mac("00:00:01:00:00:0d"), user_id=13},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=14, cidr = cidr("192.168.16.224/29"), mac = mac("00:00:01:00:00:0e"), user_id=14},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=14, cidr = cidr("192.168.16.232/29"), mac = mac("00:00:01:00:00:0e"), user_id=14},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=15, cidr = cidr("192.168.16.240/29"), mac = mac("00:00:01:00:00:0f"), user_id=15},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=15, cidr = cidr("192.168.16.248/29"), mac = mac("00:00:01:00:00:0f"), user_id=15},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=16, cidr = cidr("192.168.17.0/29"), mac = mac("00:00:01:00:00:10"), user_id=16},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=16, cidr = cidr("192.168.17.8/29"), mac = mac("00:00:01:00:00:10"), user_id=16},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=17, cidr = cidr("192.168.17.16/29"), mac = mac("00:00:01:00:00:11"), user_id=17},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=17, cidr = cidr("192.168.17.24/29"), mac = mac("00:00:01:00:00:11"), user_id=17},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=18, cidr = cidr("192.168.17.32/29"), mac = mac("00:00:01:00:00:12"), user_id=18},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=18, cidr = cidr("192.168.17.40/29"), mac = mac("00:00:01:00:00:12"), user_id=18},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=19, cidr = cidr("192.168.17.48/29"), mac = mac("00:00:01:00:00:13"), user_id=19},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=19, cidr = cidr("192.168.17.56/29"), mac = mac("00:00:01:00:00:13"), user_id=19},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=20, cidr = cidr("192.168.17.64/29"), mac = mac("00:00:01:00:00:14"), user_id=20},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=20, cidr = cidr("192.168.17.72/29"), mac = mac("00:00:01:00:00:14"), user_id=20},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=21, cidr = cidr("192.168.17.80/29"), mac = mac("00:00:01:00:00:15"), user_id=21},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=21, cidr = cidr("192.168.17.88/29"), mac = mac("00:00:01:00:00:15"), user_id=21},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=22, cidr = cidr("192.168.17.96/29"), mac = mac("00:00:01:00:00:16"), user_id=22},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=22, cidr = cidr("192.168.17.104/29"), mac = mac("00:00:01:00:00:16"), user_id=22},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=23, cidr = cidr("192.168.17.112/29"), mac = mac("00:00:01:00:00:17"), user_id=23},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=23, cidr = cidr("192.168.17.120/29"), mac = mac("00:00:01:00:00:17"), user_id=23},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=24, cidr = cidr("192.168.17.128/29"), mac = mac("00:00:01:00:00:18"), user_id=24},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=24, cidr = cidr("192.168.17.136/29"), mac = mac("00:00:01:00:00:18"), user_id=24},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=25, cidr = cidr("192.168.17.144/29"), mac = mac("00:00:01:00:00:19"), user_id=25},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=25, cidr = cidr("192.168.17.152/29"), mac = mac("00:00:01:00:00:19"), user_id=25},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=26, cidr = cidr("192.168.17.160/29"), mac = mac("00:00:01:00:00:1a"), user_id=26},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=26, cidr = cidr("192.168.17.168/29"), mac = mac("00:00:01:00:00:1a"), user_id=26},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=27, cidr = cidr("192.168.17.176/29"), mac = mac("00:00:01:00:00:1b"), user_id=27},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=27, cidr = cidr("192.168.17.184/29"), mac = mac("00:00:01:00:00:1b"), user_id=27},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=28, cidr = cidr("192.168.17.192/29"), mac = mac("00:00:01:00:00:1c"), user_id=28},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=28, cidr = cidr("192.168.17.200/29"), mac = mac("00:00:01:00:00:1c"), user_id=28},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=29, cidr = cidr("192.168.17.208/29"), mac = mac("00:00:01:00:00:1d"), user_id=29},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=29, cidr = cidr("192.168.17.216/29"), mac = mac("00:00:01:00:00:1d"), user_id=29},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=30, cidr = cidr("192.168.17.224/29"), mac = mac("00:00:01:00:00:1e"), user_id=30},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=30, cidr = cidr("192.168.17.232/29"), mac = mac("00:00:01:00:00:1e"), user_id=30},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=31, cidr = cidr("192.168.17.240/29"), mac = mac("00:00:01:00:00:1f"), user_id=31},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=31, cidr = cidr("192.168.17.248/29"), mac = mac("00:00:01:00:00:1f"), user_id=31},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=32, cidr = cidr("192.168.18.0/29"), mac = mac("00:00:01:00:00:20"), user_id=32},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=32, cidr = cidr("192.168.18.8/29"), mac = mac("00:00:01:00:00:20"), user_id=32},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=33, cidr = cidr("192.168.18.16/29"), mac = mac("00:00:01:00:00:21"), user_id=33},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=33, cidr = cidr("192.168.18.24/29"), mac = mac("00:00:01:00:00:21"), user_id=33},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=34, cidr = cidr("192.168.18.32/29"), mac = mac("00:00:01:00:00:22"), user_id=34},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=34, cidr = cidr("192.168.18.40/29"), mac = mac("00:00:01:00:00:22"), user_id=34},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=35, cidr = cidr("192.168.18.48/29"), mac = mac("00:00:01:00:00:23"), user_id=35},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=35, cidr = cidr("192.168.18.56/29"), mac = mac("00:00:01:00:00:23"), user_id=35},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=36, cidr = cidr("192.168.18.64/29"), mac = mac("00:00:01:00:00:24"), user_id=36},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=36, cidr = cidr("192.168.18.72/29"), mac = mac("00:00:01:00:00:24"), user_id=36},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=37, cidr = cidr("192.168.18.80/29"), mac = mac("00:00:01:00:00:25"), user_id=37},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=37, cidr = cidr("192.168.18.88/29"), mac = mac("00:00:01:00:00:25"), user_id=37},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=38, cidr = cidr("192.168.18.96/29"), mac = mac("00:00:01:00:00:26"), user_id=38},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=38, cidr = cidr("192.168.18.104/29"), mac = mac("00:00:01:00:00:26"), user_id=38},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=39, cidr = cidr("192.168.18.112/29"), mac = mac("00:00:01:00:00:27"), user_id=39},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=39, cidr = cidr("192.168.18.120/29"), mac = mac("00:00:01:00:00:27"), user_id=39},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=40, cidr = cidr("192.168.18.128/29"), mac = mac("00:00:01:00:00:28"), user_id=40},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=40, cidr = cidr("192.168.18.136/29"), mac = mac("00:00:01:00:00:28"), user_id=40},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=41, cidr = cidr("192.168.18.144/29"), mac = mac("00:00:01:00:00:29"), user_id=41},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=41, cidr = cidr("192.168.18.152/29"), mac = mac("00:00:01:00:00:29"), user_id=41},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=42, cidr = cidr("192.168.18.160/29"), mac = mac("00:00:01:00:00:2a"), user_id=42},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=42, cidr = cidr("192.168.18.168/29"), mac = mac("00:00:01:00:00:2a"), user_id=42},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=43, cidr = cidr("192.168.18.176/29"), mac = mac("00:00:01:00:00:2b"), user_id=43},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=43, cidr = cidr("192.168.18.184/29"), mac = mac("00:00:01:00:00:2b"), user_id=43},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=44, cidr = cidr("192.168.18.192/29"), mac = mac("00:00:01:00:00:2c"), user_id=44},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=44, cidr = cidr("192.168.18.200/29"), mac = mac("00:00:01:00:00:2c"), user_id=44},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=45, cidr = cidr("192.168.18.208/29"), mac = mac("00:00:01:00:00:2d"), user_id=45},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=45, cidr = cidr("192.168.18.216/29"), mac = mac("00:00:01:00:00:2d"), user_id=45},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=46, cidr = cidr("192.168.18.224/29"), mac = mac("00:00:01:00:00:2e"), user_id=46},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=46, cidr = cidr("192.168.18.232/29"), mac = mac("00:00:01:00:00:2e"), user_id=46},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=47, cidr = cidr("192.168.18.240/29"), mac = mac("00:00:01:00:00:2f"), user_id=47},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=47, cidr = cidr("192.168.18.248/29"), mac = mac("00:00:01:00:00:2f"), user_id=47},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=48, cidr = cidr("192.168.19.0/29"), mac = mac("00:00:01:00:00:30"), user_id=48},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=48, cidr = cidr("192.168.19.8/29"), mac = mac("00:00:01:00:00:30"), user_id=48},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=49, cidr = cidr("192.168.19.16/29"), mac = mac("00:00:01:00:00:31"), user_id=49},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=49, cidr = cidr("192.168.19.24/29"), mac = mac("00:00:01:00:00:31"), user_id=49},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=50, cidr = cidr("192.168.19.32/29"), mac = mac("00:00:01:00:00:32"), user_id=50},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=50, cidr = cidr("192.168.19.40/29"), mac = mac("00:00:01:00:00:32"), user_id=50},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=51, cidr = cidr("192.168.19.48/29"), mac = mac("00:00:01:00:00:33"), user_id=51},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=51, cidr = cidr("192.168.19.56/29"), mac = mac("00:00:01:00:00:33"), user_id=51},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=52, cidr = cidr("192.168.19.64/29"), mac = mac("00:00:01:00:00:34"), user_id=52},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=52, cidr = cidr("192.168.19.72/29"), mac = mac("00:00:01:00:00:34"), user_id=52},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=53, cidr = cidr("192.168.19.80/29"), mac = mac("00:00:01:00:00:35"), user_id=53},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=53, cidr = cidr("192.168.19.88/29"), mac = mac("00:00:01:00:00:35"), user_id=53},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=54, cidr = cidr("192.168.19.96/29"), mac = mac("00:00:01:00:00:36"), user_id=54},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=54, cidr = cidr("192.168.19.104/29"), mac = mac("00:00:01:00:00:36"), user_id=54},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=55, cidr = cidr("192.168.19.112/29"), mac = mac("00:00:01:00:00:37"), user_id=55},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=55, cidr = cidr("192.168.19.120/29"), mac = mac("00:00:01:00:00:37"), user_id=55},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=56, cidr = cidr("192.168.19.128/29"), mac = mac("00:00:01:00:00:38"), user_id=56},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=56, cidr = cidr("192.168.19.136/29"), mac = mac("00:00:01:00:00:38"), user_id=56},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=57, cidr = cidr("192.168.19.144/29"), mac = mac("00:00:01:00:00:39"), user_id=57},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=57, cidr = cidr("192.168.19.152/29"), mac = mac("00:00:01:00:00:39"), user_id=57},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=58, cidr = cidr("192.168.19.160/29"), mac = mac("00:00:01:00:00:3a"), user_id=58},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=58, cidr = cidr("192.168.19.168/29"), mac = mac("00:00:01:00:00:3a"), user_id=58},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=59, cidr = cidr("192.168.19.176/29"), mac = mac("00:00:01:00:00:3b"), user_id=59},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=59, cidr = cidr("192.168.19.184/29"), mac = mac("00:00:01:00:00:3b"), user_id=59},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=60, cidr = cidr("192.168.19.192/29"), mac = mac("00:00:01:00:00:3c"), user_id=60},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=60, cidr = cidr("192.168.19.200/29"), mac = mac("00:00:01:00:00:3c"), user_id=60},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=61, cidr = cidr("192.168.19.208/29"), mac = mac("00:00:01:00:00:3d"), user_id=61},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=61, cidr = cidr("192.168.19.216/29"), mac = mac("00:00:01:00:00:3d"), user_id=61},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=62, cidr = cidr("192.168.19.224/29"), mac = mac("00:00:01:00:00:3e"), user_id=62},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=62, cidr = cidr("192.168.19.232/29"), mac = mac("00:00:01:00:00:3e"), user_id=62},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=63, cidr = cidr("192.168.19.240/29"), mac = mac("00:00:01:00:00:3f"), user_id=63},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=63, cidr = cidr("192.168.19.248/29"), mac = mac("00:00:01:00:00:3f"), user_id=63},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=64, cidr = cidr("192.168.20.0/29"), mac = mac("00:00:01:00:00:40"), user_id=64},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=64, cidr = cidr("192.168.20.8/29"), mac = mac("00:00:01:00:00:40"), user_id=64},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=65, cidr = cidr("192.168.20.16/29"), mac = mac("00:00:01:00:00:41"), user_id=65},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=65, cidr = cidr("192.168.20.24/29"), mac = mac("00:00:01:00:00:41"), user_id=65},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=66, cidr = cidr("192.168.20.32/29"), mac = mac("00:00:01:00:00:42"), user_id=66},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=66, cidr = cidr("192.168.20.40/29"), mac = mac("00:00:01:00:00:42"), user_id=66},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=67, cidr = cidr("192.168.20.48/29"), mac = mac("00:00:01:00:00:43"), user_id=67},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=67, cidr = cidr("192.168.20.56/29"), mac = mac("00:00:01:00:00:43"), user_id=67},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=68, cidr = cidr("192.168.20.64/29"), mac = mac("00:00:01:00:00:44"), user_id=68},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=68, cidr = cidr("192.168.20.72/29"), mac = mac("00:00:01:00:00:44"), user_id=68},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=69, cidr = cidr("192.168.20.80/29"), mac = mac("00:00:01:00:00:45"), user_id=69},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=69, cidr = cidr("192.168.20.88/29"), mac = mac("00:00:01:00:00:45"), user_id=69},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=70, cidr = cidr("192.168.20.96/29"), mac = mac("00:00:01:00:00:46"), user_id=70},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=70, cidr = cidr("192.168.20.104/29"), mac = mac("00:00:01:00:00:46"), user_id=70},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=71, cidr = cidr("192.168.20.112/29"), mac = mac("00:00:01:00:00:47"), user_id=71},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=71, cidr = cidr("192.168.20.120/29"), mac = mac("00:00:01:00:00:47"), user_id=71},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=72, cidr = cidr("192.168.20.128/29"), mac = mac("00:00:01:00:00:48"), user_id=72},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=72, cidr = cidr("192.168.20.136/29"), mac = mac("00:00:01:00:00:48"), user_id=72},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=73, cidr = cidr("192.168.20.144/29"), mac = mac("00:00:01:00:00:49"), user_id=73},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=73, cidr = cidr("192.168.20.152/29"), mac = mac("00:00:01:00:00:49"), user_id=73},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=74, cidr = cidr("192.168.20.160/29"), mac = mac("00:00:01:00:00:4a"), user_id=74},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=74, cidr = cidr("192.168.20.168/29"), mac = mac("00:00:01:00:00:4a"), user_id=74},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=75, cidr = cidr("192.168.20.176/29"), mac = mac("00:00:01:00:00:4b"), user_id=75},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=75, cidr = cidr("192.168.20.184/29"), mac = mac("00:00:01:00:00:4b"), user_id=75},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=76, cidr = cidr("192.168.20.192/29"), mac = mac("00:00:01:00:00:4c"), user_id=76},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=76, cidr = cidr("192.168.20.200/29"), mac = mac("00:00:01:00:00:4c"), user_id=76},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=77, cidr = cidr("192.168.20.208/29"), mac = mac("00:00:01:00:00:4d"), user_id=77},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=77, cidr = cidr("192.168.20.216/29"), mac = mac("00:00:01:00:00:4d"), user_id=77},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=78, cidr = cidr("192.168.20.224/29"), mac = mac("00:00:01:00:00:4e"), user_id=78},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=78, cidr = cidr("192.168.20.232/29"), mac = mac("00:00:01:00:00:4e"), user_id=78},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=79, cidr = cidr("192.168.20.240/29"), mac = mac("00:00:01:00:00:4f"), user_id=79},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=79, cidr = cidr("192.168.20.248/29"), mac = mac("00:00:01:00:00:4f"), user_id=79},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=80, cidr = cidr("192.168.21.0/29"), mac = mac("00:00:01:00:00:50"), user_id=80},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=80, cidr = cidr("192.168.21.8/29"), mac = mac("00:00:01:00:00:50"), user_id=80},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=81, cidr = cidr("192.168.21.16/29"), mac = mac("00:00:01:00:00:51"), user_id=81},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=81, cidr = cidr("192.168.21.24/29"), mac = mac("00:00:01:00:00:51"), user_id=81},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=82, cidr = cidr("192.168.21.32/29"), mac = mac("00:00:01:00:00:52"), user_id=82},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=82, cidr = cidr("192.168.21.40/29"), mac = mac("00:00:01:00:00:52"), user_id=82},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=83, cidr = cidr("192.168.21.48/29"), mac = mac("00:00:01:00:00:53"), user_id=83},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=83, cidr = cidr("192.168.21.56/29"), mac = mac("00:00:01:00:00:53"), user_id=83},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=84, cidr = cidr("192.168.21.64/29"), mac = mac("00:00:01:00:00:54"), user_id=84},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=84, cidr = cidr("192.168.21.72/29"), mac = mac("00:00:01:00:00:54"), user_id=84},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=85, cidr = cidr("192.168.21.80/29"), mac = mac("00:00:01:00:00:55"), user_id=85},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=85, cidr = cidr("192.168.21.88/29"), mac = mac("00:00:01:00:00:55"), user_id=85},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=86, cidr = cidr("192.168.21.96/29"), mac = mac("00:00:01:00:00:56"), user_id=86},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=86, cidr = cidr("192.168.21.104/29"), mac = mac("00:00:01:00:00:56"), user_id=86},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=87, cidr = cidr("192.168.21.112/29"), mac = mac("00:00:01:00:00:57"), user_id=87},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=87, cidr = cidr("192.168.21.120/29"), mac = mac("00:00:01:00:00:57"), user_id=87},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=88, cidr = cidr("192.168.21.128/29"), mac = mac("00:00:01:00:00:58"), user_id=88},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=88, cidr = cidr("192.168.21.136/29"), mac = mac("00:00:01:00:00:58"), user_id=88},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=89, cidr = cidr("192.168.21.144/29"), mac = mac("00:00:01:00:00:59"), user_id=89},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=89, cidr = cidr("192.168.21.152/29"), mac = mac("00:00:01:00:00:59"), user_id=89},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=90, cidr = cidr("192.168.21.160/29"), mac = mac("00:00:01:00:00:5a"), user_id=90},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=90, cidr = cidr("192.168.21.168/29"), mac = mac("00:00:01:00:00:5a"), user_id=90},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=91, cidr = cidr("192.168.21.176/29"), mac = mac("00:00:01:00:00:5b"), user_id=91},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=91, cidr = cidr("192.168.21.184/29"), mac = mac("00:00:01:00:00:5b"), user_id=91},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=92, cidr = cidr("192.168.21.192/29"), mac = mac("00:00:01:00:00:5c"), user_id=92},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=92, cidr = cidr("192.168.21.200/29"), mac = mac("00:00:01:00:00:5c"), user_id=92},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=93, cidr = cidr("192.168.21.208/29"), mac = mac("00:00:01:00:00:5d"), user_id=93},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=93, cidr = cidr("192.168.21.216/29"), mac = mac("00:00:01:00:00:5d"), user_id=93},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=94, cidr = cidr("192.168.21.224/29"), mac = mac("00:00:01:00:00:5e"), user_id=94},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=94, cidr = cidr("192.168.21.232/29"), mac = mac("00:00:01:00:00:5e"), user_id=94},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=95, cidr = cidr("192.168.21.240/29"), mac = mac("00:00:01:00:00:5f"), user_id=95},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=95, cidr = cidr("192.168.21.248/29"), mac = mac("00:00:01:00:00:5f"), user_id=95},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=96, cidr = cidr("192.168.22.0/29"), mac = mac("00:00:01:00:00:60"), user_id=96},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=96, cidr = cidr("192.168.22.8/29"), mac = mac("00:00:01:00:00:60"), user_id=96},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=97, cidr = cidr("192.168.22.16/29"), mac = mac("00:00:01:00:00:61"), user_id=97},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=97, cidr = cidr("192.168.22.24/29"), mac = mac("00:00:01:00:00:61"), user_id=97},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=98, cidr = cidr("192.168.22.32/29"), mac = mac("00:00:01:00:00:62"), user_id=98},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=98, cidr = cidr("192.168.22.40/29"), mac = mac("00:00:01:00:00:62"), user_id=98},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=99, cidr = cidr("192.168.22.48/29"), mac = mac("00:00:01:00:00:63"), user_id=99},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=99, cidr = cidr("192.168.22.56/29"), mac = mac("00:00:01:00:00:63"), user_id=99},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=100, cidr = cidr("192.168.22.64/29"), mac = mac("00:00:01:00:00:64"), user_id=100},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=100, cidr = cidr("192.168.22.72/29"), mac = mac("00:00:01:00:00:64"), user_id=100},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=101, cidr = cidr("192.168.22.80/29"), mac = mac("00:00:01:00:00:65"), user_id=101},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=101, cidr = cidr("192.168.22.88/29"), mac = mac("00:00:01:00:00:65"), user_id=101},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=102, cidr = cidr("192.168.22.96/29"), mac = mac("00:00:01:00:00:66"), user_id=102},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=102, cidr = cidr("192.168.22.104/29"), mac = mac("00:00:01:00:00:66"), user_id=102},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=103, cidr = cidr("192.168.22.112/29"), mac = mac("00:00:01:00:00:67"), user_id=103},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=103, cidr = cidr("192.168.22.120/29"), mac = mac("00:00:01:00:00:67"), user_id=103},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=104, cidr = cidr("192.168.22.128/29"), mac = mac("00:00:01:00:00:68"), user_id=104},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=104, cidr = cidr("192.168.22.136/29"), mac = mac("00:00:01:00:00:68"), user_id=104},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=105, cidr = cidr("192.168.22.144/29"), mac = mac("00:00:01:00:00:69"), user_id=105},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=105, cidr = cidr("192.168.22.152/29"), mac = mac("00:00:01:00:00:69"), user_id=105},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=106, cidr = cidr("192.168.22.160/29"), mac = mac("00:00:01:00:00:6a"), user_id=106},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=106, cidr = cidr("192.168.22.168/29"), mac = mac("00:00:01:00:00:6a"), user_id=106},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=107, cidr = cidr("192.168.22.176/29"), mac = mac("00:00:01:00:00:6b"), user_id=107},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=107, cidr = cidr("192.168.22.184/29"), mac = mac("00:00:01:00:00:6b"), user_id=107},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=108, cidr = cidr("192.168.22.192/29"), mac = mac("00:00:01:00:00:6c"), user_id=108},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=108, cidr = cidr("192.168.22.200/29"), mac = mac("00:00:01:00:00:6c"), user_id=108},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=109, cidr = cidr("192.168.22.208/29"), mac = mac("00:00:01:00:00:6d"), user_id=109},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=109, cidr = cidr("192.168.22.216/29"), mac = mac("00:00:01:00:00:6d"), user_id=109},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=110, cidr = cidr("192.168.22.224/29"), mac = mac("00:00:01:00:00:6e"), user_id=110},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=110, cidr = cidr("192.168.22.232/29"), mac = mac("00:00:01:00:00:6e"), user_id=110},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=111, cidr = cidr("192.168.22.240/29"), mac = mac("00:00:01:00:00:6f"), user_id=111},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=111, cidr = cidr("192.168.22.248/29"), mac = mac("00:00:01:00:00:6f"), user_id=111},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=112, cidr = cidr("192.168.23.0/29"), mac = mac("00:00:01:00:00:70"), user_id=112},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=112, cidr = cidr("192.168.23.8/29"), mac = mac("00:00:01:00:00:70"), user_id=112},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=113, cidr = cidr("192.168.23.16/29"), mac = mac("00:00:01:00:00:71"), user_id=113},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=113, cidr = cidr("192.168.23.24/29"), mac = mac("00:00:01:00:00:71"), user_id=113},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=114, cidr = cidr("192.168.23.32/29"), mac = mac("00:00:01:00:00:72"), user_id=114},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=114, cidr = cidr("192.168.23.40/29"), mac = mac("00:00:01:00:00:72"), user_id=114},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=115, cidr = cidr("192.168.23.48/29"), mac = mac("00:00:01:00:00:73"), user_id=115},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=115, cidr = cidr("192.168.23.56/29"), mac = mac("00:00:01:00:00:73"), user_id=115},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=116, cidr = cidr("192.168.23.64/29"), mac = mac("00:00:01:00:00:74"), user_id=116},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=116, cidr = cidr("192.168.23.72/29"), mac = mac("00:00:01:00:00:74"), user_id=116},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=117, cidr = cidr("192.168.23.80/29"), mac = mac("00:00:01:00:00:75"), user_id=117},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=117, cidr = cidr("192.168.23.88/29"), mac = mac("00:00:01:00:00:75"), user_id=117},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=118, cidr = cidr("192.168.23.96/29"), mac = mac("00:00:01:00:00:76"), user_id=118},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=118, cidr = cidr("192.168.23.104/29"), mac = mac("00:00:01:00:00:76"), user_id=118},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=119, cidr = cidr("192.168.23.112/29"), mac = mac("00:00:01:00:00:77"), user_id=119},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=119, cidr = cidr("192.168.23.120/29"), mac = mac("00:00:01:00:00:77"), user_id=119},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=120, cidr = cidr("192.168.23.128/29"), mac = mac("00:00:01:00:00:78"), user_id=120},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=120, cidr = cidr("192.168.23.136/29"), mac = mac("00:00:01:00:00:78"), user_id=120},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=121, cidr = cidr("192.168.23.144/29"), mac = mac("00:00:01:00:00:79"), user_id=121},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=121, cidr = cidr("192.168.23.152/29"), mac = mac("00:00:01:00:00:79"), user_id=121},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=122, cidr = cidr("192.168.23.160/29"), mac = mac("00:00:01:00:00:7a"), user_id=122},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=122, cidr = cidr("192.168.23.168/29"), mac = mac("00:00:01:00:00:7a"), user_id=122},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=123, cidr = cidr("192.168.23.176/29"), mac = mac("00:00:01:00:00:7b"), user_id=123},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=123, cidr = cidr("192.168.23.184/29"), mac = mac("00:00:01:00:00:7b"), user_id=123},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=124, cidr = cidr("192.168.23.192/29"), mac = mac("00:00:01:00:00:7c"), user_id=124},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=124, cidr = cidr("192.168.23.200/29"), mac = mac("00:00:01:00:00:7c"), user_id=124},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=125, cidr = cidr("192.168.23.208/29"), mac = mac("00:00:01:00:00:7d"), user_id=125},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=125, cidr = cidr("192.168.23.216/29"), mac = mac("00:00:01:00:00:7d"), user_id=125},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=126, cidr = cidr("192.168.23.224/29"), mac = mac("00:00:01:00:00:7e"), user_id=126},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=126, cidr = cidr("192.168.23.232/29"), mac = mac("00:00:01:00:00:7e"), user_id=126},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=127, cidr = cidr("192.168.23.240/29"), mac = mac("00:00:01:00:00:7f"), user_id=127},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=127, cidr = cidr("192.168.23.248/29"), mac = mac("00:00:01:00:00:7f"), user_id=127},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=128, cidr = cidr("192.168.24.0/29"), mac = mac("00:00:01:00:00:80"), user_id=128},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=128, cidr = cidr("192.168.24.8/29"), mac = mac("00:00:01:00:00:80"), user_id=128},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=129, cidr = cidr("192.168.24.16/29"), mac = mac("00:00:01:00:00:81"), user_id=129},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=129, cidr = cidr("192.168.24.24/29"), mac = mac("00:00:01:00:00:81"), user_id=129},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=130, cidr = cidr("192.168.24.32/29"), mac = mac("00:00:01:00:00:82"), user_id=130},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=130, cidr = cidr("192.168.24.40/29"), mac = mac("00:00:01:00:00:82"), user_id=130},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=131, cidr = cidr("192.168.24.48/29"), mac = mac("00:00:01:00:00:83"), user_id=131},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=131, cidr = cidr("192.168.24.56/29"), mac = mac("00:00:01:00:00:83"), user_id=131},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=132, cidr = cidr("192.168.24.64/29"), mac = mac("00:00:01:00:00:84"), user_id=132},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=132, cidr = cidr("192.168.24.72/29"), mac = mac("00:00:01:00:00:84"), user_id=132},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=133, cidr = cidr("192.168.24.80/29"), mac = mac("00:00:01:00:00:85"), user_id=133},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=133, cidr = cidr("192.168.24.88/29"), mac = mac("00:00:01:00:00:85"), user_id=133},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=134, cidr = cidr("192.168.24.96/29"), mac = mac("00:00:01:00:00:86"), user_id=134},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=134, cidr = cidr("192.168.24.104/29"), mac = mac("00:00:01:00:00:86"), user_id=134},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=135, cidr = cidr("192.168.24.112/29"), mac = mac("00:00:01:00:00:87"), user_id=135},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=135, cidr = cidr("192.168.24.120/29"), mac = mac("00:00:01:00:00:87"), user_id=135},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=136, cidr = cidr("192.168.24.128/29"), mac = mac("00:00:01:00:00:88"), user_id=136},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=136, cidr = cidr("192.168.24.136/29"), mac = mac("00:00:01:00:00:88"), user_id=136},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=137, cidr = cidr("192.168.24.144/29"), mac = mac("00:00:01:00:00:89"), user_id=137},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=137, cidr = cidr("192.168.24.152/29"), mac = mac("00:00:01:00:00:89"), user_id=137},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=138, cidr = cidr("192.168.24.160/29"), mac = mac("00:00:01:00:00:8a"), user_id=138},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=138, cidr = cidr("192.168.24.168/29"), mac = mac("00:00:01:00:00:8a"), user_id=138},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=139, cidr = cidr("192.168.24.176/29"), mac = mac("00:00:01:00:00:8b"), user_id=139},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=139, cidr = cidr("192.168.24.184/29"), mac = mac("00:00:01:00:00:8b"), user_id=139},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=140, cidr = cidr("192.168.24.192/29"), mac = mac("00:00:01:00:00:8c"), user_id=140},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=140, cidr = cidr("192.168.24.200/29"), mac = mac("00:00:01:00:00:8c"), user_id=140},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=141, cidr = cidr("192.168.24.208/29"), mac = mac("00:00:01:00:00:8d"), user_id=141},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=141, cidr = cidr("192.168.24.216/29"), mac = mac("00:00:01:00:00:8d"), user_id=141},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=142, cidr = cidr("192.168.24.224/29"), mac = mac("00:00:01:00:00:8e"), user_id=142},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=142, cidr = cidr("192.168.24.232/29"), mac = mac("00:00:01:00:00:8e"), user_id=142},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=143, cidr = cidr("192.168.24.240/29"), mac = mac("00:00:01:00:00:8f"), user_id=143},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=143, cidr = cidr("192.168.24.248/29"), mac = mac("00:00:01:00:00:8f"), user_id=143},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=144, cidr = cidr("192.168.25.0/29"), mac = mac("00:00:01:00:00:90"), user_id=144},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=144, cidr = cidr("192.168.25.8/29"), mac = mac("00:00:01:00:00:90"), user_id=144},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=145, cidr = cidr("192.168.25.16/29"), mac = mac("00:00:01:00:00:91"), user_id=145},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=145, cidr = cidr("192.168.25.24/29"), mac = mac("00:00:01:00:00:91"), user_id=145},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=146, cidr = cidr("192.168.25.32/29"), mac = mac("00:00:01:00:00:92"), user_id=146},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=146, cidr = cidr("192.168.25.40/29"), mac = mac("00:00:01:00:00:92"), user_id=146},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=147, cidr = cidr("192.168.25.48/29"), mac = mac("00:00:01:00:00:93"), user_id=147},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=147, cidr = cidr("192.168.25.56/29"), mac = mac("00:00:01:00:00:93"), user_id=147},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=148, cidr = cidr("192.168.25.64/29"), mac = mac("00:00:01:00:00:94"), user_id=148},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=148, cidr = cidr("192.168.25.72/29"), mac = mac("00:00:01:00:00:94"), user_id=148},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=149, cidr = cidr("192.168.25.80/29"), mac = mac("00:00:01:00:00:95"), user_id=149},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=149, cidr = cidr("192.168.25.88/29"), mac = mac("00:00:01:00:00:95"), user_id=149},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=150, cidr = cidr("192.168.25.96/29"), mac = mac("00:00:01:00:00:96"), user_id=150},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=150, cidr = cidr("192.168.25.104/29"), mac = mac("00:00:01:00:00:96"), user_id=150},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=151, cidr = cidr("192.168.25.112/29"), mac = mac("00:00:01:00:00:97"), user_id=151},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=151, cidr = cidr("192.168.25.120/29"), mac = mac("00:00:01:00:00:97"), user_id=151},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=152, cidr = cidr("192.168.25.128/29"), mac = mac("00:00:01:00:00:98"), user_id=152},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=152, cidr = cidr("192.168.25.136/29"), mac = mac("00:00:01:00:00:98"), user_id=152},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=153, cidr = cidr("192.168.25.144/29"), mac = mac("00:00:01:00:00:99"), user_id=153},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=153, cidr = cidr("192.168.25.152/29"), mac = mac("00:00:01:00:00:99"), user_id=153},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=154, cidr = cidr("192.168.25.160/29"), mac = mac("00:00:01:00:00:9a"), user_id=154},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=154, cidr = cidr("192.168.25.168/29"), mac = mac("00:00:01:00:00:9a"), user_id=154},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=155, cidr = cidr("192.168.25.176/29"), mac = mac("00:00:01:00:00:9b"), user_id=155},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=155, cidr = cidr("192.168.25.184/29"), mac = mac("00:00:01:00:00:9b"), user_id=155},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=156, cidr = cidr("192.168.25.192/29"), mac = mac("00:00:01:00:00:9c"), user_id=156},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=156, cidr = cidr("192.168.25.200/29"), mac = mac("00:00:01:00:00:9c"), user_id=156},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=157, cidr = cidr("192.168.25.208/29"), mac = mac("00:00:01:00:00:9d"), user_id=157},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=157, cidr = cidr("192.168.25.216/29"), mac = mac("00:00:01:00:00:9d"), user_id=157},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=158, cidr = cidr("192.168.25.224/29"), mac = mac("00:00:01:00:00:9e"), user_id=158},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=158, cidr = cidr("192.168.25.232/29"), mac = mac("00:00:01:00:00:9e"), user_id=158},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=159, cidr = cidr("192.168.25.240/29"), mac = mac("00:00:01:00:00:9f"), user_id=159},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=159, cidr = cidr("192.168.25.248/29"), mac = mac("00:00:01:00:00:9f"), user_id=159},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=160, cidr = cidr("192.168.26.0/29"), mac = mac("00:00:01:00:00:a0"), user_id=160},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=160, cidr = cidr("192.168.26.8/29"), mac = mac("00:00:01:00:00:a0"), user_id=160},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=161, cidr = cidr("192.168.26.16/29"), mac = mac("00:00:01:00:00:a1"), user_id=161},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=161, cidr = cidr("192.168.26.24/29"), mac = mac("00:00:01:00:00:a1"), user_id=161},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=162, cidr = cidr("192.168.26.32/29"), mac = mac("00:00:01:00:00:a2"), user_id=162},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=162, cidr = cidr("192.168.26.40/29"), mac = mac("00:00:01:00:00:a2"), user_id=162},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=163, cidr = cidr("192.168.26.48/29"), mac = mac("00:00:01:00:00:a3"), user_id=163},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=163, cidr = cidr("192.168.26.56/29"), mac = mac("00:00:01:00:00:a3"), user_id=163},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=164, cidr = cidr("192.168.26.64/29"), mac = mac("00:00:01:00:00:a4"), user_id=164},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=164, cidr = cidr("192.168.26.72/29"), mac = mac("00:00:01:00:00:a4"), user_id=164},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=165, cidr = cidr("192.168.26.80/29"), mac = mac("00:00:01:00:00:a5"), user_id=165},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=165, cidr = cidr("192.168.26.88/29"), mac = mac("00:00:01:00:00:a5"), user_id=165},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=166, cidr = cidr("192.168.26.96/29"), mac = mac("00:00:01:00:00:a6"), user_id=166},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=166, cidr = cidr("192.168.26.104/29"), mac = mac("00:00:01:00:00:a6"), user_id=166},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=167, cidr = cidr("192.168.26.112/29"), mac = mac("00:00:01:00:00:a7"), user_id=167},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=167, cidr = cidr("192.168.26.120/29"), mac = mac("00:00:01:00:00:a7"), user_id=167},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=168, cidr = cidr("192.168.26.128/29"), mac = mac("00:00:01:00:00:a8"), user_id=168},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=168, cidr = cidr("192.168.26.136/29"), mac = mac("00:00:01:00:00:a8"), user_id=168},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=169, cidr = cidr("192.168.26.144/29"), mac = mac("00:00:01:00:00:a9"), user_id=169},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=169, cidr = cidr("192.168.26.152/29"), mac = mac("00:00:01:00:00:a9"), user_id=169},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=170, cidr = cidr("192.168.26.160/29"), mac = mac("00:00:01:00:00:aa"), user_id=170},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=170, cidr = cidr("192.168.26.168/29"), mac = mac("00:00:01:00:00:aa"), user_id=170},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=171, cidr = cidr("192.168.26.176/29"), mac = mac("00:00:01:00:00:ab"), user_id=171},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=171, cidr = cidr("192.168.26.184/29"), mac = mac("00:00:01:00:00:ab"), user_id=171},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=172, cidr = cidr("192.168.26.192/29"), mac = mac("00:00:01:00:00:ac"), user_id=172},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=172, cidr = cidr("192.168.26.200/29"), mac = mac("00:00:01:00:00:ac"), user_id=172},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=173, cidr = cidr("192.168.26.208/29"), mac = mac("00:00:01:00:00:ad"), user_id=173},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=173, cidr = cidr("192.168.26.216/29"), mac = mac("00:00:01:00:00:ad"), user_id=173},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=174, cidr = cidr("192.168.26.224/29"), mac = mac("00:00:01:00:00:ae"), user_id=174},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=174, cidr = cidr("192.168.26.232/29"), mac = mac("00:00:01:00:00:ae"), user_id=174},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=175, cidr = cidr("192.168.26.240/29"), mac = mac("00:00:01:00:00:af"), user_id=175},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=175, cidr = cidr("192.168.26.248/29"), mac = mac("00:00:01:00:00:af"), user_id=175},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=176, cidr = cidr("192.168.27.0/29"), mac = mac("00:00:01:00:00:b0"), user_id=176},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=176, cidr = cidr("192.168.27.8/29"), mac = mac("00:00:01:00:00:b0"), user_id=176},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=177, cidr = cidr("192.168.27.16/29"), mac = mac("00:00:01:00:00:b1"), user_id=177},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=177, cidr = cidr("192.168.27.24/29"), mac = mac("00:00:01:00:00:b1"), user_id=177},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=178, cidr = cidr("192.168.27.32/29"), mac = mac("00:00:01:00:00:b2"), user_id=178},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=178, cidr = cidr("192.168.27.40/29"), mac = mac("00:00:01:00:00:b2"), user_id=178},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=179, cidr = cidr("192.168.27.48/29"), mac = mac("00:00:01:00:00:b3"), user_id=179},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=179, cidr = cidr("192.168.27.56/29"), mac = mac("00:00:01:00:00:b3"), user_id=179},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=180, cidr = cidr("192.168.27.64/29"), mac = mac("00:00:01:00:00:b4"), user_id=180},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=180, cidr = cidr("192.168.27.72/29"), mac = mac("00:00:01:00:00:b4"), user_id=180},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=181, cidr = cidr("192.168.27.80/29"), mac = mac("00:00:01:00:00:b5"), user_id=181},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=181, cidr = cidr("192.168.27.88/29"), mac = mac("00:00:01:00:00:b5"), user_id=181},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=182, cidr = cidr("192.168.27.96/29"), mac = mac("00:00:01:00:00:b6"), user_id=182},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=182, cidr = cidr("192.168.27.104/29"), mac = mac("00:00:01:00:00:b6"), user_id=182},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=183, cidr = cidr("192.168.27.112/29"), mac = mac("00:00:01:00:00:b7"), user_id=183},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=183, cidr = cidr("192.168.27.120/29"), mac = mac("00:00:01:00:00:b7"), user_id=183},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=184, cidr = cidr("192.168.27.128/29"), mac = mac("00:00:01:00:00:b8"), user_id=184},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=184, cidr = cidr("192.168.27.136/29"), mac = mac("00:00:01:00:00:b8"), user_id=184},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=185, cidr = cidr("192.168.27.144/29"), mac = mac("00:00:01:00:00:b9"), user_id=185},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=185, cidr = cidr("192.168.27.152/29"), mac = mac("00:00:01:00:00:b9"), user_id=185},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=186, cidr = cidr("192.168.27.160/29"), mac = mac("00:00:01:00:00:ba"), user_id=186},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=186, cidr = cidr("192.168.27.168/29"), mac = mac("00:00:01:00:00:ba"), user_id=186},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=187, cidr = cidr("192.168.27.176/29"), mac = mac("00:00:01:00:00:bb"), user_id=187},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=187, cidr = cidr("192.168.27.184/29"), mac = mac("00:00:01:00:00:bb"), user_id=187},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=188, cidr = cidr("192.168.27.192/29"), mac = mac("00:00:01:00:00:bc"), user_id=188},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=188, cidr = cidr("192.168.27.200/29"), mac = mac("00:00:01:00:00:bc"), user_id=188},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=189, cidr = cidr("192.168.27.208/29"), mac = mac("00:00:01:00:00:bd"), user_id=189},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=189, cidr = cidr("192.168.27.216/29"), mac = mac("00:00:01:00:00:bd"), user_id=189},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=190, cidr = cidr("192.168.27.224/29"), mac = mac("00:00:01:00:00:be"), user_id=190},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=190, cidr = cidr("192.168.27.232/29"), mac = mac("00:00:01:00:00:be"), user_id=190},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=191, cidr = cidr("192.168.27.240/29"), mac = mac("00:00:01:00:00:bf"), user_id=191},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=191, cidr = cidr("192.168.27.248/29"), mac = mac("00:00:01:00:00:bf"), user_id=191},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=192, cidr = cidr("192.168.28.0/29"), mac = mac("00:00:01:00:00:c0"), user_id=192},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=192, cidr = cidr("192.168.28.8/29"), mac = mac("00:00:01:00:00:c0"), user_id=192},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=193, cidr = cidr("192.168.28.16/29"), mac = mac("00:00:01:00:00:c1"), user_id=193},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=193, cidr = cidr("192.168.28.24/29"), mac = mac("00:00:01:00:00:c1"), user_id=193},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=194, cidr = cidr("192.168.28.32/29"), mac = mac("00:00:01:00:00:c2"), user_id=194},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=194, cidr = cidr("192.168.28.40/29"), mac = mac("00:00:01:00:00:c2"), user_id=194},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=195, cidr = cidr("192.168.28.48/29"), mac = mac("00:00:01:00:00:c3"), user_id=195},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=195, cidr = cidr("192.168.28.56/29"), mac = mac("00:00:01:00:00:c3"), user_id=195},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=196, cidr = cidr("192.168.28.64/29"), mac = mac("00:00:01:00:00:c4"), user_id=196},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=196, cidr = cidr("192.168.28.72/29"), mac = mac("00:00:01:00:00:c4"), user_id=196},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=197, cidr = cidr("192.168.28.80/29"), mac = mac("00:00:01:00:00:c5"), user_id=197},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=197, cidr = cidr("192.168.28.88/29"), mac = mac("00:00:01:00:00:c5"), user_id=197},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=198, cidr = cidr("192.168.28.96/29"), mac = mac("00:00:01:00:00:c6"), user_id=198},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=198, cidr = cidr("192.168.28.104/29"), mac = mac("00:00:01:00:00:c6"), user_id=198},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=199, cidr = cidr("192.168.28.112/29"), mac = mac("00:00:01:00:00:c7"), user_id=199},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=199, cidr = cidr("192.168.28.120/29"), mac = mac("00:00:01:00:00:c7"), user_id=199},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=200, cidr = cidr("192.168.28.128/29"), mac = mac("00:00:01:00:00:c8"), user_id=200},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=200, cidr = cidr("192.168.28.136/29"), mac = mac("00:00:01:00:00:c8"), user_id=200},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=201, cidr = cidr("192.168.28.144/29"), mac = mac("00:00:01:00:00:c9"), user_id=201},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=201, cidr = cidr("192.168.28.152/29"), mac = mac("00:00:01:00:00:c9"), user_id=201},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=202, cidr = cidr("192.168.28.160/29"), mac = mac("00:00:01:00:00:ca"), user_id=202},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=202, cidr = cidr("192.168.28.168/29"), mac = mac("00:00:01:00:00:ca"), user_id=202},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=203, cidr = cidr("192.168.28.176/29"), mac = mac("00:00:01:00:00:cb"), user_id=203},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=203, cidr = cidr("192.168.28.184/29"), mac = mac("00:00:01:00:00:cb"), user_id=203},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=204, cidr = cidr("192.168.28.192/29"), mac = mac("00:00:01:00:00:cc"), user_id=204},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=204, cidr = cidr("192.168.28.200/29"), mac = mac("00:00:01:00:00:cc"), user_id=204},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=205, cidr = cidr("192.168.28.208/29"), mac = mac("00:00:01:00:00:cd"), user_id=205},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=205, cidr = cidr("192.168.28.216/29"), mac = mac("00:00:01:00:00:cd"), user_id=205},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=206, cidr = cidr("192.168.28.224/29"), mac = mac("00:00:01:00:00:ce"), user_id=206},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=206, cidr = cidr("192.168.28.232/29"), mac = mac("00:00:01:00:00:ce"), user_id=206},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=207, cidr = cidr("192.168.28.240/29"), mac = mac("00:00:01:00:00:cf"), user_id=207},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=207, cidr = cidr("192.168.28.248/29"), mac = mac("00:00:01:00:00:cf"), user_id=207},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=208, cidr = cidr("192.168.29.0/29"), mac = mac("00:00:01:00:00:d0"), user_id=208},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=208, cidr = cidr("192.168.29.8/29"), mac = mac("00:00:01:00:00:d0"), user_id=208},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=209, cidr = cidr("192.168.29.16/29"), mac = mac("00:00:01:00:00:d1"), user_id=209},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=209, cidr = cidr("192.168.29.24/29"), mac = mac("00:00:01:00:00:d1"), user_id=209},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=210, cidr = cidr("192.168.29.32/29"), mac = mac("00:00:01:00:00:d2"), user_id=210},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=210, cidr = cidr("192.168.29.40/29"), mac = mac("00:00:01:00:00:d2"), user_id=210},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=211, cidr = cidr("192.168.29.48/29"), mac = mac("00:00:01:00:00:d3"), user_id=211},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=211, cidr = cidr("192.168.29.56/29"), mac = mac("00:00:01:00:00:d3"), user_id=211},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=212, cidr = cidr("192.168.29.64/29"), mac = mac("00:00:01:00:00:d4"), user_id=212},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=212, cidr = cidr("192.168.29.72/29"), mac = mac("00:00:01:00:00:d4"), user_id=212},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=213, cidr = cidr("192.168.29.80/29"), mac = mac("00:00:01:00:00:d5"), user_id=213},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=213, cidr = cidr("192.168.29.88/29"), mac = mac("00:00:01:00:00:d5"), user_id=213},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=214, cidr = cidr("192.168.29.96/29"), mac = mac("00:00:01:00:00:d6"), user_id=214},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=214, cidr = cidr("192.168.29.104/29"), mac = mac("00:00:01:00:00:d6"), user_id=214},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=215, cidr = cidr("192.168.29.112/29"), mac = mac("00:00:01:00:00:d7"), user_id=215},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=215, cidr = cidr("192.168.29.120/29"), mac = mac("00:00:01:00:00:d7"), user_id=215},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=216, cidr = cidr("192.168.29.128/29"), mac = mac("00:00:01:00:00:d8"), user_id=216},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=216, cidr = cidr("192.168.29.136/29"), mac = mac("00:00:01:00:00:d8"), user_id=216},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=217, cidr = cidr("192.168.29.144/29"), mac = mac("00:00:01:00:00:d9"), user_id=217},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=217, cidr = cidr("192.168.29.152/29"), mac = mac("00:00:01:00:00:d9"), user_id=217},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=218, cidr = cidr("192.168.29.160/29"), mac = mac("00:00:01:00:00:da"), user_id=218},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=218, cidr = cidr("192.168.29.168/29"), mac = mac("00:00:01:00:00:da"), user_id=218},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=219, cidr = cidr("192.168.29.176/29"), mac = mac("00:00:01:00:00:db"), user_id=219},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=219, cidr = cidr("192.168.29.184/29"), mac = mac("00:00:01:00:00:db"), user_id=219},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=220, cidr = cidr("192.168.29.192/29"), mac = mac("00:00:01:00:00:dc"), user_id=220},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=220, cidr = cidr("192.168.29.200/29"), mac = mac("00:00:01:00:00:dc"), user_id=220},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=221, cidr = cidr("192.168.29.208/29"), mac = mac("00:00:01:00:00:dd"), user_id=221},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=221, cidr = cidr("192.168.29.216/29"), mac = mac("00:00:01:00:00:dd"), user_id=221},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=222, cidr = cidr("192.168.29.224/29"), mac = mac("00:00:01:00:00:de"), user_id=222},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=222, cidr = cidr("192.168.29.232/29"), mac = mac("00:00:01:00:00:de"), user_id=222},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=223, cidr = cidr("192.168.29.240/29"), mac = mac("00:00:01:00:00:df"), user_id=223},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=223, cidr = cidr("192.168.29.248/29"), mac = mac("00:00:01:00:00:df"), user_id=223},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=224, cidr = cidr("192.168.30.0/29"), mac = mac("00:00:01:00:00:e0"), user_id=224},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=224, cidr = cidr("192.168.30.8/29"), mac = mac("00:00:01:00:00:e0"), user_id=224},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=225, cidr = cidr("192.168.30.16/29"), mac = mac("00:00:01:00:00:e1"), user_id=225},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=225, cidr = cidr("192.168.30.24/29"), mac = mac("00:00:01:00:00:e1"), user_id=225},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=226, cidr = cidr("192.168.30.32/29"), mac = mac("00:00:01:00:00:e2"), user_id=226},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=226, cidr = cidr("192.168.30.40/29"), mac = mac("00:00:01:00:00:e2"), user_id=226},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=227, cidr = cidr("192.168.30.48/29"), mac = mac("00:00:01:00:00:e3"), user_id=227},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=227, cidr = cidr("192.168.30.56/29"), mac = mac("00:00:01:00:00:e3"), user_id=227},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=228, cidr = cidr("192.168.30.64/29"), mac = mac("00:00:01:00:00:e4"), user_id=228},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=228, cidr = cidr("192.168.30.72/29"), mac = mac("00:00:01:00:00:e4"), user_id=228},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=229, cidr = cidr("192.168.30.80/29"), mac = mac("00:00:01:00:00:e5"), user_id=229},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=229, cidr = cidr("192.168.30.88/29"), mac = mac("00:00:01:00:00:e5"), user_id=229},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=230, cidr = cidr("192.168.30.96/29"), mac = mac("00:00:01:00:00:e6"), user_id=230},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=230, cidr = cidr("192.168.30.104/29"), mac = mac("00:00:01:00:00:e6"), user_id=230},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=231, cidr = cidr("192.168.30.112/29"), mac = mac("00:00:01:00:00:e7"), user_id=231},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=231, cidr = cidr("192.168.30.120/29"), mac = mac("00:00:01:00:00:e7"), user_id=231},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=232, cidr = cidr("192.168.30.128/29"), mac = mac("00:00:01:00:00:e8"), user_id=232},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=232, cidr = cidr("192.168.30.136/29"), mac = mac("00:00:01:00:00:e8"), user_id=232},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=233, cidr = cidr("192.168.30.144/29"), mac = mac("00:00:01:00:00:e9"), user_id=233},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=233, cidr = cidr("192.168.30.152/29"), mac = mac("00:00:01:00:00:e9"), user_id=233},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=234, cidr = cidr("192.168.30.160/29"), mac = mac("00:00:01:00:00:ea"), user_id=234},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=234, cidr = cidr("192.168.30.168/29"), mac = mac("00:00:01:00:00:ea"), user_id=234},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=235, cidr = cidr("192.168.30.176/29"), mac = mac("00:00:01:00:00:eb"), user_id=235},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=235, cidr = cidr("192.168.30.184/29"), mac = mac("00:00:01:00:00:eb"), user_id=235},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=236, cidr = cidr("192.168.30.192/29"), mac = mac("00:00:01:00:00:ec"), user_id=236},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=236, cidr = cidr("192.168.30.200/29"), mac = mac("00:00:01:00:00:ec"), user_id=236},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=237, cidr = cidr("192.168.30.208/29"), mac = mac("00:00:01:00:00:ed"), user_id=237},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=237, cidr = cidr("192.168.30.216/29"), mac = mac("00:00:01:00:00:ed"), user_id=237},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=238, cidr = cidr("192.168.30.224/29"), mac = mac("00:00:01:00:00:ee"), user_id=238},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=238, cidr = cidr("192.168.30.232/29"), mac = mac("00:00:01:00:00:ee"), user_id=238},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=239, cidr = cidr("192.168.30.240/29"), mac = mac("00:00:01:00:00:ef"), user_id=239},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=239, cidr = cidr("192.168.30.248/29"), mac = mac("00:00:01:00:00:ef"), user_id=239},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=240, cidr = cidr("192.168.31.0/29"), mac = mac("00:00:01:00:00:f0"), user_id=240},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=240, cidr = cidr("192.168.31.8/29"), mac = mac("00:00:01:00:00:f0"), user_id=240},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=241, cidr = cidr("192.168.31.16/29"), mac = mac("00:00:01:00:00:f1"), user_id=241},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=241, cidr = cidr("192.168.31.24/29"), mac = mac("00:00:01:00:00:f1"), user_id=241},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=242, cidr = cidr("192.168.31.32/29"), mac = mac("00:00:01:00:00:f2"), user_id=242},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=242, cidr = cidr("192.168.31.40/29"), mac = mac("00:00:01:00:00:f2"), user_id=242},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=243, cidr = cidr("192.168.31.48/29"), mac = mac("00:00:01:00:00:f3"), user_id=243},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=243, cidr = cidr("192.168.31.56/29"), mac = mac("00:00:01:00:00:f3"), user_id=243},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=244, cidr = cidr("192.168.31.64/29"), mac = mac("00:00:01:00:00:f4"), user_id=244},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=244, cidr = cidr("192.168.31.72/29"), mac = mac("00:00:01:00:00:f4"), user_id=244},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=245, cidr = cidr("192.168.31.80/29"), mac = mac("00:00:01:00:00:f5"), user_id=245},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=245, cidr = cidr("192.168.31.88/29"), mac = mac("00:00:01:00:00:f5"), user_id=245},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=246, cidr = cidr("192.168.31.96/29"), mac = mac("00:00:01:00:00:f6"), user_id=246},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=246, cidr = cidr("192.168.31.104/29"), mac = mac("00:00:01:00:00:f6"), user_id=246},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=247, cidr = cidr("192.168.31.112/29"), mac = mac("00:00:01:00:00:f7"), user_id=247},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=247, cidr = cidr("192.168.31.120/29"), mac = mac("00:00:01:00:00:f7"), user_id=247},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=248, cidr = cidr("192.168.31.128/29"), mac = mac("00:00:01:00:00:f8"), user_id=248},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=248, cidr = cidr("192.168.31.136/29"), mac = mac("00:00:01:00:00:f8"), user_id=248},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=249, cidr = cidr("192.168.31.144/29"), mac = mac("00:00:01:00:00:f9"), user_id=249},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=249, cidr = cidr("192.168.31.152/29"), mac = mac("00:00:01:00:00:f9"), user_id=249},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=250, cidr = cidr("192.168.31.160/29"), mac = mac("00:00:01:00:00:fa"), user_id=250},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=250, cidr = cidr("192.168.31.168/29"), mac = mac("00:00:01:00:00:fa"), user_id=250},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=251, cidr = cidr("192.168.31.176/29"), mac = mac("00:00:01:00:00:fb"), user_id=251},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=251, cidr = cidr("192.168.31.184/29"), mac = mac("00:00:01:00:00:fb"), user_id=251},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=252, cidr = cidr("192.168.31.192/29"), mac = mac("00:00:01:00:00:fc"), user_id=252},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=252, cidr = cidr("192.168.31.200/29"), mac = mac("00:00:01:00:00:fc"), user_id=252},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=253, cidr = cidr("192.168.31.208/29"), mac = mac("00:00:01:00:00:fd"), user_id=253},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=253, cidr = cidr("192.168.31.216/29"), mac = mac("00:00:01:00:00:fd"), user_id=253},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=254, cidr = cidr("192.168.31.224/29"), mac = mac("00:00:01:00:00:fe"), user_id=254},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=254, cidr = cidr("192.168.31.232/29"), mac = mac("00:00:01:00:00:fe"), user_id=254},
+   {dest_id=1, gre_id=0, svlan_id=16, cvlan_id=255, cidr = cidr("192.168.31.240/29"), mac = mac("00:00:01:00:00:ff"), user_id=255},
+   {dest_id=1, gre_id=0, svlan_id=17, cvlan_id=255, cidr = cidr("192.168.31.248/29"), mac = mac("00:00:01:00:00:ff"), user_id=255},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=0, cidr = cidr("192.168.32.0/29"), mac = mac("00:00:01:00:00:00"), user_id=0},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=0, cidr = cidr("192.168.32.8/29"), mac = mac("00:00:01:00:00:00"), user_id=0},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=1, cidr = cidr("192.168.32.16/29"), mac = mac("00:00:01:00:00:01"), user_id=1},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=1, cidr = cidr("192.168.32.24/29"), mac = mac("00:00:01:00:00:01"), user_id=1},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=2, cidr = cidr("192.168.32.32/29"), mac = mac("00:00:01:00:00:02"), user_id=2},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=2, cidr = cidr("192.168.32.40/29"), mac = mac("00:00:01:00:00:02"), user_id=2},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=3, cidr = cidr("192.168.32.48/29"), mac = mac("00:00:01:00:00:03"), user_id=3},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=3, cidr = cidr("192.168.32.56/29"), mac = mac("00:00:01:00:00:03"), user_id=3},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=4, cidr = cidr("192.168.32.64/29"), mac = mac("00:00:01:00:00:04"), user_id=4},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=4, cidr = cidr("192.168.32.72/29"), mac = mac("00:00:01:00:00:04"), user_id=4},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=5, cidr = cidr("192.168.32.80/29"), mac = mac("00:00:01:00:00:05"), user_id=5},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=5, cidr = cidr("192.168.32.88/29"), mac = mac("00:00:01:00:00:05"), user_id=5},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=6, cidr = cidr("192.168.32.96/29"), mac = mac("00:00:01:00:00:06"), user_id=6},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=6, cidr = cidr("192.168.32.104/29"), mac = mac("00:00:01:00:00:06"), user_id=6},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=7, cidr = cidr("192.168.32.112/29"), mac = mac("00:00:01:00:00:07"), user_id=7},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=7, cidr = cidr("192.168.32.120/29"), mac = mac("00:00:01:00:00:07"), user_id=7},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=8, cidr = cidr("192.168.32.128/29"), mac = mac("00:00:01:00:00:08"), user_id=8},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=8, cidr = cidr("192.168.32.136/29"), mac = mac("00:00:01:00:00:08"), user_id=8},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=9, cidr = cidr("192.168.32.144/29"), mac = mac("00:00:01:00:00:09"), user_id=9},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=9, cidr = cidr("192.168.32.152/29"), mac = mac("00:00:01:00:00:09"), user_id=9},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=10, cidr = cidr("192.168.32.160/29"), mac = mac("00:00:01:00:00:0a"), user_id=10},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=10, cidr = cidr("192.168.32.168/29"), mac = mac("00:00:01:00:00:0a"), user_id=10},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=11, cidr = cidr("192.168.32.176/29"), mac = mac("00:00:01:00:00:0b"), user_id=11},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=11, cidr = cidr("192.168.32.184/29"), mac = mac("00:00:01:00:00:0b"), user_id=11},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=12, cidr = cidr("192.168.32.192/29"), mac = mac("00:00:01:00:00:0c"), user_id=12},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=12, cidr = cidr("192.168.32.200/29"), mac = mac("00:00:01:00:00:0c"), user_id=12},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=13, cidr = cidr("192.168.32.208/29"), mac = mac("00:00:01:00:00:0d"), user_id=13},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=13, cidr = cidr("192.168.32.216/29"), mac = mac("00:00:01:00:00:0d"), user_id=13},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=14, cidr = cidr("192.168.32.224/29"), mac = mac("00:00:01:00:00:0e"), user_id=14},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=14, cidr = cidr("192.168.32.232/29"), mac = mac("00:00:01:00:00:0e"), user_id=14},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=15, cidr = cidr("192.168.32.240/29"), mac = mac("00:00:01:00:00:0f"), user_id=15},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=15, cidr = cidr("192.168.32.248/29"), mac = mac("00:00:01:00:00:0f"), user_id=15},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=16, cidr = cidr("192.168.33.0/29"), mac = mac("00:00:01:00:00:10"), user_id=16},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=16, cidr = cidr("192.168.33.8/29"), mac = mac("00:00:01:00:00:10"), user_id=16},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=17, cidr = cidr("192.168.33.16/29"), mac = mac("00:00:01:00:00:11"), user_id=17},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=17, cidr = cidr("192.168.33.24/29"), mac = mac("00:00:01:00:00:11"), user_id=17},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=18, cidr = cidr("192.168.33.32/29"), mac = mac("00:00:01:00:00:12"), user_id=18},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=18, cidr = cidr("192.168.33.40/29"), mac = mac("00:00:01:00:00:12"), user_id=18},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=19, cidr = cidr("192.168.33.48/29"), mac = mac("00:00:01:00:00:13"), user_id=19},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=19, cidr = cidr("192.168.33.56/29"), mac = mac("00:00:01:00:00:13"), user_id=19},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=20, cidr = cidr("192.168.33.64/29"), mac = mac("00:00:01:00:00:14"), user_id=20},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=20, cidr = cidr("192.168.33.72/29"), mac = mac("00:00:01:00:00:14"), user_id=20},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=21, cidr = cidr("192.168.33.80/29"), mac = mac("00:00:01:00:00:15"), user_id=21},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=21, cidr = cidr("192.168.33.88/29"), mac = mac("00:00:01:00:00:15"), user_id=21},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=22, cidr = cidr("192.168.33.96/29"), mac = mac("00:00:01:00:00:16"), user_id=22},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=22, cidr = cidr("192.168.33.104/29"), mac = mac("00:00:01:00:00:16"), user_id=22},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=23, cidr = cidr("192.168.33.112/29"), mac = mac("00:00:01:00:00:17"), user_id=23},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=23, cidr = cidr("192.168.33.120/29"), mac = mac("00:00:01:00:00:17"), user_id=23},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=24, cidr = cidr("192.168.33.128/29"), mac = mac("00:00:01:00:00:18"), user_id=24},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=24, cidr = cidr("192.168.33.136/29"), mac = mac("00:00:01:00:00:18"), user_id=24},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=25, cidr = cidr("192.168.33.144/29"), mac = mac("00:00:01:00:00:19"), user_id=25},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=25, cidr = cidr("192.168.33.152/29"), mac = mac("00:00:01:00:00:19"), user_id=25},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=26, cidr = cidr("192.168.33.160/29"), mac = mac("00:00:01:00:00:1a"), user_id=26},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=26, cidr = cidr("192.168.33.168/29"), mac = mac("00:00:01:00:00:1a"), user_id=26},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=27, cidr = cidr("192.168.33.176/29"), mac = mac("00:00:01:00:00:1b"), user_id=27},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=27, cidr = cidr("192.168.33.184/29"), mac = mac("00:00:01:00:00:1b"), user_id=27},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=28, cidr = cidr("192.168.33.192/29"), mac = mac("00:00:01:00:00:1c"), user_id=28},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=28, cidr = cidr("192.168.33.200/29"), mac = mac("00:00:01:00:00:1c"), user_id=28},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=29, cidr = cidr("192.168.33.208/29"), mac = mac("00:00:01:00:00:1d"), user_id=29},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=29, cidr = cidr("192.168.33.216/29"), mac = mac("00:00:01:00:00:1d"), user_id=29},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=30, cidr = cidr("192.168.33.224/29"), mac = mac("00:00:01:00:00:1e"), user_id=30},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=30, cidr = cidr("192.168.33.232/29"), mac = mac("00:00:01:00:00:1e"), user_id=30},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=31, cidr = cidr("192.168.33.240/29"), mac = mac("00:00:01:00:00:1f"), user_id=31},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=31, cidr = cidr("192.168.33.248/29"), mac = mac("00:00:01:00:00:1f"), user_id=31},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=32, cidr = cidr("192.168.34.0/29"), mac = mac("00:00:01:00:00:20"), user_id=32},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=32, cidr = cidr("192.168.34.8/29"), mac = mac("00:00:01:00:00:20"), user_id=32},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=33, cidr = cidr("192.168.34.16/29"), mac = mac("00:00:01:00:00:21"), user_id=33},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=33, cidr = cidr("192.168.34.24/29"), mac = mac("00:00:01:00:00:21"), user_id=33},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=34, cidr = cidr("192.168.34.32/29"), mac = mac("00:00:01:00:00:22"), user_id=34},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=34, cidr = cidr("192.168.34.40/29"), mac = mac("00:00:01:00:00:22"), user_id=34},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=35, cidr = cidr("192.168.34.48/29"), mac = mac("00:00:01:00:00:23"), user_id=35},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=35, cidr = cidr("192.168.34.56/29"), mac = mac("00:00:01:00:00:23"), user_id=35},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=36, cidr = cidr("192.168.34.64/29"), mac = mac("00:00:01:00:00:24"), user_id=36},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=36, cidr = cidr("192.168.34.72/29"), mac = mac("00:00:01:00:00:24"), user_id=36},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=37, cidr = cidr("192.168.34.80/29"), mac = mac("00:00:01:00:00:25"), user_id=37},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=37, cidr = cidr("192.168.34.88/29"), mac = mac("00:00:01:00:00:25"), user_id=37},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=38, cidr = cidr("192.168.34.96/29"), mac = mac("00:00:01:00:00:26"), user_id=38},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=38, cidr = cidr("192.168.34.104/29"), mac = mac("00:00:01:00:00:26"), user_id=38},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=39, cidr = cidr("192.168.34.112/29"), mac = mac("00:00:01:00:00:27"), user_id=39},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=39, cidr = cidr("192.168.34.120/29"), mac = mac("00:00:01:00:00:27"), user_id=39},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=40, cidr = cidr("192.168.34.128/29"), mac = mac("00:00:01:00:00:28"), user_id=40},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=40, cidr = cidr("192.168.34.136/29"), mac = mac("00:00:01:00:00:28"), user_id=40},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=41, cidr = cidr("192.168.34.144/29"), mac = mac("00:00:01:00:00:29"), user_id=41},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=41, cidr = cidr("192.168.34.152/29"), mac = mac("00:00:01:00:00:29"), user_id=41},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=42, cidr = cidr("192.168.34.160/29"), mac = mac("00:00:01:00:00:2a"), user_id=42},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=42, cidr = cidr("192.168.34.168/29"), mac = mac("00:00:01:00:00:2a"), user_id=42},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=43, cidr = cidr("192.168.34.176/29"), mac = mac("00:00:01:00:00:2b"), user_id=43},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=43, cidr = cidr("192.168.34.184/29"), mac = mac("00:00:01:00:00:2b"), user_id=43},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=44, cidr = cidr("192.168.34.192/29"), mac = mac("00:00:01:00:00:2c"), user_id=44},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=44, cidr = cidr("192.168.34.200/29"), mac = mac("00:00:01:00:00:2c"), user_id=44},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=45, cidr = cidr("192.168.34.208/29"), mac = mac("00:00:01:00:00:2d"), user_id=45},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=45, cidr = cidr("192.168.34.216/29"), mac = mac("00:00:01:00:00:2d"), user_id=45},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=46, cidr = cidr("192.168.34.224/29"), mac = mac("00:00:01:00:00:2e"), user_id=46},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=46, cidr = cidr("192.168.34.232/29"), mac = mac("00:00:01:00:00:2e"), user_id=46},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=47, cidr = cidr("192.168.34.240/29"), mac = mac("00:00:01:00:00:2f"), user_id=47},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=47, cidr = cidr("192.168.34.248/29"), mac = mac("00:00:01:00:00:2f"), user_id=47},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=48, cidr = cidr("192.168.35.0/29"), mac = mac("00:00:01:00:00:30"), user_id=48},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=48, cidr = cidr("192.168.35.8/29"), mac = mac("00:00:01:00:00:30"), user_id=48},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=49, cidr = cidr("192.168.35.16/29"), mac = mac("00:00:01:00:00:31"), user_id=49},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=49, cidr = cidr("192.168.35.24/29"), mac = mac("00:00:01:00:00:31"), user_id=49},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=50, cidr = cidr("192.168.35.32/29"), mac = mac("00:00:01:00:00:32"), user_id=50},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=50, cidr = cidr("192.168.35.40/29"), mac = mac("00:00:01:00:00:32"), user_id=50},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=51, cidr = cidr("192.168.35.48/29"), mac = mac("00:00:01:00:00:33"), user_id=51},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=51, cidr = cidr("192.168.35.56/29"), mac = mac("00:00:01:00:00:33"), user_id=51},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=52, cidr = cidr("192.168.35.64/29"), mac = mac("00:00:01:00:00:34"), user_id=52},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=52, cidr = cidr("192.168.35.72/29"), mac = mac("00:00:01:00:00:34"), user_id=52},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=53, cidr = cidr("192.168.35.80/29"), mac = mac("00:00:01:00:00:35"), user_id=53},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=53, cidr = cidr("192.168.35.88/29"), mac = mac("00:00:01:00:00:35"), user_id=53},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=54, cidr = cidr("192.168.35.96/29"), mac = mac("00:00:01:00:00:36"), user_id=54},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=54, cidr = cidr("192.168.35.104/29"), mac = mac("00:00:01:00:00:36"), user_id=54},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=55, cidr = cidr("192.168.35.112/29"), mac = mac("00:00:01:00:00:37"), user_id=55},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=55, cidr = cidr("192.168.35.120/29"), mac = mac("00:00:01:00:00:37"), user_id=55},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=56, cidr = cidr("192.168.35.128/29"), mac = mac("00:00:01:00:00:38"), user_id=56},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=56, cidr = cidr("192.168.35.136/29"), mac = mac("00:00:01:00:00:38"), user_id=56},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=57, cidr = cidr("192.168.35.144/29"), mac = mac("00:00:01:00:00:39"), user_id=57},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=57, cidr = cidr("192.168.35.152/29"), mac = mac("00:00:01:00:00:39"), user_id=57},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=58, cidr = cidr("192.168.35.160/29"), mac = mac("00:00:01:00:00:3a"), user_id=58},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=58, cidr = cidr("192.168.35.168/29"), mac = mac("00:00:01:00:00:3a"), user_id=58},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=59, cidr = cidr("192.168.35.176/29"), mac = mac("00:00:01:00:00:3b"), user_id=59},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=59, cidr = cidr("192.168.35.184/29"), mac = mac("00:00:01:00:00:3b"), user_id=59},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=60, cidr = cidr("192.168.35.192/29"), mac = mac("00:00:01:00:00:3c"), user_id=60},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=60, cidr = cidr("192.168.35.200/29"), mac = mac("00:00:01:00:00:3c"), user_id=60},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=61, cidr = cidr("192.168.35.208/29"), mac = mac("00:00:01:00:00:3d"), user_id=61},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=61, cidr = cidr("192.168.35.216/29"), mac = mac("00:00:01:00:00:3d"), user_id=61},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=62, cidr = cidr("192.168.35.224/29"), mac = mac("00:00:01:00:00:3e"), user_id=62},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=62, cidr = cidr("192.168.35.232/29"), mac = mac("00:00:01:00:00:3e"), user_id=62},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=63, cidr = cidr("192.168.35.240/29"), mac = mac("00:00:01:00:00:3f"), user_id=63},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=63, cidr = cidr("192.168.35.248/29"), mac = mac("00:00:01:00:00:3f"), user_id=63},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=64, cidr = cidr("192.168.36.0/29"), mac = mac("00:00:01:00:00:40"), user_id=64},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=64, cidr = cidr("192.168.36.8/29"), mac = mac("00:00:01:00:00:40"), user_id=64},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=65, cidr = cidr("192.168.36.16/29"), mac = mac("00:00:01:00:00:41"), user_id=65},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=65, cidr = cidr("192.168.36.24/29"), mac = mac("00:00:01:00:00:41"), user_id=65},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=66, cidr = cidr("192.168.36.32/29"), mac = mac("00:00:01:00:00:42"), user_id=66},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=66, cidr = cidr("192.168.36.40/29"), mac = mac("00:00:01:00:00:42"), user_id=66},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=67, cidr = cidr("192.168.36.48/29"), mac = mac("00:00:01:00:00:43"), user_id=67},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=67, cidr = cidr("192.168.36.56/29"), mac = mac("00:00:01:00:00:43"), user_id=67},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=68, cidr = cidr("192.168.36.64/29"), mac = mac("00:00:01:00:00:44"), user_id=68},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=68, cidr = cidr("192.168.36.72/29"), mac = mac("00:00:01:00:00:44"), user_id=68},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=69, cidr = cidr("192.168.36.80/29"), mac = mac("00:00:01:00:00:45"), user_id=69},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=69, cidr = cidr("192.168.36.88/29"), mac = mac("00:00:01:00:00:45"), user_id=69},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=70, cidr = cidr("192.168.36.96/29"), mac = mac("00:00:01:00:00:46"), user_id=70},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=70, cidr = cidr("192.168.36.104/29"), mac = mac("00:00:01:00:00:46"), user_id=70},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=71, cidr = cidr("192.168.36.112/29"), mac = mac("00:00:01:00:00:47"), user_id=71},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=71, cidr = cidr("192.168.36.120/29"), mac = mac("00:00:01:00:00:47"), user_id=71},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=72, cidr = cidr("192.168.36.128/29"), mac = mac("00:00:01:00:00:48"), user_id=72},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=72, cidr = cidr("192.168.36.136/29"), mac = mac("00:00:01:00:00:48"), user_id=72},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=73, cidr = cidr("192.168.36.144/29"), mac = mac("00:00:01:00:00:49"), user_id=73},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=73, cidr = cidr("192.168.36.152/29"), mac = mac("00:00:01:00:00:49"), user_id=73},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=74, cidr = cidr("192.168.36.160/29"), mac = mac("00:00:01:00:00:4a"), user_id=74},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=74, cidr = cidr("192.168.36.168/29"), mac = mac("00:00:01:00:00:4a"), user_id=74},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=75, cidr = cidr("192.168.36.176/29"), mac = mac("00:00:01:00:00:4b"), user_id=75},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=75, cidr = cidr("192.168.36.184/29"), mac = mac("00:00:01:00:00:4b"), user_id=75},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=76, cidr = cidr("192.168.36.192/29"), mac = mac("00:00:01:00:00:4c"), user_id=76},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=76, cidr = cidr("192.168.36.200/29"), mac = mac("00:00:01:00:00:4c"), user_id=76},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=77, cidr = cidr("192.168.36.208/29"), mac = mac("00:00:01:00:00:4d"), user_id=77},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=77, cidr = cidr("192.168.36.216/29"), mac = mac("00:00:01:00:00:4d"), user_id=77},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=78, cidr = cidr("192.168.36.224/29"), mac = mac("00:00:01:00:00:4e"), user_id=78},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=78, cidr = cidr("192.168.36.232/29"), mac = mac("00:00:01:00:00:4e"), user_id=78},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=79, cidr = cidr("192.168.36.240/29"), mac = mac("00:00:01:00:00:4f"), user_id=79},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=79, cidr = cidr("192.168.36.248/29"), mac = mac("00:00:01:00:00:4f"), user_id=79},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=80, cidr = cidr("192.168.37.0/29"), mac = mac("00:00:01:00:00:50"), user_id=80},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=80, cidr = cidr("192.168.37.8/29"), mac = mac("00:00:01:00:00:50"), user_id=80},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=81, cidr = cidr("192.168.37.16/29"), mac = mac("00:00:01:00:00:51"), user_id=81},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=81, cidr = cidr("192.168.37.24/29"), mac = mac("00:00:01:00:00:51"), user_id=81},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=82, cidr = cidr("192.168.37.32/29"), mac = mac("00:00:01:00:00:52"), user_id=82},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=82, cidr = cidr("192.168.37.40/29"), mac = mac("00:00:01:00:00:52"), user_id=82},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=83, cidr = cidr("192.168.37.48/29"), mac = mac("00:00:01:00:00:53"), user_id=83},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=83, cidr = cidr("192.168.37.56/29"), mac = mac("00:00:01:00:00:53"), user_id=83},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=84, cidr = cidr("192.168.37.64/29"), mac = mac("00:00:01:00:00:54"), user_id=84},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=84, cidr = cidr("192.168.37.72/29"), mac = mac("00:00:01:00:00:54"), user_id=84},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=85, cidr = cidr("192.168.37.80/29"), mac = mac("00:00:01:00:00:55"), user_id=85},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=85, cidr = cidr("192.168.37.88/29"), mac = mac("00:00:01:00:00:55"), user_id=85},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=86, cidr = cidr("192.168.37.96/29"), mac = mac("00:00:01:00:00:56"), user_id=86},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=86, cidr = cidr("192.168.37.104/29"), mac = mac("00:00:01:00:00:56"), user_id=86},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=87, cidr = cidr("192.168.37.112/29"), mac = mac("00:00:01:00:00:57"), user_id=87},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=87, cidr = cidr("192.168.37.120/29"), mac = mac("00:00:01:00:00:57"), user_id=87},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=88, cidr = cidr("192.168.37.128/29"), mac = mac("00:00:01:00:00:58"), user_id=88},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=88, cidr = cidr("192.168.37.136/29"), mac = mac("00:00:01:00:00:58"), user_id=88},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=89, cidr = cidr("192.168.37.144/29"), mac = mac("00:00:01:00:00:59"), user_id=89},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=89, cidr = cidr("192.168.37.152/29"), mac = mac("00:00:01:00:00:59"), user_id=89},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=90, cidr = cidr("192.168.37.160/29"), mac = mac("00:00:01:00:00:5a"), user_id=90},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=90, cidr = cidr("192.168.37.168/29"), mac = mac("00:00:01:00:00:5a"), user_id=90},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=91, cidr = cidr("192.168.37.176/29"), mac = mac("00:00:01:00:00:5b"), user_id=91},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=91, cidr = cidr("192.168.37.184/29"), mac = mac("00:00:01:00:00:5b"), user_id=91},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=92, cidr = cidr("192.168.37.192/29"), mac = mac("00:00:01:00:00:5c"), user_id=92},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=92, cidr = cidr("192.168.37.200/29"), mac = mac("00:00:01:00:00:5c"), user_id=92},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=93, cidr = cidr("192.168.37.208/29"), mac = mac("00:00:01:00:00:5d"), user_id=93},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=93, cidr = cidr("192.168.37.216/29"), mac = mac("00:00:01:00:00:5d"), user_id=93},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=94, cidr = cidr("192.168.37.224/29"), mac = mac("00:00:01:00:00:5e"), user_id=94},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=94, cidr = cidr("192.168.37.232/29"), mac = mac("00:00:01:00:00:5e"), user_id=94},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=95, cidr = cidr("192.168.37.240/29"), mac = mac("00:00:01:00:00:5f"), user_id=95},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=95, cidr = cidr("192.168.37.248/29"), mac = mac("00:00:01:00:00:5f"), user_id=95},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=96, cidr = cidr("192.168.38.0/29"), mac = mac("00:00:01:00:00:60"), user_id=96},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=96, cidr = cidr("192.168.38.8/29"), mac = mac("00:00:01:00:00:60"), user_id=96},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=97, cidr = cidr("192.168.38.16/29"), mac = mac("00:00:01:00:00:61"), user_id=97},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=97, cidr = cidr("192.168.38.24/29"), mac = mac("00:00:01:00:00:61"), user_id=97},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=98, cidr = cidr("192.168.38.32/29"), mac = mac("00:00:01:00:00:62"), user_id=98},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=98, cidr = cidr("192.168.38.40/29"), mac = mac("00:00:01:00:00:62"), user_id=98},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=99, cidr = cidr("192.168.38.48/29"), mac = mac("00:00:01:00:00:63"), user_id=99},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=99, cidr = cidr("192.168.38.56/29"), mac = mac("00:00:01:00:00:63"), user_id=99},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=100, cidr = cidr("192.168.38.64/29"), mac = mac("00:00:01:00:00:64"), user_id=100},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=100, cidr = cidr("192.168.38.72/29"), mac = mac("00:00:01:00:00:64"), user_id=100},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=101, cidr = cidr("192.168.38.80/29"), mac = mac("00:00:01:00:00:65"), user_id=101},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=101, cidr = cidr("192.168.38.88/29"), mac = mac("00:00:01:00:00:65"), user_id=101},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=102, cidr = cidr("192.168.38.96/29"), mac = mac("00:00:01:00:00:66"), user_id=102},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=102, cidr = cidr("192.168.38.104/29"), mac = mac("00:00:01:00:00:66"), user_id=102},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=103, cidr = cidr("192.168.38.112/29"), mac = mac("00:00:01:00:00:67"), user_id=103},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=103, cidr = cidr("192.168.38.120/29"), mac = mac("00:00:01:00:00:67"), user_id=103},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=104, cidr = cidr("192.168.38.128/29"), mac = mac("00:00:01:00:00:68"), user_id=104},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=104, cidr = cidr("192.168.38.136/29"), mac = mac("00:00:01:00:00:68"), user_id=104},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=105, cidr = cidr("192.168.38.144/29"), mac = mac("00:00:01:00:00:69"), user_id=105},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=105, cidr = cidr("192.168.38.152/29"), mac = mac("00:00:01:00:00:69"), user_id=105},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=106, cidr = cidr("192.168.38.160/29"), mac = mac("00:00:01:00:00:6a"), user_id=106},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=106, cidr = cidr("192.168.38.168/29"), mac = mac("00:00:01:00:00:6a"), user_id=106},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=107, cidr = cidr("192.168.38.176/29"), mac = mac("00:00:01:00:00:6b"), user_id=107},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=107, cidr = cidr("192.168.38.184/29"), mac = mac("00:00:01:00:00:6b"), user_id=107},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=108, cidr = cidr("192.168.38.192/29"), mac = mac("00:00:01:00:00:6c"), user_id=108},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=108, cidr = cidr("192.168.38.200/29"), mac = mac("00:00:01:00:00:6c"), user_id=108},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=109, cidr = cidr("192.168.38.208/29"), mac = mac("00:00:01:00:00:6d"), user_id=109},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=109, cidr = cidr("192.168.38.216/29"), mac = mac("00:00:01:00:00:6d"), user_id=109},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=110, cidr = cidr("192.168.38.224/29"), mac = mac("00:00:01:00:00:6e"), user_id=110},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=110, cidr = cidr("192.168.38.232/29"), mac = mac("00:00:01:00:00:6e"), user_id=110},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=111, cidr = cidr("192.168.38.240/29"), mac = mac("00:00:01:00:00:6f"), user_id=111},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=111, cidr = cidr("192.168.38.248/29"), mac = mac("00:00:01:00:00:6f"), user_id=111},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=112, cidr = cidr("192.168.39.0/29"), mac = mac("00:00:01:00:00:70"), user_id=112},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=112, cidr = cidr("192.168.39.8/29"), mac = mac("00:00:01:00:00:70"), user_id=112},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=113, cidr = cidr("192.168.39.16/29"), mac = mac("00:00:01:00:00:71"), user_id=113},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=113, cidr = cidr("192.168.39.24/29"), mac = mac("00:00:01:00:00:71"), user_id=113},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=114, cidr = cidr("192.168.39.32/29"), mac = mac("00:00:01:00:00:72"), user_id=114},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=114, cidr = cidr("192.168.39.40/29"), mac = mac("00:00:01:00:00:72"), user_id=114},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=115, cidr = cidr("192.168.39.48/29"), mac = mac("00:00:01:00:00:73"), user_id=115},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=115, cidr = cidr("192.168.39.56/29"), mac = mac("00:00:01:00:00:73"), user_id=115},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=116, cidr = cidr("192.168.39.64/29"), mac = mac("00:00:01:00:00:74"), user_id=116},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=116, cidr = cidr("192.168.39.72/29"), mac = mac("00:00:01:00:00:74"), user_id=116},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=117, cidr = cidr("192.168.39.80/29"), mac = mac("00:00:01:00:00:75"), user_id=117},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=117, cidr = cidr("192.168.39.88/29"), mac = mac("00:00:01:00:00:75"), user_id=117},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=118, cidr = cidr("192.168.39.96/29"), mac = mac("00:00:01:00:00:76"), user_id=118},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=118, cidr = cidr("192.168.39.104/29"), mac = mac("00:00:01:00:00:76"), user_id=118},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=119, cidr = cidr("192.168.39.112/29"), mac = mac("00:00:01:00:00:77"), user_id=119},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=119, cidr = cidr("192.168.39.120/29"), mac = mac("00:00:01:00:00:77"), user_id=119},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=120, cidr = cidr("192.168.39.128/29"), mac = mac("00:00:01:00:00:78"), user_id=120},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=120, cidr = cidr("192.168.39.136/29"), mac = mac("00:00:01:00:00:78"), user_id=120},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=121, cidr = cidr("192.168.39.144/29"), mac = mac("00:00:01:00:00:79"), user_id=121},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=121, cidr = cidr("192.168.39.152/29"), mac = mac("00:00:01:00:00:79"), user_id=121},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=122, cidr = cidr("192.168.39.160/29"), mac = mac("00:00:01:00:00:7a"), user_id=122},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=122, cidr = cidr("192.168.39.168/29"), mac = mac("00:00:01:00:00:7a"), user_id=122},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=123, cidr = cidr("192.168.39.176/29"), mac = mac("00:00:01:00:00:7b"), user_id=123},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=123, cidr = cidr("192.168.39.184/29"), mac = mac("00:00:01:00:00:7b"), user_id=123},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=124, cidr = cidr("192.168.39.192/29"), mac = mac("00:00:01:00:00:7c"), user_id=124},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=124, cidr = cidr("192.168.39.200/29"), mac = mac("00:00:01:00:00:7c"), user_id=124},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=125, cidr = cidr("192.168.39.208/29"), mac = mac("00:00:01:00:00:7d"), user_id=125},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=125, cidr = cidr("192.168.39.216/29"), mac = mac("00:00:01:00:00:7d"), user_id=125},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=126, cidr = cidr("192.168.39.224/29"), mac = mac("00:00:01:00:00:7e"), user_id=126},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=126, cidr = cidr("192.168.39.232/29"), mac = mac("00:00:01:00:00:7e"), user_id=126},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=127, cidr = cidr("192.168.39.240/29"), mac = mac("00:00:01:00:00:7f"), user_id=127},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=127, cidr = cidr("192.168.39.248/29"), mac = mac("00:00:01:00:00:7f"), user_id=127},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=128, cidr = cidr("192.168.40.0/29"), mac = mac("00:00:01:00:00:80"), user_id=128},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=128, cidr = cidr("192.168.40.8/29"), mac = mac("00:00:01:00:00:80"), user_id=128},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=129, cidr = cidr("192.168.40.16/29"), mac = mac("00:00:01:00:00:81"), user_id=129},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=129, cidr = cidr("192.168.40.24/29"), mac = mac("00:00:01:00:00:81"), user_id=129},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=130, cidr = cidr("192.168.40.32/29"), mac = mac("00:00:01:00:00:82"), user_id=130},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=130, cidr = cidr("192.168.40.40/29"), mac = mac("00:00:01:00:00:82"), user_id=130},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=131, cidr = cidr("192.168.40.48/29"), mac = mac("00:00:01:00:00:83"), user_id=131},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=131, cidr = cidr("192.168.40.56/29"), mac = mac("00:00:01:00:00:83"), user_id=131},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=132, cidr = cidr("192.168.40.64/29"), mac = mac("00:00:01:00:00:84"), user_id=132},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=132, cidr = cidr("192.168.40.72/29"), mac = mac("00:00:01:00:00:84"), user_id=132},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=133, cidr = cidr("192.168.40.80/29"), mac = mac("00:00:01:00:00:85"), user_id=133},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=133, cidr = cidr("192.168.40.88/29"), mac = mac("00:00:01:00:00:85"), user_id=133},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=134, cidr = cidr("192.168.40.96/29"), mac = mac("00:00:01:00:00:86"), user_id=134},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=134, cidr = cidr("192.168.40.104/29"), mac = mac("00:00:01:00:00:86"), user_id=134},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=135, cidr = cidr("192.168.40.112/29"), mac = mac("00:00:01:00:00:87"), user_id=135},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=135, cidr = cidr("192.168.40.120/29"), mac = mac("00:00:01:00:00:87"), user_id=135},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=136, cidr = cidr("192.168.40.128/29"), mac = mac("00:00:01:00:00:88"), user_id=136},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=136, cidr = cidr("192.168.40.136/29"), mac = mac("00:00:01:00:00:88"), user_id=136},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=137, cidr = cidr("192.168.40.144/29"), mac = mac("00:00:01:00:00:89"), user_id=137},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=137, cidr = cidr("192.168.40.152/29"), mac = mac("00:00:01:00:00:89"), user_id=137},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=138, cidr = cidr("192.168.40.160/29"), mac = mac("00:00:01:00:00:8a"), user_id=138},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=138, cidr = cidr("192.168.40.168/29"), mac = mac("00:00:01:00:00:8a"), user_id=138},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=139, cidr = cidr("192.168.40.176/29"), mac = mac("00:00:01:00:00:8b"), user_id=139},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=139, cidr = cidr("192.168.40.184/29"), mac = mac("00:00:01:00:00:8b"), user_id=139},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=140, cidr = cidr("192.168.40.192/29"), mac = mac("00:00:01:00:00:8c"), user_id=140},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=140, cidr = cidr("192.168.40.200/29"), mac = mac("00:00:01:00:00:8c"), user_id=140},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=141, cidr = cidr("192.168.40.208/29"), mac = mac("00:00:01:00:00:8d"), user_id=141},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=141, cidr = cidr("192.168.40.216/29"), mac = mac("00:00:01:00:00:8d"), user_id=141},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=142, cidr = cidr("192.168.40.224/29"), mac = mac("00:00:01:00:00:8e"), user_id=142},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=142, cidr = cidr("192.168.40.232/29"), mac = mac("00:00:01:00:00:8e"), user_id=142},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=143, cidr = cidr("192.168.40.240/29"), mac = mac("00:00:01:00:00:8f"), user_id=143},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=143, cidr = cidr("192.168.40.248/29"), mac = mac("00:00:01:00:00:8f"), user_id=143},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=144, cidr = cidr("192.168.41.0/29"), mac = mac("00:00:01:00:00:90"), user_id=144},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=144, cidr = cidr("192.168.41.8/29"), mac = mac("00:00:01:00:00:90"), user_id=144},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=145, cidr = cidr("192.168.41.16/29"), mac = mac("00:00:01:00:00:91"), user_id=145},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=145, cidr = cidr("192.168.41.24/29"), mac = mac("00:00:01:00:00:91"), user_id=145},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=146, cidr = cidr("192.168.41.32/29"), mac = mac("00:00:01:00:00:92"), user_id=146},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=146, cidr = cidr("192.168.41.40/29"), mac = mac("00:00:01:00:00:92"), user_id=146},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=147, cidr = cidr("192.168.41.48/29"), mac = mac("00:00:01:00:00:93"), user_id=147},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=147, cidr = cidr("192.168.41.56/29"), mac = mac("00:00:01:00:00:93"), user_id=147},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=148, cidr = cidr("192.168.41.64/29"), mac = mac("00:00:01:00:00:94"), user_id=148},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=148, cidr = cidr("192.168.41.72/29"), mac = mac("00:00:01:00:00:94"), user_id=148},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=149, cidr = cidr("192.168.41.80/29"), mac = mac("00:00:01:00:00:95"), user_id=149},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=149, cidr = cidr("192.168.41.88/29"), mac = mac("00:00:01:00:00:95"), user_id=149},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=150, cidr = cidr("192.168.41.96/29"), mac = mac("00:00:01:00:00:96"), user_id=150},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=150, cidr = cidr("192.168.41.104/29"), mac = mac("00:00:01:00:00:96"), user_id=150},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=151, cidr = cidr("192.168.41.112/29"), mac = mac("00:00:01:00:00:97"), user_id=151},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=151, cidr = cidr("192.168.41.120/29"), mac = mac("00:00:01:00:00:97"), user_id=151},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=152, cidr = cidr("192.168.41.128/29"), mac = mac("00:00:01:00:00:98"), user_id=152},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=152, cidr = cidr("192.168.41.136/29"), mac = mac("00:00:01:00:00:98"), user_id=152},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=153, cidr = cidr("192.168.41.144/29"), mac = mac("00:00:01:00:00:99"), user_id=153},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=153, cidr = cidr("192.168.41.152/29"), mac = mac("00:00:01:00:00:99"), user_id=153},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=154, cidr = cidr("192.168.41.160/29"), mac = mac("00:00:01:00:00:9a"), user_id=154},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=154, cidr = cidr("192.168.41.168/29"), mac = mac("00:00:01:00:00:9a"), user_id=154},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=155, cidr = cidr("192.168.41.176/29"), mac = mac("00:00:01:00:00:9b"), user_id=155},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=155, cidr = cidr("192.168.41.184/29"), mac = mac("00:00:01:00:00:9b"), user_id=155},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=156, cidr = cidr("192.168.41.192/29"), mac = mac("00:00:01:00:00:9c"), user_id=156},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=156, cidr = cidr("192.168.41.200/29"), mac = mac("00:00:01:00:00:9c"), user_id=156},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=157, cidr = cidr("192.168.41.208/29"), mac = mac("00:00:01:00:00:9d"), user_id=157},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=157, cidr = cidr("192.168.41.216/29"), mac = mac("00:00:01:00:00:9d"), user_id=157},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=158, cidr = cidr("192.168.41.224/29"), mac = mac("00:00:01:00:00:9e"), user_id=158},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=158, cidr = cidr("192.168.41.232/29"), mac = mac("00:00:01:00:00:9e"), user_id=158},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=159, cidr = cidr("192.168.41.240/29"), mac = mac("00:00:01:00:00:9f"), user_id=159},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=159, cidr = cidr("192.168.41.248/29"), mac = mac("00:00:01:00:00:9f"), user_id=159},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=160, cidr = cidr("192.168.42.0/29"), mac = mac("00:00:01:00:00:a0"), user_id=160},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=160, cidr = cidr("192.168.42.8/29"), mac = mac("00:00:01:00:00:a0"), user_id=160},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=161, cidr = cidr("192.168.42.16/29"), mac = mac("00:00:01:00:00:a1"), user_id=161},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=161, cidr = cidr("192.168.42.24/29"), mac = mac("00:00:01:00:00:a1"), user_id=161},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=162, cidr = cidr("192.168.42.32/29"), mac = mac("00:00:01:00:00:a2"), user_id=162},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=162, cidr = cidr("192.168.42.40/29"), mac = mac("00:00:01:00:00:a2"), user_id=162},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=163, cidr = cidr("192.168.42.48/29"), mac = mac("00:00:01:00:00:a3"), user_id=163},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=163, cidr = cidr("192.168.42.56/29"), mac = mac("00:00:01:00:00:a3"), user_id=163},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=164, cidr = cidr("192.168.42.64/29"), mac = mac("00:00:01:00:00:a4"), user_id=164},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=164, cidr = cidr("192.168.42.72/29"), mac = mac("00:00:01:00:00:a4"), user_id=164},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=165, cidr = cidr("192.168.42.80/29"), mac = mac("00:00:01:00:00:a5"), user_id=165},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=165, cidr = cidr("192.168.42.88/29"), mac = mac("00:00:01:00:00:a5"), user_id=165},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=166, cidr = cidr("192.168.42.96/29"), mac = mac("00:00:01:00:00:a6"), user_id=166},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=166, cidr = cidr("192.168.42.104/29"), mac = mac("00:00:01:00:00:a6"), user_id=166},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=167, cidr = cidr("192.168.42.112/29"), mac = mac("00:00:01:00:00:a7"), user_id=167},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=167, cidr = cidr("192.168.42.120/29"), mac = mac("00:00:01:00:00:a7"), user_id=167},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=168, cidr = cidr("192.168.42.128/29"), mac = mac("00:00:01:00:00:a8"), user_id=168},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=168, cidr = cidr("192.168.42.136/29"), mac = mac("00:00:01:00:00:a8"), user_id=168},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=169, cidr = cidr("192.168.42.144/29"), mac = mac("00:00:01:00:00:a9"), user_id=169},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=169, cidr = cidr("192.168.42.152/29"), mac = mac("00:00:01:00:00:a9"), user_id=169},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=170, cidr = cidr("192.168.42.160/29"), mac = mac("00:00:01:00:00:aa"), user_id=170},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=170, cidr = cidr("192.168.42.168/29"), mac = mac("00:00:01:00:00:aa"), user_id=170},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=171, cidr = cidr("192.168.42.176/29"), mac = mac("00:00:01:00:00:ab"), user_id=171},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=171, cidr = cidr("192.168.42.184/29"), mac = mac("00:00:01:00:00:ab"), user_id=171},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=172, cidr = cidr("192.168.42.192/29"), mac = mac("00:00:01:00:00:ac"), user_id=172},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=172, cidr = cidr("192.168.42.200/29"), mac = mac("00:00:01:00:00:ac"), user_id=172},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=173, cidr = cidr("192.168.42.208/29"), mac = mac("00:00:01:00:00:ad"), user_id=173},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=173, cidr = cidr("192.168.42.216/29"), mac = mac("00:00:01:00:00:ad"), user_id=173},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=174, cidr = cidr("192.168.42.224/29"), mac = mac("00:00:01:00:00:ae"), user_id=174},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=174, cidr = cidr("192.168.42.232/29"), mac = mac("00:00:01:00:00:ae"), user_id=174},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=175, cidr = cidr("192.168.42.240/29"), mac = mac("00:00:01:00:00:af"), user_id=175},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=175, cidr = cidr("192.168.42.248/29"), mac = mac("00:00:01:00:00:af"), user_id=175},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=176, cidr = cidr("192.168.43.0/29"), mac = mac("00:00:01:00:00:b0"), user_id=176},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=176, cidr = cidr("192.168.43.8/29"), mac = mac("00:00:01:00:00:b0"), user_id=176},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=177, cidr = cidr("192.168.43.16/29"), mac = mac("00:00:01:00:00:b1"), user_id=177},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=177, cidr = cidr("192.168.43.24/29"), mac = mac("00:00:01:00:00:b1"), user_id=177},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=178, cidr = cidr("192.168.43.32/29"), mac = mac("00:00:01:00:00:b2"), user_id=178},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=178, cidr = cidr("192.168.43.40/29"), mac = mac("00:00:01:00:00:b2"), user_id=178},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=179, cidr = cidr("192.168.43.48/29"), mac = mac("00:00:01:00:00:b3"), user_id=179},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=179, cidr = cidr("192.168.43.56/29"), mac = mac("00:00:01:00:00:b3"), user_id=179},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=180, cidr = cidr("192.168.43.64/29"), mac = mac("00:00:01:00:00:b4"), user_id=180},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=180, cidr = cidr("192.168.43.72/29"), mac = mac("00:00:01:00:00:b4"), user_id=180},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=181, cidr = cidr("192.168.43.80/29"), mac = mac("00:00:01:00:00:b5"), user_id=181},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=181, cidr = cidr("192.168.43.88/29"), mac = mac("00:00:01:00:00:b5"), user_id=181},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=182, cidr = cidr("192.168.43.96/29"), mac = mac("00:00:01:00:00:b6"), user_id=182},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=182, cidr = cidr("192.168.43.104/29"), mac = mac("00:00:01:00:00:b6"), user_id=182},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=183, cidr = cidr("192.168.43.112/29"), mac = mac("00:00:01:00:00:b7"), user_id=183},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=183, cidr = cidr("192.168.43.120/29"), mac = mac("00:00:01:00:00:b7"), user_id=183},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=184, cidr = cidr("192.168.43.128/29"), mac = mac("00:00:01:00:00:b8"), user_id=184},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=184, cidr = cidr("192.168.43.136/29"), mac = mac("00:00:01:00:00:b8"), user_id=184},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=185, cidr = cidr("192.168.43.144/29"), mac = mac("00:00:01:00:00:b9"), user_id=185},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=185, cidr = cidr("192.168.43.152/29"), mac = mac("00:00:01:00:00:b9"), user_id=185},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=186, cidr = cidr("192.168.43.160/29"), mac = mac("00:00:01:00:00:ba"), user_id=186},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=186, cidr = cidr("192.168.43.168/29"), mac = mac("00:00:01:00:00:ba"), user_id=186},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=187, cidr = cidr("192.168.43.176/29"), mac = mac("00:00:01:00:00:bb"), user_id=187},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=187, cidr = cidr("192.168.43.184/29"), mac = mac("00:00:01:00:00:bb"), user_id=187},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=188, cidr = cidr("192.168.43.192/29"), mac = mac("00:00:01:00:00:bc"), user_id=188},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=188, cidr = cidr("192.168.43.200/29"), mac = mac("00:00:01:00:00:bc"), user_id=188},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=189, cidr = cidr("192.168.43.208/29"), mac = mac("00:00:01:00:00:bd"), user_id=189},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=189, cidr = cidr("192.168.43.216/29"), mac = mac("00:00:01:00:00:bd"), user_id=189},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=190, cidr = cidr("192.168.43.224/29"), mac = mac("00:00:01:00:00:be"), user_id=190},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=190, cidr = cidr("192.168.43.232/29"), mac = mac("00:00:01:00:00:be"), user_id=190},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=191, cidr = cidr("192.168.43.240/29"), mac = mac("00:00:01:00:00:bf"), user_id=191},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=191, cidr = cidr("192.168.43.248/29"), mac = mac("00:00:01:00:00:bf"), user_id=191},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=192, cidr = cidr("192.168.44.0/29"), mac = mac("00:00:01:00:00:c0"), user_id=192},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=192, cidr = cidr("192.168.44.8/29"), mac = mac("00:00:01:00:00:c0"), user_id=192},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=193, cidr = cidr("192.168.44.16/29"), mac = mac("00:00:01:00:00:c1"), user_id=193},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=193, cidr = cidr("192.168.44.24/29"), mac = mac("00:00:01:00:00:c1"), user_id=193},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=194, cidr = cidr("192.168.44.32/29"), mac = mac("00:00:01:00:00:c2"), user_id=194},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=194, cidr = cidr("192.168.44.40/29"), mac = mac("00:00:01:00:00:c2"), user_id=194},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=195, cidr = cidr("192.168.44.48/29"), mac = mac("00:00:01:00:00:c3"), user_id=195},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=195, cidr = cidr("192.168.44.56/29"), mac = mac("00:00:01:00:00:c3"), user_id=195},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=196, cidr = cidr("192.168.44.64/29"), mac = mac("00:00:01:00:00:c4"), user_id=196},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=196, cidr = cidr("192.168.44.72/29"), mac = mac("00:00:01:00:00:c4"), user_id=196},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=197, cidr = cidr("192.168.44.80/29"), mac = mac("00:00:01:00:00:c5"), user_id=197},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=197, cidr = cidr("192.168.44.88/29"), mac = mac("00:00:01:00:00:c5"), user_id=197},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=198, cidr = cidr("192.168.44.96/29"), mac = mac("00:00:01:00:00:c6"), user_id=198},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=198, cidr = cidr("192.168.44.104/29"), mac = mac("00:00:01:00:00:c6"), user_id=198},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=199, cidr = cidr("192.168.44.112/29"), mac = mac("00:00:01:00:00:c7"), user_id=199},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=199, cidr = cidr("192.168.44.120/29"), mac = mac("00:00:01:00:00:c7"), user_id=199},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=200, cidr = cidr("192.168.44.128/29"), mac = mac("00:00:01:00:00:c8"), user_id=200},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=200, cidr = cidr("192.168.44.136/29"), mac = mac("00:00:01:00:00:c8"), user_id=200},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=201, cidr = cidr("192.168.44.144/29"), mac = mac("00:00:01:00:00:c9"), user_id=201},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=201, cidr = cidr("192.168.44.152/29"), mac = mac("00:00:01:00:00:c9"), user_id=201},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=202, cidr = cidr("192.168.44.160/29"), mac = mac("00:00:01:00:00:ca"), user_id=202},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=202, cidr = cidr("192.168.44.168/29"), mac = mac("00:00:01:00:00:ca"), user_id=202},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=203, cidr = cidr("192.168.44.176/29"), mac = mac("00:00:01:00:00:cb"), user_id=203},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=203, cidr = cidr("192.168.44.184/29"), mac = mac("00:00:01:00:00:cb"), user_id=203},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=204, cidr = cidr("192.168.44.192/29"), mac = mac("00:00:01:00:00:cc"), user_id=204},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=204, cidr = cidr("192.168.44.200/29"), mac = mac("00:00:01:00:00:cc"), user_id=204},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=205, cidr = cidr("192.168.44.208/29"), mac = mac("00:00:01:00:00:cd"), user_id=205},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=205, cidr = cidr("192.168.44.216/29"), mac = mac("00:00:01:00:00:cd"), user_id=205},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=206, cidr = cidr("192.168.44.224/29"), mac = mac("00:00:01:00:00:ce"), user_id=206},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=206, cidr = cidr("192.168.44.232/29"), mac = mac("00:00:01:00:00:ce"), user_id=206},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=207, cidr = cidr("192.168.44.240/29"), mac = mac("00:00:01:00:00:cf"), user_id=207},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=207, cidr = cidr("192.168.44.248/29"), mac = mac("00:00:01:00:00:cf"), user_id=207},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=208, cidr = cidr("192.168.45.0/29"), mac = mac("00:00:01:00:00:d0"), user_id=208},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=208, cidr = cidr("192.168.45.8/29"), mac = mac("00:00:01:00:00:d0"), user_id=208},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=209, cidr = cidr("192.168.45.16/29"), mac = mac("00:00:01:00:00:d1"), user_id=209},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=209, cidr = cidr("192.168.45.24/29"), mac = mac("00:00:01:00:00:d1"), user_id=209},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=210, cidr = cidr("192.168.45.32/29"), mac = mac("00:00:01:00:00:d2"), user_id=210},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=210, cidr = cidr("192.168.45.40/29"), mac = mac("00:00:01:00:00:d2"), user_id=210},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=211, cidr = cidr("192.168.45.48/29"), mac = mac("00:00:01:00:00:d3"), user_id=211},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=211, cidr = cidr("192.168.45.56/29"), mac = mac("00:00:01:00:00:d3"), user_id=211},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=212, cidr = cidr("192.168.45.64/29"), mac = mac("00:00:01:00:00:d4"), user_id=212},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=212, cidr = cidr("192.168.45.72/29"), mac = mac("00:00:01:00:00:d4"), user_id=212},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=213, cidr = cidr("192.168.45.80/29"), mac = mac("00:00:01:00:00:d5"), user_id=213},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=213, cidr = cidr("192.168.45.88/29"), mac = mac("00:00:01:00:00:d5"), user_id=213},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=214, cidr = cidr("192.168.45.96/29"), mac = mac("00:00:01:00:00:d6"), user_id=214},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=214, cidr = cidr("192.168.45.104/29"), mac = mac("00:00:01:00:00:d6"), user_id=214},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=215, cidr = cidr("192.168.45.112/29"), mac = mac("00:00:01:00:00:d7"), user_id=215},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=215, cidr = cidr("192.168.45.120/29"), mac = mac("00:00:01:00:00:d7"), user_id=215},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=216, cidr = cidr("192.168.45.128/29"), mac = mac("00:00:01:00:00:d8"), user_id=216},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=216, cidr = cidr("192.168.45.136/29"), mac = mac("00:00:01:00:00:d8"), user_id=216},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=217, cidr = cidr("192.168.45.144/29"), mac = mac("00:00:01:00:00:d9"), user_id=217},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=217, cidr = cidr("192.168.45.152/29"), mac = mac("00:00:01:00:00:d9"), user_id=217},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=218, cidr = cidr("192.168.45.160/29"), mac = mac("00:00:01:00:00:da"), user_id=218},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=218, cidr = cidr("192.168.45.168/29"), mac = mac("00:00:01:00:00:da"), user_id=218},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=219, cidr = cidr("192.168.45.176/29"), mac = mac("00:00:01:00:00:db"), user_id=219},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=219, cidr = cidr("192.168.45.184/29"), mac = mac("00:00:01:00:00:db"), user_id=219},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=220, cidr = cidr("192.168.45.192/29"), mac = mac("00:00:01:00:00:dc"), user_id=220},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=220, cidr = cidr("192.168.45.200/29"), mac = mac("00:00:01:00:00:dc"), user_id=220},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=221, cidr = cidr("192.168.45.208/29"), mac = mac("00:00:01:00:00:dd"), user_id=221},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=221, cidr = cidr("192.168.45.216/29"), mac = mac("00:00:01:00:00:dd"), user_id=221},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=222, cidr = cidr("192.168.45.224/29"), mac = mac("00:00:01:00:00:de"), user_id=222},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=222, cidr = cidr("192.168.45.232/29"), mac = mac("00:00:01:00:00:de"), user_id=222},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=223, cidr = cidr("192.168.45.240/29"), mac = mac("00:00:01:00:00:df"), user_id=223},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=223, cidr = cidr("192.168.45.248/29"), mac = mac("00:00:01:00:00:df"), user_id=223},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=224, cidr = cidr("192.168.46.0/29"), mac = mac("00:00:01:00:00:e0"), user_id=224},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=224, cidr = cidr("192.168.46.8/29"), mac = mac("00:00:01:00:00:e0"), user_id=224},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=225, cidr = cidr("192.168.46.16/29"), mac = mac("00:00:01:00:00:e1"), user_id=225},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=225, cidr = cidr("192.168.46.24/29"), mac = mac("00:00:01:00:00:e1"), user_id=225},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=226, cidr = cidr("192.168.46.32/29"), mac = mac("00:00:01:00:00:e2"), user_id=226},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=226, cidr = cidr("192.168.46.40/29"), mac = mac("00:00:01:00:00:e2"), user_id=226},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=227, cidr = cidr("192.168.46.48/29"), mac = mac("00:00:01:00:00:e3"), user_id=227},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=227, cidr = cidr("192.168.46.56/29"), mac = mac("00:00:01:00:00:e3"), user_id=227},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=228, cidr = cidr("192.168.46.64/29"), mac = mac("00:00:01:00:00:e4"), user_id=228},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=228, cidr = cidr("192.168.46.72/29"), mac = mac("00:00:01:00:00:e4"), user_id=228},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=229, cidr = cidr("192.168.46.80/29"), mac = mac("00:00:01:00:00:e5"), user_id=229},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=229, cidr = cidr("192.168.46.88/29"), mac = mac("00:00:01:00:00:e5"), user_id=229},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=230, cidr = cidr("192.168.46.96/29"), mac = mac("00:00:01:00:00:e6"), user_id=230},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=230, cidr = cidr("192.168.46.104/29"), mac = mac("00:00:01:00:00:e6"), user_id=230},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=231, cidr = cidr("192.168.46.112/29"), mac = mac("00:00:01:00:00:e7"), user_id=231},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=231, cidr = cidr("192.168.46.120/29"), mac = mac("00:00:01:00:00:e7"), user_id=231},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=232, cidr = cidr("192.168.46.128/29"), mac = mac("00:00:01:00:00:e8"), user_id=232},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=232, cidr = cidr("192.168.46.136/29"), mac = mac("00:00:01:00:00:e8"), user_id=232},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=233, cidr = cidr("192.168.46.144/29"), mac = mac("00:00:01:00:00:e9"), user_id=233},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=233, cidr = cidr("192.168.46.152/29"), mac = mac("00:00:01:00:00:e9"), user_id=233},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=234, cidr = cidr("192.168.46.160/29"), mac = mac("00:00:01:00:00:ea"), user_id=234},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=234, cidr = cidr("192.168.46.168/29"), mac = mac("00:00:01:00:00:ea"), user_id=234},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=235, cidr = cidr("192.168.46.176/29"), mac = mac("00:00:01:00:00:eb"), user_id=235},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=235, cidr = cidr("192.168.46.184/29"), mac = mac("00:00:01:00:00:eb"), user_id=235},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=236, cidr = cidr("192.168.46.192/29"), mac = mac("00:00:01:00:00:ec"), user_id=236},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=236, cidr = cidr("192.168.46.200/29"), mac = mac("00:00:01:00:00:ec"), user_id=236},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=237, cidr = cidr("192.168.46.208/29"), mac = mac("00:00:01:00:00:ed"), user_id=237},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=237, cidr = cidr("192.168.46.216/29"), mac = mac("00:00:01:00:00:ed"), user_id=237},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=238, cidr = cidr("192.168.46.224/29"), mac = mac("00:00:01:00:00:ee"), user_id=238},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=238, cidr = cidr("192.168.46.232/29"), mac = mac("00:00:01:00:00:ee"), user_id=238},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=239, cidr = cidr("192.168.46.240/29"), mac = mac("00:00:01:00:00:ef"), user_id=239},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=239, cidr = cidr("192.168.46.248/29"), mac = mac("00:00:01:00:00:ef"), user_id=239},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=240, cidr = cidr("192.168.47.0/29"), mac = mac("00:00:01:00:00:f0"), user_id=240},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=240, cidr = cidr("192.168.47.8/29"), mac = mac("00:00:01:00:00:f0"), user_id=240},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=241, cidr = cidr("192.168.47.16/29"), mac = mac("00:00:01:00:00:f1"), user_id=241},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=241, cidr = cidr("192.168.47.24/29"), mac = mac("00:00:01:00:00:f1"), user_id=241},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=242, cidr = cidr("192.168.47.32/29"), mac = mac("00:00:01:00:00:f2"), user_id=242},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=242, cidr = cidr("192.168.47.40/29"), mac = mac("00:00:01:00:00:f2"), user_id=242},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=243, cidr = cidr("192.168.47.48/29"), mac = mac("00:00:01:00:00:f3"), user_id=243},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=243, cidr = cidr("192.168.47.56/29"), mac = mac("00:00:01:00:00:f3"), user_id=243},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=244, cidr = cidr("192.168.47.64/29"), mac = mac("00:00:01:00:00:f4"), user_id=244},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=244, cidr = cidr("192.168.47.72/29"), mac = mac("00:00:01:00:00:f4"), user_id=244},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=245, cidr = cidr("192.168.47.80/29"), mac = mac("00:00:01:00:00:f5"), user_id=245},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=245, cidr = cidr("192.168.47.88/29"), mac = mac("00:00:01:00:00:f5"), user_id=245},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=246, cidr = cidr("192.168.47.96/29"), mac = mac("00:00:01:00:00:f6"), user_id=246},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=246, cidr = cidr("192.168.47.104/29"), mac = mac("00:00:01:00:00:f6"), user_id=246},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=247, cidr = cidr("192.168.47.112/29"), mac = mac("00:00:01:00:00:f7"), user_id=247},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=247, cidr = cidr("192.168.47.120/29"), mac = mac("00:00:01:00:00:f7"), user_id=247},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=248, cidr = cidr("192.168.47.128/29"), mac = mac("00:00:01:00:00:f8"), user_id=248},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=248, cidr = cidr("192.168.47.136/29"), mac = mac("00:00:01:00:00:f8"), user_id=248},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=249, cidr = cidr("192.168.47.144/29"), mac = mac("00:00:01:00:00:f9"), user_id=249},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=249, cidr = cidr("192.168.47.152/29"), mac = mac("00:00:01:00:00:f9"), user_id=249},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=250, cidr = cidr("192.168.47.160/29"), mac = mac("00:00:01:00:00:fa"), user_id=250},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=250, cidr = cidr("192.168.47.168/29"), mac = mac("00:00:01:00:00:fa"), user_id=250},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=251, cidr = cidr("192.168.47.176/29"), mac = mac("00:00:01:00:00:fb"), user_id=251},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=251, cidr = cidr("192.168.47.184/29"), mac = mac("00:00:01:00:00:fb"), user_id=251},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=252, cidr = cidr("192.168.47.192/29"), mac = mac("00:00:01:00:00:fc"), user_id=252},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=252, cidr = cidr("192.168.47.200/29"), mac = mac("00:00:01:00:00:fc"), user_id=252},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=253, cidr = cidr("192.168.47.208/29"), mac = mac("00:00:01:00:00:fd"), user_id=253},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=253, cidr = cidr("192.168.47.216/29"), mac = mac("00:00:01:00:00:fd"), user_id=253},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=254, cidr = cidr("192.168.47.224/29"), mac = mac("00:00:01:00:00:fe"), user_id=254},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=254, cidr = cidr("192.168.47.232/29"), mac = mac("00:00:01:00:00:fe"), user_id=254},
+   {dest_id=2, gre_id=0, svlan_id=32, cvlan_id=255, cidr = cidr("192.168.47.240/29"), mac = mac("00:00:01:00:00:ff"), user_id=255},
+   {dest_id=2, gre_id=0, svlan_id=33, cvlan_id=255, cidr = cidr("192.168.47.248/29"), mac = mac("00:00:01:00:00:ff"), user_id=255},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=0, cidr = cidr("192.168.48.0/29"), mac = mac("00:00:01:00:00:00"), user_id=0},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=0, cidr = cidr("192.168.48.8/29"), mac = mac("00:00:01:00:00:00"), user_id=0},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=1, cidr = cidr("192.168.48.16/29"), mac = mac("00:00:01:00:00:01"), user_id=1},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=1, cidr = cidr("192.168.48.24/29"), mac = mac("00:00:01:00:00:01"), user_id=1},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=2, cidr = cidr("192.168.48.32/29"), mac = mac("00:00:01:00:00:02"), user_id=2},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=2, cidr = cidr("192.168.48.40/29"), mac = mac("00:00:01:00:00:02"), user_id=2},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=3, cidr = cidr("192.168.48.48/29"), mac = mac("00:00:01:00:00:03"), user_id=3},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=3, cidr = cidr("192.168.48.56/29"), mac = mac("00:00:01:00:00:03"), user_id=3},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=4, cidr = cidr("192.168.48.64/29"), mac = mac("00:00:01:00:00:04"), user_id=4},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=4, cidr = cidr("192.168.48.72/29"), mac = mac("00:00:01:00:00:04"), user_id=4},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=5, cidr = cidr("192.168.48.80/29"), mac = mac("00:00:01:00:00:05"), user_id=5},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=5, cidr = cidr("192.168.48.88/29"), mac = mac("00:00:01:00:00:05"), user_id=5},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=6, cidr = cidr("192.168.48.96/29"), mac = mac("00:00:01:00:00:06"), user_id=6},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=6, cidr = cidr("192.168.48.104/29"), mac = mac("00:00:01:00:00:06"), user_id=6},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=7, cidr = cidr("192.168.48.112/29"), mac = mac("00:00:01:00:00:07"), user_id=7},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=7, cidr = cidr("192.168.48.120/29"), mac = mac("00:00:01:00:00:07"), user_id=7},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=8, cidr = cidr("192.168.48.128/29"), mac = mac("00:00:01:00:00:08"), user_id=8},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=8, cidr = cidr("192.168.48.136/29"), mac = mac("00:00:01:00:00:08"), user_id=8},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=9, cidr = cidr("192.168.48.144/29"), mac = mac("00:00:01:00:00:09"), user_id=9},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=9, cidr = cidr("192.168.48.152/29"), mac = mac("00:00:01:00:00:09"), user_id=9},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=10, cidr = cidr("192.168.48.160/29"), mac = mac("00:00:01:00:00:0a"), user_id=10},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=10, cidr = cidr("192.168.48.168/29"), mac = mac("00:00:01:00:00:0a"), user_id=10},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=11, cidr = cidr("192.168.48.176/29"), mac = mac("00:00:01:00:00:0b"), user_id=11},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=11, cidr = cidr("192.168.48.184/29"), mac = mac("00:00:01:00:00:0b"), user_id=11},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=12, cidr = cidr("192.168.48.192/29"), mac = mac("00:00:01:00:00:0c"), user_id=12},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=12, cidr = cidr("192.168.48.200/29"), mac = mac("00:00:01:00:00:0c"), user_id=12},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=13, cidr = cidr("192.168.48.208/29"), mac = mac("00:00:01:00:00:0d"), user_id=13},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=13, cidr = cidr("192.168.48.216/29"), mac = mac("00:00:01:00:00:0d"), user_id=13},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=14, cidr = cidr("192.168.48.224/29"), mac = mac("00:00:01:00:00:0e"), user_id=14},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=14, cidr = cidr("192.168.48.232/29"), mac = mac("00:00:01:00:00:0e"), user_id=14},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=15, cidr = cidr("192.168.48.240/29"), mac = mac("00:00:01:00:00:0f"), user_id=15},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=15, cidr = cidr("192.168.48.248/29"), mac = mac("00:00:01:00:00:0f"), user_id=15},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=16, cidr = cidr("192.168.49.0/29"), mac = mac("00:00:01:00:00:10"), user_id=16},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=16, cidr = cidr("192.168.49.8/29"), mac = mac("00:00:01:00:00:10"), user_id=16},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=17, cidr = cidr("192.168.49.16/29"), mac = mac("00:00:01:00:00:11"), user_id=17},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=17, cidr = cidr("192.168.49.24/29"), mac = mac("00:00:01:00:00:11"), user_id=17},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=18, cidr = cidr("192.168.49.32/29"), mac = mac("00:00:01:00:00:12"), user_id=18},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=18, cidr = cidr("192.168.49.40/29"), mac = mac("00:00:01:00:00:12"), user_id=18},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=19, cidr = cidr("192.168.49.48/29"), mac = mac("00:00:01:00:00:13"), user_id=19},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=19, cidr = cidr("192.168.49.56/29"), mac = mac("00:00:01:00:00:13"), user_id=19},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=20, cidr = cidr("192.168.49.64/29"), mac = mac("00:00:01:00:00:14"), user_id=20},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=20, cidr = cidr("192.168.49.72/29"), mac = mac("00:00:01:00:00:14"), user_id=20},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=21, cidr = cidr("192.168.49.80/29"), mac = mac("00:00:01:00:00:15"), user_id=21},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=21, cidr = cidr("192.168.49.88/29"), mac = mac("00:00:01:00:00:15"), user_id=21},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=22, cidr = cidr("192.168.49.96/29"), mac = mac("00:00:01:00:00:16"), user_id=22},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=22, cidr = cidr("192.168.49.104/29"), mac = mac("00:00:01:00:00:16"), user_id=22},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=23, cidr = cidr("192.168.49.112/29"), mac = mac("00:00:01:00:00:17"), user_id=23},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=23, cidr = cidr("192.168.49.120/29"), mac = mac("00:00:01:00:00:17"), user_id=23},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=24, cidr = cidr("192.168.49.128/29"), mac = mac("00:00:01:00:00:18"), user_id=24},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=24, cidr = cidr("192.168.49.136/29"), mac = mac("00:00:01:00:00:18"), user_id=24},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=25, cidr = cidr("192.168.49.144/29"), mac = mac("00:00:01:00:00:19"), user_id=25},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=25, cidr = cidr("192.168.49.152/29"), mac = mac("00:00:01:00:00:19"), user_id=25},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=26, cidr = cidr("192.168.49.160/29"), mac = mac("00:00:01:00:00:1a"), user_id=26},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=26, cidr = cidr("192.168.49.168/29"), mac = mac("00:00:01:00:00:1a"), user_id=26},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=27, cidr = cidr("192.168.49.176/29"), mac = mac("00:00:01:00:00:1b"), user_id=27},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=27, cidr = cidr("192.168.49.184/29"), mac = mac("00:00:01:00:00:1b"), user_id=27},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=28, cidr = cidr("192.168.49.192/29"), mac = mac("00:00:01:00:00:1c"), user_id=28},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=28, cidr = cidr("192.168.49.200/29"), mac = mac("00:00:01:00:00:1c"), user_id=28},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=29, cidr = cidr("192.168.49.208/29"), mac = mac("00:00:01:00:00:1d"), user_id=29},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=29, cidr = cidr("192.168.49.216/29"), mac = mac("00:00:01:00:00:1d"), user_id=29},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=30, cidr = cidr("192.168.49.224/29"), mac = mac("00:00:01:00:00:1e"), user_id=30},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=30, cidr = cidr("192.168.49.232/29"), mac = mac("00:00:01:00:00:1e"), user_id=30},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=31, cidr = cidr("192.168.49.240/29"), mac = mac("00:00:01:00:00:1f"), user_id=31},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=31, cidr = cidr("192.168.49.248/29"), mac = mac("00:00:01:00:00:1f"), user_id=31},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=32, cidr = cidr("192.168.50.0/29"), mac = mac("00:00:01:00:00:20"), user_id=32},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=32, cidr = cidr("192.168.50.8/29"), mac = mac("00:00:01:00:00:20"), user_id=32},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=33, cidr = cidr("192.168.50.16/29"), mac = mac("00:00:01:00:00:21"), user_id=33},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=33, cidr = cidr("192.168.50.24/29"), mac = mac("00:00:01:00:00:21"), user_id=33},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=34, cidr = cidr("192.168.50.32/29"), mac = mac("00:00:01:00:00:22"), user_id=34},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=34, cidr = cidr("192.168.50.40/29"), mac = mac("00:00:01:00:00:22"), user_id=34},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=35, cidr = cidr("192.168.50.48/29"), mac = mac("00:00:01:00:00:23"), user_id=35},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=35, cidr = cidr("192.168.50.56/29"), mac = mac("00:00:01:00:00:23"), user_id=35},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=36, cidr = cidr("192.168.50.64/29"), mac = mac("00:00:01:00:00:24"), user_id=36},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=36, cidr = cidr("192.168.50.72/29"), mac = mac("00:00:01:00:00:24"), user_id=36},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=37, cidr = cidr("192.168.50.80/29"), mac = mac("00:00:01:00:00:25"), user_id=37},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=37, cidr = cidr("192.168.50.88/29"), mac = mac("00:00:01:00:00:25"), user_id=37},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=38, cidr = cidr("192.168.50.96/29"), mac = mac("00:00:01:00:00:26"), user_id=38},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=38, cidr = cidr("192.168.50.104/29"), mac = mac("00:00:01:00:00:26"), user_id=38},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=39, cidr = cidr("192.168.50.112/29"), mac = mac("00:00:01:00:00:27"), user_id=39},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=39, cidr = cidr("192.168.50.120/29"), mac = mac("00:00:01:00:00:27"), user_id=39},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=40, cidr = cidr("192.168.50.128/29"), mac = mac("00:00:01:00:00:28"), user_id=40},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=40, cidr = cidr("192.168.50.136/29"), mac = mac("00:00:01:00:00:28"), user_id=40},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=41, cidr = cidr("192.168.50.144/29"), mac = mac("00:00:01:00:00:29"), user_id=41},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=41, cidr = cidr("192.168.50.152/29"), mac = mac("00:00:01:00:00:29"), user_id=41},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=42, cidr = cidr("192.168.50.160/29"), mac = mac("00:00:01:00:00:2a"), user_id=42},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=42, cidr = cidr("192.168.50.168/29"), mac = mac("00:00:01:00:00:2a"), user_id=42},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=43, cidr = cidr("192.168.50.176/29"), mac = mac("00:00:01:00:00:2b"), user_id=43},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=43, cidr = cidr("192.168.50.184/29"), mac = mac("00:00:01:00:00:2b"), user_id=43},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=44, cidr = cidr("192.168.50.192/29"), mac = mac("00:00:01:00:00:2c"), user_id=44},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=44, cidr = cidr("192.168.50.200/29"), mac = mac("00:00:01:00:00:2c"), user_id=44},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=45, cidr = cidr("192.168.50.208/29"), mac = mac("00:00:01:00:00:2d"), user_id=45},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=45, cidr = cidr("192.168.50.216/29"), mac = mac("00:00:01:00:00:2d"), user_id=45},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=46, cidr = cidr("192.168.50.224/29"), mac = mac("00:00:01:00:00:2e"), user_id=46},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=46, cidr = cidr("192.168.50.232/29"), mac = mac("00:00:01:00:00:2e"), user_id=46},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=47, cidr = cidr("192.168.50.240/29"), mac = mac("00:00:01:00:00:2f"), user_id=47},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=47, cidr = cidr("192.168.50.248/29"), mac = mac("00:00:01:00:00:2f"), user_id=47},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=48, cidr = cidr("192.168.51.0/29"), mac = mac("00:00:01:00:00:30"), user_id=48},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=48, cidr = cidr("192.168.51.8/29"), mac = mac("00:00:01:00:00:30"), user_id=48},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=49, cidr = cidr("192.168.51.16/29"), mac = mac("00:00:01:00:00:31"), user_id=49},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=49, cidr = cidr("192.168.51.24/29"), mac = mac("00:00:01:00:00:31"), user_id=49},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=50, cidr = cidr("192.168.51.32/29"), mac = mac("00:00:01:00:00:32"), user_id=50},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=50, cidr = cidr("192.168.51.40/29"), mac = mac("00:00:01:00:00:32"), user_id=50},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=51, cidr = cidr("192.168.51.48/29"), mac = mac("00:00:01:00:00:33"), user_id=51},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=51, cidr = cidr("192.168.51.56/29"), mac = mac("00:00:01:00:00:33"), user_id=51},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=52, cidr = cidr("192.168.51.64/29"), mac = mac("00:00:01:00:00:34"), user_id=52},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=52, cidr = cidr("192.168.51.72/29"), mac = mac("00:00:01:00:00:34"), user_id=52},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=53, cidr = cidr("192.168.51.80/29"), mac = mac("00:00:01:00:00:35"), user_id=53},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=53, cidr = cidr("192.168.51.88/29"), mac = mac("00:00:01:00:00:35"), user_id=53},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=54, cidr = cidr("192.168.51.96/29"), mac = mac("00:00:01:00:00:36"), user_id=54},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=54, cidr = cidr("192.168.51.104/29"), mac = mac("00:00:01:00:00:36"), user_id=54},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=55, cidr = cidr("192.168.51.112/29"), mac = mac("00:00:01:00:00:37"), user_id=55},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=55, cidr = cidr("192.168.51.120/29"), mac = mac("00:00:01:00:00:37"), user_id=55},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=56, cidr = cidr("192.168.51.128/29"), mac = mac("00:00:01:00:00:38"), user_id=56},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=56, cidr = cidr("192.168.51.136/29"), mac = mac("00:00:01:00:00:38"), user_id=56},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=57, cidr = cidr("192.168.51.144/29"), mac = mac("00:00:01:00:00:39"), user_id=57},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=57, cidr = cidr("192.168.51.152/29"), mac = mac("00:00:01:00:00:39"), user_id=57},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=58, cidr = cidr("192.168.51.160/29"), mac = mac("00:00:01:00:00:3a"), user_id=58},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=58, cidr = cidr("192.168.51.168/29"), mac = mac("00:00:01:00:00:3a"), user_id=58},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=59, cidr = cidr("192.168.51.176/29"), mac = mac("00:00:01:00:00:3b"), user_id=59},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=59, cidr = cidr("192.168.51.184/29"), mac = mac("00:00:01:00:00:3b"), user_id=59},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=60, cidr = cidr("192.168.51.192/29"), mac = mac("00:00:01:00:00:3c"), user_id=60},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=60, cidr = cidr("192.168.51.200/29"), mac = mac("00:00:01:00:00:3c"), user_id=60},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=61, cidr = cidr("192.168.51.208/29"), mac = mac("00:00:01:00:00:3d"), user_id=61},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=61, cidr = cidr("192.168.51.216/29"), mac = mac("00:00:01:00:00:3d"), user_id=61},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=62, cidr = cidr("192.168.51.224/29"), mac = mac("00:00:01:00:00:3e"), user_id=62},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=62, cidr = cidr("192.168.51.232/29"), mac = mac("00:00:01:00:00:3e"), user_id=62},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=63, cidr = cidr("192.168.51.240/29"), mac = mac("00:00:01:00:00:3f"), user_id=63},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=63, cidr = cidr("192.168.51.248/29"), mac = mac("00:00:01:00:00:3f"), user_id=63},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=64, cidr = cidr("192.168.52.0/29"), mac = mac("00:00:01:00:00:40"), user_id=64},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=64, cidr = cidr("192.168.52.8/29"), mac = mac("00:00:01:00:00:40"), user_id=64},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=65, cidr = cidr("192.168.52.16/29"), mac = mac("00:00:01:00:00:41"), user_id=65},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=65, cidr = cidr("192.168.52.24/29"), mac = mac("00:00:01:00:00:41"), user_id=65},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=66, cidr = cidr("192.168.52.32/29"), mac = mac("00:00:01:00:00:42"), user_id=66},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=66, cidr = cidr("192.168.52.40/29"), mac = mac("00:00:01:00:00:42"), user_id=66},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=67, cidr = cidr("192.168.52.48/29"), mac = mac("00:00:01:00:00:43"), user_id=67},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=67, cidr = cidr("192.168.52.56/29"), mac = mac("00:00:01:00:00:43"), user_id=67},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=68, cidr = cidr("192.168.52.64/29"), mac = mac("00:00:01:00:00:44"), user_id=68},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=68, cidr = cidr("192.168.52.72/29"), mac = mac("00:00:01:00:00:44"), user_id=68},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=69, cidr = cidr("192.168.52.80/29"), mac = mac("00:00:01:00:00:45"), user_id=69},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=69, cidr = cidr("192.168.52.88/29"), mac = mac("00:00:01:00:00:45"), user_id=69},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=70, cidr = cidr("192.168.52.96/29"), mac = mac("00:00:01:00:00:46"), user_id=70},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=70, cidr = cidr("192.168.52.104/29"), mac = mac("00:00:01:00:00:46"), user_id=70},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=71, cidr = cidr("192.168.52.112/29"), mac = mac("00:00:01:00:00:47"), user_id=71},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=71, cidr = cidr("192.168.52.120/29"), mac = mac("00:00:01:00:00:47"), user_id=71},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=72, cidr = cidr("192.168.52.128/29"), mac = mac("00:00:01:00:00:48"), user_id=72},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=72, cidr = cidr("192.168.52.136/29"), mac = mac("00:00:01:00:00:48"), user_id=72},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=73, cidr = cidr("192.168.52.144/29"), mac = mac("00:00:01:00:00:49"), user_id=73},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=73, cidr = cidr("192.168.52.152/29"), mac = mac("00:00:01:00:00:49"), user_id=73},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=74, cidr = cidr("192.168.52.160/29"), mac = mac("00:00:01:00:00:4a"), user_id=74},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=74, cidr = cidr("192.168.52.168/29"), mac = mac("00:00:01:00:00:4a"), user_id=74},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=75, cidr = cidr("192.168.52.176/29"), mac = mac("00:00:01:00:00:4b"), user_id=75},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=75, cidr = cidr("192.168.52.184/29"), mac = mac("00:00:01:00:00:4b"), user_id=75},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=76, cidr = cidr("192.168.52.192/29"), mac = mac("00:00:01:00:00:4c"), user_id=76},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=76, cidr = cidr("192.168.52.200/29"), mac = mac("00:00:01:00:00:4c"), user_id=76},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=77, cidr = cidr("192.168.52.208/29"), mac = mac("00:00:01:00:00:4d"), user_id=77},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=77, cidr = cidr("192.168.52.216/29"), mac = mac("00:00:01:00:00:4d"), user_id=77},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=78, cidr = cidr("192.168.52.224/29"), mac = mac("00:00:01:00:00:4e"), user_id=78},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=78, cidr = cidr("192.168.52.232/29"), mac = mac("00:00:01:00:00:4e"), user_id=78},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=79, cidr = cidr("192.168.52.240/29"), mac = mac("00:00:01:00:00:4f"), user_id=79},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=79, cidr = cidr("192.168.52.248/29"), mac = mac("00:00:01:00:00:4f"), user_id=79},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=80, cidr = cidr("192.168.53.0/29"), mac = mac("00:00:01:00:00:50"), user_id=80},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=80, cidr = cidr("192.168.53.8/29"), mac = mac("00:00:01:00:00:50"), user_id=80},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=81, cidr = cidr("192.168.53.16/29"), mac = mac("00:00:01:00:00:51"), user_id=81},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=81, cidr = cidr("192.168.53.24/29"), mac = mac("00:00:01:00:00:51"), user_id=81},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=82, cidr = cidr("192.168.53.32/29"), mac = mac("00:00:01:00:00:52"), user_id=82},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=82, cidr = cidr("192.168.53.40/29"), mac = mac("00:00:01:00:00:52"), user_id=82},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=83, cidr = cidr("192.168.53.48/29"), mac = mac("00:00:01:00:00:53"), user_id=83},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=83, cidr = cidr("192.168.53.56/29"), mac = mac("00:00:01:00:00:53"), user_id=83},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=84, cidr = cidr("192.168.53.64/29"), mac = mac("00:00:01:00:00:54"), user_id=84},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=84, cidr = cidr("192.168.53.72/29"), mac = mac("00:00:01:00:00:54"), user_id=84},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=85, cidr = cidr("192.168.53.80/29"), mac = mac("00:00:01:00:00:55"), user_id=85},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=85, cidr = cidr("192.168.53.88/29"), mac = mac("00:00:01:00:00:55"), user_id=85},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=86, cidr = cidr("192.168.53.96/29"), mac = mac("00:00:01:00:00:56"), user_id=86},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=86, cidr = cidr("192.168.53.104/29"), mac = mac("00:00:01:00:00:56"), user_id=86},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=87, cidr = cidr("192.168.53.112/29"), mac = mac("00:00:01:00:00:57"), user_id=87},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=87, cidr = cidr("192.168.53.120/29"), mac = mac("00:00:01:00:00:57"), user_id=87},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=88, cidr = cidr("192.168.53.128/29"), mac = mac("00:00:01:00:00:58"), user_id=88},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=88, cidr = cidr("192.168.53.136/29"), mac = mac("00:00:01:00:00:58"), user_id=88},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=89, cidr = cidr("192.168.53.144/29"), mac = mac("00:00:01:00:00:59"), user_id=89},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=89, cidr = cidr("192.168.53.152/29"), mac = mac("00:00:01:00:00:59"), user_id=89},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=90, cidr = cidr("192.168.53.160/29"), mac = mac("00:00:01:00:00:5a"), user_id=90},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=90, cidr = cidr("192.168.53.168/29"), mac = mac("00:00:01:00:00:5a"), user_id=90},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=91, cidr = cidr("192.168.53.176/29"), mac = mac("00:00:01:00:00:5b"), user_id=91},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=91, cidr = cidr("192.168.53.184/29"), mac = mac("00:00:01:00:00:5b"), user_id=91},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=92, cidr = cidr("192.168.53.192/29"), mac = mac("00:00:01:00:00:5c"), user_id=92},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=92, cidr = cidr("192.168.53.200/29"), mac = mac("00:00:01:00:00:5c"), user_id=92},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=93, cidr = cidr("192.168.53.208/29"), mac = mac("00:00:01:00:00:5d"), user_id=93},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=93, cidr = cidr("192.168.53.216/29"), mac = mac("00:00:01:00:00:5d"), user_id=93},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=94, cidr = cidr("192.168.53.224/29"), mac = mac("00:00:01:00:00:5e"), user_id=94},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=94, cidr = cidr("192.168.53.232/29"), mac = mac("00:00:01:00:00:5e"), user_id=94},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=95, cidr = cidr("192.168.53.240/29"), mac = mac("00:00:01:00:00:5f"), user_id=95},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=95, cidr = cidr("192.168.53.248/29"), mac = mac("00:00:01:00:00:5f"), user_id=95},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=96, cidr = cidr("192.168.54.0/29"), mac = mac("00:00:01:00:00:60"), user_id=96},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=96, cidr = cidr("192.168.54.8/29"), mac = mac("00:00:01:00:00:60"), user_id=96},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=97, cidr = cidr("192.168.54.16/29"), mac = mac("00:00:01:00:00:61"), user_id=97},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=97, cidr = cidr("192.168.54.24/29"), mac = mac("00:00:01:00:00:61"), user_id=97},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=98, cidr = cidr("192.168.54.32/29"), mac = mac("00:00:01:00:00:62"), user_id=98},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=98, cidr = cidr("192.168.54.40/29"), mac = mac("00:00:01:00:00:62"), user_id=98},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=99, cidr = cidr("192.168.54.48/29"), mac = mac("00:00:01:00:00:63"), user_id=99},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=99, cidr = cidr("192.168.54.56/29"), mac = mac("00:00:01:00:00:63"), user_id=99},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=100, cidr = cidr("192.168.54.64/29"), mac = mac("00:00:01:00:00:64"), user_id=100},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=100, cidr = cidr("192.168.54.72/29"), mac = mac("00:00:01:00:00:64"), user_id=100},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=101, cidr = cidr("192.168.54.80/29"), mac = mac("00:00:01:00:00:65"), user_id=101},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=101, cidr = cidr("192.168.54.88/29"), mac = mac("00:00:01:00:00:65"), user_id=101},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=102, cidr = cidr("192.168.54.96/29"), mac = mac("00:00:01:00:00:66"), user_id=102},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=102, cidr = cidr("192.168.54.104/29"), mac = mac("00:00:01:00:00:66"), user_id=102},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=103, cidr = cidr("192.168.54.112/29"), mac = mac("00:00:01:00:00:67"), user_id=103},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=103, cidr = cidr("192.168.54.120/29"), mac = mac("00:00:01:00:00:67"), user_id=103},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=104, cidr = cidr("192.168.54.128/29"), mac = mac("00:00:01:00:00:68"), user_id=104},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=104, cidr = cidr("192.168.54.136/29"), mac = mac("00:00:01:00:00:68"), user_id=104},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=105, cidr = cidr("192.168.54.144/29"), mac = mac("00:00:01:00:00:69"), user_id=105},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=105, cidr = cidr("192.168.54.152/29"), mac = mac("00:00:01:00:00:69"), user_id=105},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=106, cidr = cidr("192.168.54.160/29"), mac = mac("00:00:01:00:00:6a"), user_id=106},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=106, cidr = cidr("192.168.54.168/29"), mac = mac("00:00:01:00:00:6a"), user_id=106},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=107, cidr = cidr("192.168.54.176/29"), mac = mac("00:00:01:00:00:6b"), user_id=107},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=107, cidr = cidr("192.168.54.184/29"), mac = mac("00:00:01:00:00:6b"), user_id=107},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=108, cidr = cidr("192.168.54.192/29"), mac = mac("00:00:01:00:00:6c"), user_id=108},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=108, cidr = cidr("192.168.54.200/29"), mac = mac("00:00:01:00:00:6c"), user_id=108},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=109, cidr = cidr("192.168.54.208/29"), mac = mac("00:00:01:00:00:6d"), user_id=109},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=109, cidr = cidr("192.168.54.216/29"), mac = mac("00:00:01:00:00:6d"), user_id=109},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=110, cidr = cidr("192.168.54.224/29"), mac = mac("00:00:01:00:00:6e"), user_id=110},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=110, cidr = cidr("192.168.54.232/29"), mac = mac("00:00:01:00:00:6e"), user_id=110},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=111, cidr = cidr("192.168.54.240/29"), mac = mac("00:00:01:00:00:6f"), user_id=111},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=111, cidr = cidr("192.168.54.248/29"), mac = mac("00:00:01:00:00:6f"), user_id=111},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=112, cidr = cidr("192.168.55.0/29"), mac = mac("00:00:01:00:00:70"), user_id=112},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=112, cidr = cidr("192.168.55.8/29"), mac = mac("00:00:01:00:00:70"), user_id=112},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=113, cidr = cidr("192.168.55.16/29"), mac = mac("00:00:01:00:00:71"), user_id=113},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=113, cidr = cidr("192.168.55.24/29"), mac = mac("00:00:01:00:00:71"), user_id=113},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=114, cidr = cidr("192.168.55.32/29"), mac = mac("00:00:01:00:00:72"), user_id=114},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=114, cidr = cidr("192.168.55.40/29"), mac = mac("00:00:01:00:00:72"), user_id=114},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=115, cidr = cidr("192.168.55.48/29"), mac = mac("00:00:01:00:00:73"), user_id=115},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=115, cidr = cidr("192.168.55.56/29"), mac = mac("00:00:01:00:00:73"), user_id=115},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=116, cidr = cidr("192.168.55.64/29"), mac = mac("00:00:01:00:00:74"), user_id=116},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=116, cidr = cidr("192.168.55.72/29"), mac = mac("00:00:01:00:00:74"), user_id=116},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=117, cidr = cidr("192.168.55.80/29"), mac = mac("00:00:01:00:00:75"), user_id=117},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=117, cidr = cidr("192.168.55.88/29"), mac = mac("00:00:01:00:00:75"), user_id=117},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=118, cidr = cidr("192.168.55.96/29"), mac = mac("00:00:01:00:00:76"), user_id=118},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=118, cidr = cidr("192.168.55.104/29"), mac = mac("00:00:01:00:00:76"), user_id=118},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=119, cidr = cidr("192.168.55.112/29"), mac = mac("00:00:01:00:00:77"), user_id=119},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=119, cidr = cidr("192.168.55.120/29"), mac = mac("00:00:01:00:00:77"), user_id=119},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=120, cidr = cidr("192.168.55.128/29"), mac = mac("00:00:01:00:00:78"), user_id=120},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=120, cidr = cidr("192.168.55.136/29"), mac = mac("00:00:01:00:00:78"), user_id=120},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=121, cidr = cidr("192.168.55.144/29"), mac = mac("00:00:01:00:00:79"), user_id=121},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=121, cidr = cidr("192.168.55.152/29"), mac = mac("00:00:01:00:00:79"), user_id=121},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=122, cidr = cidr("192.168.55.160/29"), mac = mac("00:00:01:00:00:7a"), user_id=122},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=122, cidr = cidr("192.168.55.168/29"), mac = mac("00:00:01:00:00:7a"), user_id=122},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=123, cidr = cidr("192.168.55.176/29"), mac = mac("00:00:01:00:00:7b"), user_id=123},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=123, cidr = cidr("192.168.55.184/29"), mac = mac("00:00:01:00:00:7b"), user_id=123},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=124, cidr = cidr("192.168.55.192/29"), mac = mac("00:00:01:00:00:7c"), user_id=124},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=124, cidr = cidr("192.168.55.200/29"), mac = mac("00:00:01:00:00:7c"), user_id=124},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=125, cidr = cidr("192.168.55.208/29"), mac = mac("00:00:01:00:00:7d"), user_id=125},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=125, cidr = cidr("192.168.55.216/29"), mac = mac("00:00:01:00:00:7d"), user_id=125},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=126, cidr = cidr("192.168.55.224/29"), mac = mac("00:00:01:00:00:7e"), user_id=126},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=126, cidr = cidr("192.168.55.232/29"), mac = mac("00:00:01:00:00:7e"), user_id=126},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=127, cidr = cidr("192.168.55.240/29"), mac = mac("00:00:01:00:00:7f"), user_id=127},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=127, cidr = cidr("192.168.55.248/29"), mac = mac("00:00:01:00:00:7f"), user_id=127},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=128, cidr = cidr("192.168.56.0/29"), mac = mac("00:00:01:00:00:80"), user_id=128},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=128, cidr = cidr("192.168.56.8/29"), mac = mac("00:00:01:00:00:80"), user_id=128},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=129, cidr = cidr("192.168.56.16/29"), mac = mac("00:00:01:00:00:81"), user_id=129},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=129, cidr = cidr("192.168.56.24/29"), mac = mac("00:00:01:00:00:81"), user_id=129},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=130, cidr = cidr("192.168.56.32/29"), mac = mac("00:00:01:00:00:82"), user_id=130},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=130, cidr = cidr("192.168.56.40/29"), mac = mac("00:00:01:00:00:82"), user_id=130},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=131, cidr = cidr("192.168.56.48/29"), mac = mac("00:00:01:00:00:83"), user_id=131},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=131, cidr = cidr("192.168.56.56/29"), mac = mac("00:00:01:00:00:83"), user_id=131},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=132, cidr = cidr("192.168.56.64/29"), mac = mac("00:00:01:00:00:84"), user_id=132},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=132, cidr = cidr("192.168.56.72/29"), mac = mac("00:00:01:00:00:84"), user_id=132},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=133, cidr = cidr("192.168.56.80/29"), mac = mac("00:00:01:00:00:85"), user_id=133},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=133, cidr = cidr("192.168.56.88/29"), mac = mac("00:00:01:00:00:85"), user_id=133},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=134, cidr = cidr("192.168.56.96/29"), mac = mac("00:00:01:00:00:86"), user_id=134},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=134, cidr = cidr("192.168.56.104/29"), mac = mac("00:00:01:00:00:86"), user_id=134},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=135, cidr = cidr("192.168.56.112/29"), mac = mac("00:00:01:00:00:87"), user_id=135},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=135, cidr = cidr("192.168.56.120/29"), mac = mac("00:00:01:00:00:87"), user_id=135},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=136, cidr = cidr("192.168.56.128/29"), mac = mac("00:00:01:00:00:88"), user_id=136},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=136, cidr = cidr("192.168.56.136/29"), mac = mac("00:00:01:00:00:88"), user_id=136},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=137, cidr = cidr("192.168.56.144/29"), mac = mac("00:00:01:00:00:89"), user_id=137},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=137, cidr = cidr("192.168.56.152/29"), mac = mac("00:00:01:00:00:89"), user_id=137},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=138, cidr = cidr("192.168.56.160/29"), mac = mac("00:00:01:00:00:8a"), user_id=138},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=138, cidr = cidr("192.168.56.168/29"), mac = mac("00:00:01:00:00:8a"), user_id=138},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=139, cidr = cidr("192.168.56.176/29"), mac = mac("00:00:01:00:00:8b"), user_id=139},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=139, cidr = cidr("192.168.56.184/29"), mac = mac("00:00:01:00:00:8b"), user_id=139},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=140, cidr = cidr("192.168.56.192/29"), mac = mac("00:00:01:00:00:8c"), user_id=140},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=140, cidr = cidr("192.168.56.200/29"), mac = mac("00:00:01:00:00:8c"), user_id=140},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=141, cidr = cidr("192.168.56.208/29"), mac = mac("00:00:01:00:00:8d"), user_id=141},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=141, cidr = cidr("192.168.56.216/29"), mac = mac("00:00:01:00:00:8d"), user_id=141},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=142, cidr = cidr("192.168.56.224/29"), mac = mac("00:00:01:00:00:8e"), user_id=142},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=142, cidr = cidr("192.168.56.232/29"), mac = mac("00:00:01:00:00:8e"), user_id=142},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=143, cidr = cidr("192.168.56.240/29"), mac = mac("00:00:01:00:00:8f"), user_id=143},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=143, cidr = cidr("192.168.56.248/29"), mac = mac("00:00:01:00:00:8f"), user_id=143},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=144, cidr = cidr("192.168.57.0/29"), mac = mac("00:00:01:00:00:90"), user_id=144},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=144, cidr = cidr("192.168.57.8/29"), mac = mac("00:00:01:00:00:90"), user_id=144},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=145, cidr = cidr("192.168.57.16/29"), mac = mac("00:00:01:00:00:91"), user_id=145},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=145, cidr = cidr("192.168.57.24/29"), mac = mac("00:00:01:00:00:91"), user_id=145},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=146, cidr = cidr("192.168.57.32/29"), mac = mac("00:00:01:00:00:92"), user_id=146},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=146, cidr = cidr("192.168.57.40/29"), mac = mac("00:00:01:00:00:92"), user_id=146},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=147, cidr = cidr("192.168.57.48/29"), mac = mac("00:00:01:00:00:93"), user_id=147},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=147, cidr = cidr("192.168.57.56/29"), mac = mac("00:00:01:00:00:93"), user_id=147},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=148, cidr = cidr("192.168.57.64/29"), mac = mac("00:00:01:00:00:94"), user_id=148},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=148, cidr = cidr("192.168.57.72/29"), mac = mac("00:00:01:00:00:94"), user_id=148},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=149, cidr = cidr("192.168.57.80/29"), mac = mac("00:00:01:00:00:95"), user_id=149},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=149, cidr = cidr("192.168.57.88/29"), mac = mac("00:00:01:00:00:95"), user_id=149},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=150, cidr = cidr("192.168.57.96/29"), mac = mac("00:00:01:00:00:96"), user_id=150},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=150, cidr = cidr("192.168.57.104/29"), mac = mac("00:00:01:00:00:96"), user_id=150},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=151, cidr = cidr("192.168.57.112/29"), mac = mac("00:00:01:00:00:97"), user_id=151},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=151, cidr = cidr("192.168.57.120/29"), mac = mac("00:00:01:00:00:97"), user_id=151},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=152, cidr = cidr("192.168.57.128/29"), mac = mac("00:00:01:00:00:98"), user_id=152},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=152, cidr = cidr("192.168.57.136/29"), mac = mac("00:00:01:00:00:98"), user_id=152},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=153, cidr = cidr("192.168.57.144/29"), mac = mac("00:00:01:00:00:99"), user_id=153},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=153, cidr = cidr("192.168.57.152/29"), mac = mac("00:00:01:00:00:99"), user_id=153},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=154, cidr = cidr("192.168.57.160/29"), mac = mac("00:00:01:00:00:9a"), user_id=154},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=154, cidr = cidr("192.168.57.168/29"), mac = mac("00:00:01:00:00:9a"), user_id=154},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=155, cidr = cidr("192.168.57.176/29"), mac = mac("00:00:01:00:00:9b"), user_id=155},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=155, cidr = cidr("192.168.57.184/29"), mac = mac("00:00:01:00:00:9b"), user_id=155},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=156, cidr = cidr("192.168.57.192/29"), mac = mac("00:00:01:00:00:9c"), user_id=156},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=156, cidr = cidr("192.168.57.200/29"), mac = mac("00:00:01:00:00:9c"), user_id=156},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=157, cidr = cidr("192.168.57.208/29"), mac = mac("00:00:01:00:00:9d"), user_id=157},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=157, cidr = cidr("192.168.57.216/29"), mac = mac("00:00:01:00:00:9d"), user_id=157},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=158, cidr = cidr("192.168.57.224/29"), mac = mac("00:00:01:00:00:9e"), user_id=158},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=158, cidr = cidr("192.168.57.232/29"), mac = mac("00:00:01:00:00:9e"), user_id=158},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=159, cidr = cidr("192.168.57.240/29"), mac = mac("00:00:01:00:00:9f"), user_id=159},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=159, cidr = cidr("192.168.57.248/29"), mac = mac("00:00:01:00:00:9f"), user_id=159},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=160, cidr = cidr("192.168.58.0/29"), mac = mac("00:00:01:00:00:a0"), user_id=160},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=160, cidr = cidr("192.168.58.8/29"), mac = mac("00:00:01:00:00:a0"), user_id=160},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=161, cidr = cidr("192.168.58.16/29"), mac = mac("00:00:01:00:00:a1"), user_id=161},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=161, cidr = cidr("192.168.58.24/29"), mac = mac("00:00:01:00:00:a1"), user_id=161},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=162, cidr = cidr("192.168.58.32/29"), mac = mac("00:00:01:00:00:a2"), user_id=162},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=162, cidr = cidr("192.168.58.40/29"), mac = mac("00:00:01:00:00:a2"), user_id=162},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=163, cidr = cidr("192.168.58.48/29"), mac = mac("00:00:01:00:00:a3"), user_id=163},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=163, cidr = cidr("192.168.58.56/29"), mac = mac("00:00:01:00:00:a3"), user_id=163},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=164, cidr = cidr("192.168.58.64/29"), mac = mac("00:00:01:00:00:a4"), user_id=164},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=164, cidr = cidr("192.168.58.72/29"), mac = mac("00:00:01:00:00:a4"), user_id=164},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=165, cidr = cidr("192.168.58.80/29"), mac = mac("00:00:01:00:00:a5"), user_id=165},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=165, cidr = cidr("192.168.58.88/29"), mac = mac("00:00:01:00:00:a5"), user_id=165},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=166, cidr = cidr("192.168.58.96/29"), mac = mac("00:00:01:00:00:a6"), user_id=166},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=166, cidr = cidr("192.168.58.104/29"), mac = mac("00:00:01:00:00:a6"), user_id=166},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=167, cidr = cidr("192.168.58.112/29"), mac = mac("00:00:01:00:00:a7"), user_id=167},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=167, cidr = cidr("192.168.58.120/29"), mac = mac("00:00:01:00:00:a7"), user_id=167},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=168, cidr = cidr("192.168.58.128/29"), mac = mac("00:00:01:00:00:a8"), user_id=168},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=168, cidr = cidr("192.168.58.136/29"), mac = mac("00:00:01:00:00:a8"), user_id=168},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=169, cidr = cidr("192.168.58.144/29"), mac = mac("00:00:01:00:00:a9"), user_id=169},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=169, cidr = cidr("192.168.58.152/29"), mac = mac("00:00:01:00:00:a9"), user_id=169},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=170, cidr = cidr("192.168.58.160/29"), mac = mac("00:00:01:00:00:aa"), user_id=170},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=170, cidr = cidr("192.168.58.168/29"), mac = mac("00:00:01:00:00:aa"), user_id=170},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=171, cidr = cidr("192.168.58.176/29"), mac = mac("00:00:01:00:00:ab"), user_id=171},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=171, cidr = cidr("192.168.58.184/29"), mac = mac("00:00:01:00:00:ab"), user_id=171},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=172, cidr = cidr("192.168.58.192/29"), mac = mac("00:00:01:00:00:ac"), user_id=172},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=172, cidr = cidr("192.168.58.200/29"), mac = mac("00:00:01:00:00:ac"), user_id=172},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=173, cidr = cidr("192.168.58.208/29"), mac = mac("00:00:01:00:00:ad"), user_id=173},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=173, cidr = cidr("192.168.58.216/29"), mac = mac("00:00:01:00:00:ad"), user_id=173},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=174, cidr = cidr("192.168.58.224/29"), mac = mac("00:00:01:00:00:ae"), user_id=174},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=174, cidr = cidr("192.168.58.232/29"), mac = mac("00:00:01:00:00:ae"), user_id=174},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=175, cidr = cidr("192.168.58.240/29"), mac = mac("00:00:01:00:00:af"), user_id=175},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=175, cidr = cidr("192.168.58.248/29"), mac = mac("00:00:01:00:00:af"), user_id=175},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=176, cidr = cidr("192.168.59.0/29"), mac = mac("00:00:01:00:00:b0"), user_id=176},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=176, cidr = cidr("192.168.59.8/29"), mac = mac("00:00:01:00:00:b0"), user_id=176},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=177, cidr = cidr("192.168.59.16/29"), mac = mac("00:00:01:00:00:b1"), user_id=177},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=177, cidr = cidr("192.168.59.24/29"), mac = mac("00:00:01:00:00:b1"), user_id=177},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=178, cidr = cidr("192.168.59.32/29"), mac = mac("00:00:01:00:00:b2"), user_id=178},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=178, cidr = cidr("192.168.59.40/29"), mac = mac("00:00:01:00:00:b2"), user_id=178},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=179, cidr = cidr("192.168.59.48/29"), mac = mac("00:00:01:00:00:b3"), user_id=179},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=179, cidr = cidr("192.168.59.56/29"), mac = mac("00:00:01:00:00:b3"), user_id=179},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=180, cidr = cidr("192.168.59.64/29"), mac = mac("00:00:01:00:00:b4"), user_id=180},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=180, cidr = cidr("192.168.59.72/29"), mac = mac("00:00:01:00:00:b4"), user_id=180},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=181, cidr = cidr("192.168.59.80/29"), mac = mac("00:00:01:00:00:b5"), user_id=181},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=181, cidr = cidr("192.168.59.88/29"), mac = mac("00:00:01:00:00:b5"), user_id=181},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=182, cidr = cidr("192.168.59.96/29"), mac = mac("00:00:01:00:00:b6"), user_id=182},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=182, cidr = cidr("192.168.59.104/29"), mac = mac("00:00:01:00:00:b6"), user_id=182},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=183, cidr = cidr("192.168.59.112/29"), mac = mac("00:00:01:00:00:b7"), user_id=183},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=183, cidr = cidr("192.168.59.120/29"), mac = mac("00:00:01:00:00:b7"), user_id=183},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=184, cidr = cidr("192.168.59.128/29"), mac = mac("00:00:01:00:00:b8"), user_id=184},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=184, cidr = cidr("192.168.59.136/29"), mac = mac("00:00:01:00:00:b8"), user_id=184},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=185, cidr = cidr("192.168.59.144/29"), mac = mac("00:00:01:00:00:b9"), user_id=185},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=185, cidr = cidr("192.168.59.152/29"), mac = mac("00:00:01:00:00:b9"), user_id=185},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=186, cidr = cidr("192.168.59.160/29"), mac = mac("00:00:01:00:00:ba"), user_id=186},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=186, cidr = cidr("192.168.59.168/29"), mac = mac("00:00:01:00:00:ba"), user_id=186},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=187, cidr = cidr("192.168.59.176/29"), mac = mac("00:00:01:00:00:bb"), user_id=187},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=187, cidr = cidr("192.168.59.184/29"), mac = mac("00:00:01:00:00:bb"), user_id=187},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=188, cidr = cidr("192.168.59.192/29"), mac = mac("00:00:01:00:00:bc"), user_id=188},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=188, cidr = cidr("192.168.59.200/29"), mac = mac("00:00:01:00:00:bc"), user_id=188},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=189, cidr = cidr("192.168.59.208/29"), mac = mac("00:00:01:00:00:bd"), user_id=189},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=189, cidr = cidr("192.168.59.216/29"), mac = mac("00:00:01:00:00:bd"), user_id=189},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=190, cidr = cidr("192.168.59.224/29"), mac = mac("00:00:01:00:00:be"), user_id=190},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=190, cidr = cidr("192.168.59.232/29"), mac = mac("00:00:01:00:00:be"), user_id=190},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=191, cidr = cidr("192.168.59.240/29"), mac = mac("00:00:01:00:00:bf"), user_id=191},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=191, cidr = cidr("192.168.59.248/29"), mac = mac("00:00:01:00:00:bf"), user_id=191},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=192, cidr = cidr("192.168.60.0/29"), mac = mac("00:00:01:00:00:c0"), user_id=192},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=192, cidr = cidr("192.168.60.8/29"), mac = mac("00:00:01:00:00:c0"), user_id=192},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=193, cidr = cidr("192.168.60.16/29"), mac = mac("00:00:01:00:00:c1"), user_id=193},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=193, cidr = cidr("192.168.60.24/29"), mac = mac("00:00:01:00:00:c1"), user_id=193},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=194, cidr = cidr("192.168.60.32/29"), mac = mac("00:00:01:00:00:c2"), user_id=194},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=194, cidr = cidr("192.168.60.40/29"), mac = mac("00:00:01:00:00:c2"), user_id=194},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=195, cidr = cidr("192.168.60.48/29"), mac = mac("00:00:01:00:00:c3"), user_id=195},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=195, cidr = cidr("192.168.60.56/29"), mac = mac("00:00:01:00:00:c3"), user_id=195},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=196, cidr = cidr("192.168.60.64/29"), mac = mac("00:00:01:00:00:c4"), user_id=196},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=196, cidr = cidr("192.168.60.72/29"), mac = mac("00:00:01:00:00:c4"), user_id=196},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=197, cidr = cidr("192.168.60.80/29"), mac = mac("00:00:01:00:00:c5"), user_id=197},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=197, cidr = cidr("192.168.60.88/29"), mac = mac("00:00:01:00:00:c5"), user_id=197},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=198, cidr = cidr("192.168.60.96/29"), mac = mac("00:00:01:00:00:c6"), user_id=198},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=198, cidr = cidr("192.168.60.104/29"), mac = mac("00:00:01:00:00:c6"), user_id=198},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=199, cidr = cidr("192.168.60.112/29"), mac = mac("00:00:01:00:00:c7"), user_id=199},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=199, cidr = cidr("192.168.60.120/29"), mac = mac("00:00:01:00:00:c7"), user_id=199},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=200, cidr = cidr("192.168.60.128/29"), mac = mac("00:00:01:00:00:c8"), user_id=200},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=200, cidr = cidr("192.168.60.136/29"), mac = mac("00:00:01:00:00:c8"), user_id=200},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=201, cidr = cidr("192.168.60.144/29"), mac = mac("00:00:01:00:00:c9"), user_id=201},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=201, cidr = cidr("192.168.60.152/29"), mac = mac("00:00:01:00:00:c9"), user_id=201},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=202, cidr = cidr("192.168.60.160/29"), mac = mac("00:00:01:00:00:ca"), user_id=202},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=202, cidr = cidr("192.168.60.168/29"), mac = mac("00:00:01:00:00:ca"), user_id=202},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=203, cidr = cidr("192.168.60.176/29"), mac = mac("00:00:01:00:00:cb"), user_id=203},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=203, cidr = cidr("192.168.60.184/29"), mac = mac("00:00:01:00:00:cb"), user_id=203},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=204, cidr = cidr("192.168.60.192/29"), mac = mac("00:00:01:00:00:cc"), user_id=204},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=204, cidr = cidr("192.168.60.200/29"), mac = mac("00:00:01:00:00:cc"), user_id=204},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=205, cidr = cidr("192.168.60.208/29"), mac = mac("00:00:01:00:00:cd"), user_id=205},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=205, cidr = cidr("192.168.60.216/29"), mac = mac("00:00:01:00:00:cd"), user_id=205},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=206, cidr = cidr("192.168.60.224/29"), mac = mac("00:00:01:00:00:ce"), user_id=206},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=206, cidr = cidr("192.168.60.232/29"), mac = mac("00:00:01:00:00:ce"), user_id=206},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=207, cidr = cidr("192.168.60.240/29"), mac = mac("00:00:01:00:00:cf"), user_id=207},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=207, cidr = cidr("192.168.60.248/29"), mac = mac("00:00:01:00:00:cf"), user_id=207},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=208, cidr = cidr("192.168.61.0/29"), mac = mac("00:00:01:00:00:d0"), user_id=208},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=208, cidr = cidr("192.168.61.8/29"), mac = mac("00:00:01:00:00:d0"), user_id=208},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=209, cidr = cidr("192.168.61.16/29"), mac = mac("00:00:01:00:00:d1"), user_id=209},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=209, cidr = cidr("192.168.61.24/29"), mac = mac("00:00:01:00:00:d1"), user_id=209},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=210, cidr = cidr("192.168.61.32/29"), mac = mac("00:00:01:00:00:d2"), user_id=210},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=210, cidr = cidr("192.168.61.40/29"), mac = mac("00:00:01:00:00:d2"), user_id=210},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=211, cidr = cidr("192.168.61.48/29"), mac = mac("00:00:01:00:00:d3"), user_id=211},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=211, cidr = cidr("192.168.61.56/29"), mac = mac("00:00:01:00:00:d3"), user_id=211},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=212, cidr = cidr("192.168.61.64/29"), mac = mac("00:00:01:00:00:d4"), user_id=212},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=212, cidr = cidr("192.168.61.72/29"), mac = mac("00:00:01:00:00:d4"), user_id=212},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=213, cidr = cidr("192.168.61.80/29"), mac = mac("00:00:01:00:00:d5"), user_id=213},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=213, cidr = cidr("192.168.61.88/29"), mac = mac("00:00:01:00:00:d5"), user_id=213},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=214, cidr = cidr("192.168.61.96/29"), mac = mac("00:00:01:00:00:d6"), user_id=214},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=214, cidr = cidr("192.168.61.104/29"), mac = mac("00:00:01:00:00:d6"), user_id=214},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=215, cidr = cidr("192.168.61.112/29"), mac = mac("00:00:01:00:00:d7"), user_id=215},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=215, cidr = cidr("192.168.61.120/29"), mac = mac("00:00:01:00:00:d7"), user_id=215},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=216, cidr = cidr("192.168.61.128/29"), mac = mac("00:00:01:00:00:d8"), user_id=216},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=216, cidr = cidr("192.168.61.136/29"), mac = mac("00:00:01:00:00:d8"), user_id=216},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=217, cidr = cidr("192.168.61.144/29"), mac = mac("00:00:01:00:00:d9"), user_id=217},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=217, cidr = cidr("192.168.61.152/29"), mac = mac("00:00:01:00:00:d9"), user_id=217},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=218, cidr = cidr("192.168.61.160/29"), mac = mac("00:00:01:00:00:da"), user_id=218},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=218, cidr = cidr("192.168.61.168/29"), mac = mac("00:00:01:00:00:da"), user_id=218},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=219, cidr = cidr("192.168.61.176/29"), mac = mac("00:00:01:00:00:db"), user_id=219},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=219, cidr = cidr("192.168.61.184/29"), mac = mac("00:00:01:00:00:db"), user_id=219},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=220, cidr = cidr("192.168.61.192/29"), mac = mac("00:00:01:00:00:dc"), user_id=220},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=220, cidr = cidr("192.168.61.200/29"), mac = mac("00:00:01:00:00:dc"), user_id=220},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=221, cidr = cidr("192.168.61.208/29"), mac = mac("00:00:01:00:00:dd"), user_id=221},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=221, cidr = cidr("192.168.61.216/29"), mac = mac("00:00:01:00:00:dd"), user_id=221},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=222, cidr = cidr("192.168.61.224/29"), mac = mac("00:00:01:00:00:de"), user_id=222},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=222, cidr = cidr("192.168.61.232/29"), mac = mac("00:00:01:00:00:de"), user_id=222},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=223, cidr = cidr("192.168.61.240/29"), mac = mac("00:00:01:00:00:df"), user_id=223},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=223, cidr = cidr("192.168.61.248/29"), mac = mac("00:00:01:00:00:df"), user_id=223},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=224, cidr = cidr("192.168.62.0/29"), mac = mac("00:00:01:00:00:e0"), user_id=224},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=224, cidr = cidr("192.168.62.8/29"), mac = mac("00:00:01:00:00:e0"), user_id=224},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=225, cidr = cidr("192.168.62.16/29"), mac = mac("00:00:01:00:00:e1"), user_id=225},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=225, cidr = cidr("192.168.62.24/29"), mac = mac("00:00:01:00:00:e1"), user_id=225},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=226, cidr = cidr("192.168.62.32/29"), mac = mac("00:00:01:00:00:e2"), user_id=226},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=226, cidr = cidr("192.168.62.40/29"), mac = mac("00:00:01:00:00:e2"), user_id=226},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=227, cidr = cidr("192.168.62.48/29"), mac = mac("00:00:01:00:00:e3"), user_id=227},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=227, cidr = cidr("192.168.62.56/29"), mac = mac("00:00:01:00:00:e3"), user_id=227},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=228, cidr = cidr("192.168.62.64/29"), mac = mac("00:00:01:00:00:e4"), user_id=228},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=228, cidr = cidr("192.168.62.72/29"), mac = mac("00:00:01:00:00:e4"), user_id=228},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=229, cidr = cidr("192.168.62.80/29"), mac = mac("00:00:01:00:00:e5"), user_id=229},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=229, cidr = cidr("192.168.62.88/29"), mac = mac("00:00:01:00:00:e5"), user_id=229},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=230, cidr = cidr("192.168.62.96/29"), mac = mac("00:00:01:00:00:e6"), user_id=230},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=230, cidr = cidr("192.168.62.104/29"), mac = mac("00:00:01:00:00:e6"), user_id=230},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=231, cidr = cidr("192.168.62.112/29"), mac = mac("00:00:01:00:00:e7"), user_id=231},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=231, cidr = cidr("192.168.62.120/29"), mac = mac("00:00:01:00:00:e7"), user_id=231},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=232, cidr = cidr("192.168.62.128/29"), mac = mac("00:00:01:00:00:e8"), user_id=232},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=232, cidr = cidr("192.168.62.136/29"), mac = mac("00:00:01:00:00:e8"), user_id=232},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=233, cidr = cidr("192.168.62.144/29"), mac = mac("00:00:01:00:00:e9"), user_id=233},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=233, cidr = cidr("192.168.62.152/29"), mac = mac("00:00:01:00:00:e9"), user_id=233},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=234, cidr = cidr("192.168.62.160/29"), mac = mac("00:00:01:00:00:ea"), user_id=234},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=234, cidr = cidr("192.168.62.168/29"), mac = mac("00:00:01:00:00:ea"), user_id=234},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=235, cidr = cidr("192.168.62.176/29"), mac = mac("00:00:01:00:00:eb"), user_id=235},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=235, cidr = cidr("192.168.62.184/29"), mac = mac("00:00:01:00:00:eb"), user_id=235},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=236, cidr = cidr("192.168.62.192/29"), mac = mac("00:00:01:00:00:ec"), user_id=236},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=236, cidr = cidr("192.168.62.200/29"), mac = mac("00:00:01:00:00:ec"), user_id=236},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=237, cidr = cidr("192.168.62.208/29"), mac = mac("00:00:01:00:00:ed"), user_id=237},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=237, cidr = cidr("192.168.62.216/29"), mac = mac("00:00:01:00:00:ed"), user_id=237},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=238, cidr = cidr("192.168.62.224/29"), mac = mac("00:00:01:00:00:ee"), user_id=238},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=238, cidr = cidr("192.168.62.232/29"), mac = mac("00:00:01:00:00:ee"), user_id=238},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=239, cidr = cidr("192.168.62.240/29"), mac = mac("00:00:01:00:00:ef"), user_id=239},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=239, cidr = cidr("192.168.62.248/29"), mac = mac("00:00:01:00:00:ef"), user_id=239},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=240, cidr = cidr("192.168.63.0/29"), mac = mac("00:00:01:00:00:f0"), user_id=240},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=240, cidr = cidr("192.168.63.8/29"), mac = mac("00:00:01:00:00:f0"), user_id=240},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=241, cidr = cidr("192.168.63.16/29"), mac = mac("00:00:01:00:00:f1"), user_id=241},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=241, cidr = cidr("192.168.63.24/29"), mac = mac("00:00:01:00:00:f1"), user_id=241},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=242, cidr = cidr("192.168.63.32/29"), mac = mac("00:00:01:00:00:f2"), user_id=242},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=242, cidr = cidr("192.168.63.40/29"), mac = mac("00:00:01:00:00:f2"), user_id=242},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=243, cidr = cidr("192.168.63.48/29"), mac = mac("00:00:01:00:00:f3"), user_id=243},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=243, cidr = cidr("192.168.63.56/29"), mac = mac("00:00:01:00:00:f3"), user_id=243},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=244, cidr = cidr("192.168.63.64/29"), mac = mac("00:00:01:00:00:f4"), user_id=244},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=244, cidr = cidr("192.168.63.72/29"), mac = mac("00:00:01:00:00:f4"), user_id=244},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=245, cidr = cidr("192.168.63.80/29"), mac = mac("00:00:01:00:00:f5"), user_id=245},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=245, cidr = cidr("192.168.63.88/29"), mac = mac("00:00:01:00:00:f5"), user_id=245},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=246, cidr = cidr("192.168.63.96/29"), mac = mac("00:00:01:00:00:f6"), user_id=246},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=246, cidr = cidr("192.168.63.104/29"), mac = mac("00:00:01:00:00:f6"), user_id=246},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=247, cidr = cidr("192.168.63.112/29"), mac = mac("00:00:01:00:00:f7"), user_id=247},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=247, cidr = cidr("192.168.63.120/29"), mac = mac("00:00:01:00:00:f7"), user_id=247},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=248, cidr = cidr("192.168.63.128/29"), mac = mac("00:00:01:00:00:f8"), user_id=248},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=248, cidr = cidr("192.168.63.136/29"), mac = mac("00:00:01:00:00:f8"), user_id=248},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=249, cidr = cidr("192.168.63.144/29"), mac = mac("00:00:01:00:00:f9"), user_id=249},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=249, cidr = cidr("192.168.63.152/29"), mac = mac("00:00:01:00:00:f9"), user_id=249},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=250, cidr = cidr("192.168.63.160/29"), mac = mac("00:00:01:00:00:fa"), user_id=250},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=250, cidr = cidr("192.168.63.168/29"), mac = mac("00:00:01:00:00:fa"), user_id=250},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=251, cidr = cidr("192.168.63.176/29"), mac = mac("00:00:01:00:00:fb"), user_id=251},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=251, cidr = cidr("192.168.63.184/29"), mac = mac("00:00:01:00:00:fb"), user_id=251},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=252, cidr = cidr("192.168.63.192/29"), mac = mac("00:00:01:00:00:fc"), user_id=252},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=252, cidr = cidr("192.168.63.200/29"), mac = mac("00:00:01:00:00:fc"), user_id=252},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=253, cidr = cidr("192.168.63.208/29"), mac = mac("00:00:01:00:00:fd"), user_id=253},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=253, cidr = cidr("192.168.63.216/29"), mac = mac("00:00:01:00:00:fd"), user_id=253},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=254, cidr = cidr("192.168.63.224/29"), mac = mac("00:00:01:00:00:fe"), user_id=254},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=254, cidr = cidr("192.168.63.232/29"), mac = mac("00:00:01:00:00:fe"), user_id=254},
+   {dest_id=3, gre_id=0, svlan_id=48, cvlan_id=255, cidr = cidr("192.168.63.240/29"), mac = mac("00:00:01:00:00:ff"), user_id=255},
+   {dest_id=3, gre_id=0, svlan_id=49, cvlan_id=255, cidr = cidr("192.168.63.248/29"), mac = mac("00:00:01:00:00:ff"), user_id=255},
+}
diff --git a/VNFs/DPPD-PROX/config/cpe_table_short.lua b/VNFs/DPPD-PROX/config/cpe_table_short.lua
new file mode 100644
index 00000000..c2314897
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/cpe_table_short.lua
@@ -0,0 +1,32 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+t2={}
+svlan_id=0
+ip1=2^24*192 + 2^16*168 + 2^8*0 + 0;
+for id1=0,3,1 do
+  for cvlan_id=0,255,1 do
+    mac_s=string.format("00:00:01:00:00:%02x", cvlan_id);
+    table.insert(t2,{dest_id=id1, gre_id=0, svlan_id=svlan_id, cvlan_id=cvlan_id, cidr = {ip=ip(ip1),depth=29}, mac = mac(mac_s), user_id=cvlan_id});
+    ip1=ip1+8
+    table.insert(t2,{dest_id=id1, gre_id=0, svlan_id=svlan_id+1, cvlan_id=cvlan_id, cidr = {ip=ip(ip1),depth=29}, mac = mac(mac_s), user_id=cvlan_id});
+    ip1=ip1+8
+  end
+  svlan_id=svlan_id+16
+end
+
+return t;
+
diff --git a/VNFs/DPPD-PROX/config/dscp.lua b/VNFs/DPPD-PROX/config/dscp.lua
new file mode 100644
index 00000000..ff994b16
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/dscp.lua
@@ -0,0 +1,82 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+return {
+   {dscp = 0,  tc = 0, queue = 0},
+   {dscp = 1,  tc = 0, queue = 1},
+   {dscp = 2,  tc = 0, queue = 2},
+   {dscp = 3,  tc = 0, queue = 3},
+   {dscp = 4,  tc = 1, queue = 0},
+   {dscp = 5,  tc = 1, queue = 1},
+   {dscp = 6,  tc = 1, queue = 2},
+   {dscp = 7,  tc = 1, queue = 3},
+   {dscp = 8,  tc = 2, queue = 0},
+   {dscp = 9,  tc = 2, queue = 1},
+   {dscp = 10, tc = 2, queue = 2},
+   {dscp = 11, tc = 2, queue = 3},
+   {dscp = 12, tc = 3, queue = 0},
+   {dscp = 13, tc = 3, queue = 1},
+   {dscp = 14, tc = 3, queue = 2},
+   {dscp = 15, tc = 3, queue = 3},
+   {dscp = 16, tc = 0, queue = 0},
+   {dscp = 17, tc = 0, queue = 1},
+   {dscp = 18, tc = 0, queue = 2},
+   {dscp = 19, tc = 0, queue = 3},
+   {dscp = 20, tc = 1, queue = 0},
+   {dscp = 21, tc = 1, queue = 1},
+   {dscp = 22, tc = 1, queue = 2},
+   {dscp = 23, tc = 1, queue = 3},
+   {dscp = 24, tc = 2, queue = 0},
+   {dscp = 25, tc = 2, queue = 1},
+   {dscp = 26, tc = 2, queue = 2},
+   {dscp = 27, tc = 2, queue = 3},
+   {dscp = 28, tc = 3, queue = 0},
+   {dscp = 29, tc = 3, queue = 1},
+   {dscp = 30, tc = 3, queue = 2},
+   {dscp = 31, tc = 3, queue = 3},
+   {dscp = 32, tc = 0, queue = 0},
+   {dscp = 33, tc = 0, queue = 1},
+   {dscp = 34, tc = 0, queue = 2},
+   {dscp = 35, tc = 0, queue = 3},
+   {dscp = 36, tc = 1, queue = 0},
+   {dscp = 37, tc = 1, queue = 1},
+   {dscp = 38, tc = 1, queue = 2},
+   {dscp = 39, tc = 1, queue = 3},
+   {dscp = 40, tc = 2, queue = 0},
+   {dscp = 41, tc = 2, queue = 1},
+   {dscp = 42, tc = 2, queue = 2},
+   {dscp = 43, tc = 2, queue = 3},
+   {dscp = 44, tc = 3, queue = 0},
+   {dscp = 45, tc = 3, queue = 1},
+   {dscp = 46, tc = 3, queue = 2},
+   {dscp = 47, tc = 3, queue = 3},
+   {dscp = 48, tc = 0, queue = 0},
+   {dscp = 49, tc = 0, queue = 1},
+   {dscp = 50, tc = 0, queue = 2},
+   {dscp = 51, tc = 0, queue = 3},
+   {dscp = 52, tc = 1, queue = 0},
+   {dscp = 53, tc = 1, queue = 1},
+   {dscp = 54, tc = 1, queue = 2},
+   {dscp = 55, tc = 1, queue = 3},
+   {dscp = 56, tc = 2, queue = 0},
+   {dscp = 57, tc = 2, queue = 1},
+   {dscp = 58, tc = 2, queue = 2},
+   {dscp = 59, tc = 2, queue = 3},
+   {dscp = 60, tc = 3, queue = 0},
+   {dscp = 61, tc = 3, queue = 1},
+   {dscp = 62, tc = 3, queue = 2},
+   {dscp = 63, tc = 3, queue = 3},
+}
diff --git a/VNFs/DPPD-PROX/config/dscp2.lua b/VNFs/DPPD-PROX/config/dscp2.lua
new file mode 100644
index 00000000..0bc044a8
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/dscp2.lua
@@ -0,0 +1,22 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+local dscp = {}
+for i = 1,2^6 do
+   dscp[i] = {dscp = i, tc = 0, queue = 0}
+end
+
+return dscp;
diff --git a/VNFs/DPPD-PROX/config/ip6_tun_bind.lua b/VNFs/DPPD-PROX/config/ip6_tun_bind.lua
new file mode 100644
index 00000000..75910048
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/ip6_tun_bind.lua
@@ -0,0 +1,25 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+-- Bindings for lwaftr: lwB4 IPv6 address, next hop MAC address
+-- towards lwB4, IPv4 Public address, IPv4 Public Port Set
+
+return {
+   {ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0000"), mac = mac("fe:80:00:00:00:00"), ip = ip("171.205.239.1"), port = 4608},
+   {ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0001"), mac = mac("fe:80:00:00:00:00"), ip = ip("171.205.239.1"), port = 4672},
+   {ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0002"), mac = mac("fe:80:00:00:00:00"), ip = ip("171.205.239.1"), port = 4736},
+   {ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0003"), mac = mac("fe:80:00:00:00:00"), ip = ip("171.205.239.1"), port = 4800},
+}
diff --git a/VNFs/DPPD-PROX/config/ipv4-2.lua b/VNFs/DPPD-PROX/config/ipv4-2.lua
new file mode 100644
index 00000000..0283ed48
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/ipv4-2.lua
@@ -0,0 +1,109 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+local lpm4 = {}
+lpm4.next_hops = {
+   {id = 0,  port_id = 0, ip = ip("1.1.1.1"),  mac = mac("00:00:00:00:00:01"), mpls = 0x112},
+   {id = 1,  port_id = 1, ip = ip("2.1.1.1"),  mac = mac("00:00:00:00:00:02"), mpls = 0x212},
+   {id = 2,  port_id = 0, ip = ip("3.1.1.1"),  mac = mac("00:00:00:00:00:03"), mpls = 0x312},
+   {id = 3,  port_id = 1, ip = ip("4.1.1.1"),  mac = mac("00:00:00:00:00:04"), mpls = 0x412},
+   {id = 4,  port_id = 0, ip = ip("5.1.1.1"),  mac = mac("00:00:00:00:00:05"), mpls = 0x512},
+   {id = 5,  port_id = 1, ip = ip("6.1.1.1"),  mac = mac("00:00:00:00:00:06"), mpls = 0x612},
+   {id = 6,  port_id = 0, ip = ip("7.1.1.1"),  mac = mac("00:00:00:00:00:07"), mpls = 0x712},
+   {id = 7,  port_id = 1, ip = ip("8.1.1.1"),  mac = mac("00:00:00:00:00:08"), mpls = 0x812},
+   {id = 8,  port_id = 0, ip = ip("9.1.1.1"),  mac = mac("00:00:00:00:00:09"), mpls = 0x912},
+   {id = 9,  port_id = 1, ip = ip("10.1.1.1"), mac = mac("00:00:00:00:00:10"), mpls = 0x1012},
+   {id = 10, port_id = 0, ip = ip("11.1.1.1"), mac = mac("00:00:00:00:00:11"), mpls = 0x1112},
+   {id = 11, port_id = 1, ip = ip("12.1.1.1"), mac = mac("00:00:00:00:00:12"), mpls = 0x1212},
+   {id = 12, port_id = 0, ip = ip("13.1.1.1"), mac = mac("00:00:00:00:00:13"), mpls = 0x1312},
+   {id = 13, port_id = 1, ip = ip("14.1.1.1"), mac = mac("00:00:00:00:00:14"), mpls = 0x1412},
+   {id = 14, port_id = 0, ip = ip("15.1.1.1"), mac = mac("00:00:00:00:00:15"), mpls = 0x1512},
+   {id = 15, port_id = 1, ip = ip("16.1.1.1"), mac = mac("00:00:00:00:00:16"), mpls = 0x1612},
+   {id = 16, port_id = 0, ip = ip("17.1.1.1"), mac = mac("00:00:00:00:00:17"), mpls = 0x1712},
+   {id = 17, port_id = 1, ip = ip("18.1.1.1"), mac = mac("00:00:00:00:00:18"), mpls = 0x1812},
+   {id = 18, port_id = 0, ip = ip("19.1.1.1"), mac = mac("00:00:00:00:00:19"), mpls = 0x1912},
+   {id = 19, port_id = 1, ip = ip("20.1.1.1"), mac = mac("00:00:00:00:00:20"), mpls = 0x2012},
+   {id = 20, port_id = 0, ip = ip("21.1.1.1"), mac = mac("00:00:00:00:00:21"), mpls = 0x2112},
+   {id = 21, port_id = 1, ip = ip("22.1.1.1"), mac = mac("00:00:00:00:00:22"), mpls = 0x2212},
+   {id = 22, port_id = 0, ip = ip("23.1.1.1"), mac = mac("00:00:00:00:00:23"), mpls = 0x2312},
+   {id = 23, port_id = 1, ip = ip("24.1.1.1"), mac = mac("00:00:00:00:00:24"), mpls = 0x2412},
+   {id = 24, port_id = 0, ip = ip("25.1.1.1"), mac = mac("00:00:00:00:00:25"), mpls = 0x2512},
+   {id = 25, port_id = 1, ip = ip("26.1.1.1"), mac = mac("00:00:00:00:00:26"), mpls = 0x2612},
+   {id = 26, port_id = 0, ip = ip("27.1.1.1"), mac = mac("00:00:00:00:00:27"), mpls = 0x2712},
+   {id = 27, port_id = 1, ip = ip("28.1.1.1"), mac = mac("00:00:00:00:00:28"), mpls = 0x2812},
+   {id = 28, port_id = 0, ip = ip("29.1.1.1"), mac = mac("00:00:00:00:00:29"), mpls = 0x2912},
+   {id = 29, port_id = 1, ip = ip("30.1.1.1"), mac = mac("00:00:00:00:00:30"), mpls = 0x3012},
+   {id = 30, port_id = 0, ip = ip("31.1.1.1"), mac = mac("00:00:00:00:00:31"), mpls = 0x3112},
+   {id = 31, port_id = 1, ip = ip("32.1.1.1"), mac = mac("00:00:00:00:00:32"), mpls = 0x3212},
+   {id = 32, port_id = 0, ip = ip("33.1.1.1"), mac = mac("00:00:00:00:00:33"), mpls = 0x3312},
+   {id = 33, port_id = 1, ip = ip("34.1.1.1"), mac = mac("00:00:00:00:00:34"), mpls = 0x3412},
+   {id = 34, port_id = 0, ip = ip("35.1.1.1"), mac = mac("00:00:00:00:00:35"), mpls = 0x3512},
+   {id = 35, port_id = 1, ip = ip("36.1.1.1"), mac = mac("00:00:00:00:00:36"), mpls = 0x3612},
+   {id = 36, port_id = 0, ip = ip("37.1.1.1"), mac = mac("00:00:00:00:00:37"), mpls = 0x3712},
+   {id = 37, port_id = 1, ip = ip("38.1.1.1"), mac = mac("00:00:00:00:00:38"), mpls = 0x3812},
+   {id = 38, port_id = 0, ip = ip("39.1.1.1"), mac = mac("00:00:00:00:00:39"), mpls = 0x3912},
+   {id = 39, port_id = 1, ip = ip("40.1.1.1"), mac = mac("00:00:00:00:00:40"), mpls = 0x4012},
+   {id = 40, port_id = 0, ip = ip("41.1.1.1"), mac = mac("00:00:00:00:00:41"), mpls = 0x4112},
+   {id = 41, port_id = 1, ip = ip("42.1.1.1"), mac = mac("00:00:00:00:00:42"), mpls = 0x4212},
+   {id = 42, port_id = 0, ip = ip("43.1.1.1"), mac = mac("00:00:00:00:00:43"), mpls = 0x4312},
+   {id = 43, port_id = 1, ip = ip("44.1.1.1"), mac = mac("00:00:00:00:00:44"), mpls = 0x4412},
+   {id = 44, port_id = 0, ip = ip("45.1.1.1"), mac = mac("00:00:00:00:00:45"), mpls = 0x4512},
+   {id = 45, port_id = 1, ip = ip("46.1.1.1"), mac = mac("00:00:00:00:00:46"), mpls = 0x4612},
+   {id = 46, port_id = 0, ip = ip("47.1.1.1"), mac = mac("00:00:00:00:00:47"), mpls = 0x4712},
+   {id = 47, port_id = 1, ip = ip("48.1.1.1"), mac = mac("00:00:00:00:00:48"), mpls = 0x4812},
+   {id = 48, port_id = 0, ip = ip("49.1.1.1"), mac = mac("00:00:00:00:00:49"), mpls = 0x4912},
+   {id = 49, port_id = 1, ip = ip("50.1.1.1"), mac = mac("00:00:00:00:00:50"), mpls = 0x5012},
+   {id = 50, port_id = 0, ip = ip("51.1.1.1"), mac = mac("00:00:00:00:00:51"), mpls = 0x5112},
+   {id = 51, port_id = 1, ip = ip("52.1.1.1"), mac = mac("00:00:00:00:00:52"), mpls = 0x5212},
+   {id = 52, port_id = 0, ip = ip("53.1.1.1"), mac = mac("00:00:00:00:00:53"), mpls = 0x5312},
+   {id = 53, port_id = 1, ip = ip("54.1.1.1"), mac = mac("00:00:00:00:00:54"), mpls = 0x5412},
+   {id = 54, port_id = 0, ip = ip("55.1.1.1"), mac = mac("00:00:00:00:00:55"), mpls = 0x5512},
+   {id = 55, port_id = 1, ip = ip("56.1.1.1"), mac = mac("00:00:00:00:00:56"), mpls = 0x5612},
+   {id = 56, port_id = 0, ip = ip("57.1.1.1"), mac = mac("00:00:00:00:00:57"), mpls = 0x5712},
+   {id = 57, port_id = 1, ip = ip("58.1.1.1"), mac = mac("00:00:00:00:00:58"), mpls = 0x5812},
+   {id = 58, port_id = 0, ip = ip("59.1.1.1"), mac = mac("00:00:00:00:00:59"), mpls = 0x5912},
+   {id = 59, port_id = 1, ip = ip("60.1.1.1"), mac = mac("00:00:00:00:00:60"), mpls = 0x6012},
+   {id = 60, port_id = 0, ip = ip("61.1.1.1"), mac = mac("00:00:00:00:00:61"), mpls = 0x6112},
+   {id = 61, port_id = 1, ip = ip("62.1.1.1"), mac = mac("00:00:00:00:00:62"), mpls = 0x6212},
+   {id = 62, port_id = 0, ip = ip("63.1.1.1"), mac = mac("00:00:00:00:00:63"), mpls = 0x6312},
+   {id = 63, port_id = 1, ip = ip("64.1.1.1"), mac = mac("00:00:00:00:00:64"), mpls = 0x6412},
+}
+
+lpm4.routes = {};
+
+base_ip = 10 * 2^24;
+
+for i = 1,2^13 do
+   res = ip(base_ip + (1 * 2^12) * (i - 1));
+
+   lpm4.routes[i] = {
+      cidr        = {ip = res, depth = 24},
+      next_hop_id = (i - 1) % 64,
+   }
+end
+
+base_ip = 74 * 2^24;
+
+for i = 1,2^13 do
+   res = ip(base_ip + (1 * 2^12) * (i - 1));
+
+   lpm4.routes[2^13 + i] = {
+      cidr        = {ip = res, depth = 24},
+      next_hop_id = (i - 1) % 64,
+   }
+end
+
+return lpm4;
diff --git a/VNFs/DPPD-PROX/config/ipv4-4ports.lua b/VNFs/DPPD-PROX/config/ipv4-4ports.lua
new file mode 100644
index 00000000..54b102e8
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/ipv4-4ports.lua
@@ -0,0 +1,98 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+local lpm4 = {}
+lpm4.next_hops = {
+   {id = 0,  port_id = 0, ip = ip("1.1.1.1"),  mac = mac("00:00:00:00:00:01"), mpls = 0x112},
+   {id = 1,  port_id = 1, ip = ip("2.1.1.1"),  mac = mac("00:00:00:00:00:02"), mpls = 0x212},
+   {id = 2,  port_id = 2, ip = ip("3.1.1.1"),  mac = mac("00:00:00:00:00:03"), mpls = 0x312},
+   {id = 3,  port_id = 3, ip = ip("4.1.1.1"),  mac = mac("00:00:00:00:00:04"), mpls = 0x412},
+   {id = 4,  port_id = 0, ip = ip("5.1.1.1"),  mac = mac("00:00:00:00:00:05"), mpls = 0x512},
+   {id = 5,  port_id = 1, ip = ip("6.1.1.1"),  mac = mac("00:00:00:00:00:06"), mpls = 0x612},
+   {id = 6,  port_id = 2, ip = ip("7.1.1.1"),  mac = mac("00:00:00:00:00:07"), mpls = 0x712},
+   {id = 7,  port_id = 3, ip = ip("8.1.1.1"),  mac = mac("00:00:00:00:00:08"), mpls = 0x812},
+   {id = 8,  port_id = 0, ip = ip("9.1.1.1"),  mac = mac("00:00:00:00:00:09"), mpls = 0x912},
+   {id = 9,  port_id = 1, ip = ip("10.1.1.1"), mac = mac("00:00:00:00:00:10"), mpls = 0x1012},
+   {id = 10, port_id = 2, ip = ip("11.1.1.1"), mac = mac("00:00:00:00:00:11"), mpls = 0x1112},
+   {id = 11, port_id = 3, ip = ip("12.1.1.1"), mac = mac("00:00:00:00:00:12"), mpls = 0x1212},
+   {id = 12, port_id = 0, ip = ip("13.1.1.1"), mac = mac("00:00:00:00:00:13"), mpls = 0x1312},
+   {id = 13, port_id = 1, ip = ip("14.1.1.1"), mac = mac("00:00:00:00:00:14"), mpls = 0x1412},
+   {id = 14, port_id = 2, ip = ip("15.1.1.1"), mac = mac("00:00:00:00:00:15"), mpls = 0x1512},
+   {id = 15, port_id = 3, ip = ip("16.1.1.1"), mac = mac("00:00:00:00:00:16"), mpls = 0x1612},
+   {id = 16, port_id = 0, ip = ip("17.1.1.1"), mac = mac("00:00:00:00:00:17"), mpls = 0x1712},
+   {id = 17, port_id = 1, ip = ip("18.1.1.1"), mac = mac("00:00:00:00:00:18"), mpls = 0x1812},
+   {id = 18, port_id = 2, ip = ip("19.1.1.1"), mac = mac("00:00:00:00:00:19"), mpls = 0x1912},
+   {id = 19, port_id = 3, ip = ip("20.1.1.1"), mac = mac("00:00:00:00:00:20"), mpls = 0x2012},
+   {id = 20, port_id = 0, ip = ip("21.1.1.1"), mac = mac("00:00:00:00:00:21"), mpls = 0x2112},
+   {id = 21, port_id = 1, ip = ip("22.1.1.1"), mac = mac("00:00:00:00:00:22"), mpls = 0x2212},
+   {id = 22, port_id = 2, ip = ip("23.1.1.1"), mac = mac("00:00:00:00:00:23"), mpls = 0x2312},
+   {id = 23, port_id = 3, ip = ip("24.1.1.1"), mac = mac("00:00:00:00:00:24"), mpls = 0x2412},
+   {id = 24, port_id = 0, ip = ip("25.1.1.1"), mac = mac("00:00:00:00:00:25"), mpls = 0x2512},
+   {id = 25, port_id = 1, ip = ip("26.1.1.1"), mac = mac("00:00:00:00:00:26"), mpls = 0x2612},
+   {id = 26, port_id = 2, ip = ip("27.1.1.1"), mac = mac("00:00:00:00:00:27"), mpls = 0x2712},
+   {id = 27, port_id = 3, ip = ip("28.1.1.1"), mac = mac("00:00:00:00:00:28"), mpls = 0x2812},
+   {id = 28, port_id = 0, ip = ip("29.1.1.1"), mac = mac("00:00:00:00:00:29"), mpls = 0x2912},
+   {id = 29, port_id = 1, ip = ip("30.1.1.1"), mac = mac("00:00:00:00:00:30"), mpls = 0x3012},
+   {id = 30, port_id = 2, ip = ip("31.1.1.1"), mac = mac("00:00:00:00:00:31"), mpls = 0x3112},
+   {id = 31, port_id = 3, ip = ip("32.1.1.1"), mac = mac("00:00:00:00:00:32"), mpls = 0x3212},
+   {id = 32, port_id = 0, ip = ip("33.1.1.1"), mac = mac("00:00:00:00:00:33"), mpls = 0x3312},
+   {id = 33, port_id = 1, ip = ip("34.1.1.1"), mac = mac("00:00:00:00:00:34"), mpls = 0x3412},
+   {id = 34, port_id = 2, ip = ip("35.1.1.1"), mac = mac("00:00:00:00:00:35"), mpls = 0x3512},
+   {id = 35, port_id = 3, ip = ip("36.1.1.1"), mac = mac("00:00:00:00:00:36"), mpls = 0x3612},
+   {id = 36, port_id = 0, ip = ip("37.1.1.1"), mac = mac("00:00:00:00:00:37"), mpls = 0x3712},
+   {id = 37, port_id = 1, ip = ip("38.1.1.1"), mac = mac("00:00:00:00:00:38"), mpls = 0x3812},
+   {id = 38, port_id = 2, ip = ip("39.1.1.1"), mac = mac("00:00:00:00:00:39"), mpls = 0x3912},
+   {id = 39, port_id = 3, ip = ip("40.1.1.1"), mac = mac("00:00:00:00:00:40"), mpls = 0x4012},
+   {id = 40, port_id = 0, ip = ip("41.1.1.1"), mac = mac("00:00:00:00:00:41"), mpls = 0x4112},
+   {id = 41, port_id = 1, ip = ip("42.1.1.1"), mac = mac("00:00:00:00:00:42"), mpls = 0x4212},
+   {id = 42, port_id = 2, ip = ip("43.1.1.1"), mac = mac("00:00:00:00:00:43"), mpls = 0x4312},
+   {id = 43, port_id = 3, ip = ip("44.1.1.1"), mac = mac("00:00:00:00:00:44"), mpls = 0x4412},
+   {id = 44, port_id = 0, ip = ip("45.1.1.1"), mac = mac("00:00:00:00:00:45"), mpls = 0x4512},
+   {id = 45, port_id = 1, ip = ip("46.1.1.1"), mac = mac("00:00:00:00:00:46"), mpls = 0x4612},
+   {id = 46, port_id = 2, ip = ip("47.1.1.1"), mac = mac("00:00:00:00:00:47"), mpls = 0x4712},
+   {id = 47, port_id = 3, ip = ip("48.1.1.1"), mac = mac("00:00:00:00:00:48"), mpls = 0x4812},
+   {id = 48, port_id = 0, ip = ip("49.1.1.1"), mac = mac("00:00:00:00:00:49"), mpls = 0x4912},
+   {id = 49, port_id = 1, ip = ip("50.1.1.1"), mac = mac("00:00:00:00:00:50"), mpls = 0x5012},
+   {id = 50, port_id = 2, ip = ip("51.1.1.1"), mac = mac("00:00:00:00:00:51"), mpls = 0x5112},
+   {id = 51, port_id = 3, ip = ip("52.1.1.1"), mac = mac("00:00:00:00:00:52"), mpls = 0x5212},
+   {id = 52, port_id = 0, ip = ip("53.1.1.1"), mac = mac("00:00:00:00:00:53"), mpls = 0x5312},
+   {id = 53, port_id = 1, ip = ip("54.1.1.1"), mac = mac("00:00:00:00:00:54"), mpls = 0x5412},
+   {id = 54, port_id = 2, ip = ip("55.1.1.1"), mac = mac("00:00:00:00:00:55"), mpls = 0x5512},
+   {id = 55, port_id = 3, ip = ip("56.1.1.1"), mac = mac("00:00:00:00:00:56"), mpls = 0x5612},
+   {id = 56, port_id = 0, ip = ip("57.1.1.1"), mac = mac("00:00:00:00:00:57"), mpls = 0x5712},
+   {id = 57, port_id = 1, ip = ip("58.1.1.1"), mac = mac("00:00:00:00:00:58"), mpls = 0x5812},
+   {id = 58, port_id = 2, ip = ip("59.1.1.1"), mac = mac("00:00:00:00:00:59"), mpls = 0x5912},
+   {id = 59, port_id = 3, ip = ip("60.1.1.1"), mac = mac("00:00:00:00:00:60"), mpls = 0x6012},
+   {id = 60, port_id = 0, ip = ip("61.1.1.1"), mac = mac("00:00:00:00:00:61"), mpls = 0x6112},
+   {id = 61, port_id = 1, ip = ip("62.1.1.1"), mac = mac("00:00:00:00:00:62"), mpls = 0x6212},
+   {id = 62, port_id = 2, ip = ip("63.1.1.1"), mac = mac("00:00:00:00:00:63"), mpls = 0x6312},
+   {id = 63, port_id = 3, ip = ip("64.1.1.1"), mac = mac("00:00:00:00:00:64"), mpls = 0x6412},
+}
+
+lpm4.routes = {};
+
+base_ip = 10 * 2^24;
+
+for i = 1,2^13 do
+   res = ip(base_ip + (1 *2^12) * (i - 1));
+
+   lpm4.routes[i] = {
+      cidr        = {ip = res, depth = 24},
+      next_hop_id = (i - 1) % 64,
+   }
+end
+
+return lpm4
diff --git a/VNFs/DPPD-PROX/config/ipv4.lua b/VNFs/DPPD-PROX/config/ipv4.lua
new file mode 100644
index 00000000..9fb8c385
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/ipv4.lua
@@ -0,0 +1,98 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+local lpm4 = {}
+lpm4.next_hops = {
+   {id = 0,  port_id = 0, ip = ip("1.1.1.1"),  mac = mac("00:00:00:00:00:01"), mpls = 0x112},
+   {id = 1,  port_id = 1, ip = ip("2.1.1.1"),  mac = mac("00:00:00:00:00:02"), mpls = 0x212},
+   {id = 2,  port_id = 0, ip = ip("3.1.1.1"),  mac = mac("00:00:00:00:00:03"), mpls = 0x312},
+   {id = 3,  port_id = 1, ip = ip("4.1.1.1"),  mac = mac("00:00:00:00:00:04"), mpls = 0x412},
+   {id = 4,  port_id = 0, ip = ip("5.1.1.1"),  mac = mac("00:00:00:00:00:05"), mpls = 0x512},
+   {id = 5,  port_id = 1, ip = ip("6.1.1.1"),  mac = mac("00:00:00:00:00:06"), mpls = 0x612},
+   {id = 6,  port_id = 0, ip = ip("7.1.1.1"),  mac = mac("00:00:00:00:00:07"), mpls = 0x712},
+   {id = 7,  port_id = 1, ip = ip("8.1.1.1"),  mac = mac("00:00:00:00:00:08"), mpls = 0x812},
+   {id = 8,  port_id = 0, ip = ip("9.1.1.1"),  mac = mac("00:00:00:00:00:09"), mpls = 0x912},
+   {id = 9,  port_id = 1, ip = ip("10.1.1.1"), mac = mac("00:00:00:00:00:10"), mpls = 0x1012},
+   {id = 10, port_id = 0, ip = ip("11.1.1.1"), mac = mac("00:00:00:00:00:11"), mpls = 0x1112},
+   {id = 11, port_id = 1, ip = ip("12.1.1.1"), mac = mac("00:00:00:00:00:12"), mpls = 0x1212},
+   {id = 12, port_id = 0, ip = ip("13.1.1.1"), mac = mac("00:00:00:00:00:13"), mpls = 0x1312},
+   {id = 13, port_id = 1, ip = ip("14.1.1.1"), mac = mac("00:00:00:00:00:14"), mpls = 0x1412},
+   {id = 14, port_id = 0, ip = ip("15.1.1.1"), mac = mac("00:00:00:00:00:15"), mpls = 0x1512},
+   {id = 15, port_id = 1, ip = ip("16.1.1.1"), mac = mac("00:00:00:00:00:16"), mpls = 0x1612},
+   {id = 16, port_id = 0, ip = ip("17.1.1.1"), mac = mac("00:00:00:00:00:17"), mpls = 0x1712},
+   {id = 17, port_id = 1, ip = ip("18.1.1.1"), mac = mac("00:00:00:00:00:18"), mpls = 0x1812},
+   {id = 18, port_id = 0, ip = ip("19.1.1.1"), mac = mac("00:00:00:00:00:19"), mpls = 0x1912},
+   {id = 19, port_id = 1, ip = ip("20.1.1.1"), mac = mac("00:00:00:00:00:20"), mpls = 0x2012},
+   {id = 20, port_id = 0, ip = ip("21.1.1.1"), mac = mac("00:00:00:00:00:21"), mpls = 0x2112},
+   {id = 21, port_id = 1, ip = ip("22.1.1.1"), mac = mac("00:00:00:00:00:22"), mpls = 0x2212},
+   {id = 22, port_id = 0, ip = ip("23.1.1.1"), mac = mac("00:00:00:00:00:23"), mpls = 0x2312},
+   {id = 23, port_id = 1, ip = ip("24.1.1.1"), mac = mac("00:00:00:00:00:24"), mpls = 0x2412},
+   {id = 24, port_id = 0, ip = ip("25.1.1.1"), mac = mac("00:00:00:00:00:25"), mpls = 0x2512},
+   {id = 25, port_id = 1, ip = ip("26.1.1.1"), mac = mac("00:00:00:00:00:26"), mpls = 0x2612},
+   {id = 26, port_id = 0, ip = ip("27.1.1.1"), mac = mac("00:00:00:00:00:27"), mpls = 0x2712},
+   {id = 27, port_id = 1, ip = ip("28.1.1.1"), mac = mac("00:00:00:00:00:28"), mpls = 0x2812},
+   {id = 28, port_id = 0, ip = ip("29.1.1.1"), mac = mac("00:00:00:00:00:29"), mpls = 0x2912},
+   {id = 29, port_id = 1, ip = ip("30.1.1.1"), mac = mac("00:00:00:00:00:30"), mpls = 0x3012},
+   {id = 30, port_id = 0, ip = ip("31.1.1.1"), mac = mac("00:00:00:00:00:31"), mpls = 0x3112},
+   {id = 31, port_id = 1, ip = ip("32.1.1.1"), mac = mac("00:00:00:00:00:32"), mpls = 0x3212},
+   {id = 32, port_id = 0, ip = ip("33.1.1.1"), mac = mac("00:00:00:00:00:33"), mpls = 0x3312},
+   {id = 33, port_id = 1, ip = ip("34.1.1.1"), mac = mac("00:00:00:00:00:34"), mpls = 0x3412},
+   {id = 34, port_id = 0, ip = ip("35.1.1.1"), mac = mac("00:00:00:00:00:35"), mpls = 0x3512},
+   {id = 35, port_id = 1, ip = ip("36.1.1.1"), mac = mac("00:00:00:00:00:36"), mpls = 0x3612},
+   {id = 36, port_id = 0, ip = ip("37.1.1.1"), mac = mac("00:00:00:00:00:37"), mpls = 0x3712},
+   {id = 37, port_id = 1, ip = ip("38.1.1.1"), mac = mac("00:00:00:00:00:38"), mpls = 0x3812},
+   {id = 38, port_id = 0, ip = ip("39.1.1.1"), mac = mac("00:00:00:00:00:39"), mpls = 0x3912},
+   {id = 39, port_id = 1, ip = ip("40.1.1.1"), mac = mac("00:00:00:00:00:40"), mpls = 0x4012},
+   {id = 40, port_id = 0, ip = ip("41.1.1.1"), mac = mac("00:00:00:00:00:41"), mpls = 0x4112},
+   {id = 41, port_id = 1, ip = ip("42.1.1.1"), mac = mac("00:00:00:00:00:42"), mpls = 0x4212},
+   {id = 42, port_id = 0, ip = ip("43.1.1.1"), mac = mac("00:00:00:00:00:43"), mpls = 0x4312},
+   {id = 43, port_id = 1, ip = ip("44.1.1.1"), mac = mac("00:00:00:00:00:44"), mpls = 0x4412},
+   {id = 44, port_id = 0, ip = ip("45.1.1.1"), mac = mac("00:00:00:00:00:45"), mpls = 0x4512},
+   {id = 45, port_id = 1, ip = ip("46.1.1.1"), mac = mac("00:00:00:00:00:46"), mpls = 0x4612},
+   {id = 46, port_id = 0, ip = ip("47.1.1.1"), mac = mac("00:00:00:00:00:47"), mpls = 0x4712},
+   {id = 47, port_id = 1, ip = ip("48.1.1.1"), mac = mac("00:00:00:00:00:48"), mpls = 0x4812},
+   {id = 48, port_id = 0, ip = ip("49.1.1.1"), mac = mac("00:00:00:00:00:49"), mpls = 0x4912},
+   {id = 49, port_id = 1, ip = ip("50.1.1.1"), mac = mac("00:00:00:00:00:50"), mpls = 0x5012},
+   {id = 50, port_id = 0, ip = ip("51.1.1.1"), mac = mac("00:00:00:00:00:51"), mpls = 0x5112},
+   {id = 51, port_id = 1, ip = ip("52.1.1.1"), mac = mac("00:00:00:00:00:52"), mpls = 0x5212},
+   {id = 52, port_id = 0, ip = ip("53.1.1.1"), mac = mac("00:00:00:00:00:53"), mpls = 0x5312},
+   {id = 53, port_id = 1, ip = ip("54.1.1.1"), mac = mac("00:00:00:00:00:54"), mpls = 0x5412},
+   {id = 54, port_id = 0, ip = ip("55.1.1.1"), mac = mac("00:00:00:00:00:55"), mpls = 0x5512},
+   {id = 55, port_id = 1, ip = ip("56.1.1.1"), mac = mac("00:00:00:00:00:56"), mpls = 0x5612},
+   {id = 56, port_id = 0, ip = ip("57.1.1.1"), mac = mac("00:00:00:00:00:57"), mpls = 0x5712},
+   {id = 57, port_id = 1, ip = ip("58.1.1.1"), mac = mac("00:00:00:00:00:58"), mpls = 0x5812},
+   {id = 58, port_id = 0, ip = ip("59.1.1.1"), mac = mac("00:00:00:00:00:59"), mpls = 0x5912},
+   {id = 59, port_id = 1, ip = ip("60.1.1.1"), mac = mac("00:00:00:00:00:60"), mpls = 0x6012},
+   {id = 60, port_id = 0, ip = ip("61.1.1.1"), mac = mac("00:00:00:00:00:61"), mpls = 0x6112},
+   {id = 61, port_id = 1, ip = ip("62.1.1.1"), mac = mac("00:00:00:00:00:62"), mpls = 0x6212},
+   {id = 62, port_id = 0, ip = ip("63.1.1.1"), mac = mac("00:00:00:00:00:63"), mpls = 0x6312},
+   {id = 63, port_id = 1, ip = ip("64.1.1.1"), mac = mac("00:00:00:00:00:64"), mpls = 0x6412},
+}
+
+lpm4.routes = {};
+
+base_ip = 10 * 2^24;
+
+for i = 1,2^13 do
+   res = ip(base_ip + (1 * 2^12) * (i - 1));
+
+   lpm4.routes[i] = {
+      cidr        = {ip = res, depth = 24},
+      next_hop_id = (i - 1) % 64,
+   }
+end
+
+return lpm4
diff --git a/VNFs/DPPD-PROX/config/ipv4_1port.lua b/VNFs/DPPD-PROX/config/ipv4_1port.lua
new file mode 100644
index 00000000..ad5c3472
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/ipv4_1port.lua
@@ -0,0 +1,98 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+local lpm4 = {}
+lpm4.next_hops = {
+   {id = 0,  port_id = 0, ip = ip("1.1.1.1"),  mac = mac("00:00:00:00:00:01"), mpls = 0x112},
+   {id = 1,  port_id = 0, ip = ip("2.1.1.1"),  mac = mac("00:00:00:00:00:02"), mpls = 0x212},
+   {id = 2,  port_id = 0, ip = ip("3.1.1.1"),  mac = mac("00:00:00:00:00:03"), mpls = 0x312},
+   {id = 3,  port_id = 0, ip = ip("4.1.1.1"),  mac = mac("00:00:00:00:00:04"), mpls = 0x412},
+   {id = 4,  port_id = 0, ip = ip("5.1.1.1"),  mac = mac("00:00:00:00:00:05"), mpls = 0x512},
+   {id = 5,  port_id = 0, ip = ip("6.1.1.1"),  mac = mac("00:00:00:00:00:06"), mpls = 0x612},
+   {id = 6,  port_id = 0, ip = ip("7.1.1.1"),  mac = mac("00:00:00:00:00:07"), mpls = 0x712},
+   {id = 7,  port_id = 0, ip = ip("8.1.1.1"),  mac = mac("00:00:00:00:00:08"), mpls = 0x812},
+   {id = 8,  port_id = 0, ip = ip("9.1.1.1"),  mac = mac("00:00:00:00:00:09"), mpls = 0x912},
+   {id = 9,  port_id = 0, ip = ip("10.1.1.1"), mac = mac("00:00:00:00:00:10"), mpls = 0x1012},
+   {id = 10, port_id = 0, ip = ip("11.1.1.1"), mac = mac("00:00:00:00:00:11"), mpls = 0x1112},
+   {id = 11, port_id = 0, ip = ip("12.1.1.1"), mac = mac("00:00:00:00:00:12"), mpls = 0x1212},
+   {id = 12, port_id = 0, ip = ip("13.1.1.1"), mac = mac("00:00:00:00:00:13"), mpls = 0x1312},
+   {id = 13, port_id = 0, ip = ip("14.1.1.1"), mac = mac("00:00:00:00:00:14"), mpls = 0x1412},
+   {id = 14, port_id = 0, ip = ip("15.1.1.1"), mac = mac("00:00:00:00:00:15"), mpls = 0x1512},
+   {id = 15, port_id = 0, ip = ip("16.1.1.1"), mac = mac("00:00:00:00:00:16"), mpls = 0x1612},
+   {id = 16, port_id = 0, ip = ip("17.1.1.1"), mac = mac("00:00:00:00:00:17"), mpls = 0x1712},
+   {id = 17, port_id = 0, ip = ip("18.1.1.1"), mac = mac("00:00:00:00:00:18"), mpls = 0x1812},
+   {id = 18, port_id = 0, ip = ip("19.1.1.1"), mac = mac("00:00:00:00:00:19"), mpls = 0x1912},
+   {id = 19, port_id = 0, ip = ip("20.1.1.1"), mac = mac("00:00:00:00:00:20"), mpls = 0x2012},
+   {id = 20, port_id = 0, ip = ip("21.1.1.1"), mac = mac("00:00:00:00:00:21"), mpls = 0x2112},
+   {id = 21, port_id = 0, ip = ip("22.1.1.1"), mac = mac("00:00:00:00:00:22"), mpls = 0x2212},
+   {id = 22, port_id = 0, ip = ip("23.1.1.1"), mac = mac("00:00:00:00:00:23"), mpls = 0x2312},
+   {id = 23, port_id = 0, ip = ip("24.1.1.1"), mac = mac("00:00:00:00:00:24"), mpls = 0x2412},
+   {id = 24, port_id = 0, ip = ip("25.1.1.1"), mac = mac("00:00:00:00:00:25"), mpls = 0x2512},
+   {id = 25, port_id = 0, ip = ip("26.1.1.1"), mac = mac("00:00:00:00:00:26"), mpls = 0x2612},
+   {id = 26, port_id = 0, ip = ip("27.1.1.1"), mac = mac("00:00:00:00:00:27"), mpls = 0x2712},
+   {id = 27, port_id = 0, ip = ip("28.1.1.1"), mac = mac("00:00:00:00:00:28"), mpls = 0x2812},
+   {id = 28, port_id = 0, ip = ip("29.1.1.1"), mac = mac("00:00:00:00:00:29"), mpls = 0x2912},
+   {id = 29, port_id = 0, ip = ip("30.1.1.1"), mac = mac("00:00:00:00:00:30"), mpls = 0x3012},
+   {id = 30, port_id = 0, ip = ip("31.1.1.1"), mac = mac("00:00:00:00:00:31"), mpls = 0x3112},
+   {id = 31, port_id = 0, ip = ip("32.1.1.1"), mac = mac("00:00:00:00:00:32"), mpls = 0x3212},
+   {id = 32, port_id = 0, ip = ip("33.1.1.1"), mac = mac("00:00:00:00:00:33"), mpls = 0x3312},
+   {id = 33, port_id = 0, ip = ip("34.1.1.1"), mac = mac("00:00:00:00:00:34"), mpls = 0x3412},
+   {id = 34, port_id = 0, ip = ip("35.1.1.1"), mac = mac("00:00:00:00:00:35"), mpls = 0x3512},
+   {id = 35, port_id = 0, ip = ip("36.1.1.1"), mac = mac("00:00:00:00:00:36"), mpls = 0x3612},
+   {id = 36, port_id = 0, ip = ip("37.1.1.1"), mac = mac("00:00:00:00:00:37"), mpls = 0x3712},
+   {id = 37, port_id = 0, ip = ip("38.1.1.1"), mac = mac("00:00:00:00:00:38"), mpls = 0x3812},
+   {id = 38, port_id = 0, ip = ip("39.1.1.1"), mac = mac("00:00:00:00:00:39"), mpls = 0x3912},
+   {id = 39, port_id = 0, ip = ip("40.1.1.1"), mac = mac("00:00:00:00:00:40"), mpls = 0x4012},
+   {id = 40, port_id = 0, ip = ip("41.1.1.1"), mac = mac("00:00:00:00:00:41"), mpls = 0x4112},
+   {id = 41, port_id = 0, ip = ip("42.1.1.1"), mac = mac("00:00:00:00:00:42"), mpls = 0x4212},
+   {id = 42, port_id = 0, ip = ip("43.1.1.1"), mac = mac("00:00:00:00:00:43"), mpls = 0x4312},
+   {id = 43, port_id = 0, ip = ip("44.1.1.1"), mac = mac("00:00:00:00:00:44"), mpls = 0x4412},
+   {id = 44, port_id = 0, ip = ip("45.1.1.1"), mac = mac("00:00:00:00:00:45"), mpls = 0x4512},
+   {id = 45, port_id = 0, ip = ip("46.1.1.1"), mac = mac("00:00:00:00:00:46"), mpls = 0x4612},
+   {id = 46, port_id = 0, ip = ip("47.1.1.1"), mac = mac("00:00:00:00:00:47"), mpls = 0x4712},
+   {id = 47, port_id = 0, ip = ip("48.1.1.1"), mac = mac("00:00:00:00:00:48"), mpls = 0x4812},
+   {id = 48, port_id = 0, ip = ip("49.1.1.1"), mac = mac("00:00:00:00:00:49"), mpls = 0x4912},
+   {id = 49, port_id = 0, ip = ip("50.1.1.1"), mac = mac("00:00:00:00:00:50"), mpls = 0x5012},
+   {id = 50, port_id = 0, ip = ip("51.1.1.1"), mac = mac("00:00:00:00:00:51"), mpls = 0x5112},
+   {id = 51, port_id = 0, ip = ip("52.1.1.1"), mac = mac("00:00:00:00:00:52"), mpls = 0x5212},
+   {id = 52, port_id = 0, ip = ip("53.1.1.1"), mac = mac("00:00:00:00:00:53"), mpls = 0x5312},
+   {id = 53, port_id = 0, ip = ip("54.1.1.1"), mac = mac("00:00:00:00:00:54"), mpls = 0x5412},
+   {id = 54, port_id = 0, ip = ip("55.1.1.1"), mac = mac("00:00:00:00:00:55"), mpls = 0x5512},
+   {id = 55, port_id = 0, ip = ip("56.1.1.1"), mac = mac("00:00:00:00:00:56"), mpls = 0x5612},
+   {id = 56, port_id = 0, ip = ip("57.1.1.1"), mac = mac("00:00:00:00:00:57"), mpls = 0x5712},
+   {id = 57, port_id = 0, ip = ip("58.1.1.1"), mac = mac("00:00:00:00:00:58"), mpls = 0x5812},
+   {id = 58, port_id = 0, ip = ip("59.1.1.1"), mac = mac("00:00:00:00:00:59"), mpls = 0x5912},
+   {id = 59, port_id = 0, ip = ip("60.1.1.1"), mac = mac("00:00:00:00:00:60"), mpls = 0x6012},
+   {id = 60, port_id = 0, ip = ip("61.1.1.1"), mac = mac("00:00:00:00:00:61"), mpls = 0x6112},
+   {id = 61, port_id = 0, ip = ip("62.1.1.1"), mac = mac("00:00:00:00:00:62"), mpls = 0x6212},
+   {id = 62, port_id = 0, ip = ip("63.1.1.1"), mac = mac("00:00:00:00:00:63"), mpls = 0x6312},
+   {id = 63, port_id = 0, ip = ip("64.1.1.1"), mac = mac("00:00:00:00:00:64"), mpls = 0x6412},
+}
+
+lpm4.routes = {};
+
+base_ip = 10 * 2^24;
+
+for i = 1,2^13 do
+   res = ip(base_ip + (1 * 2^12) * (i - 1));
+
+   lpm4.routes[i] = {
+      cidr        = {ip = res, depth = 24},
+      next_hop_id = (i - 1) % 64,
+   }
+end
+
+return lpm4
diff --git a/VNFs/DPPD-PROX/config/ipv6.lua b/VNFs/DPPD-PROX/config/ipv6.lua
new file mode 100644
index 00000000..dcd6058f
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/ipv6.lua
@@ -0,0 +1,111 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+lpm6 = {}
+lpm6.next_hops6 = {
+   {id = 0,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0000"), mac = mac("fe:80:00:00:00:00"), mpls = 4660},
+   {id = 1,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0001"), mac = mac("fe:80:00:00:00:00"), mpls = 4661},
+   {id = 2,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0002"), mac = mac("fe:80:00:00:00:00"), mpls = 4662},
+   {id = 3,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0003"), mac = mac("fe:80:00:00:00:00"), mpls = 4663},
+   {id = 4,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0004"), mac = mac("fe:80:00:00:00:00"), mpls = 4664},
+   {id = 5,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0005"), mac = mac("fe:80:00:00:00:00"), mpls = 4665},
+   {id = 6,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0006"), mac = mac("fe:80:00:00:00:00"), mpls = 4666},
+   {id = 7,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0007"), mac = mac("fe:80:00:00:00:00"), mpls = 4667},
+   {id = 8,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0008"), mac = mac("fe:80:00:00:00:00"), mpls = 4668},
+   {id = 9,  port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0009"), mac = mac("fe:80:00:00:00:00"), mpls = 4669},
+   {id = 10, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:000a"), mac = mac("fe:80:00:00:00:00"), mpls = 4670},
+   {id = 11, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:000b"), mac = mac("fe:80:00:00:00:00"), mpls = 4671},
+   {id = 12, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:000c"), mac = mac("fe:80:00:00:00:00"), mpls = 4672},
+   {id = 13, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:000d"), mac = mac("fe:80:00:00:00:00"), mpls = 4673},
+   {id = 14, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:000e"), mac = mac("fe:80:00:00:00:00"), mpls = 4674},
+   {id = 15, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:000f"), mac = mac("fe:80:00:00:00:00"), mpls = 4675},
+   {id = 16, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0010"), mac = mac("fe:80:00:00:00:00"), mpls = 4676},
+   {id = 17, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0011"), mac = mac("fe:80:00:00:00:00"), mpls = 4677},
+   {id = 18, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0012"), mac = mac("fe:80:00:00:00:00"), mpls = 4678},
+   {id = 19, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0013"), mac = mac("fe:80:00:00:00:00"), mpls = 4679},
+   {id = 20, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0014"), mac = mac("fe:80:00:00:00:00"), mpls = 4680},
+   {id = 21, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0015"), mac = mac("fe:80:00:00:00:00"), mpls = 4681},
+   {id = 22, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0016"), mac = mac("fe:80:00:00:00:00"), mpls = 4682},
+   {id = 23, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0017"), mac = mac("fe:80:00:00:00:00"), mpls = 4683},
+   {id = 24, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0018"), mac = mac("fe:80:00:00:00:00"), mpls = 4684},
+   {id = 25, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0019"), mac = mac("fe:80:00:00:00:00"), mpls = 4685},
+   {id = 26, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:001a"), mac = mac("fe:80:00:00:00:00"), mpls = 4686},
+   {id = 27, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:001b"), mac = mac("fe:80:00:00:00:00"), mpls = 4687},
+   {id = 28, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:001c"), mac = mac("fe:80:00:00:00:00"), mpls = 4688},
+   {id = 29, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:001d"), mac = mac("fe:80:00:00:00:00"), mpls = 4689},
+   {id = 30, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:001e"), mac = mac("fe:80:00:00:00:00"), mpls = 4690},
+   {id = 31, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:001f"), mac = mac("fe:80:00:00:00:00"), mpls = 4691},
+   {id = 32, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0020"), mac = mac("fe:80:00:00:00:00"), mpls = 4692},
+   {id = 33, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0021"), mac = mac("fe:80:00:00:00:00"), mpls = 4693},
+   {id = 34, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0022"), mac = mac("fe:80:00:00:00:00"), mpls = 4694},
+   {id = 35, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0023"), mac = mac("fe:80:00:00:00:00"), mpls = 4695},
+   {id = 36, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0024"), mac = mac("fe:80:00:00:00:00"), mpls = 4696},
+   {id = 37, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0025"), mac = mac("fe:80:00:00:00:00"), mpls = 4697},
+   {id = 38, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0026"), mac = mac("fe:80:00:00:00:00"), mpls = 4698},
+   {id = 39, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0027"), mac = mac("fe:80:00:00:00:00"), mpls = 4699},
+   {id = 40, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0028"), mac = mac("fe:80:00:00:00:00"), mpls = 4700},
+   {id = 41, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0029"), mac = mac("fe:80:00:00:00:00"), mpls = 4701},
+   {id = 42, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:002a"), mac = mac("fe:80:00:00:00:00"), mpls = 4702},
+   {id = 43, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:002b"), mac = mac("fe:80:00:00:00:00"), mpls = 4703},
+   {id = 44, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:002c"), mac = mac("fe:80:00:00:00:00"), mpls = 4704},
+   {id = 45, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:002d"), mac = mac("fe:80:00:00:00:00"), mpls = 4705},
+   {id = 46, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:002e"), mac = mac("fe:80:00:00:00:00"), mpls = 4706},
+   {id = 47, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:002f"), mac = mac("fe:80:00:00:00:00"), mpls = 4707},
+   {id = 48, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0030"), mac = mac("fe:80:00:00:00:00"), mpls = 4708},
+   {id = 49, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0031"), mac = mac("fe:80:00:00:00:00"), mpls = 4709},
+   {id = 50, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0032"), mac = mac("fe:80:00:00:00:00"), mpls = 4710},
+   {id = 51, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0033"), mac = mac("fe:80:00:00:00:00"), mpls = 4711},
+   {id = 52, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0034"), mac = mac("fe:80:00:00:00:00"), mpls = 4712},
+   {id = 53, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0035"), mac = mac("fe:80:00:00:00:00"), mpls = 4713},
+   {id = 54, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0036"), mac = mac("fe:80:00:00:00:00"), mpls = 4714},
+   {id = 55, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0037"), mac = mac("fe:80:00:00:00:00"), mpls = 4715},
+   {id = 56, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0038"), mac = mac("fe:80:00:00:00:00"), mpls = 4716},
+   {id = 57, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0039"), mac = mac("fe:80:00:00:00:00"), mpls = 4717},
+   {id = 58, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:003a"), mac = mac("fe:80:00:00:00:00"), mpls = 4718},
+   {id = 59, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:003b"), mac = mac("fe:80:00:00:00:00"), mpls = 4719},
+   {id = 60, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:003c"), mac = mac("fe:80:00:00:00:00"), mpls = 4720},
+   {id = 61, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:003d"), mac = mac("fe:80:00:00:00:00"), mpls = 4721},
+   {id = 62, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:003e"), mac = mac("fe:80:00:00:00:00"), mpls = 4722},
+   {id = 63, port_id = 0, ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:003f"), mac = mac("fe:80:00:00:00:00"), mpls = 4723},
+}
+
+lpm6.routes6 = {}
+
+-- add 1K routes with depth /128
+for i = 1,2^10 do
+   lpm6.routes6[i] = {
+      cidr6 = cidr6("fe80:0000:0000:0000:0200:00ff:fe00:".. string.format("%04x", i - 1) .."/128"),
+      next_hop_id = (i - 1) % 64,
+   }
+end
+
+-- add 1K routes with depth /64
+for i = 1,2^10 do
+   lpm6.routes6[i + 2^10] = {
+      cidr6 = cidr6("fe80:0000:0000:" .. string.format("%04x", i - 1) .. ":0200:00ff:fe00:03e7/64"),
+      next_hop_id = (i - 1) % 64,
+   }
+end
+
+-- -- add fallback routes
+lpm6.routes6[2^11] = {
+   cidr6 = cidr6("fe80:0000:0000:03e7:0200:00ff:fe00:03e7/1"),
+   next_hop_id = 0,
+}
+lpm6.routes6[2^11 + 1] = {
+   cidr6 = cidr6("7e80:0000:0000:03e7:0200:00ff:fe00:03e7/1"),
+   next_hop_id = 0,
+}
diff --git a/VNFs/DPPD-PROX/config/irq.cfg b/VNFs/DPPD-PROX/config/irq.cfg
new file mode 100644
index 00000000..d34c7977
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/irq.cfg
@@ -0,0 +1,46 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[global]
+start time=5
+name=Interrupt (4x)
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=irq
+task=0
+mode=irq
+
+[core 2s0]
+name=irq
+task=0
+mode=irq
+
+[core 3s0]
+name=irq
+task=0
+mode=irq
+
+[core 4s0]
+name=irq
+task=0
+mode=irq
diff --git a/VNFs/DPPD-PROX/config/l2fwd-4ports.cfg b/VNFs/DPPD-PROX/config/l2fwd-4ports.cfg
new file mode 100644
index 00000000..27fd08e5
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/l2fwd-4ports.cfg
@@ -0,0 +1,74 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=if0
+mac=50:00:00:00:00:01
+[port 1]
+name=if1
+mac=50:00:00:00:00:02
+[port 2]
+name=if2
+mac=50:00:00:00:00:03
+[port 3]
+name=if3
+mac=50:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=L2 forward (4x)
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=L2 fwd
+task=0
+mode=l2fwd
+rx port=if0
+tx port=if1
+drop=no
+
+[core 2s0]
+name=L2 fwd
+task=0
+mode=l2fwd
+rx port=if1
+tx port=if0
+drop=no
+
+[core 3s0]
+name=L2 fwd
+task=0
+mode=l2fwd
+rx port=if2
+tx port=if3
+drop=no
+
+[core 4s0]
+name=L2 fwd
+task=0
+mode=l2fwd
+rx port=if3
+tx port=if2
+drop=no
diff --git a/VNFs/DPPD-PROX/config/l3fwd-4ports.cfg b/VNFs/DPPD-PROX/config/l3fwd-4ports.cfg
new file mode 100644
index 00000000..3c452b0e
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/l3fwd-4ports.cfg
@@ -0,0 +1,81 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=if0
+mac=50:00:00:00:00:01
+[port 1]
+name=if1
+mac=50:00:00:00:00:02
+[port 2]
+name=if2
+mac=50:00:00:00:00:03
+[port 3]
+name=if3
+mac=50:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[lua]
+lpm4 = dofile("ipv4.lua")
+
+[global]
+start time=5
+name=Routing (4x)
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=Routing
+task=0
+mode=routing
+route table=lpm4
+rx port=if0
+tx port=if0,if1
+drop=no
+
+[core 2s0]
+name=Routing
+task=0
+mode=routing
+route table=lpm4
+rx port=if1
+tx port=if0,if1
+drop=no
+
+[core 3s0]
+name=Routing
+task=0
+mode=routing
+route table=lpm4
+rx port=if2
+tx port=if2,if3
+drop=no
+
+[core 4s0]
+name=Routing
+task=0
+mode=routing
+route table=lpm4
+rx port=if3
+tx port=if2,if3
+drop=no
diff --git a/VNFs/DPPD-PROX/config/lb_5tuple.cfg b/VNFs/DPPD-PROX/config/lb_5tuple.cfg
new file mode 100644
index 00000000..e958acca
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/lb_5tuple.cfg
@@ -0,0 +1,52 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[lua]
+dofile("tuples.lua")
+
+[port 0]
+name=if0
+mac=hardware
+[port 1]
+name=if1
+mac=hardware
+[port 2]
+name=if2
+mac=hardware
+[port 3]
+name=if3
+mac=hardware
+
+[defaults]
+mempool size=8K
+
+[global]
+start time=5
+name=Load balance 5-tuple
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=lb 5tuple
+task=0
+mode=lb5tuple
+rx port=if0
+tx port=if0,if1,if2,if3
diff --git a/VNFs/DPPD-PROX/config/lw_aftr.cfg b/VNFs/DPPD-PROX/config/lw_aftr.cfg
new file mode 100644
index 00000000..eaed2c5d
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/lw_aftr.cfg
@@ -0,0 +1,115 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration creates the functionality of a lwAFTR component of the
+; lw4over6 architecture as described in IETF draft available at:
+;   http://tools.ietf.org/id/draft-ietf-softwire-lw4over6-13.txt
+; The lwAFTR simply terminates IPv6 tunnels that carry IPv4 traffic for many
+; customers (one tunnel per customer). It consists of two tasks:
+; 1) ipv6_encap that encapsulates IPv4 packets into IPv6 and sends those tunnel
+;    packets towards the customer tunnel endpoint. For this, it must use a
+;    binding table that associates with each tunnel, a public IPv4 address and a
+;    set of ports.
+; 2) ipv6_decap which handles packets arriving from the tunnel, checks they use
+;    a source IPv4 address and port combination that matches their originating
+;    tunnel (based on the same binding table as used by ipv6_encap), removes the
+;    IPv6 encapsulation and sends them out its "internet" interface.
+; The binding table must be loaded in the [lua] section and assigned to the
+; tasks using the "tun_bindings" parameter. This configuration loads its binding
+; table from the provided ip6_tun_bind.lua but other binding tables can be used.
+;
+; Binding tables of different sizes and different ranges of addresses and ports
+; can be generated by a provided helper script:
+;   helper-scripts/ipv6_tun/ipv6_tun_bindings.pl -n <num_entries>
+; Most other parameters of the generated binding table can be tweaked through
+; script command-line switches. For more details, refer to the documentation of
+; the script obtained by running it with -help as argument.
+; The same script can also generate tables for testing tools to generate packets
+; with addresses and ports that match entries from the binding table (randomly
+; selecting entries from the binding table).
+; Additionally, the helper-scripts/ipv6_tun/gen_4over6.pl script can be used to
+; generate pcap files with IPv6 (tunnel) and IPv4 (internet) traffic matching a
+; given binding table.
+; Example usage:
+;   ./helper-scripts/ipv6_tun/ipv6_tun_bindings.pl -n 100000 -suffix _100k
+;   ./helper-scripts/ipv6_tun/gen_4over6.pl -tun -count=200000 \
+;       -in ip6_tun_bind_100k.lua -out lwAFTR_tun_100k.pcap
+;   ./helper-scripts/ipv6_tun/gen_4over6.pl -inet -count=200000 \
+;       -in ip6_tun_bind_100k.lua -out lwAFTR_inet_100k.pcap
+; The above sequence of invocations generates a binding table with 100k entries,
+; written to file ip6_tun_bind_100k.lua (which the PROX configuration file needs
+; to load in the [lua] section then assign using the "tun_bindings" parameter),
+; and two pcap files to be used to generate traffic that will hit valid entries
+; from the binding table. Each pcap file contains 200k packets of either IPv4 or
+; IPv6 traffic.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=inet_0
+mac=00:00:00:00:00:01
+[port 1]
+name=lwB4_0
+mac=00:00:00:00:00:03
+
+[variables]
+$tun_hop_limit=5
+$local_ipv6=fe80:0000:0000:0000:0100:00ff:fe00:0000
+$lookup_port_mask=0xffc0
+
+[lua]
+bindings = dofile("ip6_tun_bind.lua")
+
+[defaults]
+mempool size=16K
+
+[global]
+start time=20
+name=lwAFTR
+
+[core 0s0]
+mode=master
+
+;*****************************************************************************************
+;##### Send Internet IPv4 traffic into IPv6 tunnels, according to binding table ####
+[core 1s0]
+name=v6_encap
+task=0
+mode=ipv6_encap
+rx port=inet_0
+tx port=lwB4_0
+local ipv6=$local_ipv6
+tunnel hop limit=$tun_hop_limit
+lookup port mask=$lookup_port_mask
+tun_bindings=bindings
+;*****************************************************************************************
+;##### Terminate IPv6 tunnels and transmit IPv4 out to Internet ####
+;# Binding table is checked to ensure src IPv4 address and port combo is allocated to the originating tunnel
+[core 2s0]
+name=v6_decap
+task=0
+mode=ipv6_decap
+rx port=lwB4_0
+tx port=inet_0
+dst mac=fe:80:00:ee:00:01
+local ipv6=$local_ipv6
+tunnel hop limit=$tun_hop_limit
+lookup port mask=$lookup_port_mask
+tun_bindings=bindings
diff --git a/VNFs/DPPD-PROX/config/nat_table.lua b/VNFs/DPPD-PROX/config/nat_table.lua
new file mode 100644
index 00000000..4e3a78ab
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/nat_table.lua
@@ -0,0 +1,26 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+return {
+   {from = ip("10.10.100.100"), to = ip("192.168.1.1")},
+   {from = ip("192.168.1.1"), to = ip("10.10.100.100")},
+   {from = ip("192.168.1.101"), to = ip("10.10.10.101")},
+   {from = ip("10.10.10.101"), to = ip("192.168.1.101")},
+   {from = ip("192.168.1.102"), to = ip("10.10.10.102")},
+   {from = ip("10.10.10.102"), to = ip("192.168.1.102")},
+   {from = ip("192.168.100.100"), to = ip("10.0.100.100")},
+   {from = ip("10.0.100.100"), to = ip("192.168.100.100")},
+}
diff --git a/VNFs/DPPD-PROX/config/nop-rings.cfg b/VNFs/DPPD-PROX/config/nop-rings.cfg
new file mode 100644
index 00000000..000353ad
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/nop-rings.cfg
@@ -0,0 +1,109 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This configuration is similar to config/nop.cfg with the difference being the
+; type of interfaces. The physical ports are replaced by DPDK rings. To use this
+; functionality, RTE_TARGET must be set to x86_64-ivshmem-linuxapp-gcc before
+; compiling DPDK (i.e. export RTE_TARGET=x86_64-ivshmem-linuxapp-gcc). Also,
+; DPDK needs to be compiled with both CONFIG_RTE_BUILD_COMBINE_LIBS=y and
+; CONFIG_RTE_LIBRTE_VHOST=y
+; The configuration can then be used inside a VM running on top of Open vSwitch.
+; The SHA-1 of the Open vSwitch version that has been tested is c78a00b112c9. To
+; run the VM, Qemu needs to be patched to support ivshmem with multiple regions
+; and the right command line arguments to be used to share memory. Download and
+; patch Qemu 1.6.2 using the following commands:
+;   git clone git://git.qemu-project.org/qemu.git
+;   cd qemu
+;   git checkout v1.6.2
+;   wget https://01.org/sites/default/files/page/qemu-v1.6.2-ivshmem-dpdk.patch
+;   patch -p1 < qemu-v1.6.2-ivshmem-dpdk.patch
+;   ./configure
+;   make
+; After Open vSwitch has been configured with DPDK rings as ports (i.e. ports
+; with type dpdkr), Qemu needs to be started with the correct command line
+; arguments. Refer to Section 11.1 from the DPDK Programmer's Guide on how to
+; build the Qemu command line arguments.
+; This configuration uses 4 ports. This means that 8 rings (4 for TX and 4 for
+; RX) will need to be shared with the VM through ivshmem.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=if0
+mac=00:00:00:00:00:01
+rx_ring=dpdkr0_tx
+tx_ring=dpdkr0_rx
+[port 1]
+name=if1
+mac=00:00:00:00:00:02
+rx_ring=dpdkr1_tx
+tx_ring=dpdkr1_rx
+[port 2]
+name=if2
+mac=00:00:00:00:00:03
+rx_ring=dpdkr2_tx
+tx_ring=dpdkr2_rx
+[port 3]
+name=if3
+mac=00:00:00:00:00:04
+rx_ring=dpdkr3_tx
+tx_ring=dpdkr3_rx
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=NOP forwarding rings (4x)
+
+[core 0]
+mode=master
+
+[core 1]
+name=nop
+task=0
+mode=nop
+rx port=if0
+tx port=if1
+drop=no
+
+[core 2]
+name=nop
+task=0
+mode=nop
+rx port=if1
+tx port=if0
+drop=no
+
+[core 3]
+name=nop
+task=0
+mode=nop
+rx port=if2
+tx port=if3
+drop=no
+
+[core 4]
+name=nop
+task=0
+mode=nop
+rx port=if3
+tx port=if2
+drop=no
diff --git a/VNFs/DPPD-PROX/config/nop.cfg b/VNFs/DPPD-PROX/config/nop.cfg
new file mode 100644
index 00000000..757b1eda
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/nop.cfg
@@ -0,0 +1,86 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+;;
+; This is one of the most basic configurations. Note that this configuration
+; does not perform any real work as opposed to configurations like BNG/BRAS
+; or lwAFTR. This configuration sets up four interfaces and five cores (one
+; master core and four worker cores). Packets are passed (i.e. without being
+; touched) as follows:
+; - interface 0 to interface 1 (handled by core 1)
+; - interface 1 to interface 0 (handled by core 2)
+; - interface 2 to interface 3 (handled by core 3)
+; - interface 3 to interface 2 (handled by core 4)
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=if0
+mac=hardware
+[port 1]
+name=if1
+mac=hardware
+[port 2]
+name=if2
+mac=hardware
+[port 3]
+name=if3
+mac=hardware
+
+[defaults]
+mempool size=2K
+
+[global]
+start time=5
+name=NOP forwarding (4x)
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=nop
+task=0
+mode=nop
+rx port=if0
+tx port=if1
+drop=no
+
+[core 2s0]
+name=nop
+task=0
+mode=nop
+rx port=if1
+tx port=if0
+drop=no
+
+[core 3s0]
+name=nop
+task=0
+mode=nop
+rx port=if2
+tx port=if3
+drop=no
+
+[core 4s0]
+name=nop
+task=0
+mode=nop
+rx port=if3
+tx port=if2
+drop=no
diff --git a/VNFs/DPPD-PROX/config/nsh_acl.cfg b/VNFs/DPPD-PROX/config/nsh_acl.cfg
new file mode 100644
index 00000000..2893bd4d
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/nsh_acl.cfg
@@ -0,0 +1,58 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=if0
+mac=hardware
+[port 1]
+name=if1
+mac=hardware
+[lua]
+acl_table=dofile("acl_table.lua")
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=Firewall
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=firewall
+task=0
+mode=decapnsh
+rx port=if0
+tx cores=${self}t1
+
+task=1
+mode=acl
+rx ring=yes
+tx cores=${self}t2
+rules=acl_table
+qinq=no
+
+task=2
+mode=encapnsh
+rx ring=yes
+tx port=if0
+drop=no
diff --git a/VNFs/DPPD-PROX/config/nsh_nat.cfg b/VNFs/DPPD-PROX/config/nsh_nat.cfg
new file mode 100644
index 00000000..bb3bf4bc
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/nsh_nat.cfg
@@ -0,0 +1,57 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=if0
+mac=hardware
+[port 1]
+name=if1
+mac=hardware
+[lua]
+nat_table = dofile("nat_table.lua")
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=Network Address Translation
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=nat
+task=0
+mode=decapnsh
+rx port=if0
+tx cores=${self}t1
+
+task=1
+mode=nat
+rx ring=yes
+tx cores=${self}t2
+nat table=nat_table
+
+task=2
+mode=encapnsh
+rx ring=yes
+tx port=if0
+drop=no
diff --git a/VNFs/DPPD-PROX/config/pe-4ports.cfg b/VNFs/DPPD-PROX/config/pe-4ports.cfg
new file mode 100644
index 00000000..1c7556e1
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/pe-4ports.cfg
@@ -0,0 +1,170 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=if0
+mac=hardware
+[port 1]
+name=inet0
+mac=hardware
+[port 2]
+name=if1
+mac=hardware
+[port 3]
+name=inet1
+mac=hardware
+[lua]
+lpm4 = dofile("ipv4-2.lua")
+dscp_table = dofile("dscp2.lua")
+cpe_table = dofile("cpe_table.lua")
+acl_table = dofile("rules-2.lua")
+user_table = dofile("user_table-pe.lua")
+[defaults]
+mempool size=65K
+[global]
+start time=5
+name=PE
+cpe table map=if0,if1,if0,if1
+
+[variables]
+;$wkd=5s1-6s1,5s1h-6s1h; 4 workers
+;$wku=7s1-9s1,7s1h-9s1h; 6 workers
+$wkd=5s1-6s1,5s1h-6s1h; 6 workers
+$wku=7s1-9s1,7s1h-9s1h; 10 workers
+[core 0s1]
+task=0
+mode=master
+tx cores=(${wku})t3m
+
+[core 1s1]
+name=LB-inet0
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wkd})t0 proto=ipv4
+
+[core 1s1h]
+name=LB-inet1
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet1
+tx cores=(${wkd})t0 proto=ipv4
+
+[core 2s1]
+name=LB-c0
+task=0
+mode=lbnetwork
+rx port=if0
+mempool size=16K
+untag mpls=no
+tx cores=(${wku})t0 proto=ipv4
+
+[core 2s1h]
+name=LB-c1
+task=0
+mode=lbnetwork
+mempool size=16K
+untag mpls=no
+rx port=if1
+tx cores=(${wku})t0 proto=ipv4
+
+[core $wkd]
+name=W-down
+task=0
+mode=qinqencapv4
+sub mode=pe
+rx ring=yes
+tx cores from cpe table=3s1,4s1 remap=if0,if1
+user table=user_table
+cpe table=cpe_table
+classify=yes
+dscp=dscp_table
+
+[core $wku]
+name=W-up
+task=0
+mode=acl
+rx ring=yes
+rules=acl_table
+tx cores=${self}t1
+max rules=32768
+
+task=1
+mode=police
+sub mode=trtcm
+police action=yellow io=green,green
+police action=drop io=green,yellow
+police action=drop io=green,red
+police action=drop io=yellow,yellow
+police action=drop io=yellow,red
+police action=drop io=red,red
+cir=4000000000
+pir=4000000000
+cbs=20480
+pbs=20480
+classify=yes
+rx ring=yes
+tx cores=${self}t2
+users=256
+mark=yes
+user table=user_table
+
+task=2
+mode=untag
+ether type=0xa888
+rx ring=yes
+tx cores=${self}t3
+
+task=3
+mode=routing
+add mpls=yes
+rx ring=yes
+tx ports from routing table=inet0,inet1,inet0,inet1
+route table=lpm4
+mark=yes
+mark green=1
+mark yellow=2
+mark red=3
+
+[core 3s1]
+name=qos1
+task=0
+rx ring=yes
+mode=qos
+tx port=if0
+pipes=256
+pipe tb rate=6250000
+pipe tc rate=6250000
+drop=no
+user table=user_table
+
+[core 4s1]
+name=qos1
+rx ring=yes
+task=0
+mode=qos
+tx port=if1
+pipes=256
+pipe tb rate=6250000
+pipe tc rate=6250000
+drop=no
+user table=user_table
diff --git a/VNFs/DPPD-PROX/config/pe-8ports.cfg b/VNFs/DPPD-PROX/config/pe-8ports.cfg
new file mode 100644
index 00000000..b67c48ba
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/pe-8ports.cfg
@@ -0,0 +1,232 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=if0
+mac=hardware
+[port 1]
+name=inet0
+mac=hardware
+[port 2]
+name=if1
+mac=hardware
+[port 3]
+name=inet1
+mac=hardware
+[port 4]
+name=if2
+mac=hardware
+[port 5]
+name=inet2
+mac=hardware
+[port 6]
+name=if3
+mac=hardware
+[port 7]
+name=inet3
+mac=hardware
+[lua]
+lpm4 = dofile("ipv4-2.lua")
+dscp_table = dofile("dscp2.lua")
+cpe_table = dofile("cpe_table.lua")
+acl_table = dofile("rules-2.lua")
+user_table = dofile("user_table-pe.lua")
+[defaults]
+mempool size=65K
+[global]
+start time=5
+name=PE
+cpe table map=if0,if1,if2,if3
+
+[variables]
+$wkd=5s1-6s1,5s1h-6s1h; 4 workers
+$wku=7s1-9s1,7s1h-9s1h; 6 workers
+;$wkd=5s1-6s1,5s1h-6s1h; 6 workers
+;$wku=7s1-9s1,7s1h-9s1h; 10 workers
+[core 0s1]
+task=0
+mode=master
+tx cores=(${wku})t3m
+
+[core 1s1]
+name=LB-inet0
+task=0
+mode=lbnetwork
+rx port=inet0
+untag mpls=yes
+tx cores=(${wkd})t0 proto=ipv4
+
+task=1
+mode=lbnetwork
+rx port=inet2
+untag mpls=yes
+tx cores=(${wkd})t0 proto=ipv4
+
+[core 1s1h]
+name=LB-inet1
+task=0
+mode=lbnetwork
+untag mpls=yes
+rx port=inet1
+tx cores=(${wkd})t0 proto=ipv4
+
+task=1
+mode=lbnetwork
+untag mpls=yes
+rx port=inet3
+tx cores=(${wkd})t0 proto=ipv4
+
+[core 2s1]
+name=LB-c0
+task=0
+mode=lbnetwork
+rx port=if0
+mempool size=16K
+untag mpls=no
+tx cores=(${wku})t0 proto=ipv4
+
+task=1
+mode=lbnetwork
+rx port=if2
+mempool size=16K
+untag mpls=no
+tx cores=(${wku})t0 proto=ipv4
+
+[core 2s1h]
+name=LB-c1
+task=0
+mode=lbnetwork
+mempool size=16K
+untag mpls=no
+rx port=if1
+tx cores=(${wku})t0 proto=ipv4
+
+task=1
+mode=lbnetwork
+mempool size=16K
+untag mpls=no
+rx port=if3
+tx cores=(${wku})t0 proto=ipv4
+
+[core $wkd]
+name=W-down
+task=0
+mode=qinqencapv4
+sub mode=pe
+rx ring=yes
+tx cores from cpe table=3s1,4s1,3s1h,4s1h remap=if0,if1,if2,if3
+user table=user_table
+cpe table=cpe_table
+classify=yes
+dscp=dscp_table
+
+[core $wku]
+name=W-up
+task=0
+mode=acl
+rx ring=yes
+rules=acl_table
+tx cores=${self}t1
+max rules=32768
+
+task=1
+mode=police
+sub mode=trtcm
+police action=yellow io=green,green
+police action=drop io=green,yellow
+police action=drop io=green,red
+police action=drop io=yellow,yellow
+police action=drop io=yellow,red
+police action=drop io=red,red
+cir=4000000000
+pir=4000000000
+cbs=20480
+pbs=20480
+classify=yes
+rx ring=yes
+tx cores=${self}t2
+users=256
+mark=yes
+user table=user_table
+
+task=2
+mode=untag
+ether type=0xa888
+rx ring=yes
+tx cores=${self}t3
+
+task=3
+mode=routing
+add mpls=yes
+rx ring=yes
+tx ports from routing table=inet0,inet1,inet2,inet3
+route table=lpm4
+mark=yes
+mark green=1
+mark yellow=2
+mark red=3
+
+[core 3s1]
+name=qos1
+task=0
+rx ring=yes
+mode=qos
+tx port=if0
+pipes=256
+pipe tb rate=6250000
+pipe tc rate=6250000
+drop=no
+user table=user_table
+
+[core 4s1]
+name=qos1
+rx ring=yes
+task=0
+mode=qos
+tx port=if1
+pipes=256
+pipe tb rate=6250000
+pipe tc rate=6250000
+drop=no
+user table=user_table
+
+[core 3s1h]
+name=qos1
+task=0
+rx ring=yes
+mode=qos
+tx port=if2
+pipes=256
+pipe tb rate=6250000
+pipe tc rate=6250000
+drop=no
+user table=user_table
+
+[core 4s1h]
+name=qos1
+rx ring=yes
+task=0
+mode=qos
+tx port=if3
+pipes=256
+pipe tb rate=6250000
+pipe tc rate=6250000
+drop=no
+user table=user_table
diff --git a/VNFs/DPPD-PROX/config/rules-1.lua b/VNFs/DPPD-PROX/config/rules-1.lua
new file mode 100644
index 00000000..20d33f3d
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/rules-1.lua
@@ -0,0 +1,33 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+seven_tuple = function(svlan, cvlan, ip_proto, src, dst, sport, dport, action)
+   return {
+      svlan_id = svlan,
+      cvlan_id = cvlan,
+      ip_proto = ip_proto,
+      src_cidr = src,
+      dst_cidr = dst,
+      sport    = sport,
+      dport    = dport,
+      action   = action,
+   }
+end
+
+return {
+   seven_tuple(val_mask(0, 0x0000), val_mask(0, 0x0000), val_mask(17, 0xff), cidr("192.168.0.0/18"), cidr("10.0.0.0/7"), val_range(0,65535), val_range(0,65535), "allow"),
+   seven_tuple(val_mask(0, 0x0000), val_mask(0, 0x0000), val_mask(17, 0xff), cidr("192.168.0.0/18"), cidr("74.0.0.0/7"), val_range(0,65535), val_range(0,65535), "allow"),
+}
diff --git a/VNFs/DPPD-PROX/config/rules-2.lua b/VNFs/DPPD-PROX/config/rules-2.lua
new file mode 100644
index 00000000..3e2762be
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/rules-2.lua
@@ -0,0 +1,51 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+seven_tuple = function(svlan, cvlan, ip_proto, src, dst, sport, dport, action)
+   return {
+      svlan_id = svlan,
+      cvlan_id = cvlan,
+      ip_proto = ip_proto,
+      src_cidr = src,
+      dst_cidr = dst,
+      sport    = sport,
+      dport    = dport,
+      action   = action,
+   }
+end
+
+rules2={};
+sports={0,2,4,6,8,10,12,14};
+src_t={{s="192.168.0.0/18", svlan1=0, svlan2=1},
+       {s="192.168.16.0/18", svlan1=16, svlan2=17},
+       {s="192.168.32.0/18", svlan1=32, svlan2=33},
+       {s="192.168.48.0/18", svlan1=48, svlan2=49},
+      };
+
+for srck,srcv in pairs(src_t) do
+ for cvlan_mask = 0,255 do
+  for spk,spv in pairs(sports) do
+    table.insert(rules2,seven_tuple(val_mask(srcv.svlan1,0x0fff), val_mask(cvlan_mask,0x0fff), val_mask(17,0xff), cidr(srcv.s), cidr("10.0.0.0/7"), val_range(spv,spv), val_range(0,511), "allow"));
+    table.insert(rules2,seven_tuple(val_mask(srcv.svlan1,0x0fff), val_mask(cvlan_mask,0x0fff), val_mask(17,0xff), cidr(srcv.s), cidr("74.0.0.0/7"), val_range(spv,spv), val_range(0,511), "allow"));
+    table.insert(rules2,seven_tuple(val_mask(srcv.svlan2,0x0fff), val_mask(cvlan_mask,0x0fff), val_mask(17,0xff), cidr(srcv.s), cidr("10.0.0.0/7"), val_range(spv,spv), val_range(0,511), "allow"));
+    table.insert(rules2,seven_tuple(val_mask(srcv.svlan2,0x0fff), val_mask(cvlan_mask,0x0fff), val_mask(17,0xff), cidr(srcv.s), cidr("74.0.0.0/7"), val_range(spv,spv), val_range(0,511), "allow"));
+   table.insert(rules2,rules4);
+  end
+ end
+end
+
+return rules2
+
diff --git a/VNFs/DPPD-PROX/config/tuples.lua b/VNFs/DPPD-PROX/config/tuples.lua
new file mode 100644
index 00000000..268efff4
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/tuples.lua
@@ -0,0 +1,28 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+tuples = {};
+
+for i = 0,2^23-1 do
+    tuples[i] = {if_out = i%4,
+                ip_src = i%2^5,
+                ip_dst = ((i-i%2^5)/2^5)%2^5,
+                port_src = ((i-i%2^10)/2^10)%2^5,
+                port_dst = ((i-i%2^15)/2^15)%2^5,
+                proto = ((i-i%2^20)/2^20)%2^3 * 2^5,
+            }
+end
+
diff --git a/VNFs/DPPD-PROX/config/user_table-131K-bng.lua b/VNFs/DPPD-PROX/config/user_table-131K-bng.lua
new file mode 100644
index 00000000..10475796
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/user_table-131K-bng.lua
@@ -0,0 +1,74 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+-- This script generates a user table containing 131072 users. It is
+-- meant to be used in a BNG with 4 CPE facing ports. Each of the CPE
+-- facing ports has 32768 users behind it. Each user has a unique
+-- svlan/cvlan combination. The only difference between the two sets
+-- of users is the svlan id. Note that any arbitrary configuration is
+-- possible.
+
+local user_table = {}
+
+for i = 1,2^15 do
+   idx = i - 1
+   user_table[i] = {
+      gre_id   = idx,
+      -- svlan_id is 000000000XXXXXXX at the bit level
+      -- cvlan_id is 0000XXXX00XX00XX at the bit level
+      svlan_id = mask(idx, 0x7f00) / 2^8,
+      cvlan_id = mask(idx, 0xf0) * 2^4 + mask(idx, 0xc) * 2^2 + mask(idx, 0x3),
+      user_id  = idx,
+   }
+end
+
+for i = 1,2^15 do
+   idx = i - 1
+   user_table[2^15 + i] = {
+      gre_id   = 2^15 + idx,
+      -- svlan_id is 000000001XXXXXXX at the bit level
+      -- cvlan_id is 0000XXXX00XX00XX at the bit level
+      svlan_id = mask(idx, 0x7f00) / 2^8 + 0x80,
+      cvlan_id = mask(idx, 0xf0) * 2^4 + mask(idx, 0xc) * 2^2 + mask(idx, 0x3),
+      user_id  = idx,
+   }
+end
+
+for i = 1,2^15 do
+   idx = i - 1
+   user_table[2*2^15 + i] = {
+      gre_id   = 2*2^15 + idx,
+      -- svlan_id is 000000010XXXXXXX at the bit level
+      -- cvlan_id is 0000XXXX00XX00XX at the bit level
+      svlan_id = mask(idx, 0x7f00) / 2^8 + 0x100,
+      cvlan_id = mask(idx, 0xf0) * 2^4 + mask(idx, 0xc) * 2^2 + mask(idx, 0x3),
+      user_id  = idx,
+   }
+end
+
+for i = 1,2^15 do
+   idx = i - 1
+   user_table[3*2^15 + i] = {
+      gre_id   = 3*2^15 + idx,
+      -- svlan_id is 000000011XXXXXXX at the bit level
+      -- cvlan_id is 0000XXXX00XX00XX at the bit level
+      svlan_id = mask(idx, 0x7f00) / 2^8 + 0x180,
+      cvlan_id = mask(idx, 0xf0) * 2^4 + mask(idx, 0xc) * 2^2 + mask(idx, 0x3),
+      user_id  = idx,
+   }
+end
+
+return user_table
diff --git a/VNFs/DPPD-PROX/config/user_table-65K-bng.lua b/VNFs/DPPD-PROX/config/user_table-65K-bng.lua
new file mode 100644
index 00000000..aa62874c
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/user_table-65K-bng.lua
@@ -0,0 +1,50 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+-- This script generates a user table containing 65536 users. It is
+-- meant to be used in a BNG with 2 CPE facing ports. Each of the CPE
+-- facing ports has 32768 users behind it. Each user has a unique
+-- svlan/cvlan combination. The only difference between the two sets
+-- of users is the svlan id. Note that any arbitrary configuration is
+-- possible.
+
+local user_table = {}
+
+for i = 1,2^15 do
+   idx = i - 1
+   user_table[i] = {
+      gre_id   = idx,
+      -- svlan_id is 000000000XXXXXXX at the bit level
+      -- cvlan_id is 0000XXXX00XX00XX at the bit level
+      svlan_id = mask(idx, 0x7f00) / 2^8,
+      cvlan_id = mask(idx, 0xf0) * 2^4 + mask(idx, 0xc) * 2^2 + mask(idx, 0x3),
+      user_id  = idx,
+   }
+end
+
+for i = 1,2^15 do
+   idx = i - 1
+   user_table[2^15 + i] = {
+      gre_id   = 2^15 + idx,
+      -- svlan_id is 000000001XXXXXXX at the bit level
+      -- cvlan_id is 0000XXXX00XX00XX at the bit level
+      svlan_id = mask(idx, 0x7f00) / 2^8 + 0x80,
+      cvlan_id = mask(idx, 0xf0) * 2^4 + mask(idx, 0xc) * 2^2 + mask(idx, 0x3),
+      user_id  = idx,
+   }
+end
+
+return user_table
diff --git a/VNFs/DPPD-PROX/config/user_table-pe.lua b/VNFs/DPPD-PROX/config/user_table-pe.lua
new file mode 100644
index 00000000..67afbffa
--- /dev/null
+++ b/VNFs/DPPD-PROX/config/user_table-pe.lua
@@ -0,0 +1,2066 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+return {
+   {gre_id = 0, svlan_id = 0, cvlan_id = 0, user_id = 0},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 0, user_id = 0},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 1, user_id = 1},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 1, user_id = 1},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 2, user_id = 2},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 2, user_id = 2},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 3, user_id = 3},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 3, user_id = 3},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 4, user_id = 4},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 4, user_id = 4},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 5, user_id = 5},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 5, user_id = 5},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 6, user_id = 6},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 6, user_id = 6},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 7, user_id = 7},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 7, user_id = 7},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 8, user_id = 8},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 8, user_id = 8},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 9, user_id = 9},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 9, user_id = 9},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 10, user_id = 10},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 10, user_id = 10},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 11, user_id = 11},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 11, user_id = 11},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 12, user_id = 12},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 12, user_id = 12},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 13, user_id = 13},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 13, user_id = 13},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 14, user_id = 14},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 14, user_id = 14},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 15, user_id = 15},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 15, user_id = 15},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 16, user_id = 16},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 16, user_id = 16},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 17, user_id = 17},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 17, user_id = 17},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 18, user_id = 18},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 18, user_id = 18},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 19, user_id = 19},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 19, user_id = 19},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 20, user_id = 20},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 20, user_id = 20},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 21, user_id = 21},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 21, user_id = 21},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 22, user_id = 22},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 22, user_id = 22},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 23, user_id = 23},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 23, user_id = 23},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 24, user_id = 24},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 24, user_id = 24},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 25, user_id = 25},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 25, user_id = 25},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 26, user_id = 26},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 26, user_id = 26},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 27, user_id = 27},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 27, user_id = 27},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 28, user_id = 28},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 28, user_id = 28},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 29, user_id = 29},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 29, user_id = 29},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 30, user_id = 30},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 30, user_id = 30},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 31, user_id = 31},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 31, user_id = 31},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 32, user_id = 32},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 32, user_id = 32},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 33, user_id = 33},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 33, user_id = 33},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 34, user_id = 34},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 34, user_id = 34},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 35, user_id = 35},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 35, user_id = 35},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 36, user_id = 36},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 36, user_id = 36},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 37, user_id = 37},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 37, user_id = 37},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 38, user_id = 38},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 38, user_id = 38},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 39, user_id = 39},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 39, user_id = 39},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 40, user_id = 40},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 40, user_id = 40},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 41, user_id = 41},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 41, user_id = 41},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 42, user_id = 42},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 42, user_id = 42},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 43, user_id = 43},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 43, user_id = 43},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 44, user_id = 44},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 44, user_id = 44},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 45, user_id = 45},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 45, user_id = 45},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 46, user_id = 46},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 46, user_id = 46},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 47, user_id = 47},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 47, user_id = 47},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 48, user_id = 48},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 48, user_id = 48},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 49, user_id = 49},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 49, user_id = 49},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 50, user_id = 50},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 50, user_id = 50},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 51, user_id = 51},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 51, user_id = 51},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 52, user_id = 52},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 52, user_id = 52},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 53, user_id = 53},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 53, user_id = 53},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 54, user_id = 54},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 54, user_id = 54},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 55, user_id = 55},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 55, user_id = 55},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 56, user_id = 56},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 56, user_id = 56},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 57, user_id = 57},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 57, user_id = 57},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 58, user_id = 58},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 58, user_id = 58},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 59, user_id = 59},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 59, user_id = 59},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 60, user_id = 60},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 60, user_id = 60},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 61, user_id = 61},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 61, user_id = 61},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 62, user_id = 62},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 62, user_id = 62},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 63, user_id = 63},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 63, user_id = 63},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 64, user_id = 64},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 64, user_id = 64},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 65, user_id = 65},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 65, user_id = 65},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 66, user_id = 66},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 66, user_id = 66},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 67, user_id = 67},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 67, user_id = 67},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 68, user_id = 68},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 68, user_id = 68},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 69, user_id = 69},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 69, user_id = 69},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 70, user_id = 70},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 70, user_id = 70},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 71, user_id = 71},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 71, user_id = 71},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 72, user_id = 72},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 72, user_id = 72},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 73, user_id = 73},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 73, user_id = 73},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 74, user_id = 74},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 74, user_id = 74},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 75, user_id = 75},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 75, user_id = 75},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 76, user_id = 76},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 76, user_id = 76},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 77, user_id = 77},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 77, user_id = 77},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 78, user_id = 78},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 78, user_id = 78},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 79, user_id = 79},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 79, user_id = 79},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 80, user_id = 80},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 80, user_id = 80},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 81, user_id = 81},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 81, user_id = 81},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 82, user_id = 82},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 82, user_id = 82},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 83, user_id = 83},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 83, user_id = 83},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 84, user_id = 84},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 84, user_id = 84},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 85, user_id = 85},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 85, user_id = 85},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 86, user_id = 86},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 86, user_id = 86},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 87, user_id = 87},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 87, user_id = 87},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 88, user_id = 88},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 88, user_id = 88},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 89, user_id = 89},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 89, user_id = 89},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 90, user_id = 90},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 90, user_id = 90},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 91, user_id = 91},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 91, user_id = 91},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 92, user_id = 92},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 92, user_id = 92},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 93, user_id = 93},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 93, user_id = 93},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 94, user_id = 94},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 94, user_id = 94},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 95, user_id = 95},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 95, user_id = 95},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 96, user_id = 96},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 96, user_id = 96},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 97, user_id = 97},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 97, user_id = 97},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 98, user_id = 98},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 98, user_id = 98},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 99, user_id = 99},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 99, user_id = 99},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 100, user_id = 100},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 100, user_id = 100},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 101, user_id = 101},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 101, user_id = 101},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 102, user_id = 102},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 102, user_id = 102},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 103, user_id = 103},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 103, user_id = 103},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 104, user_id = 104},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 104, user_id = 104},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 105, user_id = 105},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 105, user_id = 105},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 106, user_id = 106},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 106, user_id = 106},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 107, user_id = 107},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 107, user_id = 107},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 108, user_id = 108},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 108, user_id = 108},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 109, user_id = 109},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 109, user_id = 109},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 110, user_id = 110},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 110, user_id = 110},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 111, user_id = 111},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 111, user_id = 111},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 112, user_id = 112},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 112, user_id = 112},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 113, user_id = 113},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 113, user_id = 113},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 114, user_id = 114},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 114, user_id = 114},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 115, user_id = 115},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 115, user_id = 115},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 116, user_id = 116},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 116, user_id = 116},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 117, user_id = 117},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 117, user_id = 117},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 118, user_id = 118},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 118, user_id = 118},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 119, user_id = 119},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 119, user_id = 119},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 120, user_id = 120},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 120, user_id = 120},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 121, user_id = 121},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 121, user_id = 121},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 122, user_id = 122},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 122, user_id = 122},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 123, user_id = 123},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 123, user_id = 123},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 124, user_id = 124},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 124, user_id = 124},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 125, user_id = 125},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 125, user_id = 125},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 126, user_id = 126},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 126, user_id = 126},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 127, user_id = 127},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 127, user_id = 127},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 128, user_id = 128},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 128, user_id = 128},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 129, user_id = 129},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 129, user_id = 129},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 130, user_id = 130},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 130, user_id = 130},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 131, user_id = 131},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 131, user_id = 131},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 132, user_id = 132},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 132, user_id = 132},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 133, user_id = 133},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 133, user_id = 133},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 134, user_id = 134},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 134, user_id = 134},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 135, user_id = 135},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 135, user_id = 135},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 136, user_id = 136},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 136, user_id = 136},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 137, user_id = 137},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 137, user_id = 137},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 138, user_id = 138},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 138, user_id = 138},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 139, user_id = 139},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 139, user_id = 139},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 140, user_id = 140},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 140, user_id = 140},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 141, user_id = 141},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 141, user_id = 141},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 142, user_id = 142},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 142, user_id = 142},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 143, user_id = 143},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 143, user_id = 143},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 144, user_id = 144},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 144, user_id = 144},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 145, user_id = 145},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 145, user_id = 145},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 146, user_id = 146},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 146, user_id = 146},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 147, user_id = 147},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 147, user_id = 147},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 148, user_id = 148},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 148, user_id = 148},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 149, user_id = 149},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 149, user_id = 149},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 150, user_id = 150},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 150, user_id = 150},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 151, user_id = 151},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 151, user_id = 151},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 152, user_id = 152},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 152, user_id = 152},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 153, user_id = 153},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 153, user_id = 153},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 154, user_id = 154},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 154, user_id = 154},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 155, user_id = 155},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 155, user_id = 155},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 156, user_id = 156},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 156, user_id = 156},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 157, user_id = 157},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 157, user_id = 157},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 158, user_id = 158},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 158, user_id = 158},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 159, user_id = 159},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 159, user_id = 159},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 160, user_id = 160},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 160, user_id = 160},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 161, user_id = 161},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 161, user_id = 161},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 162, user_id = 162},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 162, user_id = 162},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 163, user_id = 163},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 163, user_id = 163},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 164, user_id = 164},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 164, user_id = 164},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 165, user_id = 165},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 165, user_id = 165},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 166, user_id = 166},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 166, user_id = 166},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 167, user_id = 167},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 167, user_id = 167},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 168, user_id = 168},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 168, user_id = 168},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 169, user_id = 169},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 169, user_id = 169},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 170, user_id = 170},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 170, user_id = 170},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 171, user_id = 171},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 171, user_id = 171},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 172, user_id = 172},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 172, user_id = 172},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 173, user_id = 173},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 173, user_id = 173},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 174, user_id = 174},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 174, user_id = 174},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 175, user_id = 175},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 175, user_id = 175},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 176, user_id = 176},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 176, user_id = 176},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 177, user_id = 177},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 177, user_id = 177},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 178, user_id = 178},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 178, user_id = 178},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 179, user_id = 179},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 179, user_id = 179},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 180, user_id = 180},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 180, user_id = 180},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 181, user_id = 181},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 181, user_id = 181},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 182, user_id = 182},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 182, user_id = 182},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 183, user_id = 183},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 183, user_id = 183},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 184, user_id = 184},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 184, user_id = 184},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 185, user_id = 185},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 185, user_id = 185},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 186, user_id = 186},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 186, user_id = 186},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 187, user_id = 187},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 187, user_id = 187},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 188, user_id = 188},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 188, user_id = 188},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 189, user_id = 189},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 189, user_id = 189},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 190, user_id = 190},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 190, user_id = 190},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 191, user_id = 191},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 191, user_id = 191},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 192, user_id = 192},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 192, user_id = 192},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 193, user_id = 193},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 193, user_id = 193},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 194, user_id = 194},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 194, user_id = 194},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 195, user_id = 195},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 195, user_id = 195},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 196, user_id = 196},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 196, user_id = 196},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 197, user_id = 197},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 197, user_id = 197},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 198, user_id = 198},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 198, user_id = 198},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 199, user_id = 199},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 199, user_id = 199},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 200, user_id = 200},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 200, user_id = 200},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 201, user_id = 201},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 201, user_id = 201},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 202, user_id = 202},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 202, user_id = 202},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 203, user_id = 203},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 203, user_id = 203},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 204, user_id = 204},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 204, user_id = 204},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 205, user_id = 205},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 205, user_id = 205},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 206, user_id = 206},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 206, user_id = 206},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 207, user_id = 207},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 207, user_id = 207},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 208, user_id = 208},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 208, user_id = 208},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 209, user_id = 209},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 209, user_id = 209},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 210, user_id = 210},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 210, user_id = 210},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 211, user_id = 211},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 211, user_id = 211},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 212, user_id = 212},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 212, user_id = 212},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 213, user_id = 213},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 213, user_id = 213},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 214, user_id = 214},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 214, user_id = 214},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 215, user_id = 215},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 215, user_id = 215},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 216, user_id = 216},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 216, user_id = 216},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 217, user_id = 217},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 217, user_id = 217},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 218, user_id = 218},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 218, user_id = 218},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 219, user_id = 219},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 219, user_id = 219},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 220, user_id = 220},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 220, user_id = 220},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 221, user_id = 221},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 221, user_id = 221},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 222, user_id = 222},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 222, user_id = 222},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 223, user_id = 223},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 223, user_id = 223},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 224, user_id = 224},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 224, user_id = 224},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 225, user_id = 225},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 225, user_id = 225},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 226, user_id = 226},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 226, user_id = 226},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 227, user_id = 227},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 227, user_id = 227},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 228, user_id = 228},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 228, user_id = 228},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 229, user_id = 229},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 229, user_id = 229},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 230, user_id = 230},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 230, user_id = 230},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 231, user_id = 231},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 231, user_id = 231},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 232, user_id = 232},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 232, user_id = 232},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 233, user_id = 233},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 233, user_id = 233},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 234, user_id = 234},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 234, user_id = 234},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 235, user_id = 235},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 235, user_id = 235},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 236, user_id = 236},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 236, user_id = 236},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 237, user_id = 237},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 237, user_id = 237},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 238, user_id = 238},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 238, user_id = 238},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 239, user_id = 239},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 239, user_id = 239},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 240, user_id = 240},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 240, user_id = 240},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 241, user_id = 241},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 241, user_id = 241},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 242, user_id = 242},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 242, user_id = 242},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 243, user_id = 243},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 243, user_id = 243},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 244, user_id = 244},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 244, user_id = 244},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 245, user_id = 245},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 245, user_id = 245},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 246, user_id = 246},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 246, user_id = 246},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 247, user_id = 247},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 247, user_id = 247},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 248, user_id = 248},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 248, user_id = 248},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 249, user_id = 249},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 249, user_id = 249},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 250, user_id = 250},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 250, user_id = 250},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 251, user_id = 251},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 251, user_id = 251},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 252, user_id = 252},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 252, user_id = 252},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 253, user_id = 253},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 253, user_id = 253},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 254, user_id = 254},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 254, user_id = 254},
+   {gre_id = 0, svlan_id = 0, cvlan_id = 255, user_id = 255},
+   {gre_id = 0, svlan_id = 1, cvlan_id = 255, user_id = 255},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 0, user_id = 0},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 0, user_id = 0},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 1, user_id = 1},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 1, user_id = 1},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 2, user_id = 2},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 2, user_id = 2},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 3, user_id = 3},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 3, user_id = 3},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 4, user_id = 4},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 4, user_id = 4},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 5, user_id = 5},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 5, user_id = 5},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 6, user_id = 6},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 6, user_id = 6},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 7, user_id = 7},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 7, user_id = 7},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 8, user_id = 8},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 8, user_id = 8},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 9, user_id = 9},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 9, user_id = 9},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 10, user_id = 10},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 10, user_id = 10},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 11, user_id = 11},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 11, user_id = 11},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 12, user_id = 12},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 12, user_id = 12},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 13, user_id = 13},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 13, user_id = 13},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 14, user_id = 14},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 14, user_id = 14},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 15, user_id = 15},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 15, user_id = 15},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 16, user_id = 16},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 16, user_id = 16},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 17, user_id = 17},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 17, user_id = 17},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 18, user_id = 18},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 18, user_id = 18},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 19, user_id = 19},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 19, user_id = 19},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 20, user_id = 20},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 20, user_id = 20},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 21, user_id = 21},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 21, user_id = 21},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 22, user_id = 22},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 22, user_id = 22},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 23, user_id = 23},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 23, user_id = 23},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 24, user_id = 24},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 24, user_id = 24},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 25, user_id = 25},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 25, user_id = 25},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 26, user_id = 26},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 26, user_id = 26},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 27, user_id = 27},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 27, user_id = 27},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 28, user_id = 28},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 28, user_id = 28},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 29, user_id = 29},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 29, user_id = 29},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 30, user_id = 30},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 30, user_id = 30},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 31, user_id = 31},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 31, user_id = 31},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 32, user_id = 32},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 32, user_id = 32},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 33, user_id = 33},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 33, user_id = 33},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 34, user_id = 34},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 34, user_id = 34},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 35, user_id = 35},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 35, user_id = 35},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 36, user_id = 36},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 36, user_id = 36},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 37, user_id = 37},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 37, user_id = 37},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 38, user_id = 38},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 38, user_id = 38},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 39, user_id = 39},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 39, user_id = 39},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 40, user_id = 40},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 40, user_id = 40},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 41, user_id = 41},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 41, user_id = 41},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 42, user_id = 42},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 42, user_id = 42},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 43, user_id = 43},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 43, user_id = 43},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 44, user_id = 44},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 44, user_id = 44},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 45, user_id = 45},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 45, user_id = 45},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 46, user_id = 46},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 46, user_id = 46},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 47, user_id = 47},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 47, user_id = 47},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 48, user_id = 48},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 48, user_id = 48},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 49, user_id = 49},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 49, user_id = 49},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 50, user_id = 50},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 50, user_id = 50},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 51, user_id = 51},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 51, user_id = 51},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 52, user_id = 52},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 52, user_id = 52},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 53, user_id = 53},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 53, user_id = 53},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 54, user_id = 54},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 54, user_id = 54},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 55, user_id = 55},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 55, user_id = 55},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 56, user_id = 56},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 56, user_id = 56},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 57, user_id = 57},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 57, user_id = 57},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 58, user_id = 58},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 58, user_id = 58},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 59, user_id = 59},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 59, user_id = 59},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 60, user_id = 60},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 60, user_id = 60},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 61, user_id = 61},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 61, user_id = 61},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 62, user_id = 62},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 62, user_id = 62},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 63, user_id = 63},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 63, user_id = 63},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 64, user_id = 64},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 64, user_id = 64},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 65, user_id = 65},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 65, user_id = 65},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 66, user_id = 66},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 66, user_id = 66},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 67, user_id = 67},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 67, user_id = 67},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 68, user_id = 68},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 68, user_id = 68},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 69, user_id = 69},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 69, user_id = 69},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 70, user_id = 70},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 70, user_id = 70},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 71, user_id = 71},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 71, user_id = 71},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 72, user_id = 72},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 72, user_id = 72},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 73, user_id = 73},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 73, user_id = 73},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 74, user_id = 74},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 74, user_id = 74},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 75, user_id = 75},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 75, user_id = 75},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 76, user_id = 76},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 76, user_id = 76},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 77, user_id = 77},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 77, user_id = 77},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 78, user_id = 78},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 78, user_id = 78},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 79, user_id = 79},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 79, user_id = 79},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 80, user_id = 80},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 80, user_id = 80},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 81, user_id = 81},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 81, user_id = 81},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 82, user_id = 82},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 82, user_id = 82},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 83, user_id = 83},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 83, user_id = 83},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 84, user_id = 84},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 84, user_id = 84},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 85, user_id = 85},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 85, user_id = 85},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 86, user_id = 86},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 86, user_id = 86},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 87, user_id = 87},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 87, user_id = 87},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 88, user_id = 88},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 88, user_id = 88},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 89, user_id = 89},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 89, user_id = 89},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 90, user_id = 90},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 90, user_id = 90},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 91, user_id = 91},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 91, user_id = 91},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 92, user_id = 92},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 92, user_id = 92},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 93, user_id = 93},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 93, user_id = 93},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 94, user_id = 94},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 94, user_id = 94},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 95, user_id = 95},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 95, user_id = 95},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 96, user_id = 96},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 96, user_id = 96},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 97, user_id = 97},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 97, user_id = 97},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 98, user_id = 98},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 98, user_id = 98},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 99, user_id = 99},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 99, user_id = 99},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 100, user_id = 100},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 100, user_id = 100},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 101, user_id = 101},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 101, user_id = 101},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 102, user_id = 102},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 102, user_id = 102},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 103, user_id = 103},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 103, user_id = 103},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 104, user_id = 104},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 104, user_id = 104},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 105, user_id = 105},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 105, user_id = 105},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 106, user_id = 106},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 106, user_id = 106},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 107, user_id = 107},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 107, user_id = 107},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 108, user_id = 108},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 108, user_id = 108},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 109, user_id = 109},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 109, user_id = 109},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 110, user_id = 110},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 110, user_id = 110},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 111, user_id = 111},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 111, user_id = 111},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 112, user_id = 112},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 112, user_id = 112},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 113, user_id = 113},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 113, user_id = 113},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 114, user_id = 114},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 114, user_id = 114},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 115, user_id = 115},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 115, user_id = 115},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 116, user_id = 116},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 116, user_id = 116},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 117, user_id = 117},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 117, user_id = 117},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 118, user_id = 118},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 118, user_id = 118},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 119, user_id = 119},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 119, user_id = 119},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 120, user_id = 120},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 120, user_id = 120},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 121, user_id = 121},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 121, user_id = 121},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 122, user_id = 122},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 122, user_id = 122},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 123, user_id = 123},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 123, user_id = 123},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 124, user_id = 124},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 124, user_id = 124},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 125, user_id = 125},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 125, user_id = 125},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 126, user_id = 126},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 126, user_id = 126},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 127, user_id = 127},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 127, user_id = 127},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 128, user_id = 128},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 128, user_id = 128},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 129, user_id = 129},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 129, user_id = 129},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 130, user_id = 130},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 130, user_id = 130},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 131, user_id = 131},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 131, user_id = 131},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 132, user_id = 132},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 132, user_id = 132},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 133, user_id = 133},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 133, user_id = 133},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 134, user_id = 134},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 134, user_id = 134},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 135, user_id = 135},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 135, user_id = 135},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 136, user_id = 136},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 136, user_id = 136},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 137, user_id = 137},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 137, user_id = 137},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 138, user_id = 138},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 138, user_id = 138},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 139, user_id = 139},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 139, user_id = 139},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 140, user_id = 140},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 140, user_id = 140},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 141, user_id = 141},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 141, user_id = 141},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 142, user_id = 142},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 142, user_id = 142},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 143, user_id = 143},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 143, user_id = 143},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 144, user_id = 144},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 144, user_id = 144},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 145, user_id = 145},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 145, user_id = 145},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 146, user_id = 146},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 146, user_id = 146},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 147, user_id = 147},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 147, user_id = 147},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 148, user_id = 148},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 148, user_id = 148},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 149, user_id = 149},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 149, user_id = 149},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 150, user_id = 150},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 150, user_id = 150},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 151, user_id = 151},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 151, user_id = 151},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 152, user_id = 152},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 152, user_id = 152},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 153, user_id = 153},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 153, user_id = 153},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 154, user_id = 154},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 154, user_id = 154},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 155, user_id = 155},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 155, user_id = 155},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 156, user_id = 156},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 156, user_id = 156},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 157, user_id = 157},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 157, user_id = 157},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 158, user_id = 158},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 158, user_id = 158},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 159, user_id = 159},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 159, user_id = 159},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 160, user_id = 160},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 160, user_id = 160},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 161, user_id = 161},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 161, user_id = 161},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 162, user_id = 162},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 162, user_id = 162},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 163, user_id = 163},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 163, user_id = 163},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 164, user_id = 164},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 164, user_id = 164},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 165, user_id = 165},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 165, user_id = 165},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 166, user_id = 166},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 166, user_id = 166},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 167, user_id = 167},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 167, user_id = 167},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 168, user_id = 168},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 168, user_id = 168},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 169, user_id = 169},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 169, user_id = 169},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 170, user_id = 170},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 170, user_id = 170},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 171, user_id = 171},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 171, user_id = 171},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 172, user_id = 172},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 172, user_id = 172},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 173, user_id = 173},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 173, user_id = 173},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 174, user_id = 174},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 174, user_id = 174},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 175, user_id = 175},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 175, user_id = 175},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 176, user_id = 176},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 176, user_id = 176},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 177, user_id = 177},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 177, user_id = 177},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 178, user_id = 178},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 178, user_id = 178},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 179, user_id = 179},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 179, user_id = 179},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 180, user_id = 180},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 180, user_id = 180},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 181, user_id = 181},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 181, user_id = 181},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 182, user_id = 182},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 182, user_id = 182},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 183, user_id = 183},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 183, user_id = 183},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 184, user_id = 184},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 184, user_id = 184},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 185, user_id = 185},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 185, user_id = 185},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 186, user_id = 186},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 186, user_id = 186},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 187, user_id = 187},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 187, user_id = 187},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 188, user_id = 188},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 188, user_id = 188},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 189, user_id = 189},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 189, user_id = 189},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 190, user_id = 190},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 190, user_id = 190},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 191, user_id = 191},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 191, user_id = 191},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 192, user_id = 192},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 192, user_id = 192},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 193, user_id = 193},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 193, user_id = 193},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 194, user_id = 194},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 194, user_id = 194},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 195, user_id = 195},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 195, user_id = 195},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 196, user_id = 196},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 196, user_id = 196},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 197, user_id = 197},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 197, user_id = 197},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 198, user_id = 198},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 198, user_id = 198},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 199, user_id = 199},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 199, user_id = 199},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 200, user_id = 200},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 200, user_id = 200},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 201, user_id = 201},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 201, user_id = 201},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 202, user_id = 202},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 202, user_id = 202},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 203, user_id = 203},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 203, user_id = 203},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 204, user_id = 204},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 204, user_id = 204},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 205, user_id = 205},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 205, user_id = 205},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 206, user_id = 206},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 206, user_id = 206},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 207, user_id = 207},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 207, user_id = 207},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 208, user_id = 208},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 208, user_id = 208},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 209, user_id = 209},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 209, user_id = 209},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 210, user_id = 210},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 210, user_id = 210},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 211, user_id = 211},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 211, user_id = 211},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 212, user_id = 212},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 212, user_id = 212},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 213, user_id = 213},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 213, user_id = 213},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 214, user_id = 214},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 214, user_id = 214},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 215, user_id = 215},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 215, user_id = 215},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 216, user_id = 216},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 216, user_id = 216},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 217, user_id = 217},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 217, user_id = 217},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 218, user_id = 218},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 218, user_id = 218},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 219, user_id = 219},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 219, user_id = 219},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 220, user_id = 220},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 220, user_id = 220},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 221, user_id = 221},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 221, user_id = 221},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 222, user_id = 222},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 222, user_id = 222},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 223, user_id = 223},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 223, user_id = 223},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 224, user_id = 224},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 224, user_id = 224},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 225, user_id = 225},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 225, user_id = 225},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 226, user_id = 226},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 226, user_id = 226},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 227, user_id = 227},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 227, user_id = 227},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 228, user_id = 228},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 228, user_id = 228},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 229, user_id = 229},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 229, user_id = 229},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 230, user_id = 230},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 230, user_id = 230},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 231, user_id = 231},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 231, user_id = 231},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 232, user_id = 232},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 232, user_id = 232},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 233, user_id = 233},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 233, user_id = 233},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 234, user_id = 234},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 234, user_id = 234},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 235, user_id = 235},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 235, user_id = 235},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 236, user_id = 236},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 236, user_id = 236},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 237, user_id = 237},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 237, user_id = 237},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 238, user_id = 238},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 238, user_id = 238},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 239, user_id = 239},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 239, user_id = 239},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 240, user_id = 240},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 240, user_id = 240},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 241, user_id = 241},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 241, user_id = 241},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 242, user_id = 242},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 242, user_id = 242},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 243, user_id = 243},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 243, user_id = 243},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 244, user_id = 244},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 244, user_id = 244},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 245, user_id = 245},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 245, user_id = 245},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 246, user_id = 246},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 246, user_id = 246},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 247, user_id = 247},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 247, user_id = 247},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 248, user_id = 248},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 248, user_id = 248},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 249, user_id = 249},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 249, user_id = 249},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 250, user_id = 250},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 250, user_id = 250},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 251, user_id = 251},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 251, user_id = 251},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 252, user_id = 252},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 252, user_id = 252},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 253, user_id = 253},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 253, user_id = 253},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 254, user_id = 254},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 254, user_id = 254},
+   {gre_id = 0, svlan_id = 16, cvlan_id = 255, user_id = 255},
+   {gre_id = 0, svlan_id = 17, cvlan_id = 255, user_id = 255},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 0, user_id = 0},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 0, user_id = 0},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 1, user_id = 1},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 1, user_id = 1},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 2, user_id = 2},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 2, user_id = 2},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 3, user_id = 3},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 3, user_id = 3},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 4, user_id = 4},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 4, user_id = 4},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 5, user_id = 5},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 5, user_id = 5},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 6, user_id = 6},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 6, user_id = 6},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 7, user_id = 7},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 7, user_id = 7},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 8, user_id = 8},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 8, user_id = 8},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 9, user_id = 9},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 9, user_id = 9},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 10, user_id = 10},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 10, user_id = 10},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 11, user_id = 11},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 11, user_id = 11},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 12, user_id = 12},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 12, user_id = 12},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 13, user_id = 13},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 13, user_id = 13},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 14, user_id = 14},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 14, user_id = 14},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 15, user_id = 15},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 15, user_id = 15},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 16, user_id = 16},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 16, user_id = 16},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 17, user_id = 17},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 17, user_id = 17},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 18, user_id = 18},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 18, user_id = 18},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 19, user_id = 19},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 19, user_id = 19},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 20, user_id = 20},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 20, user_id = 20},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 21, user_id = 21},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 21, user_id = 21},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 22, user_id = 22},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 22, user_id = 22},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 23, user_id = 23},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 23, user_id = 23},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 24, user_id = 24},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 24, user_id = 24},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 25, user_id = 25},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 25, user_id = 25},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 26, user_id = 26},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 26, user_id = 26},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 27, user_id = 27},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 27, user_id = 27},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 28, user_id = 28},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 28, user_id = 28},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 29, user_id = 29},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 29, user_id = 29},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 30, user_id = 30},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 30, user_id = 30},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 31, user_id = 31},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 31, user_id = 31},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 32, user_id = 32},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 32, user_id = 32},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 33, user_id = 33},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 33, user_id = 33},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 34, user_id = 34},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 34, user_id = 34},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 35, user_id = 35},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 35, user_id = 35},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 36, user_id = 36},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 36, user_id = 36},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 37, user_id = 37},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 37, user_id = 37},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 38, user_id = 38},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 38, user_id = 38},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 39, user_id = 39},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 39, user_id = 39},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 40, user_id = 40},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 40, user_id = 40},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 41, user_id = 41},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 41, user_id = 41},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 42, user_id = 42},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 42, user_id = 42},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 43, user_id = 43},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 43, user_id = 43},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 44, user_id = 44},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 44, user_id = 44},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 45, user_id = 45},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 45, user_id = 45},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 46, user_id = 46},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 46, user_id = 46},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 47, user_id = 47},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 47, user_id = 47},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 48, user_id = 48},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 48, user_id = 48},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 49, user_id = 49},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 49, user_id = 49},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 50, user_id = 50},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 50, user_id = 50},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 51, user_id = 51},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 51, user_id = 51},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 52, user_id = 52},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 52, user_id = 52},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 53, user_id = 53},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 53, user_id = 53},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 54, user_id = 54},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 54, user_id = 54},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 55, user_id = 55},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 55, user_id = 55},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 56, user_id = 56},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 56, user_id = 56},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 57, user_id = 57},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 57, user_id = 57},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 58, user_id = 58},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 58, user_id = 58},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 59, user_id = 59},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 59, user_id = 59},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 60, user_id = 60},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 60, user_id = 60},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 61, user_id = 61},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 61, user_id = 61},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 62, user_id = 62},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 62, user_id = 62},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 63, user_id = 63},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 63, user_id = 63},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 64, user_id = 64},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 64, user_id = 64},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 65, user_id = 65},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 65, user_id = 65},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 66, user_id = 66},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 66, user_id = 66},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 67, user_id = 67},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 67, user_id = 67},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 68, user_id = 68},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 68, user_id = 68},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 69, user_id = 69},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 69, user_id = 69},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 70, user_id = 70},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 70, user_id = 70},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 71, user_id = 71},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 71, user_id = 71},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 72, user_id = 72},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 72, user_id = 72},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 73, user_id = 73},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 73, user_id = 73},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 74, user_id = 74},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 74, user_id = 74},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 75, user_id = 75},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 75, user_id = 75},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 76, user_id = 76},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 76, user_id = 76},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 77, user_id = 77},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 77, user_id = 77},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 78, user_id = 78},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 78, user_id = 78},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 79, user_id = 79},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 79, user_id = 79},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 80, user_id = 80},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 80, user_id = 80},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 81, user_id = 81},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 81, user_id = 81},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 82, user_id = 82},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 82, user_id = 82},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 83, user_id = 83},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 83, user_id = 83},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 84, user_id = 84},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 84, user_id = 84},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 85, user_id = 85},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 85, user_id = 85},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 86, user_id = 86},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 86, user_id = 86},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 87, user_id = 87},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 87, user_id = 87},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 88, user_id = 88},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 88, user_id = 88},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 89, user_id = 89},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 89, user_id = 89},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 90, user_id = 90},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 90, user_id = 90},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 91, user_id = 91},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 91, user_id = 91},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 92, user_id = 92},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 92, user_id = 92},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 93, user_id = 93},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 93, user_id = 93},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 94, user_id = 94},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 94, user_id = 94},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 95, user_id = 95},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 95, user_id = 95},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 96, user_id = 96},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 96, user_id = 96},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 97, user_id = 97},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 97, user_id = 97},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 98, user_id = 98},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 98, user_id = 98},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 99, user_id = 99},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 99, user_id = 99},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 100, user_id = 100},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 100, user_id = 100},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 101, user_id = 101},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 101, user_id = 101},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 102, user_id = 102},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 102, user_id = 102},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 103, user_id = 103},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 103, user_id = 103},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 104, user_id = 104},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 104, user_id = 104},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 105, user_id = 105},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 105, user_id = 105},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 106, user_id = 106},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 106, user_id = 106},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 107, user_id = 107},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 107, user_id = 107},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 108, user_id = 108},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 108, user_id = 108},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 109, user_id = 109},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 109, user_id = 109},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 110, user_id = 110},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 110, user_id = 110},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 111, user_id = 111},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 111, user_id = 111},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 112, user_id = 112},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 112, user_id = 112},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 113, user_id = 113},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 113, user_id = 113},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 114, user_id = 114},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 114, user_id = 114},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 115, user_id = 115},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 115, user_id = 115},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 116, user_id = 116},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 116, user_id = 116},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 117, user_id = 117},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 117, user_id = 117},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 118, user_id = 118},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 118, user_id = 118},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 119, user_id = 119},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 119, user_id = 119},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 120, user_id = 120},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 120, user_id = 120},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 121, user_id = 121},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 121, user_id = 121},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 122, user_id = 122},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 122, user_id = 122},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 123, user_id = 123},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 123, user_id = 123},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 124, user_id = 124},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 124, user_id = 124},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 125, user_id = 125},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 125, user_id = 125},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 126, user_id = 126},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 126, user_id = 126},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 127, user_id = 127},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 127, user_id = 127},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 128, user_id = 128},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 128, user_id = 128},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 129, user_id = 129},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 129, user_id = 129},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 130, user_id = 130},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 130, user_id = 130},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 131, user_id = 131},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 131, user_id = 131},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 132, user_id = 132},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 132, user_id = 132},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 133, user_id = 133},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 133, user_id = 133},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 134, user_id = 134},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 134, user_id = 134},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 135, user_id = 135},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 135, user_id = 135},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 136, user_id = 136},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 136, user_id = 136},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 137, user_id = 137},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 137, user_id = 137},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 138, user_id = 138},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 138, user_id = 138},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 139, user_id = 139},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 139, user_id = 139},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 140, user_id = 140},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 140, user_id = 140},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 141, user_id = 141},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 141, user_id = 141},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 142, user_id = 142},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 142, user_id = 142},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 143, user_id = 143},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 143, user_id = 143},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 144, user_id = 144},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 144, user_id = 144},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 145, user_id = 145},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 145, user_id = 145},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 146, user_id = 146},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 146, user_id = 146},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 147, user_id = 147},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 147, user_id = 147},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 148, user_id = 148},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 148, user_id = 148},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 149, user_id = 149},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 149, user_id = 149},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 150, user_id = 150},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 150, user_id = 150},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 151, user_id = 151},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 151, user_id = 151},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 152, user_id = 152},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 152, user_id = 152},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 153, user_id = 153},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 153, user_id = 153},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 154, user_id = 154},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 154, user_id = 154},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 155, user_id = 155},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 155, user_id = 155},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 156, user_id = 156},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 156, user_id = 156},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 157, user_id = 157},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 157, user_id = 157},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 158, user_id = 158},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 158, user_id = 158},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 159, user_id = 159},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 159, user_id = 159},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 160, user_id = 160},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 160, user_id = 160},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 161, user_id = 161},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 161, user_id = 161},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 162, user_id = 162},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 162, user_id = 162},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 163, user_id = 163},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 163, user_id = 163},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 164, user_id = 164},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 164, user_id = 164},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 165, user_id = 165},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 165, user_id = 165},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 166, user_id = 166},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 166, user_id = 166},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 167, user_id = 167},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 167, user_id = 167},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 168, user_id = 168},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 168, user_id = 168},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 169, user_id = 169},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 169, user_id = 169},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 170, user_id = 170},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 170, user_id = 170},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 171, user_id = 171},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 171, user_id = 171},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 172, user_id = 172},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 172, user_id = 172},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 173, user_id = 173},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 173, user_id = 173},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 174, user_id = 174},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 174, user_id = 174},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 175, user_id = 175},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 175, user_id = 175},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 176, user_id = 176},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 176, user_id = 176},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 177, user_id = 177},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 177, user_id = 177},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 178, user_id = 178},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 178, user_id = 178},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 179, user_id = 179},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 179, user_id = 179},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 180, user_id = 180},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 180, user_id = 180},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 181, user_id = 181},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 181, user_id = 181},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 182, user_id = 182},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 182, user_id = 182},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 183, user_id = 183},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 183, user_id = 183},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 184, user_id = 184},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 184, user_id = 184},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 185, user_id = 185},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 185, user_id = 185},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 186, user_id = 186},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 186, user_id = 186},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 187, user_id = 187},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 187, user_id = 187},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 188, user_id = 188},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 188, user_id = 188},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 189, user_id = 189},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 189, user_id = 189},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 190, user_id = 190},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 190, user_id = 190},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 191, user_id = 191},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 191, user_id = 191},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 192, user_id = 192},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 192, user_id = 192},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 193, user_id = 193},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 193, user_id = 193},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 194, user_id = 194},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 194, user_id = 194},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 195, user_id = 195},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 195, user_id = 195},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 196, user_id = 196},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 196, user_id = 196},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 197, user_id = 197},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 197, user_id = 197},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 198, user_id = 198},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 198, user_id = 198},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 199, user_id = 199},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 199, user_id = 199},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 200, user_id = 200},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 200, user_id = 200},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 201, user_id = 201},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 201, user_id = 201},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 202, user_id = 202},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 202, user_id = 202},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 203, user_id = 203},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 203, user_id = 203},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 204, user_id = 204},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 204, user_id = 204},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 205, user_id = 205},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 205, user_id = 205},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 206, user_id = 206},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 206, user_id = 206},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 207, user_id = 207},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 207, user_id = 207},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 208, user_id = 208},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 208, user_id = 208},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 209, user_id = 209},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 209, user_id = 209},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 210, user_id = 210},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 210, user_id = 210},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 211, user_id = 211},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 211, user_id = 211},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 212, user_id = 212},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 212, user_id = 212},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 213, user_id = 213},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 213, user_id = 213},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 214, user_id = 214},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 214, user_id = 214},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 215, user_id = 215},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 215, user_id = 215},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 216, user_id = 216},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 216, user_id = 216},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 217, user_id = 217},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 217, user_id = 217},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 218, user_id = 218},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 218, user_id = 218},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 219, user_id = 219},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 219, user_id = 219},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 220, user_id = 220},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 220, user_id = 220},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 221, user_id = 221},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 221, user_id = 221},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 222, user_id = 222},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 222, user_id = 222},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 223, user_id = 223},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 223, user_id = 223},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 224, user_id = 224},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 224, user_id = 224},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 225, user_id = 225},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 225, user_id = 225},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 226, user_id = 226},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 226, user_id = 226},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 227, user_id = 227},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 227, user_id = 227},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 228, user_id = 228},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 228, user_id = 228},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 229, user_id = 229},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 229, user_id = 229},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 230, user_id = 230},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 230, user_id = 230},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 231, user_id = 231},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 231, user_id = 231},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 232, user_id = 232},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 232, user_id = 232},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 233, user_id = 233},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 233, user_id = 233},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 234, user_id = 234},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 234, user_id = 234},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 235, user_id = 235},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 235, user_id = 235},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 236, user_id = 236},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 236, user_id = 236},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 237, user_id = 237},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 237, user_id = 237},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 238, user_id = 238},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 238, user_id = 238},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 239, user_id = 239},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 239, user_id = 239},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 240, user_id = 240},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 240, user_id = 240},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 241, user_id = 241},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 241, user_id = 241},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 242, user_id = 242},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 242, user_id = 242},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 243, user_id = 243},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 243, user_id = 243},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 244, user_id = 244},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 244, user_id = 244},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 245, user_id = 245},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 245, user_id = 245},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 246, user_id = 246},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 246, user_id = 246},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 247, user_id = 247},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 247, user_id = 247},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 248, user_id = 248},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 248, user_id = 248},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 249, user_id = 249},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 249, user_id = 249},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 250, user_id = 250},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 250, user_id = 250},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 251, user_id = 251},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 251, user_id = 251},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 252, user_id = 252},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 252, user_id = 252},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 253, user_id = 253},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 253, user_id = 253},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 254, user_id = 254},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 254, user_id = 254},
+   {gre_id = 0, svlan_id = 32, cvlan_id = 255, user_id = 255},
+   {gre_id = 0, svlan_id = 33, cvlan_id = 255, user_id = 255},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 0, user_id = 0},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 0, user_id = 0},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 1, user_id = 1},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 1, user_id = 1},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 2, user_id = 2},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 2, user_id = 2},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 3, user_id = 3},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 3, user_id = 3},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 4, user_id = 4},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 4, user_id = 4},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 5, user_id = 5},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 5, user_id = 5},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 6, user_id = 6},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 6, user_id = 6},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 7, user_id = 7},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 7, user_id = 7},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 8, user_id = 8},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 8, user_id = 8},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 9, user_id = 9},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 9, user_id = 9},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 10, user_id = 10},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 10, user_id = 10},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 11, user_id = 11},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 11, user_id = 11},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 12, user_id = 12},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 12, user_id = 12},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 13, user_id = 13},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 13, user_id = 13},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 14, user_id = 14},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 14, user_id = 14},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 15, user_id = 15},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 15, user_id = 15},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 16, user_id = 16},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 16, user_id = 16},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 17, user_id = 17},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 17, user_id = 17},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 18, user_id = 18},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 18, user_id = 18},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 19, user_id = 19},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 19, user_id = 19},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 20, user_id = 20},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 20, user_id = 20},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 21, user_id = 21},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 21, user_id = 21},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 22, user_id = 22},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 22, user_id = 22},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 23, user_id = 23},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 23, user_id = 23},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 24, user_id = 24},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 24, user_id = 24},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 25, user_id = 25},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 25, user_id = 25},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 26, user_id = 26},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 26, user_id = 26},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 27, user_id = 27},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 27, user_id = 27},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 28, user_id = 28},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 28, user_id = 28},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 29, user_id = 29},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 29, user_id = 29},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 30, user_id = 30},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 30, user_id = 30},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 31, user_id = 31},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 31, user_id = 31},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 32, user_id = 32},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 32, user_id = 32},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 33, user_id = 33},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 33, user_id = 33},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 34, user_id = 34},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 34, user_id = 34},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 35, user_id = 35},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 35, user_id = 35},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 36, user_id = 36},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 36, user_id = 36},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 37, user_id = 37},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 37, user_id = 37},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 38, user_id = 38},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 38, user_id = 38},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 39, user_id = 39},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 39, user_id = 39},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 40, user_id = 40},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 40, user_id = 40},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 41, user_id = 41},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 41, user_id = 41},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 42, user_id = 42},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 42, user_id = 42},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 43, user_id = 43},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 43, user_id = 43},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 44, user_id = 44},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 44, user_id = 44},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 45, user_id = 45},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 45, user_id = 45},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 46, user_id = 46},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 46, user_id = 46},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 47, user_id = 47},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 47, user_id = 47},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 48, user_id = 48},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 48, user_id = 48},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 49, user_id = 49},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 49, user_id = 49},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 50, user_id = 50},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 50, user_id = 50},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 51, user_id = 51},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 51, user_id = 51},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 52, user_id = 52},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 52, user_id = 52},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 53, user_id = 53},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 53, user_id = 53},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 54, user_id = 54},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 54, user_id = 54},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 55, user_id = 55},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 55, user_id = 55},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 56, user_id = 56},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 56, user_id = 56},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 57, user_id = 57},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 57, user_id = 57},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 58, user_id = 58},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 58, user_id = 58},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 59, user_id = 59},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 59, user_id = 59},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 60, user_id = 60},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 60, user_id = 60},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 61, user_id = 61},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 61, user_id = 61},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 62, user_id = 62},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 62, user_id = 62},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 63, user_id = 63},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 63, user_id = 63},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 64, user_id = 64},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 64, user_id = 64},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 65, user_id = 65},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 65, user_id = 65},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 66, user_id = 66},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 66, user_id = 66},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 67, user_id = 67},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 67, user_id = 67},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 68, user_id = 68},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 68, user_id = 68},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 69, user_id = 69},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 69, user_id = 69},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 70, user_id = 70},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 70, user_id = 70},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 71, user_id = 71},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 71, user_id = 71},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 72, user_id = 72},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 72, user_id = 72},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 73, user_id = 73},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 73, user_id = 73},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 74, user_id = 74},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 74, user_id = 74},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 75, user_id = 75},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 75, user_id = 75},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 76, user_id = 76},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 76, user_id = 76},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 77, user_id = 77},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 77, user_id = 77},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 78, user_id = 78},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 78, user_id = 78},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 79, user_id = 79},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 79, user_id = 79},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 80, user_id = 80},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 80, user_id = 80},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 81, user_id = 81},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 81, user_id = 81},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 82, user_id = 82},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 82, user_id = 82},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 83, user_id = 83},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 83, user_id = 83},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 84, user_id = 84},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 84, user_id = 84},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 85, user_id = 85},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 85, user_id = 85},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 86, user_id = 86},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 86, user_id = 86},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 87, user_id = 87},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 87, user_id = 87},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 88, user_id = 88},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 88, user_id = 88},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 89, user_id = 89},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 89, user_id = 89},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 90, user_id = 90},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 90, user_id = 90},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 91, user_id = 91},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 91, user_id = 91},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 92, user_id = 92},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 92, user_id = 92},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 93, user_id = 93},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 93, user_id = 93},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 94, user_id = 94},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 94, user_id = 94},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 95, user_id = 95},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 95, user_id = 95},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 96, user_id = 96},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 96, user_id = 96},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 97, user_id = 97},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 97, user_id = 97},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 98, user_id = 98},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 98, user_id = 98},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 99, user_id = 99},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 99, user_id = 99},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 100, user_id = 100},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 100, user_id = 100},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 101, user_id = 101},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 101, user_id = 101},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 102, user_id = 102},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 102, user_id = 102},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 103, user_id = 103},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 103, user_id = 103},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 104, user_id = 104},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 104, user_id = 104},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 105, user_id = 105},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 105, user_id = 105},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 106, user_id = 106},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 106, user_id = 106},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 107, user_id = 107},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 107, user_id = 107},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 108, user_id = 108},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 108, user_id = 108},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 109, user_id = 109},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 109, user_id = 109},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 110, user_id = 110},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 110, user_id = 110},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 111, user_id = 111},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 111, user_id = 111},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 112, user_id = 112},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 112, user_id = 112},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 113, user_id = 113},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 113, user_id = 113},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 114, user_id = 114},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 114, user_id = 114},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 115, user_id = 115},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 115, user_id = 115},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 116, user_id = 116},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 116, user_id = 116},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 117, user_id = 117},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 117, user_id = 117},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 118, user_id = 118},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 118, user_id = 118},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 119, user_id = 119},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 119, user_id = 119},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 120, user_id = 120},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 120, user_id = 120},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 121, user_id = 121},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 121, user_id = 121},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 122, user_id = 122},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 122, user_id = 122},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 123, user_id = 123},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 123, user_id = 123},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 124, user_id = 124},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 124, user_id = 124},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 125, user_id = 125},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 125, user_id = 125},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 126, user_id = 126},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 126, user_id = 126},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 127, user_id = 127},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 127, user_id = 127},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 128, user_id = 128},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 128, user_id = 128},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 129, user_id = 129},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 129, user_id = 129},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 130, user_id = 130},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 130, user_id = 130},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 131, user_id = 131},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 131, user_id = 131},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 132, user_id = 132},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 132, user_id = 132},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 133, user_id = 133},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 133, user_id = 133},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 134, user_id = 134},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 134, user_id = 134},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 135, user_id = 135},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 135, user_id = 135},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 136, user_id = 136},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 136, user_id = 136},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 137, user_id = 137},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 137, user_id = 137},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 138, user_id = 138},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 138, user_id = 138},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 139, user_id = 139},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 139, user_id = 139},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 140, user_id = 140},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 140, user_id = 140},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 141, user_id = 141},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 141, user_id = 141},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 142, user_id = 142},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 142, user_id = 142},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 143, user_id = 143},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 143, user_id = 143},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 144, user_id = 144},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 144, user_id = 144},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 145, user_id = 145},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 145, user_id = 145},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 146, user_id = 146},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 146, user_id = 146},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 147, user_id = 147},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 147, user_id = 147},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 148, user_id = 148},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 148, user_id = 148},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 149, user_id = 149},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 149, user_id = 149},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 150, user_id = 150},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 150, user_id = 150},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 151, user_id = 151},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 151, user_id = 151},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 152, user_id = 152},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 152, user_id = 152},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 153, user_id = 153},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 153, user_id = 153},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 154, user_id = 154},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 154, user_id = 154},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 155, user_id = 155},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 155, user_id = 155},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 156, user_id = 156},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 156, user_id = 156},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 157, user_id = 157},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 157, user_id = 157},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 158, user_id = 158},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 158, user_id = 158},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 159, user_id = 159},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 159, user_id = 159},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 160, user_id = 160},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 160, user_id = 160},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 161, user_id = 161},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 161, user_id = 161},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 162, user_id = 162},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 162, user_id = 162},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 163, user_id = 163},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 163, user_id = 163},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 164, user_id = 164},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 164, user_id = 164},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 165, user_id = 165},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 165, user_id = 165},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 166, user_id = 166},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 166, user_id = 166},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 167, user_id = 167},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 167, user_id = 167},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 168, user_id = 168},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 168, user_id = 168},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 169, user_id = 169},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 169, user_id = 169},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 170, user_id = 170},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 170, user_id = 170},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 171, user_id = 171},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 171, user_id = 171},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 172, user_id = 172},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 172, user_id = 172},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 173, user_id = 173},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 173, user_id = 173},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 174, user_id = 174},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 174, user_id = 174},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 175, user_id = 175},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 175, user_id = 175},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 176, user_id = 176},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 176, user_id = 176},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 177, user_id = 177},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 177, user_id = 177},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 178, user_id = 178},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 178, user_id = 178},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 179, user_id = 179},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 179, user_id = 179},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 180, user_id = 180},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 180, user_id = 180},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 181, user_id = 181},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 181, user_id = 181},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 182, user_id = 182},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 182, user_id = 182},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 183, user_id = 183},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 183, user_id = 183},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 184, user_id = 184},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 184, user_id = 184},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 185, user_id = 185},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 185, user_id = 185},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 186, user_id = 186},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 186, user_id = 186},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 187, user_id = 187},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 187, user_id = 187},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 188, user_id = 188},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 188, user_id = 188},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 189, user_id = 189},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 189, user_id = 189},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 190, user_id = 190},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 190, user_id = 190},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 191, user_id = 191},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 191, user_id = 191},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 192, user_id = 192},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 192, user_id = 192},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 193, user_id = 193},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 193, user_id = 193},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 194, user_id = 194},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 194, user_id = 194},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 195, user_id = 195},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 195, user_id = 195},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 196, user_id = 196},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 196, user_id = 196},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 197, user_id = 197},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 197, user_id = 197},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 198, user_id = 198},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 198, user_id = 198},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 199, user_id = 199},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 199, user_id = 199},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 200, user_id = 200},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 200, user_id = 200},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 201, user_id = 201},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 201, user_id = 201},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 202, user_id = 202},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 202, user_id = 202},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 203, user_id = 203},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 203, user_id = 203},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 204, user_id = 204},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 204, user_id = 204},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 205, user_id = 205},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 205, user_id = 205},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 206, user_id = 206},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 206, user_id = 206},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 207, user_id = 207},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 207, user_id = 207},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 208, user_id = 208},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 208, user_id = 208},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 209, user_id = 209},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 209, user_id = 209},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 210, user_id = 210},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 210, user_id = 210},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 211, user_id = 211},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 211, user_id = 211},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 212, user_id = 212},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 212, user_id = 212},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 213, user_id = 213},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 213, user_id = 213},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 214, user_id = 214},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 214, user_id = 214},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 215, user_id = 215},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 215, user_id = 215},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 216, user_id = 216},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 216, user_id = 216},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 217, user_id = 217},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 217, user_id = 217},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 218, user_id = 218},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 218, user_id = 218},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 219, user_id = 219},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 219, user_id = 219},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 220, user_id = 220},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 220, user_id = 220},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 221, user_id = 221},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 221, user_id = 221},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 222, user_id = 222},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 222, user_id = 222},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 223, user_id = 223},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 223, user_id = 223},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 224, user_id = 224},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 224, user_id = 224},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 225, user_id = 225},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 225, user_id = 225},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 226, user_id = 226},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 226, user_id = 226},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 227, user_id = 227},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 227, user_id = 227},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 228, user_id = 228},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 228, user_id = 228},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 229, user_id = 229},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 229, user_id = 229},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 230, user_id = 230},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 230, user_id = 230},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 231, user_id = 231},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 231, user_id = 231},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 232, user_id = 232},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 232, user_id = 232},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 233, user_id = 233},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 233, user_id = 233},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 234, user_id = 234},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 234, user_id = 234},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 235, user_id = 235},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 235, user_id = 235},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 236, user_id = 236},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 236, user_id = 236},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 237, user_id = 237},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 237, user_id = 237},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 238, user_id = 238},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 238, user_id = 238},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 239, user_id = 239},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 239, user_id = 239},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 240, user_id = 240},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 240, user_id = 240},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 241, user_id = 241},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 241, user_id = 241},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 242, user_id = 242},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 242, user_id = 242},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 243, user_id = 243},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 243, user_id = 243},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 244, user_id = 244},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 244, user_id = 244},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 245, user_id = 245},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 245, user_id = 245},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 246, user_id = 246},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 246, user_id = 246},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 247, user_id = 247},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 247, user_id = 247},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 248, user_id = 248},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 248, user_id = 248},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 249, user_id = 249},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 249, user_id = 249},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 250, user_id = 250},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 250, user_id = 250},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 251, user_id = 251},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 251, user_id = 251},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 252, user_id = 252},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 252, user_id = 252},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 253, user_id = 253},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 253, user_id = 253},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 254, user_id = 254},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 254, user_id = 254},
+   {gre_id = 0, svlan_id = 48, cvlan_id = 255, user_id = 255},
+   {gre_id = 0, svlan_id = 49, cvlan_id = 255, user_id = 255},
+}
diff --git a/VNFs/DPPD-PROX/cqm.c b/VNFs/DPPD-PROX/cqm.c
new file mode 100644
index 00000000..19ea19de
--- /dev/null
+++ b/VNFs/DPPD-PROX/cqm.c
@@ -0,0 +1,310 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <unistd.h>
+#include <stdio.h>
+#include <fcntl.h>
+
+#include "msr.h"
+#include "cqm.h"
+#include "log.h"
+#include "prox_cfg.h"
+
+#define IA32_QM_EVTSEL		0xC8D
+#define IA32_QM_CTR		0xC8E
+#define IA32_QM_ASSOC		0xC8F
+#define IA32_QM_L3CA_START	0xC90
+#define IA32_QM_L3CA_END        0xD0F
+
+#define L3_CACHE_OCCUPANCY		1
+#define L3_TOTAL_EXTERNAL_BANDWIDTH	2
+#define L3_LOCAL_EXTERNAL_BANDWIDTH	3
+
+static struct rdt_features rdt_features;
+static int cat_features = 0;
+
+static int stat_core;
+
+struct reg {
+	uint32_t eax;
+	uint32_t ebx;
+	uint32_t ecx;
+	uint32_t edx;
+};
+
+static void cpuid(struct reg* r, uint32_t a, uint32_t b, uint32_t c, uint32_t d)
+{
+	asm volatile("cpuid"
+		     : "=a" (r->eax), "=b" (r->ebx), "=c" (r->ecx), "=d" (r->edx)
+		     : "a" (a), "b" (b), "c" (c), "d" (d));
+}
+
+void read_rdt_info(void)
+{
+	struct reg r;
+	int i;
+	uint64_t tmp_rmid;
+	int rc;
+
+	cpuid(&r, 0x7, 0x0, 0x0, 0x0);
+	if ((r.ebx >> 12) & 1) {
+		plog_info("\tRDT-M. Supports Intel RDT Monitoring capability\n");
+		rdt_features.rdtm_supported = 1;
+	} else {
+		plog_info("\tDoes not support Intel RDT Monitoring capability\n");
+		return;
+	}
+	if ((r.ebx >> 15) & 1) {
+		plog_info("\tRDT-A. Supports Intel RDT Allocation capability\n");
+		rdt_features.rdta_supported = 1;
+	} else {
+		plog_info("\tDoes not support Intel RDT Allocation capability\n");
+	}
+
+	cpuid(&r, 0xf, 0x0, 0x0, 0x0);
+	if ((r.edx >> 1) & 1) {
+		plog_info("\tSupports L3 Cache Intel RDT Monitoring\n");
+		rdt_features.cmt_supported = 1;
+	}
+	plog_info("\tIntel RDT Monitoring has %d maximum RMID\n", r.ebx);
+	rdt_features.rdtm_max_rmid = r.ebx;
+
+	cpuid(&r, 0xf, 0x0, 0x1, 0x0);
+	if ((r.edx >> 0) & 1) {
+		plog_info("\tSupports L3 occupancy monitoring\n");
+		rdt_features.cmt_supported = 1;
+	}
+	if ((r.edx >> 1) & 1) {
+		plog_info("\tSupports L3 Total bandwidth monitoring\n");
+		rdt_features.mbm_tot_supported = 1;
+	}
+	if ((r.edx >> 2) & 1) {
+		plog_info("\tSupports L3 Local bandwidth monitoring\n");
+		rdt_features.mbm_loc_supported = 1;
+	}
+	rdt_features.cmt_max_rmid = r.ecx;
+	rdt_features.upscaling_factor = r.ebx;
+	rdt_features.event_types = r.edx;
+
+	plog_info("\tL3 Cache Intel RDT Monitoring Capability has %d maximum RMID\n", r.ecx);
+	plog_info("\tUpscaling_factor = %d\n", rdt_features.upscaling_factor);
+
+	cpuid(&r, 0x10, 0x0, 0x0, 0x0);
+	if ((r.ebx >> 1) & 1) {
+		plog_info("\tSupports L3 Cache Allocation Technology\n");
+		rdt_features.l3_cat_supported = 1;
+	}
+	if ((r.ebx >> 2) & 1) {
+		plog_info("\tSupports L2 Cache Allocation Technology\n");
+		rdt_features.l2_cat_supported = 1;
+	}
+	if ((r.ebx >> 3) & 1) {
+		plog_info("\tSupports MBA Allocation Technology\n");
+		rdt_features.mba_supported = 1;
+	}
+
+	cpuid(&r, 0x10, 0x0, 0x1, 0x0);
+	if ((r.ecx >> 2) & 1)
+		plog_info("\tCode and Data Prioritization Technology supported\n");
+	plog_info("\tL3 Cache Allocation Technology Enumeration Highest COS number = %d\n", r.edx & 0xffff);
+	rdt_features.cat_max_rmid = r.edx & 0xffff;
+	rdt_features.cat_num_ways = r.eax + 1;
+
+	cpuid(&r, 0x10, 0x0, 0x2, 0x0);
+	plog_info("\tL2 Cache Allocation Technology Enumeration COS number = %d\n", r.edx & 0xffff);
+
+	cpuid(&r, 0x10, 0x0, 0x3, 0x0);
+	plog_info("\tMemory Bandwidth Allocation Enumeration COS number = %d\n", r.edx & 0xffff);
+	rdt_features.mba_max_rmid = r.ecx;
+}
+int mbm_is_supported(void)
+{
+	return (rdt_features.rdtm_supported && rdt_features.mbm_tot_supported && rdt_features.mbm_loc_supported);
+}
+
+int mba_is_supported(void)
+{
+	return (rdt_features.rdta_supported && rdt_features.mba_supported);
+}
+
+int cmt_is_supported(void)
+{
+	if ((rdt_features.rdtm_supported || rdt_features.rdta_supported) && (prox_cfg.flags & DSF_DISABLE_CMT)) {
+		rdt_features.rdtm_supported = rdt_features.rdta_supported  = 0;
+		plog_info("cqm and cat features disabled by config file\n");
+	}
+	return (rdt_features.rdtm_supported && rdt_features.cmt_supported);
+}
+
+int cat_is_supported(void)
+{
+	if ((rdt_features.rdtm_supported || rdt_features.rdta_supported) && (prox_cfg.flags & DSF_DISABLE_CMT)) {
+		rdt_features.rdtm_supported = rdt_features.rdta_supported  = 0;
+		plog_info("cqm and cat features disabled by config file\n");
+	}
+	return (rdt_features.rdta_supported && rdt_features.l3_cat_supported);
+}
+
+int rdt_is_supported(void)
+{
+	return (cmt_is_supported() || cat_is_supported());
+}
+
+int rdt_get_features(struct rdt_features* feat)
+{
+	if (!cmt_is_supported() && !cat_is_supported())
+		return 1;
+
+	*feat = rdt_features;
+	return 0;
+}
+
+int cqm_assoc(uint8_t lcore_id, uint64_t rmid)
+{
+	uint64_t val = 0;
+	int ret = 0;
+	ret = msr_read(&val, lcore_id, IA32_QM_ASSOC);
+	if (ret != 0) {
+		plog_err("Unable to read msr %x on core %u\n", IA32_QM_ASSOC, lcore_id);
+	}
+	val &= 0x3FFULL;
+	plog_dbg("core %u, rmid was %lu, now setting to %lu\n", lcore_id, val, rmid);
+	val |= (uint64_t)(rmid & 0x3FFULL);
+	ret = msr_write(lcore_id, rmid, IA32_QM_ASSOC);
+	if (ret != 0) {
+		plog_err("Unable to set msr %x on core %u to value %lx\n", IA32_QM_ASSOC, lcore_id, val);
+	}
+	return ret;
+}
+
+int cqm_assoc_read(uint8_t lcore_id, uint64_t *rmid)
+{
+	return msr_read(rmid, lcore_id, IA32_QM_ASSOC);
+}
+
+void rdt_init_stat_core(uint8_t lcore_id)
+{
+	stat_core = lcore_id;
+}
+
+/* read a specific rmid value using core 0 */
+int cmt_read_ctr(uint64_t* ret, uint64_t rmid, uint8_t lcore_id)
+{
+	uint64_t event_id = L3_CACHE_OCCUPANCY;
+
+	uint64_t es = rmid;
+	es = (es << 32) | event_id;
+
+	if (msr_write(lcore_id, es, IA32_QM_EVTSEL) < 0) {
+		return 1;
+	}
+
+	if (msr_read(ret, lcore_id, IA32_QM_CTR) < 0) {
+		return 2;
+	}
+
+	return 0;
+}
+
+int mbm_read_tot_bdw(uint64_t* ret, uint64_t rmid, uint8_t lcore_id)
+{
+	uint64_t event_id = L3_TOTAL_EXTERNAL_BANDWIDTH;
+
+	uint64_t es = rmid;
+	es = (es << 32) | event_id;
+
+	if (msr_write(lcore_id, es, IA32_QM_EVTSEL) < 0) {
+		return 1;
+	}
+
+	if (msr_read(ret, lcore_id, IA32_QM_CTR) < 0) {
+		return 2;
+	}
+	return 0;
+}
+
+int mbm_read_loc_bdw(uint64_t* ret, uint64_t rmid, uint8_t lcore_id)
+{
+	uint64_t event_id = L3_LOCAL_EXTERNAL_BANDWIDTH;
+
+	uint64_t es = rmid;
+	es = (es << 32) | event_id;
+
+	if (msr_write(lcore_id, es, IA32_QM_EVTSEL) < 0) {
+		return 1;
+	}
+
+	if (msr_read(ret, lcore_id, IA32_QM_CTR) < 0) {
+		return 2;
+	}
+	return 0;
+}
+
+int cat_log_init(uint8_t lcore_id)
+{
+	uint64_t tmp_rmid;
+	int rc, i = 0;
+	for (i = 0; i < IA32_QM_L3CA_END - IA32_QM_L3CA_START; i++) {
+		rc = msr_read(&tmp_rmid,lcore_id,IA32_QM_L3CA_START + i);
+		if (rc < 0) {
+			break;
+		}
+		plog_info("\tAt initialization: Cache allocation set %d (msr %x): mask %lx\n", i, IA32_QM_L3CA_START + i, tmp_rmid);
+	}
+	return i;
+}
+
+int cat_set_class_mask(uint8_t lcore_id, uint32_t set, uint32_t mask)
+{
+	uint64_t tmp_rmid;
+	int rc;
+	rc = msr_write(lcore_id, mask, IA32_QM_L3CA_START + set);
+	if (rc < 0) {
+		plog_err("Failed to write Cache allocation\n");
+		return -1;
+	}
+	return 0;
+}
+
+int cat_get_class_mask(uint8_t lcore_id, uint32_t set, uint32_t *mask)
+{
+	uint64_t tmp_rmid;
+	int rc;
+	rc = msr_read(&tmp_rmid,lcore_id,IA32_QM_L3CA_START + set);
+	if (rc < 0) {
+		plog_err("Failed to read Cache allocation\n");
+		return -1;
+	}
+	*mask = tmp_rmid & 0xffffffff;
+	return 0;
+}
+
+void cat_reset_cache(uint32_t lcore_id)
+{
+	int rc;
+	uint32_t mask = (1 << rdt_features.cat_num_ways) -1;
+	for (uint32_t set = 0; set <= rdt_features.cat_max_rmid; set++) {
+		rc = msr_write(lcore_id, mask, IA32_QM_L3CA_START + set);
+		if (rc < 0) {
+			plog_err("Failed to reset Cache allocation\n");
+		}
+	}
+}
+
+int cat_get_num_ways(void)
+{
+	return rdt_features.cat_num_ways;
+}
diff --git a/VNFs/DPPD-PROX/cqm.h b/VNFs/DPPD-PROX/cqm.h
new file mode 100644
index 00000000..65b1f453
--- /dev/null
+++ b/VNFs/DPPD-PROX/cqm.h
@@ -0,0 +1,73 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _CQM_H_
+#define _CQM_H_
+
+#include <inttypes.h>
+#include <stdio.h>
+
+#define PROX_MAX_CACHE_SET      16
+
+struct rdt_features {
+	uint8_t rdtm_supported;
+	uint8_t rdta_supported;
+	uint8_t cmt_supported;
+	uint8_t	mbm_tot_supported;
+	uint8_t	mbm_loc_supported;
+	uint8_t l3_cat_supported;
+	uint8_t l2_cat_supported;
+	uint8_t mba_supported;
+	uint32_t rdtm_max_rmid;
+	uint32_t cmt_max_rmid;
+	uint32_t cat_max_rmid;
+	uint32_t mba_max_rmid;
+	uint32_t cat_num_ways;
+	uint32_t upscaling_factor;
+	uint32_t event_types;
+};
+
+struct prox_cache_set_cfg {
+	uint32_t mask;
+	uint32_t lcore_id;
+	int32_t socket_id;
+};
+
+int rdt_is_supported(void);
+int cmt_is_supported(void);
+int cat_is_supported(void);
+int mbm_is_supported(void);
+int mba_is_supported(void);
+
+int rdt_get_features(struct rdt_features* feat);
+
+int cqm_assoc(uint8_t lcore_id, uint64_t rmid);
+int cqm_assoc_read(uint8_t lcore_id, uint64_t *rmid);
+
+void rdt_init_stat_core(uint8_t lcore_id);
+
+int cmt_read_ctr(uint64_t* ret, uint64_t rmid, uint8_t lcore_id);
+int mbm_read_tot_bdw(uint64_t* ret, uint64_t rmid, uint8_t lcore_id);
+int mbm_read_loc_bdw(uint64_t* ret, uint64_t rmid, uint8_t lcore_id);
+void read_rdt_info(void);
+extern struct prox_cache_set_cfg prox_cache_set_cfg[PROX_MAX_CACHE_SET];
+int cat_log_init(uint8_t lcore_id);
+int cat_set_class_mask(uint8_t lcore_id,  uint32_t set, uint32_t mask);
+int cat_get_class_mask(uint8_t lcore_id, uint32_t set, uint32_t *mask);
+void cat_reset_cache(uint32_t lcore_id);
+int cat_get_num_ways(void);
+
+#endif /* _CQM_H_ */
diff --git a/VNFs/DPPD-PROX/defaults.c b/VNFs/DPPD-PROX/defaults.c
new file mode 100644
index 00000000..eeb21b2d
--- /dev/null
+++ b/VNFs/DPPD-PROX/defaults.c
@@ -0,0 +1,186 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <libgen.h>
+#include <rte_sched.h>
+#include <rte_version.h>
+
+#include "lconf.h"
+#include "defaults.h"
+#include "defines.h"
+#include "prox_cfg.h"
+#include "prox_port_cfg.h"
+#include "etypes.h"
+#include "toeplitz.h"
+
+#define TEN_GIGABIT     1250000000
+#define QUEUE_SIZES     128
+#define NB_PIPES        32768
+#define NB_MBUF         4096
+#define RING_RX_SIZE    256
+#define NB_RX_RING_DESC 256
+#define NB_TX_RING_DESC 256
+
+/* 1500000 milliseconds */
+#define DEFAULT_CPE_TIMEOUT_MS    1500000
+
+/**/
+#if DEFAULT_CPE_TIMEOUT_MS < (DRAIN_TIMEOUT/3000000)
+#error DEFAULT_CPE_TIMEOUT_MS too small (needs to be at least 2 ms)
+#endif
+
+static const struct rte_eth_conf default_port_conf = {
+	.rxmode = {
+		.split_hdr_size = 0,
+		.header_split   = 0, /* Header Split disabled */
+		.hw_ip_checksum = 0, /* IP checksum offload disabled */
+		.hw_vlan_filter = 0, /* VLAN filtering disabled */
+		.hw_vlan_strip = 0, /* VLAN filtering disabled */
+		.jumbo_frame    = 0, /* Jumbo frame support disabled */
+		.hw_strip_crc   = 1, /* CRC stripped by hardware --- always set to 1 in VF */
+		.hw_vlan_extend = 0,
+		.mq_mode        = 0
+	},
+	.rx_adv_conf = {
+		.rss_conf = {
+			.rss_key = NULL,
+		},
+	},
+	.intr_conf = {
+		.lsc = 1, /* lsc interrupt feature enabled */
+	},
+};
+
+static const struct rte_eth_rxconf default_rx_conf = {
+	.rx_free_thresh = 32,
+};
+
+static struct rte_eth_txconf default_tx_conf = {
+	.tx_thresh = {
+		.pthresh = 32,
+		.hthresh = 8,
+		.wthresh = 0,
+	},
+	.tx_free_thresh = 32, /* Use PMD default values */
+	.tx_rs_thresh = 32, /* Use PMD default values */
+};
+
+static struct rte_sched_port_params port_params_default = {
+	.name = "port_0",
+	.socket = 0,
+	.mtu = 6 + 6 + 4 + 4 + 2 + 1500,
+	.rate = 0,
+	.frame_overhead = RTE_SCHED_FRAME_OVERHEAD_DEFAULT,
+	.n_subports_per_port = 1,
+	.n_pipes_per_subport = NB_PIPES,
+	.qsize = {QUEUE_SIZES, QUEUE_SIZES, QUEUE_SIZES, QUEUE_SIZES},
+	.pipe_profiles = NULL,
+	.n_pipe_profiles = 1 /* only one profile */
+};
+
+static struct rte_sched_pipe_params pipe_params_default = {
+	.tb_rate = TEN_GIGABIT / NB_PIPES,
+	.tb_size = 4000000,
+
+	.tc_rate = {TEN_GIGABIT / NB_PIPES, TEN_GIGABIT / NB_PIPES, TEN_GIGABIT / NB_PIPES, TEN_GIGABIT / NB_PIPES},
+	.tc_period = 40,
+
+	.wrr_weights = {1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1},
+};
+
+static struct rte_sched_subport_params subport_params_default = {
+	.tb_rate = TEN_GIGABIT,
+	.tb_size = 4000000,
+	.tc_rate = {TEN_GIGABIT, TEN_GIGABIT, TEN_GIGABIT, TEN_GIGABIT},
+	.tc_period = 40, /* default was 10 */
+};
+
+void set_global_defaults(__attribute__((unused)) struct prox_cfg *prox_cfg)
+{
+}
+
+void set_task_defaults(struct prox_cfg* prox_cfg, struct lcore_cfg* lcore_cfg_init)
+{
+	prox_cfg->master = RTE_MAX_LCORE;
+
+	for (uint32_t i = 0; i < RTE_DIM(prox_cfg->cpe_table_ports); ++i) {
+		prox_cfg->cpe_table_ports[i] = -1;
+	}
+
+	for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
+		struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
+		cur_lcore_cfg_init->id = lcore_id;
+		for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
+			struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
+			for (uint8_t port_id = 0; port_id < PROX_MAX_PORTS; ++port_id) {
+				targ->rx_port_queue[port_id].port = OUT_DISCARD;
+			}
+			targ->flags |= TASK_ARG_DROP;
+			targ->flags |= TASK_ARG_QINQ_ACL;
+			targ->cpe_table_timeout_ms = DEFAULT_CPE_TIMEOUT_MS;
+			targ->n_flows = NB_PIPES;
+			/* configure default values for QoS (can be overwritten by config) */
+			targ->qos_conf.port_params = port_params_default;
+			targ->qos_conf.pipe_params[0] = pipe_params_default;
+			targ->qos_conf.subport_params[0] = subport_params_default;
+			targ->qos_conf.port_params.pipe_profiles = targ->qos_conf.pipe_params;
+			targ->qos_conf.port_params.rate = TEN_GIGABIT;
+			targ->qinq_tag = ETYPE_8021ad;
+			targ->n_concur_conn = 8192*2;
+
+			for (uint8_t port_id = 0; port_id < PROX_MAX_PORTS; ++port_id) {
+				targ->tx_port_queue[port_id].port = OUT_DISCARD;
+			}
+
+			for (uint8_t i = 0; i < PROX_MAX_PORTS; ++i) {
+				targ->mapping[i] = i; // identity
+			}
+
+			targ->cbs = ETHER_MAX_LEN;
+			targ->ebs = ETHER_MAX_LEN;
+			targ->pbs = ETHER_MAX_LEN;
+
+			targ->n_max_rules = 1024;
+			targ->ring_size = RING_RX_SIZE;
+			targ->nb_cache_mbuf = MAX_PKT_BURST * 4;
+			targ->overhead = ETHER_CRC_LEN + 20;
+
+			targ->tunnel_hop_limit = 3;
+			targ->ctrl_freq = 1000;
+			targ->lb_friend_core = 0xFF;
+			targ->mbuf_size = MBUF_SIZE;
+			targ->n_pkts = 1024*64;
+			targ->runtime_flags |= TASK_TX_CRC;
+			targ->accuracy_limit_nsec = 5000;
+		}
+	}
+}
+
+void set_port_defaults(void)
+{
+	for (uint8_t i = 0; i < PROX_MAX_PORTS; ++i ) {
+		prox_port_cfg[i].promiscuous = 1;
+		prox_port_cfg[i].n_rxd = NB_RX_RING_DESC;
+		prox_port_cfg[i].n_txd = NB_TX_RING_DESC;
+		prox_port_cfg[i].port_conf = default_port_conf;
+		prox_port_cfg[i].tx_conf = default_tx_conf;
+		prox_port_cfg[i].rx_conf = default_rx_conf;
+		prox_port_cfg[i].rx_ring[0] = '\0';
+		prox_port_cfg[i].tx_ring[0] = '\0';
+		prox_port_cfg[i].mtu = PROX_MTU;
+	}
+}
diff --git a/VNFs/DPPD-PROX/defaults.h b/VNFs/DPPD-PROX/defaults.h
new file mode 100644
index 00000000..5fb31207
--- /dev/null
+++ b/VNFs/DPPD-PROX/defaults.h
@@ -0,0 +1,46 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _DEFAULTS_H_
+#define _DEFAULTS_H_
+
+#include <rte_ether.h>
+
+struct prox_cfg;
+struct lcore_cfg;
+
+void set_global_defaults(struct prox_cfg* prox_cfg);
+void set_task_defaults(struct prox_cfg* prox_cfg, struct lcore_cfg* lcore_cfg_init);
+void set_port_defaults(void);
+
+#define MAX_PKT_BURST   64
+#define MAX_RING_BURST	64
+
+#if MAX_RING_BURST < MAX_PKT_BURST
+#error MAX_RING_BURST < MAX_PKT_BURST
+#endif
+
+#define NUM_VCPES               65536
+#define GRE_BUCKET_ENTRIES      4
+#define MAX_GRE                 (NUM_VCPES * GRE_BUCKET_ENTRIES)
+#define MAX_RSS_QUEUE_BITS      9
+
+#define PROX_VLAN_TAG_SIZE	4
+#define MBUF_SIZE (ETHER_MAX_LEN + (unsigned)sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM +  2 * PROX_VLAN_TAG_SIZE)
+
+#define PROX_MTU   ETHER_MAX_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN
+
+#endif /* _DEFAULTS_H_ */
diff --git a/VNFs/DPPD-PROX/defines.h b/VNFs/DPPD-PROX/defines.h
new file mode 100644
index 00000000..c2309be1
--- /dev/null
+++ b/VNFs/DPPD-PROX/defines.h
@@ -0,0 +1,59 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _DEFINES_H_
+#define _DEFINES_H_
+
+// with 3GHz CPU
+#define DRAIN_TIMEOUT  __UINT64_C(6000000)             // drain TX buffer every 2ms
+#define TERM_TIMEOUT   __UINT64_C(3000000000)          // check if terminated every 1s
+
+/* DRAIN_TIMEOUT should be smaller than TERM_TIMEOUT as TERM_TIMEOUT
+   is only checked after DRAIN_TIMEOUT */
+#if TERM_TIMEOUT < DRAIN_TIMEOUT
+#error TERM_TIMEOUT < DRAIN_TIMEOUT
+#endif
+
+#ifndef IPv4_BYTES
+#define IPv4_BYTES_FMT  "%d.%d.%d.%d"
+#define IPv4_BYTES(addr)                        \
+        addr[0],  addr[1],  addr[2],  addr[3]
+#endif
+
+#ifndef IPv6_BYTES
+#define IPv6_BYTES_FMT	"%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x"
+#define IPv6_BYTES(addr)			\
+	addr[0],  addr[1],  addr[2],  addr[3],	\
+	addr[4],  addr[5],  addr[6],  addr[7],	\
+	addr[8],  addr[9],  addr[10], addr[11],	\
+	addr[12], addr[13], addr[14], addr[15]
+#endif
+
+#ifndef MAC_BYTES
+#define MAC_BYTES_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
+
+#define MAC_BYTES(addr)   \
+	addr[0], addr[1], \
+	addr[2], addr[3], \
+	addr[4], addr[5]
+#endif
+
+/* assume cpu byte order is little endian */
+#define PKT_TO_LUTQINQ(svlan, cvlan) ((((uint32_t)svlan) & 0x000F) << 4 | (((uint32_t)svlan) & 0xFF00) << 8 | (((uint32_t)cvlan) & 0xFF0F))
+
+#define ROUTE_ERR 254
+
+#endif /* _DEFINES_H_ */
diff --git a/VNFs/DPPD-PROX/display.c b/VNFs/DPPD-PROX/display.c
new file mode 100644
index 00000000..2a351a09
--- /dev/null
+++ b/VNFs/DPPD-PROX/display.c
@@ -0,0 +1,994 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <curses.h>
+
+#include <rte_cycles.h>
+#include <string.h>
+#include <signal.h>
+#include <math.h>
+#include <signal.h>
+
+#include "display_latency.h"
+#include "display_mempools.h"
+#include "display_ports.h"
+#include "display_priority.h"
+#include "display_rings.h"
+#include "display_pkt_len.h"
+#include "display_l4gen.h"
+#include "display_tasks.h"
+
+#include "cqm.h"
+#include "msr.h"
+#include "display.h"
+#include "log.h"
+#include "commands.h"
+#include "main.h"
+#include "stats.h"
+#include "stats_port.h"
+#include "stats_latency.h"
+#include "stats_global.h"
+#include "stats_core.h"
+#include "prox_cfg.h"
+#include "prox_assert.h"
+#include "version.h"
+#include "quit.h"
+#include "prox_port_cfg.h"
+
+static struct screen_state screen_state = {
+	.pps_unit = 1000,
+	.chosen_screen = -1,
+};
+
+static struct display_screen *display_screens[16];
+static struct display_screen *current_screen;
+static size_t n_screens;
+static size_t longest_title;
+
+void display_set_pps_unit(int val)
+{
+	screen_state.pps_unit = val;
+}
+
+/* Set up the display mutex  as recursive. This enables threads to use
+   display_[un]lock() to lock  the display when multiple  calls to for
+   instance plog_info() need to be made. */
+static pthread_mutex_t disp_mtx = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+
+static void stats_display_layout(uint8_t in_place);
+
+void display_lock(void)
+{
+	pthread_mutex_lock(&disp_mtx);
+}
+
+void display_unlock(void)
+{
+	pthread_mutex_unlock(&disp_mtx);
+}
+
+/* Advanced text output */
+static WINDOW *scr = NULL, *win_txt, *win_general, *win_cmd, *win_stat, *win_title, *win_tabs, *win_help;
+static int win_txt_height = 1;
+static int title_len;
+
+static uint16_t max_n_lines;
+
+static int cmd_cursor_pos;
+static const char *cmd_cmd;
+static int cmd_len;
+
+/* Colors used in the interface */
+enum colors {
+	INVALID_COLOR,
+	NO_COLOR,
+	RED_ON_BLACK,
+	BLACK_ON_CYAN,
+	BLACK_ON_GREEN,
+	BLACK_ON_WHITE,
+	BLACK_ON_YELLOW,
+	YELLOW_ON_BLACK,
+	WHITE_ON_RED,
+	YELLOW_ON_NOTHING,
+	GREEN_ON_NOTHING,
+	RED_ON_NOTHING,
+	BLUE_ON_NOTHING,
+	CYAN_ON_NOTHING,
+	MAGENTA_ON_NOTHING,
+	WHITE_ON_NOTHING,
+};
+
+int display_getch(void)
+{
+	int ret;
+
+	display_lock();
+	ret = wgetch(scr);
+	display_unlock();
+
+	return ret;
+}
+
+void display_cmd(const char *cmd, int cl, int cursor_pos)
+{
+	cmd_len = cl;
+	if (cursor_pos == -1 || cursor_pos > cmd_len)
+		cursor_pos = cmd_len;
+	cmd_cursor_pos = cursor_pos;
+	cmd_cmd = cmd;
+
+	display_lock();
+	werase(win_cmd);
+	if (cursor_pos < cmd_len) {
+		waddnstr(win_cmd, cmd, cursor_pos);
+		wbkgdset(win_cmd, COLOR_PAIR(YELLOW_ON_BLACK));
+		waddnstr(win_cmd, cmd + cursor_pos, 1);
+		wbkgdset(win_cmd, COLOR_PAIR(BLACK_ON_YELLOW));
+		waddnstr(win_cmd, cmd + cursor_pos + 1, cmd_len - (cursor_pos + 1));
+	}
+	else {
+		waddnstr(win_cmd, cmd, cmd_len);
+		wmove(win_cmd, cursor_pos, 0);
+		wbkgdset(win_cmd, COLOR_PAIR(YELLOW_ON_BLACK));
+		waddstr(win_cmd, " ");
+		wbkgdset(win_cmd, COLOR_PAIR(BLACK_ON_YELLOW));
+	}
+
+	wattroff(win_stat, A_UNDERLINE);
+	wrefresh(win_cmd);
+	display_unlock();
+}
+
+static void refresh_cmd_win(void)
+{
+	display_cmd(cmd_cmd, cmd_len, cmd_cursor_pos);
+}
+
+static WINDOW *create_subwindow(int height, int width, int y_pos, int x_pos)
+{
+	WINDOW *win = subwin(scr, height, width, y_pos, x_pos);
+	touchwin(scr);
+	return win;
+}
+
+/* The limit parameter sets the last column that something can be
+   printed. If characters would be printed _past_ the limit, the last
+   character printed within the limit will be a '~' to signify that
+   the string cut off. The limit parameter will be ignored if its
+   value is -1 */
+static inline int mvwaddstrv(WINDOW *win, int y, int x, int limit, const char *fmt, va_list ap)
+{
+	char buf[1024];
+	int ret;
+
+	ret = vsnprintf(buf, sizeof(buf), fmt, ap);
+	int len = ret;
+
+	wmove(win, y, x);
+	if (x > COLS - 1) {
+		return 0;
+	}
+
+	/* To prevent strings from wrapping, cut the string at the end
+	   of the screen. */
+	if (x + len > COLS) {
+		buf[COLS - 1 - x] = 0;
+		len = COLS - x;
+	}
+
+	if (limit != -1 && x + len > limit) {
+		int new_len = limit - x;
+
+		if (new_len < 0)
+			return 0;
+		buf[new_len] = '~';
+		buf[new_len + 1] = 0;
+	}
+
+	waddstr(win, buf);
+	return ret;
+}
+
+/* Format string capable [mv]waddstr() wrappers */
+__attribute__((format(printf, 4, 5))) static inline int mvwaddstrf(WINDOW* win, int y, int x, const char *fmt, ...)
+{
+	int ret;
+	va_list ap;
+
+	va_start(ap, fmt);
+	ret = mvwaddstrv(win, y, x, -1, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+
+__attribute__((format(printf, 5, 6))) static inline int mvwaddstrf_limit(WINDOW* win, int y, int x, int limit, const char *fmt, ...)
+{
+	int ret;
+	va_list ap;
+
+	va_start(ap, fmt);
+	ret = mvwaddstrv(win, y, x, limit, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+
+// red: link down; Green: link up
+static short link_color(const uint8_t if_port)
+{
+	return COLOR_PAIR(prox_port_cfg[if_port].link_up? GREEN_ON_NOTHING : RED_ON_NOTHING);
+}
+
+static void (*ncurses_sigwinch)(int);
+
+static void sigwinch(int in)
+{
+	if (ncurses_sigwinch)
+		ncurses_sigwinch(in);
+	refresh();
+	stats_display_layout(0);
+}
+
+static void set_signal_handler(void)
+{
+	struct sigaction old;
+
+	sigaction(SIGWINCH, NULL, &old);
+	ncurses_sigwinch = old.sa_handler;
+
+	signal(SIGWINCH, sigwinch);
+}
+
+void display_column_port_ring(const struct display_column *display_column, int row, struct port_queue *ports, int port_count, struct rte_ring **rings, int ring_count)
+{
+	if (row >= max_n_lines)
+		return;
+
+	int pos = display_column->offset;
+	int limit = pos + display_column->width;
+
+	for (int i = 0; i < port_count && pos < limit; i++) {
+		wbkgdset(win_stat, link_color(ports[i].port));
+		pos += mvwaddstrf_limit(win_stat, row + 2, pos, limit, "%u", ports[i].port);
+		wbkgdset(win_stat, COLOR_PAIR(NO_COLOR));
+
+		if (i != port_count - 1)
+			pos += mvwaddstrf_limit(win_stat, row + 2, pos, limit, " ");
+	}
+
+	for (uint8_t ring_id = 0; ring_id < ring_count && pos < limit; ++ring_id) {
+		pos += mvwaddstrf_limit(win_stat, row + 2, pos, limit, "%s", rings[ring_id]->name);
+	}
+}
+
+static void display_add_screen(struct display_screen *screen)
+{
+	display_screens[n_screens++] = screen;
+	if (longest_title < strlen(screen->title))
+		longest_title = strlen(screen->title);
+}
+
+static void display_init_screens(void)
+{
+	if (n_screens)
+		return;
+
+	display_add_screen(display_tasks());
+	display_add_screen(display_ports());
+	display_add_screen(display_mempools());
+	display_add_screen(display_latency());
+	display_add_screen(display_rings());
+	display_add_screen(display_l4gen());
+	display_add_screen(display_pkt_len());
+	display_add_screen(display_priority());
+}
+
+void display_init(void)
+{
+	scr = initscr();
+	start_color();
+	/* Assign default foreground/background colors to color number -1 */
+	use_default_colors();
+
+	init_pair(NO_COLOR,   -1,  -1);
+	init_pair(RED_ON_BLACK,     COLOR_RED,  COLOR_BLACK);
+	init_pair(BLACK_ON_CYAN,   COLOR_BLACK,  COLOR_CYAN);
+	init_pair(BLACK_ON_GREEN,  COLOR_BLACK,  COLOR_GREEN);
+	init_pair(BLACK_ON_WHITE,  COLOR_BLACK,  COLOR_WHITE);
+	init_pair(BLACK_ON_YELLOW, COLOR_BLACK,  COLOR_YELLOW);
+	init_pair(YELLOW_ON_BLACK, COLOR_YELLOW,  COLOR_BLACK);
+	init_pair(WHITE_ON_RED,    COLOR_WHITE,  COLOR_RED);
+	init_pair(YELLOW_ON_NOTHING,   COLOR_YELLOW,  -1);
+	init_pair(GREEN_ON_NOTHING,   COLOR_GREEN,  -1);
+	init_pair(RED_ON_NOTHING,   COLOR_RED,  -1);
+	init_pair(BLUE_ON_NOTHING,  COLOR_BLUE, -1);
+	init_pair(CYAN_ON_NOTHING,  COLOR_CYAN, -1);
+	init_pair(MAGENTA_ON_NOTHING,  COLOR_MAGENTA, -1);
+	init_pair(WHITE_ON_NOTHING,  COLOR_WHITE, -1);
+	/* nodelay(scr, TRUE); */
+	noecho();
+	curs_set(0);
+	/* Create fullscreen log window. When stats are displayed
+	   later, it is recreated with appropriate dimensions. */
+	win_txt = create_subwindow(0, 0, 0, 0);
+	wbkgd(win_txt, COLOR_PAIR(0));
+
+	idlok(win_txt, FALSE);
+	/* Get scrolling */
+	scrollok(win_txt, TRUE);
+	/* Leave cursor where it was */
+	leaveok(win_txt, TRUE);
+
+	refresh();
+
+	set_signal_handler();
+
+	max_n_lines = (LINES - 5 - 2 - 3);
+	/* core_port_height = max_n_lines < stats_get_n_tasks_tot()? max_n_lines : stats_get_n_tasks_tot(); */
+
+	display_init_screens();
+	display_screen(0);
+	stats_display_layout(0);
+}
+
+static void display_page_recalc_offsets(struct display_page *display_page)
+{
+	struct display_table *table;
+	struct display_column *col;
+	int total_offset = 0;
+
+	for (int i = 0; i < display_page->n_tables; ++i) {
+		table = &display_page->tables[i];
+
+		if (i != 0)
+			total_offset += 1;
+		table->offset = total_offset;
+		for (int j = 0; j < table->n_cols; ++j) {
+			col = &table->cols[j];
+			col->offset = total_offset;
+			if (j + 1 != table->n_cols)
+				total_offset += 1;
+			total_offset += col->width;
+		}
+		table->width = total_offset - table->offset;
+	}
+}
+
+void display_page_init(struct display_page *display_page)
+{
+	struct display_table *table;
+	struct display_column *col;
+	int table_width = 0;
+	int table_offset = 0;
+
+	memset(display_page, 0, sizeof(*display_page));
+	display_page->n_tables = 0;
+	for (size_t i = 0; i < sizeof(display_page->tables)/sizeof(display_page->tables[0]); ++i) {
+		table = &display_page->tables[i];
+		for (size_t j = 0; j < sizeof(table->cols)/sizeof(table->cols[0]); ++j) {
+			col = &table->cols[j];
+			col->display_page = display_page;
+		}
+	}
+}
+
+struct display_table *display_page_add_table(struct display_page *display_page)
+{
+	struct display_table *table = &display_page->tables[display_page->n_tables];
+
+	display_page->n_tables++;
+	return table;
+}
+
+void display_table_init(struct display_table *table, const char *title)
+{
+	strcpy(table->title, title);
+	table->n_cols = 0;
+}
+
+struct display_column *display_table_add_col(struct display_table *table)
+{
+	struct display_column *col = &table->cols[table->n_cols];
+
+	table->n_cols++;
+	return col;
+}
+
+void display_column_init(struct display_column *display_column, const char *title, unsigned width)
+{
+	if (width < strlen(title))
+		width = strlen(title);
+
+	strcpy(display_column->title, title);
+	display_column->width = width;
+	display_page_recalc_offsets(display_column->display_page);
+}
+
+int display_column_get_width(const struct display_column *display_column)
+{
+	return display_column->width;
+}
+
+void display_page_draw_frame(const struct display_page *display_page, int height)
+{
+	const struct display_table *table;
+	const struct display_column *col;
+
+	wattron(win_stat, A_BOLD);
+	wbkgdset(win_stat, COLOR_PAIR(YELLOW_ON_NOTHING));
+
+	for (int i = 0; i < display_page->n_tables; ++i) {
+		table = &display_page->tables[i];
+
+		if (i != 0)
+			mvwvline(win_stat, 0, table->offset - 1,  ACS_VLINE, height + 2);
+
+		mvwaddstrf(win_stat, 0, table->offset + table->width / 2 - strlen(table->title) / 2, "%s", table->title);
+		for (int j = 0; j < table->n_cols; ++j) {
+			col = &table->cols[j];
+
+			if (j != 0)
+				mvwvline(win_stat, 1, col->offset - 1, ACS_VLINE, height + 1);
+			mvwaddstrf(win_stat, 1, col->offset + col->width / 2 - strlen(col->title) / 2, "%s", col->title);
+		}
+
+		if (i + 1 == display_page->n_tables)
+			mvwvline(win_stat, 0, table->offset + table->width,  ACS_VLINE, height + 2);
+	}
+	wbkgdset(win_stat, COLOR_PAIR(NO_COLOR));
+	wattroff(win_stat, A_BOLD);
+}
+
+void display_column_print(const struct display_column *display_column, int row, const char *fmt, ...)
+{
+	if (row >= max_n_lines)
+		return;
+
+	va_list ap;
+	char buffer[128] = {0};
+	char *to_print = buffer + 64;
+
+	va_start(ap, fmt);
+	int len = vsnprintf(to_print, sizeof(buffer) - 64, fmt, ap);
+	va_end(ap);
+
+	int offset = 0;
+	/* If column is too long, add ~ at the end. If it is too
+	   short, align on the right. */
+	if (len > display_column->width) {
+		to_print[display_column->width - 1] = '~';
+		to_print[display_column->width] = '\0';
+	} else {
+		int diff = display_column->width - len;
+
+		to_print += len;
+		to_print -= display_column->width;
+		for (int i = 0; i < diff; i++)
+			to_print[i] = ' ';
+	}
+
+	mvwaddstrf(win_stat, row + 2, display_column->offset, "%s", to_print);
+}
+
+void display_column_print_core_task(const struct display_column *display_column, int row, struct lcore_cfg *lconf, struct task_args *targ)
+{
+	if (row >= max_n_lines)
+		return;
+
+	if (lconf->n_tasks_run == 0) {
+		wattron(win_stat, A_BOLD);
+		wbkgdset(win_stat, COLOR_PAIR(RED_ON_NOTHING));
+	}
+	if (targ->id == 0)
+		mvwaddstrf(win_stat, row + 2, display_column->offset, "%2u/", lconf->id);
+	if (lconf->n_tasks_run == 0) {
+		wattroff(win_stat, A_BOLD);
+		wbkgdset(win_stat, COLOR_PAIR(NO_COLOR));
+	}
+	if (!lconf_task_is_running(lconf, targ->id)) {
+		wattron(win_stat, A_BOLD);
+		wbkgdset(win_stat, COLOR_PAIR(RED_ON_NOTHING));
+	}
+	mvwaddstrf(win_stat, row + 2, display_column->offset + 3, "%1u", targ->id);
+	if (!lconf_task_is_running(lconf, targ->id)) {
+		wattroff(win_stat, A_BOLD);
+		wbkgdset(win_stat, COLOR_PAIR(NO_COLOR));
+	}
+}
+
+static void redraw_tabs(unsigned screen_id)
+{
+	const size_t len = longest_title + 1;
+
+	for (size_t i = 0; i < n_screens; ++i) {
+		if (i == screen_id)
+			wbkgdset(win_tabs, COLOR_PAIR(BLACK_ON_GREEN));
+
+		mvwaddstrf(win_tabs, 0, i*(len + 3), "%zu ", i+1);
+		if (i != screen_id)
+			wbkgdset(win_tabs, COLOR_PAIR(GREEN_ON_NOTHING));
+		mvwaddstrf(win_tabs, 0, i*(len + 3) + 2, "%s", display_screens[i]->title);
+		for (size_t j = strlen(display_screens[i]->title); j < len - 1; ++j)
+			mvwaddstrf(win_tabs, 0, i*(len + 3) + 2 + j, " ");
+		if (i != screen_id)
+			wbkgdset(win_tabs, COLOR_PAIR(NO_COLOR));
+		if (i == screen_id)
+			wbkgdset(win_tabs, COLOR_PAIR(NO_COLOR));
+	}
+
+	wrefresh(win_tabs);
+}
+
+static void draw_title(void)
+{
+	char title_str[128];
+
+	snprintf(title_str, sizeof(title_str), "%s %s: %s", PROGRAM_NAME, VERSION_STR, prox_cfg.name);
+
+	wbkgd(win_title, COLOR_PAIR(BLACK_ON_GREEN));
+	title_len = strlen(title_str);
+	mvwaddstrf(win_title, 0, (COLS - title_len)/2, "%s", title_str);
+
+	redraw_tabs(screen_state.chosen_screen);
+}
+
+static void draw_general_frame(void)
+{
+	if (screen_state.toggle == 0) {
+		wattron(win_general, A_BOLD);
+		wbkgdset(win_general, COLOR_PAIR(MAGENTA_ON_NOTHING));
+		mvwaddstrf(win_general, 0, 9, "rx:         tx:          diff:                     rx:          tx:                        %%:");
+		mvwaddstrf(win_general, 1, 9, "rx:         tx:          err:                      rx:          tx:          err:          %%:");
+		wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
+
+		wbkgdset(win_general, COLOR_PAIR(BLUE_ON_NOTHING));
+		mvwaddstrf(win_general, 0, 0, "Host pps ");
+		mvwaddstrf(win_general, 1, 0, "NICs pps ");
+
+		wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING));
+		mvwaddstrf(win_general, 0, 56, "avg");
+		mvwaddstrf(win_general, 1, 56, "avg");
+		wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
+		wattroff(win_general, A_BOLD);
+	} else {
+		wattron(win_general, A_BOLD);
+		wbkgdset(win_general, COLOR_PAIR(BLUE_ON_NOTHING));
+		mvwaddstrf(win_general, 0, 9, "rx:                   tx:                   rx-tx:                      tx/rx:            rx/tx:");
+		mvwaddstrf(win_general, 1, 9, "rx:                   tx:                   err:                        tx/rx:            rx/tx:");
+		wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
+
+		wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING));
+		mvwaddstrf(win_general, 0, 0, "Host tot ");
+		mvwaddstrf(win_general, 1, 0, "NICs tot ");
+		wattroff(win_general, A_BOLD);
+	}
+}
+
+static void draw_status_bar(void)
+{
+	wbkgd(win_help, COLOR_PAIR(BLACK_ON_WHITE));
+	werase(win_help);
+	mvwaddstrf(win_help, 0, 0,
+		   "Enter 'help' or command, <ESC> or 'quit' to exit, "
+		   "1-%zu to switch screens and 0 to reset stats, '=' to toggle between per-sec and total stats",
+		   n_screens);
+	wrefresh(win_help);
+	mvwin(win_help, LINES - 1, 0);
+}
+
+static void draw_log_window(void)
+{
+	idlok(win_txt, FALSE);
+	/* Get scrolling */
+	scrollok(win_txt, TRUE);
+
+	/* Leave cursor where it was */
+	leaveok(win_txt, TRUE);
+	wbkgd(win_txt, COLOR_PAIR(BLACK_ON_CYAN));
+	wrefresh(win_txt);
+}
+
+static void stats_display_layout(uint8_t in_place)
+{
+	uint8_t cur_stats_height;
+
+	cur_stats_height = current_screen->get_height();
+	cur_stats_height = cur_stats_height > max_n_lines? max_n_lines: cur_stats_height;
+
+	display_lock();
+	if (!in_place) {
+		// moving existing windows does not work
+		delwin(win_txt);
+		delwin(win_general);
+		delwin(win_title);
+		delwin(win_tabs);
+		delwin(win_cmd);
+		delwin(win_txt);
+		delwin(win_help);
+
+		clear();
+	}
+
+	if (!in_place) {
+		win_stat = create_subwindow(cur_stats_height + 2, 0, 4, 0);
+		win_tabs = create_subwindow(1, 0, 1, 0);
+		win_general = create_subwindow(2, 0, 2, 0);
+		win_title = create_subwindow(1, 0, 0, 0);
+		win_cmd = create_subwindow(1, 0, cur_stats_height + 2 + 4,  0);
+		win_txt_height = LINES - cur_stats_height - 2 - 3 - 3;
+		win_txt = create_subwindow(win_txt_height, 0, cur_stats_height + 4 + 3, 0);
+		win_help = create_subwindow(1, 0, LINES - 1, 0);
+	}
+
+	draw_title();
+	draw_general_frame();
+	/* Command line */
+	wbkgd(win_cmd, COLOR_PAIR(BLACK_ON_YELLOW));
+	idlok(win_cmd, FALSE);
+	/* Move cursor at insertion point */
+	leaveok(win_cmd, FALSE);
+
+	draw_status_bar();
+	draw_log_window();
+
+	/* Draw everything to the screen */
+	refresh();
+	current_screen->draw_frame(&screen_state);
+	display_unlock();
+
+	refresh_cmd_win();
+	display_stats();
+}
+
+void display_end(void)
+{
+	pthread_mutex_destroy(&disp_mtx);
+
+	if (scr != NULL) {
+		endwin();
+	}
+}
+
+static void pps_print(WINDOW *dst_scr, int y, int x, uint64_t val, int is_blue)
+{
+	uint64_t rx_pps_disp = val;
+	uint64_t rx_pps_disp_frac = 0;
+	uint32_t ten_pow3 = 0;
+	static const char *units = " KMG";
+	char rx_unit = ' ';
+
+	while (rx_pps_disp > 1000) {
+		rx_pps_disp /= 1000;
+		rx_pps_disp_frac = (val - rx_pps_disp*1000) / 10;
+		val /= 1000;
+		ten_pow3++;
+	}
+
+	if (ten_pow3 >= strlen(units)) {
+		wbkgdset(dst_scr, COLOR_PAIR(RED_ON_NOTHING));
+		mvwaddstrf(dst_scr, y, x, "---");
+		wbkgdset(dst_scr, COLOR_PAIR(NO_COLOR));
+		return;
+	}
+
+	rx_unit = units[ten_pow3];
+
+	wattron(dst_scr, A_BOLD);
+	if (is_blue) {
+		wbkgdset(dst_scr, COLOR_PAIR(BLUE_ON_NOTHING));
+	}
+	else
+		wbkgdset(dst_scr, COLOR_PAIR(CYAN_ON_NOTHING));
+
+	mvwaddstrf(dst_scr, y, x, "%3lu", rx_pps_disp);
+	if (rx_unit != ' ') {
+		mvwaddstrf(dst_scr, y, x + 3, ".%02lu", rx_pps_disp_frac);
+		wattroff(dst_scr, A_BOLD);
+		wbkgdset(dst_scr, COLOR_PAIR(WHITE_ON_NOTHING));
+		wattron(dst_scr, A_BOLD);
+		mvwaddstrf(dst_scr, y, x + 6, "%c", rx_unit);
+		wattroff(dst_scr, A_BOLD);
+		wbkgdset(dst_scr, COLOR_PAIR(NO_COLOR));
+	}
+	else {
+		mvwaddstrf(dst_scr, y, x + 3, "    ");
+	}
+	wattroff(dst_scr, A_BOLD);
+	wbkgdset(dst_scr, COLOR_PAIR(NO_COLOR));
+}
+
+static void display_stats_general_per_sec(void)
+{
+	struct global_stats_sample *gsl = stats_get_global_stats(1);
+	struct global_stats_sample *gsp = stats_get_global_stats(0);
+
+	uint64_t rx_pps = val_to_rate(gsl->host_rx_packets - gsp->host_rx_packets, gsl->tsc - gsp->tsc);
+	uint64_t tx_pps = val_to_rate(gsl->host_tx_packets - gsp->host_tx_packets, gsl->tsc - gsp->tsc);
+	/* Host: RX, TX, Diff */
+	pps_print(win_general, 0, 12, rx_pps, 1);
+	pps_print(win_general, 0, 25, tx_pps, 1);
+
+	uint64_t diff = 0;
+	if (rx_pps > tx_pps)
+		diff = rx_pps - tx_pps;
+	pps_print(win_general, 0, 40, diff, 1);
+
+	uint64_t nics_rx_pps = val_to_rate(gsl->nics_rx_packets - gsp->nics_rx_packets, gsl->tsc - gsp->tsc);
+	uint64_t nics_tx_pps = val_to_rate(gsl->nics_tx_packets - gsp->nics_tx_packets, gsl->tsc - gsp->tsc);
+	uint64_t nics_ierrors = val_to_rate(gsl->nics_ierrors - gsp->nics_ierrors, gsl->tsc - gsp->tsc);
+	uint64_t nics_imissed = val_to_rate(gsl->nics_imissed - gsp->nics_imissed, gsl->tsc - gsp->tsc);
+
+	/* NIC: RX, TX, Diff */
+	pps_print(win_general, 1, 12, nics_rx_pps, 1);
+	pps_print(win_general, 1, 25, nics_tx_pps, 1);
+	pps_print(win_general, 1, 40, nics_ierrors + nics_imissed, 1);
+
+	wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING));
+	wattron(win_general, A_BOLD);
+	mvwaddstrf(win_general, 0, 103, "%6.2f", tx_pps > rx_pps? 100 : tx_pps * 100.0 / rx_pps);
+	wattroff(win_general, A_BOLD);
+	wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
+
+	struct global_stats_sample *gsb = stats_get_global_stats_beg();
+	if (gsb) {
+		uint64_t rx_pps = val_to_rate(gsl->host_rx_packets - gsb->host_rx_packets, gsl->tsc - gsb->tsc);
+		uint64_t tx_pps = val_to_rate(gsl->host_tx_packets - gsb->host_tx_packets, gsl->tsc - gsb->tsc);
+
+		uint64_t nics_rx_pps = val_to_rate(gsl->nics_rx_packets - gsb->nics_rx_packets, gsl->tsc - gsb->tsc);
+		uint64_t nics_tx_pps = val_to_rate(gsl->nics_tx_packets - gsb->nics_tx_packets, gsl->tsc - gsb->tsc);
+		uint64_t nics_ierrors = val_to_rate(gsl->nics_ierrors - gsb->nics_ierrors, gsl->tsc - gsb->tsc);
+		uint64_t nics_imissed = val_to_rate(gsl->nics_imissed - gsb->nics_imissed, gsl->tsc - gsb->tsc);
+
+		pps_print(win_general, 0, 64, rx_pps, 0);
+		pps_print(win_general, 0, 77, tx_pps, 0);
+
+		pps_print(win_general, 1, 64, nics_rx_pps, 0);
+		pps_print(win_general, 1, 77, nics_tx_pps, 0);
+		pps_print(win_general, 1, 91, nics_ierrors + nics_imissed, 0);
+
+		wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING));
+		wattron(win_general, A_BOLD);
+		uint64_t nics_in = gsl->host_rx_packets - gsb->host_rx_packets + gsl->nics_ierrors - gsb->nics_ierrors + gsl->nics_imissed - gsb->nics_imissed;
+		uint64_t nics_out = gsl->host_tx_packets - gsb->host_tx_packets;
+		mvwaddstrf(win_general, 1, 103, "%6.2f", nics_out > nics_in?
+			   100 : nics_out * 100.0 / nics_in);
+		wattron(win_general, A_BOLD);
+		wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
+	}
+}
+
+static void display_stats_general_total(void)
+{
+	struct global_stats_sample *gsl = stats_get_global_stats(1);
+
+	int64_t diff = (int64_t)gsl->host_rx_packets - gsl->host_tx_packets;
+	uint32_t percent;
+
+	/* Host: RX, TX, Diff */
+	mvwaddstrf(win_general, 0, 13, "%16lu", gsl->host_rx_packets);
+	mvwaddstrf(win_general, 0, 35, "%16lu", gsl->host_tx_packets);
+	mvwaddstrf(win_general, 0, 60, "%16"PRId64"", diff);
+	if (gsl->host_rx_packets == 0)
+		percent = 1000000;
+	else
+		percent = gsl->host_tx_packets * 1000000 / gsl->host_rx_packets;
+	mvwaddstrf(win_general, 0, 88, "%3u.%04u%%", percent / 10000, percent % 10000);
+	if (gsl->host_tx_packets == 0)
+		percent = 1000000;
+	else
+		percent = gsl->host_rx_packets * 1000000 / gsl->host_tx_packets;
+	mvwaddstrf(win_general, 0, 106, "%3u.%04u%%", percent / 10000, percent % 10000);
+
+	mvwaddstrf(win_general, 1, 13, "%16lu", gsl->nics_rx_packets);
+	mvwaddstrf(win_general, 1, 35, "%16lu", gsl->nics_tx_packets);
+	mvwaddstrf(win_general, 1, 60, "%16lu", gsl->nics_ierrors + gsl->nics_imissed);
+	if (gsl->nics_rx_packets == 0)
+		percent = 1000000;
+	else
+		percent = gsl->nics_tx_packets * 1000000 / gsl->nics_rx_packets;
+	mvwaddstrf(win_general, 1, 88, "%3u.%04u%%", percent / 10000, percent % 10000);
+	if (gsl->nics_tx_packets == 0)
+		percent = 1000000;
+	else
+		percent = gsl->nics_rx_packets * 1000000 / gsl->nics_tx_packets;
+	mvwaddstrf(win_general, 1, 106, "%3u.%04u%%", percent / 10000, percent % 10000);
+}
+
+static void display_stats_general(void)
+{
+	/* moment when stats were gathered. */
+	uint64_t cur_tsc = stats_get_last_tsc();
+	uint64_t up_time = tsc_to_sec(cur_tsc - stats_global_start_tsc());
+	uint64_t up_time2 = tsc_to_sec(cur_tsc - stats_global_beg_tsc());
+	uint64_t rem_time = -1;
+	char title_str[128] = {0};
+
+	if (stats_global_end_tsc()) {
+		uint64_t rem_tsc = stats_global_end_tsc() > cur_tsc? stats_global_end_tsc() - cur_tsc : 0;
+
+		rem_time = tsc_to_sec(rem_tsc);
+	}
+
+	if (up_time != up_time2 && cur_tsc >= stats_global_beg_tsc()) {
+		if (stats_global_end_tsc())
+			snprintf(title_str, sizeof(title_str), "%5lu (%lu) up, %lu rem", up_time, up_time2, rem_time);
+		else
+			snprintf(title_str, sizeof(title_str), "%5lu (%lu) up", up_time, up_time2);
+	}
+	else {
+		if (stats_global_end_tsc())
+			snprintf(title_str, sizeof(title_str), "%5lu up, %lu rem", up_time, rem_time);
+		else
+			snprintf(title_str, sizeof(title_str), "%5lu up", up_time);
+	}
+
+	/* Only print up time information if there is enough space */
+	if ((int)((COLS + title_len)/2 + strlen(title_str) + 1) < COLS) {
+		mvwaddstrf(win_title, 0, COLS - strlen(title_str), "%s", title_str);
+		wrefresh(win_title);
+	}
+
+	if (screen_state.toggle == 0)
+		display_stats_general_per_sec();
+	else
+		display_stats_general_total();
+
+	wrefresh(win_general);
+}
+
+char *print_time_unit_err_usec(char *dst, struct time_unit_err *t)
+{
+	uint64_t nsec_total = time_unit_to_nsec(&t->time);
+
+	uint64_t usec = nsec_total/1000;
+	uint64_t nsec = nsec_total - usec*1000;
+
+	uint64_t nsec_total_error = time_unit_to_nsec(&t->error);
+
+	uint64_t usec_error = nsec_total_error/1000;
+	uint64_t nsec_error = nsec_total_error - usec_error*1000;
+
+	sprintf(dst, "%4"PRIu64".%03"PRIu64" +/- %2"PRIu64".%03"PRIu64"", usec, nsec, usec_error, nsec_error);
+	return dst;
+}
+
+char *print_time_unit_usec(char *dst, struct time_unit *t)
+{
+	uint64_t nsec_total = time_unit_to_nsec(t);
+
+	uint64_t usec = nsec_total/1000;
+	uint64_t nsec = nsec_total - usec*1000;
+
+	sprintf(dst, "%4"PRIu64".%03"PRIu64"", usec, nsec);
+	return dst;
+}
+
+void toggle_display_screen(void)
+{
+	screen_state.toggle = !screen_state.toggle;
+	stats_display_layout(0);
+}
+
+void display_screen(unsigned screen_id)
+{
+	if (screen_id >= n_screens) {
+		plog_err("Unsupported screen %d\n", screen_id + 1);
+		return;
+	}
+
+	if (screen_state.chosen_screen == screen_id) {
+		stats_display_layout(1);
+	}
+	else {
+		screen_state.chosen_screen = screen_id;
+		current_screen = display_screens[screen_id];
+		stats_display_layout(0);
+	}
+}
+
+void display_page_up(void)
+{
+}
+
+void display_page_down(void)
+{
+}
+
+void display_refresh(void)
+{
+	stats_display_layout(1);
+}
+
+void display_stats(void)
+{
+	display_lock();
+	current_screen->draw_stats(&screen_state);
+	display_stats_general();
+	wrefresh(win_stat);
+	display_unlock();
+}
+
+static char pages[32768] = {0};
+static int cur_idx = 0;
+static size_t pages_len = 0;
+
+void display_print_page(void)
+{
+	int n_lines = 0;
+	int cur_idx_prev = cur_idx;
+
+	if (cur_idx >= (int)pages_len) {
+		return;
+	}
+
+	display_lock();
+	for (size_t i = cur_idx; i < pages_len; ++i) {
+		if (pages[i] == '\n') {
+			n_lines++;
+			if (n_lines == win_txt_height - 2) {
+				pages[i] = 0;
+				cur_idx = i + 1;
+				break;
+			}
+		}
+	}
+
+	waddstr(win_txt, pages + cur_idx_prev);
+	if (cur_idx != cur_idx_prev && cur_idx < (int)pages_len)
+		waddstr(win_txt, "\nPRESS ENTER FOR MORE...\n");
+	else {
+		pages_len = 0;
+	}
+	wrefresh(win_txt);
+	display_unlock();
+}
+
+void display_print(const char *str)
+{
+	display_lock();
+
+	if (scr == NULL) {
+		fputs(str, stdout);
+		fflush(stdout);
+		display_unlock();
+		return;
+	}
+
+	/* Check if the whole string can fit on the screen. */
+	pages_len = strlen(str);
+	int n_lines = 0;
+	memset(pages, 0, sizeof(pages));
+	memcpy(pages, str, pages_len);
+	cur_idx = 0;
+	for (size_t i = 0; i < pages_len; ++i) {
+		if (pages[i] == '\n') {
+			n_lines++;
+			if (n_lines == win_txt_height - 2) {
+				pages[i] = 0;
+				cur_idx = i + 1;
+				break;
+			}
+		}
+	}
+
+	waddstr(win_txt, pages);
+	if (cur_idx != 0)
+		waddstr(win_txt, "\nPRESS ENTER FOR MORE...\n");
+	else
+		pages_len = 0;
+
+	wrefresh(win_txt);
+	display_unlock();
+}
diff --git a/VNFs/DPPD-PROX/display.h b/VNFs/DPPD-PROX/display.h
new file mode 100644
index 00000000..4b517546
--- /dev/null
+++ b/VNFs/DPPD-PROX/display.h
@@ -0,0 +1,109 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _DISPLAY_H_
+#define _DISPLAY_H_
+
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "display_latency.h"
+#include "stats_cons.h"
+#include "clock.h"
+
+struct display_column {
+	char title[32];
+	int  offset;
+	int  width;
+	struct display_page *display_page;
+};
+
+struct display_table {
+	struct display_column cols[16];
+	char title[32];
+	int n_cols;
+	int offset;
+	int width;
+};
+
+struct display_page {
+	struct display_table tables[8];
+	int n_tables;
+	int width;
+};
+
+struct screen_state {
+	unsigned chosen_screen;
+	unsigned chosen_page;
+	int toggle;
+	int pps_unit;
+};
+
+struct display_screen {
+	void (*draw_frame)(struct screen_state *screen_state);
+	void (*draw_stats)(struct screen_state *screen_state);
+	int (*get_height)(void);
+	const char *title;
+};
+
+void display_set_pps_unit(int val);
+
+struct lcore_cfg;
+struct task_args;
+
+void display_page_draw_frame(const struct display_page *display_page, int height);
+int display_column_get_width(const struct display_column *display_column);
+void display_column_init(struct display_column *display_column, const char *title, unsigned width);
+struct display_column *display_table_add_col(struct display_table *table);
+void display_table_init(struct display_table *table, const char *title);
+struct display_table *display_page_add_table(struct display_page *display_page);
+void display_page_init(struct display_page *display_page);
+__attribute__((format(printf, 3, 4))) void display_column_print(const struct display_column *display_column, int row, const char *fmt, ...);
+void display_column_print_core_task(const struct display_column *display_column, int row, struct lcore_cfg *lconf, struct task_args *targ);
+void display_column_print_number(const struct display_column *display_column, int row, uint64_t number);
+
+char *print_time_unit_err_usec(char *dst, struct time_unit_err *t);
+char *print_time_unit_usec(char *dst, struct time_unit *t);
+struct port_queue;
+struct rte_ring;
+void display_column_port_ring(const struct display_column *display_column, int row, struct port_queue *ports, int port_count, struct rte_ring **rings, int ring_count);
+
+void display_init(void);
+void display_end(void);
+void display_stats(void);
+void display_refresh(void);
+void display_print(const char *str);
+void display_cmd(const char *cmd, int cmd_len, int cursor_pos);
+void display_screen(unsigned screen_id);
+void toggle_display_screen(void);
+void display_page_up(void);
+void display_page_down(void);
+void display_print_page(void);
+void display_lock(void);
+void display_unlock(void);
+
+int display_getch(void);
+
+static struct stats_cons display = {
+	.init    = display_init,
+	.notify  = display_stats,
+	.refresh = display_refresh,
+	.finish  = display_end,
+	.flags   = STATS_CONS_F_ALL,
+};
+
+#endif /* _DISPLAY_H_ */
diff --git a/VNFs/DPPD-PROX/display_l4gen.c b/VNFs/DPPD-PROX/display_l4gen.c
new file mode 100644
index 00000000..7cc1f5f3
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_l4gen.c
@@ -0,0 +1,172 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "display.h"
+#include "display_l4gen.h"
+#include "stats_l4gen.h"
+
+static struct display_page display_page_l4gen;
+
+static struct display_column *core_col;
+static struct display_column *tcp_setup_col;
+static struct display_column *udp_setup_col;
+static struct display_column *all_setup_col;
+static struct display_column *bundles_setup_col;
+static struct display_column *tcp_teardown_col;
+static struct display_column *tcp_teardown_retx_col;
+static struct display_column *udp_teardown_col;
+static struct display_column *tcp_expire_col;
+static struct display_column *udp_expire_col;
+static struct display_column *active_col;
+static struct display_column *retx_col;
+
+static void display_l4gen_draw_frame(struct screen_state *state)
+{
+	const uint32_t n_l4gen = stats_get_n_l4gen();
+
+	display_page_init(&display_page_l4gen);
+
+	struct display_table *core = display_page_add_table(&display_page_l4gen);
+	struct display_table *setup_rate = display_page_add_table(&display_page_l4gen);
+	struct display_table *teardown_rate = display_page_add_table(&display_page_l4gen);
+	struct display_table *expire_rate = display_page_add_table(&display_page_l4gen);
+	struct display_table *other = display_page_add_table(&display_page_l4gen);
+
+	display_table_init(core, "Core");
+	display_table_init(setup_rate, "Setup rate (flows/s)");
+	display_table_init(teardown_rate, "Teardown rate (flows/s)");
+	display_table_init(expire_rate, "Expire rate (flows/s)");
+	display_table_init(other, "Other");
+
+	core_col = display_table_add_col(core);
+	display_column_init(core_col, "Nb", 4);
+
+	tcp_setup_col = display_table_add_col(setup_rate);
+	display_column_init(tcp_setup_col, "TCP", 10);
+	udp_setup_col = display_table_add_col(setup_rate);
+	display_column_init(udp_setup_col, "UDP", 10);
+	all_setup_col = display_table_add_col(setup_rate);
+	display_column_init(all_setup_col, "TCP + UDP", 9);
+	bundles_setup_col = display_table_add_col(setup_rate);
+	display_column_init(bundles_setup_col, "Bundles", 9);
+
+	tcp_teardown_col = display_table_add_col(teardown_rate);
+	display_column_init(tcp_teardown_col, "TCP w/o reTX", 12);
+	tcp_teardown_retx_col = display_table_add_col(teardown_rate);
+	display_column_init(tcp_teardown_retx_col, "TCP w/  reTX", 12);
+	udp_teardown_col = display_table_add_col(teardown_rate);
+	display_column_init(udp_teardown_col, "UDP", 12);
+
+	tcp_expire_col = display_table_add_col(expire_rate);
+	display_column_init(tcp_expire_col, "TCP", 10);
+	udp_expire_col = display_table_add_col(expire_rate);
+	display_column_init(udp_expire_col, "TCP", 10);
+
+	active_col = display_table_add_col(other);
+	display_column_init(active_col, "Active (#)", 10);
+	retx_col = display_table_add_col(other);
+	display_column_init(retx_col, "reTX (/s)", 10);
+
+	display_page_draw_frame(&display_page_l4gen, n_l4gen);
+
+	for (uint16_t i = 0; i < n_l4gen; ++i) {
+		struct task_l4_stats *tls = stats_get_l4_stats(i);
+
+		display_column_print(core_col, i, "%2u/%1u", tls->lcore_id, tls->task_id);
+	}
+}
+
+static void display_l4gen_draw_stats_line(int row, struct l4_stats_sample *clast, struct l4_stats_sample *cprev)
+{
+	struct l4_stats *last = &clast->stats;
+	struct l4_stats *prev = &cprev->stats;
+
+	uint64_t delta_t = clast->tsc - cprev->tsc;
+
+	uint64_t tcp_created = last->tcp_created - prev->tcp_created;
+	uint64_t udp_created = last->udp_created - prev->udp_created;
+
+	uint64_t tcp_finished_no_retransmit = last->tcp_finished_no_retransmit - prev->tcp_finished_no_retransmit;
+	uint64_t tcp_finished_retransmit = last->tcp_finished_retransmit - prev->tcp_finished_retransmit;
+	uint64_t tcp_expired = last->tcp_expired - prev->tcp_expired;
+	uint64_t tcp_retransmits = last->tcp_retransmits - prev->tcp_retransmits;
+	uint64_t udp_finished = last->udp_finished - prev->udp_finished;
+	uint64_t udp_expired = last->udp_expired - prev->udp_expired;
+	uint64_t bundles_created = last->bundles_created - prev->bundles_created;
+
+	uint64_t tcp_setup_rate = val_to_rate(tcp_created, delta_t);
+	uint64_t udp_setup_rate = val_to_rate(udp_created, delta_t);
+	uint64_t all_setup_rate = val_to_rate(tcp_created + udp_created, delta_t);
+	uint64_t bundle_setup_rate = val_to_rate(bundles_created, delta_t);
+
+	uint64_t tcp_teardown_rate = val_to_rate(tcp_finished_no_retransmit, delta_t);
+	uint64_t tcp_teardown_retx_rate = val_to_rate(tcp_finished_retransmit, delta_t);
+	uint64_t udp_teardown_rate = val_to_rate(udp_finished, delta_t);
+
+	uint64_t tcp_expire_rate = val_to_rate(tcp_expired, delta_t);
+	uint64_t udp_expire_rate = val_to_rate(udp_expired, delta_t);
+
+	display_column_print(tcp_setup_col, row, "%"PRIu64"", tcp_setup_rate);
+	display_column_print(udp_setup_col, row,  "%"PRIu64"", udp_setup_rate);
+	display_column_print(all_setup_col, row,  "%"PRIu64"", all_setup_rate);
+	display_column_print(bundles_setup_col, row,  "%"PRIu64"", bundle_setup_rate);
+
+	display_column_print(tcp_teardown_col, row, "%"PRIu64"", tcp_teardown_rate);
+	display_column_print(tcp_teardown_retx_col, row, "%"PRIu64"", tcp_teardown_retx_rate);
+	display_column_print(udp_teardown_col, row, "%"PRIu64"", udp_teardown_rate);
+
+	display_column_print(tcp_expire_col, row, "%"PRIu64"", tcp_expire_rate);
+	display_column_print(udp_expire_col, row, "%"PRIu64"", udp_expire_rate);
+
+	uint64_t tot_created = last->tcp_created + last->udp_created;
+	uint64_t tot_finished = last->tcp_finished_retransmit + last->tcp_finished_no_retransmit +
+		last->udp_finished + last->udp_expired + last->tcp_expired;
+
+	uint64_t active = tot_created - tot_finished;
+	uint64_t retx = tcp_retransmits;
+
+	display_column_print(active_col, row, "%10"PRIu64"", active);
+	display_column_print(retx_col, row, "%10"PRIu64"", retx);
+}
+
+static void display_l4gen_draw_stats(struct screen_state *state)
+{
+	const uint32_t n_l4gen = stats_get_n_l4gen();
+
+	for (uint16_t i = 0; i < n_l4gen; ++i) {
+		struct l4_stats_sample *clast = stats_get_l4_stats_sample(i, 1);
+		struct l4_stats_sample *cprev = stats_get_l4_stats_sample(i, 0);
+
+		display_l4gen_draw_stats_line(i, clast, cprev);
+	}
+}
+
+static int display_l4gen_get_height(void)
+{
+	return stats_get_n_l4gen();
+}
+
+static struct display_screen display_screen_l4gen = {
+	.draw_frame = display_l4gen_draw_frame,
+	.draw_stats = display_l4gen_draw_stats,
+	.get_height = display_l4gen_get_height,
+	.title = "l4gen",
+};
+
+struct display_screen *display_l4gen(void)
+{
+	return &display_screen_l4gen;
+}
diff --git a/VNFs/DPPD-PROX/display_l4gen.h b/VNFs/DPPD-PROX/display_l4gen.h
new file mode 100644
index 00000000..24b6c5af
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_l4gen.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef DISPLAY_L4GEN_H
+#define DISPLAY_L4GEN_H
+
+struct display_screen;
+struct display_screen *display_l4gen(void);
+
+#endif /* DISPLAY_L4GEN_H */
diff --git a/VNFs/DPPD-PROX/display_latency.c b/VNFs/DPPD-PROX/display_latency.c
new file mode 100644
index 00000000..04382e46
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_latency.c
@@ -0,0 +1,154 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "display.h"
+#include "display_latency.h"
+#include "stats_latency.h"
+#include "lconf.h"
+
+static struct display_column *min_col;
+static struct display_column *max_col;
+static struct display_column *avg_col;
+static struct display_column *stddev_col;
+static struct display_column *accuracy_limit_col;
+static struct display_column *used_col;
+static struct display_column *lost_col;
+static struct display_page display_page_latency;
+
+static void display_latency_draw_frame(struct screen_state *screen_state)
+{
+	const uint32_t n_latency = stats_get_n_latency();
+	struct display_column *core_col;
+	struct display_column *port_col;
+
+	display_page_init(&display_page_latency);
+
+	struct display_table *core = display_page_add_table(&display_page_latency);
+	struct display_table *port = display_page_add_table(&display_page_latency);
+	struct display_table *lat = display_page_add_table(&display_page_latency);
+	struct display_table *acc = display_page_add_table(&display_page_latency);
+	struct display_table *other = display_page_add_table(&display_page_latency);
+
+	display_table_init(core, "Core");
+	core_col = display_table_add_col(core);
+	display_column_init(core_col, "Nb", 4);
+
+	display_table_init(port, "Port Nb");
+	port_col = display_table_add_col(port);
+	display_column_init(port_col, "RX", 8);
+
+	if (screen_state->toggle == 0)
+		display_table_init(lat, "Measured Latency per interval");
+	else
+		display_table_init(lat, "Measured Latency since reset");
+
+	min_col = display_table_add_col(lat);
+	display_column_init(min_col, "Min (us)", 20);
+	max_col = display_table_add_col(lat);
+	display_column_init(max_col, "Max (us)", 20);
+	avg_col = display_table_add_col(lat);
+	display_column_init(avg_col, "Avg (us)", 20);
+	stddev_col = display_table_add_col(lat);
+	display_column_init(stddev_col, "Stddev (us)", 20);
+
+	display_table_init(acc, "Accuracy ");
+	used_col = display_table_add_col(acc);
+	display_column_init(used_col, "Used Packets (%)", 16);
+	accuracy_limit_col = display_table_add_col(acc);
+	display_column_init(accuracy_limit_col, "limit (us)", 16);
+
+	display_table_init(other, "Other");
+
+	lost_col = display_table_add_col(other);
+	display_column_init(lost_col, "Lost Packets", 16);
+
+	display_page_draw_frame(&display_page_latency, n_latency);
+
+	for (uint16_t i = 0; i < n_latency; ++i) {
+		uint32_t lcore_id = stats_latency_get_core_id(i);
+		uint32_t task_id = stats_latency_get_task_id(i);
+		struct task_args *targ = &lcore_cfg[lcore_id].targs[task_id];
+
+		display_column_print(core_col, i, "%2u/%1u", lcore_id, task_id);
+		display_column_port_ring(port_col, i, targ->rx_port_queue, targ->nb_rxports, targ->rx_rings, targ->nb_rxrings);
+	}
+}
+
+#define AFTER_POINT 1000000
+
+static void display_stats_latency_entry(int row, struct stats_latency *stats_latency)
+{
+	struct time_unit_err avg = stats_latency->avg;
+	struct time_unit_err min = stats_latency->min;
+	struct time_unit_err max = stats_latency->max;
+	struct time_unit_err stddev = stats_latency->stddev;
+	struct time_unit accuracy_limit = stats_latency->accuracy_limit;
+
+	uint32_t used = 0;
+
+	if (stats_latency->tot_all_packets)
+		used = stats_latency->tot_packets * (100 * AFTER_POINT) / stats_latency->tot_all_packets;
+
+	char dst[32];
+
+	if (stats_latency->tot_packets) {
+		display_column_print(min_col, row, "%s", print_time_unit_err_usec(dst, &min));
+		display_column_print(max_col, row, "%s", print_time_unit_err_usec(dst, &max));
+		display_column_print(avg_col, row, "%s", print_time_unit_err_usec(dst, &avg));
+		display_column_print(stddev_col, row, "%s", print_time_unit_err_usec(dst, &stddev));
+	} else {
+		display_column_print(min_col, row, "%s", "N/A");
+		display_column_print(max_col, row, "%s", "N/A");
+		display_column_print(avg_col, row, "%s", "N/A");
+		display_column_print(stddev_col, row, "%s", "N/A");
+	}
+
+	display_column_print(accuracy_limit_col, row, "%s", print_time_unit_usec(dst, &accuracy_limit));
+	display_column_print(lost_col, row, "%16"PRIu64"", stats_latency->lost_packets);
+	display_column_print(used_col, row, "%3u.%06u", used / AFTER_POINT, used % AFTER_POINT);
+}
+
+static void display_latency_draw_stats(struct screen_state *screen_state)
+{
+	const uint32_t n_latency = stats_get_n_latency();
+	struct stats_latency *stats_latency;
+
+	for (uint16_t i = 0; i < n_latency; ++i) {
+		if (screen_state->toggle == 0)
+			stats_latency = stats_latency_get(i);
+		else
+			stats_latency = stats_latency_tot_get(i);
+
+		display_stats_latency_entry(i, stats_latency);
+	}
+}
+
+static int display_latency_get_height(void)
+{
+	return stats_get_n_latency();
+}
+
+static struct display_screen display_screen_latency = {
+	.draw_frame = display_latency_draw_frame,
+	.draw_stats = display_latency_draw_stats,
+	.get_height = display_latency_get_height,
+	.title = "latency",
+};
+
+struct display_screen *display_latency(void)
+{
+	return &display_screen_latency;
+}
diff --git a/VNFs/DPPD-PROX/display_latency.h b/VNFs/DPPD-PROX/display_latency.h
new file mode 100644
index 00000000..0821b2d9
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_latency.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef DISPLAY_LATENCY_H
+#define DISPLAY_LATENCY_H
+
+struct display_screen;
+struct display_screen *display_latency(void);
+
+#endif /* DISPLAY_LATENCY_H */
diff --git a/VNFs/DPPD-PROX/display_mempools.c b/VNFs/DPPD-PROX/display_mempools.c
new file mode 100644
index 00000000..2982104b
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_mempools.c
@@ -0,0 +1,111 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "display_mempools.h"
+#include "stats_mempool.h"
+#include "display.h"
+#include "defaults.h"
+
+static struct display_page display_page_mempools;
+static struct display_column *nb_col;
+static struct display_column *queue_col;
+static struct display_column *occup_col;
+static struct display_column *used_col;
+static struct display_column *free_col;
+static struct display_column *total_col;
+static struct display_column *mem_used_col;
+static struct display_column *mem_free_col;
+static struct display_column *mem_tot_col;
+
+static void display_mempools_draw_frame(struct screen_state *screen_state)
+{
+	const uint32_t n_mempools = stats_get_n_mempools();
+
+	display_page_init(&display_page_mempools);
+
+	struct display_table *port = display_page_add_table(&display_page_mempools);
+	struct display_table *stats = display_page_add_table(&display_page_mempools);
+
+	display_table_init(port, "Port");
+	display_table_init(stats, "Sampled statistics");
+
+	nb_col = display_table_add_col(port);
+	queue_col = display_table_add_col(port);
+	display_column_init(nb_col, "Nb", 4);
+	display_column_init(queue_col, "Queue", 5);
+
+	occup_col = display_table_add_col(stats);
+	display_column_init(occup_col, "Occup (%)", 9);
+	used_col = display_table_add_col(stats);
+	display_column_init(used_col, "Used (#)", 12);
+	free_col = display_table_add_col(stats);
+	display_column_init(free_col, "Free (#)", 12);
+	total_col = display_table_add_col(stats);
+	display_column_init(total_col, "Total (#)", 13);
+
+	mem_used_col = display_table_add_col(stats);
+	display_column_init(mem_used_col, "Mem Used (KB)", 13);
+	mem_free_col = display_table_add_col(stats);
+	display_column_init(mem_free_col, "Mem Free (KB)", 13);
+	mem_tot_col = display_table_add_col(stats);
+	display_column_init(mem_tot_col, "Mem Tot (KB)", 12);
+
+	display_page_draw_frame(&display_page_mempools, n_mempools);
+
+	for (uint16_t i = 0; i < n_mempools; ++i) {
+		struct mempool_stats *ms = stats_get_mempool_stats(i);
+
+		display_column_print(nb_col, i, "%4u", ms->port);
+		display_column_print(queue_col, i, "%5u", ms->queue);
+		display_column_print(total_col, i, "%13zu", ms->size);
+		display_column_print(mem_tot_col, i, "%12zu", ms->size * MBUF_SIZE/1024);
+	}
+}
+
+static void display_mempools_draw_stats(struct screen_state *state)
+{
+	const uint32_t n_mempools = stats_get_n_mempools();
+
+	for (uint16_t i = 0; i < n_mempools; ++i) {
+		struct mempool_stats *ms = stats_get_mempool_stats(i);
+		const size_t used = ms->size - ms->free;
+		const uint32_t used_frac = used*10000/ms->size;
+
+		display_column_print(occup_col, i, "%6u.%02u", used_frac/100, used_frac % 100);
+		display_column_print(used_col, i, "%12zu", used);
+		display_column_print(free_col, i, "%12zu", ms->free);
+
+		display_column_print(mem_free_col, i, "%13zu", used * MBUF_SIZE/1024);
+		display_column_print(mem_used_col, i, "%13zu", ms->free * MBUF_SIZE/1024);
+	}
+}
+
+static int display_mempools_get_height(void)
+{
+	return stats_get_n_mempools();
+}
+
+static struct display_screen display_screen_mempools = {
+	.draw_frame = display_mempools_draw_frame,
+	.draw_stats = display_mempools_draw_stats,
+	.get_height = display_mempools_get_height,
+	.title = "mempools",
+};
+
+struct display_screen *display_mempools(void)
+{
+	return &display_screen_mempools;
+}
diff --git a/VNFs/DPPD-PROX/display_mempools.h b/VNFs/DPPD-PROX/display_mempools.h
new file mode 100644
index 00000000..b5c4d99c
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_mempools.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef DISPLAY_MEMPOOLS_H
+#define DISPLAY_MEMPOOLS_H
+
+struct display_screen;
+struct display_screen *display_mempools(void);
+
+#endif /* DISPLAY_MEMPOOLS_H */
diff --git a/VNFs/DPPD-PROX/display_pkt_len.c b/VNFs/DPPD-PROX/display_pkt_len.c
new file mode 100644
index 00000000..df34616a
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_pkt_len.c
@@ -0,0 +1,138 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "prox_globals.h"
+#include "display_pkt_len.h"
+#include "stats_port.h"
+#include "display.h"
+#include "defaults.h"
+#include "prox_port_cfg.h"
+#include "clock.h"
+
+static struct display_page display_page_pkt_len;
+static struct display_column *port_col;
+static struct display_column *name_col;
+static struct display_column *type_col;
+static struct display_column *stats_col[PKT_SIZE_COUNT];
+
+const char *titles[] = {
+	"64B (#)",
+	"65-127B (#)",
+	"128-255B (#)",
+	"256-511B (#)",
+	"512-1023B (#)",
+	"1024-1522B (#)",
+	"1523B+ (#)",
+};
+
+static int port_disp[PROX_MAX_PORTS];
+static int n_port_disp;
+
+static void display_pkt_len_draw_frame(struct screen_state *screen_state)
+{
+	n_port_disp = 0;
+	for (uint8_t i = 0; i < PROX_MAX_PORTS; ++i) {
+		if (prox_port_cfg[i].active) {
+			port_disp[n_port_disp++] = i;
+		}
+	}
+
+	display_page_init(&display_page_pkt_len);
+
+	struct display_table *port_name = display_page_add_table(&display_page_pkt_len);
+
+	display_table_init(port_name, "Port");
+	port_col = display_table_add_col(port_name);
+	name_col = display_table_add_col(port_name);
+	type_col = display_table_add_col(port_name);
+
+	display_column_init(port_col, "ID", 4);
+	display_column_init(name_col, "Name", 8);
+	display_column_init(type_col, "Type", 7);
+
+	struct display_table *stats = display_page_add_table(&display_page_pkt_len);
+
+	if (screen_state->toggle == 0)
+		display_table_init(stats, "Statistics per second");
+	else
+		display_table_init(stats, "Total Statistics");
+
+	for (int i = 0; i < PKT_SIZE_COUNT; ++i) {
+		stats_col[i] = display_table_add_col(stats);
+		display_column_init(stats_col[i], titles[i], 13);
+	}
+
+	display_page_draw_frame(&display_page_pkt_len, n_port_disp);
+
+	for (uint8_t i = 0; i < n_port_disp; ++i) {
+		const uint32_t port_id = port_disp[i];
+
+		display_column_print(port_col, i, "%4u", port_id);
+		display_column_print(name_col, i, "%8s", prox_port_cfg[port_id].name);
+		display_column_print(type_col, i, "%7s", prox_port_cfg[port_id].short_name);
+	}
+}
+
+static void display_pkt_len_draw_stats(struct screen_state *state)
+{
+	for (uint8_t i = 0; i < n_port_disp; ++i) {
+		const uint32_t port_id = port_disp[i];
+		struct port_stats_sample *last = stats_get_port_stats_sample(port_id, 1);
+		struct port_stats_sample *prev = stats_get_port_stats_sample(port_id, 0);
+
+		uint64_t delta_t = last->tsc - prev->tsc;
+		if (delta_t == 0) // This could happen if we just reset the screen => stats will be updated later
+			continue;
+
+		if (state->toggle == 0) {
+			uint64_t diff;
+
+			for (int j = 0; j < PKT_SIZE_COUNT; ++j) {
+				if (last->tx_pkt_size[j] == (uint64_t)-1) {
+					display_column_print(stats_col[j], i, "     ---     ");
+				} else {
+					diff = last->tx_pkt_size[j] - prev->tx_pkt_size[j];
+					display_column_print(stats_col[j], i, "%13lu", val_to_rate(diff, delta_t));
+				}
+			}
+		} else {
+			for (int j = 0; j < PKT_SIZE_COUNT; ++j) {
+				if (last->tx_pkt_size[j] == (uint64_t)-1) {
+					display_column_print(stats_col[j], i, "     ---     ");
+				} else {
+					display_column_print(stats_col[j], i, "%13lu", last->tx_pkt_size[j]);
+				}
+			}
+		}
+	}
+}
+
+static int display_pkt_len_get_height(void)
+{
+	return stats_get_n_ports();
+}
+
+static struct display_screen display_screen_pkt_len = {
+	.draw_frame = display_pkt_len_draw_frame,
+	.draw_stats = display_pkt_len_draw_stats,
+	.get_height = display_pkt_len_get_height,
+	.title = "pkt_len",
+};
+
+struct display_screen *display_pkt_len(void)
+{
+	return &display_screen_pkt_len;
+}
diff --git a/VNFs/DPPD-PROX/display_pkt_len.h b/VNFs/DPPD-PROX/display_pkt_len.h
new file mode 100644
index 00000000..2c7af420
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_pkt_len.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef DISPLAY_PKT_LEN_H
+#define DISPLAY_PKT_LEN_H
+
+struct display_screen;
+struct display_screen *display_pkt_len(void);
+
+#endif /* DISPLAY_PKT_LEN_H */
diff --git a/VNFs/DPPD-PROX/display_ports.c b/VNFs/DPPD-PROX/display_ports.c
new file mode 100644
index 00000000..b1027f93
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_ports.c
@@ -0,0 +1,252 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+
+#include "clock.h"
+#include "display_ports.h"
+#include "display.h"
+#include "stats_port.h"
+#include "prox_globals.h"
+#include "prox_port_cfg.h"
+
+static struct display_page display_page_ports;
+static struct display_column *nb_col;
+static struct display_column *name_col;
+static struct display_column *type_col;
+
+static struct display_column *no_mbufs_col;
+static struct display_column *ierrors_col;
+static struct display_column *imissed_col;
+static struct display_column *oerrors_col;
+static struct display_column *rx_col;
+static struct display_column *tx_col;
+static struct display_column *rx_bytes_col;
+static struct display_column *tx_bytes_col;
+static struct display_column *rx_percent_col;
+static struct display_column *tx_percent_col;
+
+static int port_disp[PROX_MAX_PORTS];
+static int n_port_disp;
+
+static void display_ports_draw_frame(struct screen_state *state)
+{
+	n_port_disp = 0;
+	for (uint8_t i = 0; i < PROX_MAX_PORTS; ++i) {
+		if (prox_port_cfg[i].active) {
+			port_disp[n_port_disp++] = i;
+		}
+	}
+
+	const uint32_t n_ports = stats_get_n_ports();
+	char name[32];
+	char *ptr;
+
+	display_page_init(&display_page_ports);
+
+	struct display_table *port = display_page_add_table(&display_page_ports);
+	struct display_table *stats = display_page_add_table(&display_page_ports);
+
+	display_table_init(port, "Port");
+
+	nb_col = display_table_add_col(port);
+	name_col = display_table_add_col(port);
+	type_col = display_table_add_col(port);
+
+	display_column_init(nb_col, "Nb", 4);
+	display_column_init(name_col, "Name", 8);
+	display_column_init(type_col, "Type", 7);
+
+	if (state->toggle == 0) {
+		display_table_init(stats, "Statistics per second");
+		no_mbufs_col = display_table_add_col(stats);
+		ierrors_col = display_table_add_col(stats);
+		imissed_col = display_table_add_col(stats);
+		oerrors_col = display_table_add_col(stats);
+		rx_col = display_table_add_col(stats);
+		tx_col = display_table_add_col(stats);
+		rx_bytes_col = display_table_add_col(stats);
+		tx_bytes_col = display_table_add_col(stats);
+		rx_percent_col = display_table_add_col(stats);
+		tx_percent_col = display_table_add_col(stats);
+
+		display_column_init(no_mbufs_col, "no mbufs (#)", 12);
+		display_column_init(ierrors_col, "ierrors (#)", 12);
+		display_column_init(imissed_col, "imissed (#)", 12);
+		display_column_init(oerrors_col, "oerrors (#)", 12);
+		display_column_init(rx_col, "RX (Kpps)", 10);
+		display_column_init(tx_col, "TX (Kpps)", 10);
+		display_column_init(rx_bytes_col, "RX (Kbps)", 10);
+		display_column_init(tx_bytes_col, "TX (Kbps)", 10);
+		display_column_init(rx_percent_col, "RX (%)", 8);
+		display_column_init(tx_percent_col, "TX (%)", 8);
+	} else {
+		display_table_init(stats, "Total statistics");
+		no_mbufs_col = display_table_add_col(stats);
+		ierrors_col = display_table_add_col(stats);
+		imissed_col = display_table_add_col(stats);
+		oerrors_col = display_table_add_col(stats);
+		rx_col = display_table_add_col(stats);
+		tx_col = display_table_add_col(stats);
+
+		display_column_init(no_mbufs_col, "no mbufs (#)", 13);
+		display_column_init(ierrors_col, "ierrors (#)", 13);
+		display_column_init(imissed_col, "imissed (#)", 13);
+		display_column_init(oerrors_col, "oerrors (#)", 13);
+		display_column_init(rx_col, "RX (#)", 13);
+		display_column_init(tx_col, "TX (#)", 13);
+	}
+
+	display_page_draw_frame(&display_page_ports, n_port_disp);
+	for (uint8_t i = 0; i < n_port_disp; ++i) {
+		const uint32_t port_id = port_disp[i];
+
+		display_column_print(nb_col, i, "%u", port_id);
+		display_column_print(name_col, i, "%s", prox_port_cfg[port_id].name);
+		display_column_print(type_col, i, "%s", prox_port_cfg[port_id].short_name);
+	}
+}
+
+struct percent {
+	uint32_t percent;
+	uint32_t part;
+};
+
+static struct percent calc_percent(uint64_t val, uint64_t delta_t)
+{
+	struct percent ret;
+	uint64_t normalized = 0;
+
+	if (val == 0) {
+		ret.percent = 0;
+		ret.part = 0;
+	} else if (val < thresh) {
+		ret.percent = val * tsc_hz / delta_t / 12500000;
+		ret.part = (val * tsc_hz / delta_t / 1250) % 10000;
+	} else if (delta_t > tsc_hz) {
+		ret.percent = val / (delta_t / tsc_hz) / 12500000;
+		ret.part = (val / (delta_t / tsc_hz) / 1250) % 10000;
+	} else {
+		ret.percent = 0;
+		ret.part = 0;
+	}
+	return ret;
+}
+
+static void display_ports_draw_per_sec_stats(void)
+{
+	for (uint8_t i = 0; i < n_port_disp; ++i) {
+		const uint32_t port_id = port_disp[i];
+		struct port_stats_sample *last = stats_get_port_stats_sample(port_id, 1);
+		struct port_stats_sample *prev = stats_get_port_stats_sample(port_id, 0);
+
+		uint64_t delta_t = last->tsc - prev->tsc;
+
+		/* This could happen if we just reset the screen.
+		   stats will be updated later */
+		if (delta_t == 0)
+			continue;
+
+		uint64_t no_mbufs_rate = val_to_rate(last->no_mbufs - prev->no_mbufs, delta_t);
+		uint64_t ierrors_rate = val_to_rate(last->ierrors - prev->ierrors, delta_t);
+		uint64_t imissed_rate = val_to_rate(last->imissed - prev->imissed, delta_t);
+		uint64_t oerrors_rate = val_to_rate(last->oerrors - prev->oerrors, delta_t);
+
+		uint64_t rx_kbps_rate = val_to_rate((last->rx_bytes - prev->rx_bytes) * 8, delta_t) / 1000;
+		uint64_t tx_kbps_rate = val_to_rate((last->tx_bytes - prev->tx_bytes) * 8, delta_t) / 1000;
+
+		uint64_t rx_rate = val_to_rate(last->rx_tot - prev->rx_tot, delta_t) / 1000;
+		if (unlikely(prev->rx_tot > last->rx_tot))
+			rx_rate = 0;
+		uint64_t tx_rate = val_to_rate(last->tx_tot - prev->tx_tot, delta_t) / 1000;
+		if (unlikely(prev->tx_tot > last->tx_tot))
+			tx_rate = 0;
+
+		/* Take 20 bytes overhead (or 24 if crc strip is enabled) into accound */
+		struct percent rx_percent;
+		struct percent tx_percent;
+		if (strcmp(prox_port_cfg[port_id].short_name, "i40e") == 0) {
+			if (prox_port_cfg[port_id].port_conf.rxmode.hw_strip_crc == 1) {
+				rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 24 * (last->rx_tot - prev->rx_tot), delta_t);
+				tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 24 * (last->tx_tot - prev->tx_tot), delta_t);
+			} else {
+				rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 20 * (last->rx_tot - prev->rx_tot), delta_t);
+				tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 20 * (last->tx_tot - prev->tx_tot), delta_t);
+			}
+		} else {
+			if (prox_port_cfg[port_id].port_conf.rxmode.hw_strip_crc == 1) {
+				rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 24 * (last->rx_tot - prev->rx_tot), delta_t);
+				tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 24 * (last->tx_tot - prev->tx_tot), delta_t);
+			} else {
+				rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 20 * (last->rx_tot - prev->rx_tot), delta_t);
+				tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 20 * (last->tx_tot - prev->tx_tot), delta_t);
+			}
+		}
+
+		display_column_print(no_mbufs_col, i, "%lu", no_mbufs_rate);
+		display_column_print(ierrors_col, i, "%lu", ierrors_rate);
+		display_column_print(imissed_col, i, "%lu", imissed_rate);
+		display_column_print(oerrors_col, i, "%lu", oerrors_rate);
+
+		display_column_print(rx_bytes_col, i, "%lu", rx_kbps_rate);
+		display_column_print(tx_bytes_col, i, "%lu", tx_kbps_rate);
+		display_column_print(rx_col, i, "%lu", rx_rate);
+		display_column_print(tx_col, i, "%lu", tx_rate);
+
+		display_column_print(rx_percent_col, i, "%3u.%04u", rx_percent.percent, rx_percent.part);
+		display_column_print(tx_percent_col, i, "%3u.%04u", tx_percent.percent, tx_percent.part);
+	}
+}
+
+static void display_ports_draw_total_stats(void)
+{
+	for (uint8_t i = 0; i < n_port_disp; ++i) {
+		const uint32_t port_id = port_disp[i];
+		struct port_stats_sample *last = stats_get_port_stats_sample(port_id, 1);
+
+		display_column_print(no_mbufs_col, i, "%lu", last->no_mbufs);
+		display_column_print(ierrors_col, i, "%lu", last->ierrors);
+		display_column_print(imissed_col, i, "%lu", last->imissed);
+		display_column_print(oerrors_col, i, "%lu", last->oerrors);
+		display_column_print(rx_col, i, "%lu", last->rx_tot);
+		display_column_print(tx_col, i, "%lu", last->tx_tot);
+	}
+}
+
+static void display_ports_draw_stats(struct screen_state *state)
+{
+	if (state->toggle == 0)
+		display_ports_draw_per_sec_stats();
+	else
+		display_ports_draw_total_stats();
+}
+
+static int display_ports_get_height(void)
+{
+	return stats_get_n_ports();
+}
+
+static struct display_screen display_screen_ports = {
+	.draw_frame = display_ports_draw_frame,
+	.draw_stats = display_ports_draw_stats,
+	.get_height = display_ports_get_height,
+	.title = "ports",
+};
+
+struct display_screen *display_ports(void)
+{
+	return &display_screen_ports;
+}
diff --git a/VNFs/DPPD-PROX/display_ports.h b/VNFs/DPPD-PROX/display_ports.h
new file mode 100644
index 00000000..520662fb
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_ports.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef DISPLAY_PORTS_H
+#define DISPLAY_PORTS_H
+
+struct display_screen;
+struct display_screen *display_ports(void);
+
+#endif /* DISPLAY_PORTS_H */
diff --git a/VNFs/DPPD-PROX/display_priority.c b/VNFs/DPPD-PROX/display_priority.c
new file mode 100644
index 00000000..c997d85d
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_priority.c
@@ -0,0 +1,144 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "display_priority.h"
+#include "stats_prio_task.h"
+#include "display.h"
+#include "lconf.h"
+
+#define PRIORITY_COUNT 8
+
+static struct display_page display_page_priority;
+static struct display_column *stats_tx[PRIORITY_COUNT];
+static struct display_column *stats_drop[PRIORITY_COUNT];
+static struct display_column *core_col;
+static struct display_column *name_col;
+
+static void display_priority_draw_frame(struct screen_state *state)
+{
+  	uint32_t n_tasks = stats_get_n_prio_tasks_tot();
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+	char name[32];
+	char *ptr;
+
+	display_page_init(&display_page_priority);
+
+	struct display_table *core_name = display_page_add_table(&display_page_priority);
+
+	display_table_init(core_name, "Core/task");
+	core_col = display_table_add_col(core_name);
+	name_col = display_table_add_col(core_name);
+	display_column_init(core_col, "Nb", 4);
+	display_column_init(name_col, "Name", 5);
+
+	struct display_table *stats = display_page_add_table(&display_page_priority);
+	if (state->toggle == 0) {
+		display_table_init(stats, "Statistics per second");
+
+		char title[64];
+		for (int i = 0; i < PRIORITY_COUNT; ++i) {
+			stats_tx[i] = display_table_add_col(stats);
+			snprintf(title, sizeof(title), "TX %d (K)", i);
+			display_column_init(stats_tx[i], title, 9);
+
+			stats_drop[i] = display_table_add_col(stats);
+			snprintf(title, sizeof(title), "DRP %d (K)", i);
+			display_column_init(stats_drop[i], title, 9);
+		}
+	} else {
+		display_table_init(stats, "Total statistics");
+
+		char title[64];
+		for (int i = 0; i < PRIORITY_COUNT; ++i) {
+			stats_tx[i] = display_table_add_col(stats);
+			snprintf(title, sizeof(title), "TX %d (#)", i);
+			display_column_init(stats_tx[i], title, 9);
+
+			stats_drop[i] = display_table_add_col(stats);
+			snprintf(title, sizeof(title), "DRP %d (#)", i);
+			display_column_init(stats_drop[i], title, 9);
+		}
+	}
+
+	display_page_draw_frame(&display_page_priority, n_tasks);
+
+	uint32_t count = 0;
+	lconf = NULL;
+	while (core_targ_next(&lconf, &targ, 0) == 0) {
+		if (strcmp(targ->task_init->mode_str, "aggreg") == 0) {
+			display_column_print_core_task(core_col, count, lconf, targ);
+			if (targ->id == 0)
+				display_column_print(name_col, count, "%s", lconf->name);
+			count++;
+		}
+	}
+}
+
+static void display_priority_draw_stats(struct screen_state *state)
+{
+	uint64_t rx_prio;
+	uint64_t drop_tx_fail_prio;
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+	const uint32_t n_stats_prio = stats_get_n_prio_tasks_tot();
+
+	if (state->toggle == 0) {
+		for (uint32_t count = 0; count < n_stats_prio; ++count) {
+			struct prio_task_stats_sample *last = stats_get_prio_task_stats_sample(count, 1);
+			struct prio_task_stats_sample *prev = stats_get_prio_task_stats_sample(count, 0);
+
+			uint64_t delta_t = (last->tsc - prev->tsc) * 1000;
+			if (delta_t == 0) // This could happen if we just reset the screen => stats will be updated later
+				continue;
+
+			for (uint8_t i = 0; i < PRIORITY_COUNT; i++) {
+				rx_prio = last->rx_prio[i] - prev->rx_prio[i];
+				drop_tx_fail_prio = last->drop_tx_fail_prio[i] - prev->drop_tx_fail_prio[i];
+
+				display_column_print(stats_tx[i], count, "%9lu", val_to_rate(rx_prio, delta_t));
+				display_column_print(stats_drop[i], count, "%9lu", val_to_rate(drop_tx_fail_prio, delta_t));
+			}
+		}
+	} else {
+		for (uint32_t count = 0; count < n_stats_prio; ++count) {
+			for (uint8_t i = 0; i < PRIORITY_COUNT; i++) {
+				rx_prio = stats_core_task_tot_rx_prio(count, i);
+				drop_tx_fail_prio = stats_core_task_tot_drop_tx_fail_prio(count, i);
+
+				display_column_print(stats_tx[i], count, "%9lu", rx_prio);
+				display_column_print(stats_drop[i], count, "%9lu", drop_tx_fail_prio);
+			}
+		}
+	}
+}
+
+static int display_priority_get_height(void)
+{
+	return stats_get_n_prio_tasks_tot();
+}
+
+static struct display_screen display_screen_priority = {
+	.draw_frame = display_priority_draw_frame,
+	.draw_stats = display_priority_draw_stats,
+	.get_height = display_priority_get_height,
+	.title = "priority",
+};
+
+struct display_screen *display_priority(void)
+{
+	return &display_screen_priority;
+}
diff --git a/VNFs/DPPD-PROX/display_priority.h b/VNFs/DPPD-PROX/display_priority.h
new file mode 100644
index 00000000..a15c03e6
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_priority.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef DISPLAY_PRIORITY_H
+#define DISPLAY_PRIORITY_H
+
+struct display_screen;
+struct display_screen *display_priority(void);
+
+#endif /* DISPLAY_PRIORITY_H */
diff --git a/VNFs/DPPD-PROX/display_rings.c b/VNFs/DPPD-PROX/display_rings.c
new file mode 100644
index 00000000..618350e2
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_rings.c
@@ -0,0 +1,111 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ring.h>
+
+#include "display.h"
+#include "display_rings.h"
+#include "stats_ring.h"
+#include "prox_port_cfg.h"
+
+static struct display_page display_page_rings;
+static struct display_column *ring_col;
+static struct display_column *occup_col;
+static struct display_column *free_col;
+static struct display_column *size_col;
+static struct display_column *sc_col;
+static struct display_column *sp_col;
+
+static void display_rings_draw_frame(struct screen_state *state)
+{
+	const uint32_t n_rings = stats_get_n_rings();
+	char sc_val, sp_val;
+
+	display_page_init(&display_page_rings);
+
+	struct display_table *ring_table = display_page_add_table(&display_page_rings);
+	struct display_table *stats_table = display_page_add_table(&display_page_rings);
+
+	display_table_init(ring_table, "Name");
+
+	display_table_init(stats_table, "Sampled statistics");
+
+	ring_col = display_table_add_col(ring_table);
+	display_column_init(ring_col, "Ring/Port", 11);
+	occup_col = display_table_add_col(stats_table);
+	display_column_init(occup_col, "Occup (%)", 11);
+	free_col = display_table_add_col(stats_table);
+	display_column_init(free_col, "Free", 11);
+	size_col = display_table_add_col(stats_table);
+	display_column_init(size_col, "Size", 11);
+	sc_col = display_table_add_col(stats_table);
+	display_column_init(sc_col, "SC", 2);
+	sp_col = display_table_add_col(stats_table);
+	display_column_init(sp_col, "SP", 2);
+
+	display_page_draw_frame(&display_page_rings, n_rings);
+
+	for (uint16_t i = 0; i < n_rings; ++i) {
+		struct ring_stats *rs = stats_get_ring_stats(i);
+
+		if (rs->nb_ports == 0) {
+			display_column_print(ring_col, i, "%s", rs->ring->name);
+		} else {
+			char name[64] = {0};
+			int offset = 0;
+
+			for (uint32_t j = 0; j < rs->nb_ports; j++)
+				offset += sprintf(name + offset, "%s", rs->port[j]->name);
+		}
+
+		sc_val = (rs->ring->flags & RING_F_SC_DEQ) ? 'y' : 'n';
+		sp_val = (rs->ring->flags & RING_F_SP_ENQ) ? 'y' : 'n';
+
+		display_column_print(sc_col, i, " %c", sc_val);
+		display_column_print(sp_col, i, " %c", sp_val);
+	}
+}
+
+static void display_rings_draw_stats(struct screen_state *state)
+{
+	const uint32_t n_rings = stats_get_n_rings();
+
+	for (uint32_t i = 0; i < n_rings; ++i) {
+		struct ring_stats *rs = stats_get_ring_stats(i);
+		uint32_t used = ((rs->size - rs->free)*10000)/rs->size;
+
+		display_column_print(occup_col, i, "%8u.%02u", used/100, used%100);
+		display_column_print(free_col, i, "%11u", rs->free);
+		display_column_print(size_col, i, "%11u", rs->size);
+	}
+}
+
+static int display_rings_get_height(void)
+{
+	return stats_get_n_rings();
+}
+
+static struct display_screen display_screen_rings = {
+	.draw_frame = display_rings_draw_frame,
+	.draw_stats = display_rings_draw_stats,
+	.get_height = display_rings_get_height,
+	.title = "rings",
+};
+
+struct display_screen *display_rings(void)
+{
+	return &display_screen_rings;
+}
diff --git a/VNFs/DPPD-PROX/display_rings.h b/VNFs/DPPD-PROX/display_rings.h
new file mode 100644
index 00000000..421bb16e
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_rings.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef DISPLAY_RINGS_H
+#define DISPLAY_RINGS_H
+
+struct display_screen;
+struct display_screen *display_rings(void);
+
+#endif /* DISPLAY_RINGS_H */
diff --git a/VNFs/DPPD-PROX/display_tasks.c b/VNFs/DPPD-PROX/display_tasks.c
new file mode 100644
index 00000000..75075a10
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_tasks.c
@@ -0,0 +1,331 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "display_tasks.h"
+#include "display.h"
+#include "prox_globals.h"
+#include "stats_task.h"
+#include "stats_core.h"
+#include "lconf.h"
+
+struct task_stats_disp {
+	uint32_t lcore_id;
+	uint32_t task_id;
+	uint32_t lcore_stat_id;
+};
+
+static int col_offset;
+static struct task_stats_disp task_stats_disp[RTE_MAX_LCORE * MAX_TASKS_PER_CORE];
+
+static struct display_page display_page_tasks;
+
+static struct display_column *nb_col;
+static struct display_column *name_col;
+static struct display_column *mode_col;
+static struct display_column *rx_name_col;
+static struct display_column *tx_name_col;
+static struct display_column *idle_col;
+static struct display_column *rx_col;
+static struct display_column *tx_col;
+static struct display_column *tx_fail_col;
+static struct display_column *discard_col;
+static struct display_column *handled_col;
+static struct display_column *cpp_col;
+static struct display_column *ghz_col;
+static struct display_column *rx_col;
+static struct display_column *tx_col;
+static struct display_column *tx_fail_col;
+static struct display_column *discard_col;
+static struct display_column *handled_col;
+static struct display_column *occup_col;
+static struct display_column *mask_col;
+static struct display_column *class_col;
+static struct display_column *mbm_tot_col;
+static struct display_column *mbm_loc_col;
+static struct display_column *frac_col;
+
+static void stats_display_core_task_entry(struct lcore_cfg *lconf, struct task_args *targ, unsigned row)
+{
+	display_column_print_core_task(nb_col, row, lconf, targ);
+
+	display_column_print(name_col, row, "%s", targ->id == 0 ? lconf->name : "");
+	display_column_print(mode_col, row, "%s", targ->task_init->mode_str);
+
+	display_column_port_ring(rx_name_col, row, targ->rx_port_queue, targ->nb_rxports, targ->rx_rings, targ->nb_rxrings);
+	display_column_port_ring(tx_name_col, row, targ->tx_port_queue, targ->nb_txports, targ->tx_rings, targ->nb_txrings);
+}
+
+static void display_tasks_draw_frame(struct screen_state *state)
+{
+	const uint32_t n_tasks_tot = stats_get_n_tasks_tot();
+
+	display_page_init(&display_page_tasks);
+
+	struct display_table *core_task = display_page_add_table(&display_page_tasks);
+	struct display_table *rx_tx = display_page_add_table(&display_page_tasks);
+
+	display_table_init(core_task, "Core/Task");
+
+	nb_col = display_table_add_col(core_task);
+	display_column_init(nb_col, "Nb", 4);
+	name_col = display_table_add_col(core_task);
+	display_column_init(name_col, "Name", 7);
+	mode_col = display_table_add_col(core_task);
+	display_column_init(mode_col, "Mode", 9);
+
+	display_table_init(rx_tx, "Port ID/Ring Name");
+	rx_name_col = display_table_add_col(rx_tx);
+	display_column_init(rx_name_col, "RX", 9);
+	tx_name_col = display_table_add_col(rx_tx);
+	display_column_init(tx_name_col, "TX", 9);
+
+	struct display_table *stats = display_page_add_table(&display_page_tasks);
+
+	if (state->toggle == 0) {
+		display_table_init(stats, "Statistics per second");
+
+		idle_col = display_table_add_col(stats);
+		display_column_init(idle_col, "Idle (%)", 5);
+
+		rx_col = display_table_add_col(stats);
+		display_column_init(rx_col, "RX (K)", 9);
+
+		tx_col = display_table_add_col(stats);
+		display_column_init(tx_col, "TX (K)", 9);
+
+		tx_fail_col = display_table_add_col(stats);
+		display_column_init(tx_fail_col, "TX Fail (K)", 9);
+
+		discard_col = display_table_add_col(stats);
+		display_column_init(discard_col, "Discard (K)", 9);
+
+		handled_col = display_table_add_col(stats);
+		display_column_init(handled_col, "Handled (K)", 9);
+
+		if (stats_cpu_freq_enabled()) {
+			struct display_table *other = display_page_add_table(&display_page_tasks);
+
+			display_table_init(other, "Other");
+
+			cpp_col = display_table_add_col(other);
+			display_column_init(cpp_col, "CPP", 9);
+
+			ghz_col = display_table_add_col(other);
+			display_column_init(ghz_col, "Clk (GHz)", 9);
+		}
+		if (stats_mbm_enabled()) {
+			struct display_table *other = display_page_add_table(&display_page_tasks);
+			mbm_tot_col = display_table_add_col(other);
+			display_column_init(mbm_tot_col, "Tot Bdw(M)", 10);
+			mbm_loc_col = display_table_add_col(other);
+			display_column_init(mbm_loc_col, "Loc Bdw(M)", 10);
+		}
+	} else {
+		display_table_init(stats, "Total Statistics");
+
+		rx_col = display_table_add_col(stats);
+		display_column_init(rx_col, "RX (K)", 14);
+
+		tx_col = display_table_add_col(stats);
+		display_column_init(tx_col, "TX (K)", 14);
+
+		tx_fail_col = display_table_add_col(stats);
+		display_column_init(tx_fail_col, "TX Fail (K)", 14);
+
+		discard_col = display_table_add_col(stats);
+		display_column_init(discard_col, "Discard (K)", 14);
+
+		handled_col = display_table_add_col(stats);
+		display_column_init(handled_col, "Handled (K)", 14);
+
+		if (stats_cmt_enabled()) {
+			struct display_table *other = display_page_add_table(&display_page_tasks);
+
+			display_table_init(other, "Cache QoS Monitoring");
+
+			occup_col = display_table_add_col(other);
+			display_column_init(occup_col, "Occupancy (KB)", 15);
+
+			frac_col = display_table_add_col(other);
+			display_column_init(frac_col, "Fraction", 9);
+		}
+		if (stats_cat_enabled()) {
+			struct display_table *other = display_page_add_table(&display_page_tasks);
+			mask_col = display_table_add_col(other);
+			display_column_init(mask_col, "Cache mask", 10);
+			class_col = display_table_add_col(other);
+			display_column_init(class_col, "Class", 5);
+		}
+	}
+	display_page_draw_frame(&display_page_tasks, n_tasks_tot);
+
+	uint16_t element_count = 0;
+
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+
+	while (core_targ_next(&lconf, &targ, 0) == 0) {
+		PROX_ASSERT(element_count < RTE_MAX_LCORE * MAX_TASKS_PER_CORE);
+
+		stats_display_core_task_entry(lconf, targ, element_count);
+
+		task_stats_disp[element_count].lcore_id = lconf->id;
+		task_stats_disp[element_count].task_id = targ->id;
+		task_stats_disp[element_count].lcore_stat_id = stats_lcore_find_stat_id(lconf->id);
+		element_count++;
+	}
+}
+
+static void print_kpps(struct display_column *col, int row, uint64_t nb_pkts, uint64_t delta_t)
+{
+	nb_pkts *= tsc_hz;
+	if (nb_pkts && nb_pkts /100 < delta_t) {
+		uint64_t int_part = nb_pkts/delta_t;
+		uint64_t frac_part = (nb_pkts - int_part * delta_t) * 1000 /delta_t;
+		display_column_print(col, row, "%2lu.%03lu", int_part, frac_part);
+	}
+	else {
+		display_column_print(col, row, "%9lu", nb_pkts / delta_t);
+	}
+}
+
+static void display_core_task_stats_per_sec(const struct task_stats_disp *t, struct screen_state *state, int row)
+{
+	struct task_stats_sample *last = stats_get_task_stats_sample(t->lcore_id, t->task_id, 1);
+	struct task_stats_sample *prev = stats_get_task_stats_sample(t->lcore_id, t->task_id, 0);
+
+	/* delta_t in units of clock ticks */
+	uint64_t delta_t = last->tsc - prev->tsc;
+
+	uint64_t empty_cycles = last->empty_cycles - prev->empty_cycles;
+
+	if (empty_cycles > delta_t) {
+		empty_cycles = 10000;
+	}
+	else {
+		empty_cycles = empty_cycles * 10000 / delta_t;
+	}
+
+	/* empty_cycles has 2 digits after point, (usefull when only a very small idle time) */
+
+	display_column_print(idle_col, row, "%3lu.%02lu", empty_cycles / 100, empty_cycles % 100);
+
+	// Display per second statistics in Kpps unit
+	delta_t *= state->pps_unit;
+
+	print_kpps(rx_col, row, last->rx_pkt_count - prev->rx_pkt_count, delta_t);
+	print_kpps(tx_col, row, last->tx_pkt_count - prev->tx_pkt_count, delta_t);
+	print_kpps(tx_fail_col, row, last->drop_tx_fail - prev->drop_tx_fail, delta_t);
+	print_kpps(discard_col, row, last->drop_discard - prev->drop_discard, delta_t);
+	print_kpps(handled_col, row, last->drop_handled - prev->drop_handled, delta_t);
+
+	if (stats_cpu_freq_enabled()) {
+		uint8_t lcore_stat_id = t->lcore_stat_id;
+		struct lcore_stats_sample *clast = stats_get_lcore_stats_sample(lcore_stat_id, 1);
+		struct lcore_stats_sample *cprev = stats_get_lcore_stats_sample(lcore_stat_id, 0);
+
+		uint64_t adiff = clast->afreq - cprev->afreq;
+		uint64_t mdiff = clast->mfreq - cprev->mfreq;
+
+		uint64_t cpp = 0;
+
+		uint64_t pkt_diff_rx = last->rx_pkt_count - prev->rx_pkt_count;
+		uint64_t pkt_diff_tx = last->tx_pkt_count - prev->tx_pkt_count;
+
+		uint64_t pkt_diff = pkt_diff_tx > pkt_diff_rx? pkt_diff_tx : pkt_diff_rx;
+
+		if (pkt_diff && mdiff) {
+			cpp = delta_t/pkt_diff*adiff/mdiff/1000;
+		}
+
+		uint64_t mhz;
+		if (mdiff)
+			mhz = tsc_hz*adiff/mdiff/1000000;
+		else
+			mhz = 0;
+
+		display_column_print(cpp_col, row, "%lu", cpp);
+		display_column_print(ghz_col, row, "%lu.%03lu", mhz/1000, mhz%1000);
+	}
+	if (stats_mbm_enabled()) {
+		struct lcore_stats *c = stats_get_lcore_stats(t->lcore_stat_id);
+		uint8_t lcore_stat_id = t->lcore_stat_id;
+		struct lcore_stats_sample *clast = stats_get_lcore_stats_sample(lcore_stat_id, 1);
+		struct lcore_stats_sample *cprev = stats_get_lcore_stats_sample(lcore_stat_id, 0);
+		if ((clast->mbm_tot_bytes - cprev->mbm_tot_bytes) >> 20)
+			display_column_print(mbm_tot_col, row, "%lu", (clast->mbm_tot_bytes - cprev->mbm_tot_bytes) >> 20);
+		else
+			display_column_print(mbm_tot_col, row, "0.%03lu", (clast->mbm_tot_bytes - cprev->mbm_tot_bytes) >> 10);
+		if( (clast->mbm_loc_bytes - cprev->mbm_loc_bytes) >> 20)
+			display_column_print(mbm_loc_col, row, "%lu", (clast->mbm_loc_bytes - cprev->mbm_loc_bytes) >> 20);
+		else
+			display_column_print(mbm_loc_col, row, "0.%03lu", (clast->mbm_loc_bytes - cprev->mbm_loc_bytes) >> 10);
+	}
+}
+
+static void display_core_task_stats_tot(const struct task_stats_disp *t, struct screen_state *state, int row)
+{
+	struct task_stats *ts = stats_get_task_stats(t->lcore_id, t->task_id);
+
+	display_column_print(rx_col, row, "%lu", ts->tot_rx_pkt_count);
+	display_column_print(tx_col, row, "%lu", ts->tot_tx_pkt_count);
+	display_column_print(tx_fail_col, row, "%lu", ts->tot_drop_tx_fail);
+	display_column_print(discard_col, row, "%lu", ts->tot_drop_discard);
+	display_column_print(handled_col, row, "%lu", ts->tot_drop_handled);
+
+	if (stats_cmt_enabled()) {
+		struct lcore_stats *c = stats_get_lcore_stats(t->lcore_stat_id);
+		display_column_print(occup_col, row, "%lu", c->cmt_bytes >> 10);
+		display_column_print(frac_col, row, "%3lu.%02lu", c->cmt_fraction/100, c->cmt_fraction%100);
+	}
+	if (stats_cat_enabled()) {
+		struct lcore_stats *c = stats_get_lcore_stats(t->lcore_stat_id);
+		display_column_print(mask_col, row, "%x", c->cat_mask);
+		display_column_print(class_col, row, "%x", c->class);
+	}
+}
+
+static void display_tasks_draw_stats(struct screen_state *state)
+{
+	const uint32_t n_tasks_tot = stats_get_n_tasks_tot();
+
+	for (uint8_t i = 0; i < n_tasks_tot; ++i) {
+		const struct task_stats_disp *disp = &task_stats_disp[i];
+
+		if (state->toggle == 0) {
+			display_core_task_stats_per_sec(disp, state, i);
+		} else {
+			display_core_task_stats_tot(disp, state, i);
+		}
+	}
+}
+
+static int display_tasks_get_height(void)
+{
+	return stats_get_n_tasks_tot();
+}
+
+static struct display_screen display_screen_tasks = {
+	.draw_frame = display_tasks_draw_frame,
+	.draw_stats = display_tasks_draw_stats,
+	.get_height = display_tasks_get_height,
+	.title = "tasks",
+};
+
+struct display_screen *display_tasks(void)
+{
+	return &display_screen_tasks;
+}
diff --git a/VNFs/DPPD-PROX/display_tasks.h b/VNFs/DPPD-PROX/display_tasks.h
new file mode 100644
index 00000000..b369b6bd
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_tasks.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef DISPLAY_TASKS_H
+#define DISPLAY_TASKS_H
+
+struct display_screen;
+struct display_screen *display_tasks(void);
+
+#endif /* DISPLAY_TASKS_H */
diff --git a/VNFs/DPPD-PROX/dpi/Makefile b/VNFs/DPPD-PROX/dpi/Makefile
new file mode 100644
index 00000000..fc943580
--- /dev/null
+++ b/VNFs/DPPD-PROX/dpi/Makefile
@@ -0,0 +1,18 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+all:
+	gcc -fpic -shared dpi_stub.c -o dpi_stub.so
diff --git a/VNFs/DPPD-PROX/dpi/dpi.h b/VNFs/DPPD-PROX/dpi/dpi.h
new file mode 100644
index 00000000..5ce1015d
--- /dev/null
+++ b/VNFs/DPPD-PROX/dpi/dpi.h
@@ -0,0 +1,76 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _DPI_H_
+#define _DPI_H_
+
+#include <sys/time.h>
+#include <inttypes.h>
+#include <stddef.h>
+
+struct flow_info {
+	uint32_t ip_src;
+	uint32_t ip_dst;
+	uint8_t ip_proto;
+	uint16_t port_src;
+	uint16_t port_dst;
+	uint8_t reservered[3];
+} __attribute__((packed));
+
+struct dpi_payload {
+	uint8_t  *payload;
+	uint16_t len;
+	uint16_t client_to_server;
+	struct timeval tv;
+};
+
+struct dpi_engine {
+	/* Returns 0 on success, This function is called from an
+	   arbitrary thread before any other function in this struct
+	   is called. */
+	int (*dpi_init)(uint32_t thread_count, int argc, const char *argv[]);
+	/* Return the size that should be allocated in the flow
+	   table. It is the sizeof(*flow_data) passed to
+	   dpi_process(). */
+	size_t (*dpi_get_flow_entry_size)(void);
+	/* Called before the flow entry is expired. */
+	void (*dpi_flow_expire)(void *flow_data);
+	/* start function called from a DPI thread itself. The opaque
+	   pointer returned here will be passed to dpi_thread_stop and
+	   dpi_process. */
+	void *(*dpi_thread_start)(void);
+	/* Stop function called from a DPI thread itself. */
+	void (*dpi_thread_stop)(void *opaque);
+	/* Processing function to perform actual DPI work. struct
+	   flow_info contains the 5 tuple, flow_data is the entry in
+	   the flow table which has a size specified by
+	   dpi_get_flow_entry_size(). The payload (together with the
+	   time and the direction) is passed through the payload
+	   parameter. DPI results are returned by the results
+	   array. The function returns 0 on success. */
+	int (*dpi_process)(void *opaque, struct flow_info *fi, void *flow_data,
+			   struct dpi_payload *payload, uint32_t results[],
+			   size_t *result_len);
+	/* Called once at cleanup. */
+	void (*dpi_finish)(void);
+	/* Function used for printing. */
+	int (*dpi_print)(const char *fmt, ...);
+};
+
+/* Returns the implementation of a dpi_engine. */
+struct dpi_engine *get_dpi_engine(void);
+
+#endif /* _DPI_H_ */
diff --git a/VNFs/DPPD-PROX/dpi/dpi_stub.c b/VNFs/DPPD-PROX/dpi/dpi_stub.c
new file mode 100644
index 00000000..8febbcb9
--- /dev/null
+++ b/VNFs/DPPD-PROX/dpi/dpi_stub.c
@@ -0,0 +1,57 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <stdio.h>
+
+#include "dpi.h"
+
+/* The following functions are not a real implementation of a
+   DPI. They serve only to create dpi_stub.so which can be loaded into
+   prox. */
+
+static int dpi_init(uint32_t thread_count, int argc, const char *argv[])
+{
+	return 0;
+}
+
+size_t dpi_get_flow_entry_size(void) {return 0;}
+void flow_data_dpi_flow_expire(void *flow_data) {}
+void *dpi_thread_start() {return NULL;}
+void dpi_thread_stop(void *opaque) {}
+void dpi_finish(void) {}
+
+int dpi_process(void *opaque, struct flow_info *fi, void *flow_data,
+		struct dpi_payload *payload, uint32_t results[],
+		size_t *result_len)
+{
+	return 0;
+}
+
+static struct dpi_engine dpi_engine = {
+	.dpi_init = dpi_init,
+	.dpi_get_flow_entry_size = dpi_get_flow_entry_size,
+	.dpi_flow_expire = flow_data_dpi_flow_expire,
+	.dpi_thread_start = dpi_thread_start,
+	.dpi_thread_stop = dpi_thread_stop,
+	.dpi_process = dpi_process,
+	.dpi_finish = dpi_finish,
+	.dpi_print = printf,
+};
+
+struct dpi_engine *get_dpi_engine(void)
+{
+	return &dpi_engine;
+}
diff --git a/VNFs/DPPD-PROX/eld.h b/VNFs/DPPD-PROX/eld.h
new file mode 100644
index 00000000..b5de59d7
--- /dev/null
+++ b/VNFs/DPPD-PROX/eld.h
@@ -0,0 +1,82 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _ELD_H_
+#define _ELD_H_
+
+#define PACKET_QUEUE_BITS      14
+#define PACKET_QUEUE_SIZE      (1 << PACKET_QUEUE_BITS)
+#define PACKET_QUEUE_MASK      (PACKET_QUEUE_SIZE - 1)
+
+#define QUEUE_ID_BITS		(32 - PACKET_QUEUE_BITS)
+#define QUEUE_ID_SIZE		(1 << QUEUE_ID_BITS)
+#define QUEUE_ID_MASK		(QUEUE_ID_SIZE - 1)
+
+struct early_loss_detect {
+	uint32_t entries[PACKET_QUEUE_SIZE];
+	uint32_t last_pkt_idx;
+};
+
+static void early_loss_detect_reset(struct early_loss_detect *eld)
+{
+	for (size_t i = 0; i < PACKET_QUEUE_SIZE; i++) {
+		eld->entries[i] = -1;
+	}
+}
+
+static uint32_t early_loss_detect_count_remaining_loss(struct early_loss_detect *eld)
+{
+	uint32_t queue_id;
+	uint32_t n_loss;
+	uint32_t n_loss_total = 0;
+
+	/* Need to check if we lost any packet before last packet
+	   received Any packet lost AFTER the last packet received
+	   cannot be counted.  Such a packet will be counted after both
+	   lat and gen restarted */
+	queue_id = eld->last_pkt_idx >> PACKET_QUEUE_BITS;
+	for (uint32_t i = (eld->last_pkt_idx + 1) & PACKET_QUEUE_MASK; i < PACKET_QUEUE_SIZE; i++) {
+		// We ** might ** have received OOO packets; do not count them as lost next time...
+		if (queue_id - eld->entries[i] != 0) {
+			n_loss = (queue_id - eld->entries[i] - 1) & QUEUE_ID_MASK;
+			n_loss_total += n_loss;
+		}
+	}
+	for (uint32_t i = 0; i < (eld->last_pkt_idx & PACKET_QUEUE_MASK); i++) {
+		// We ** might ** have received OOO packets; do not count them as lost next time...
+		if (eld->entries[i] - queue_id != 1) {
+			n_loss = (queue_id - eld->entries[i]) & QUEUE_ID_MASK;
+			n_loss_total += n_loss;
+		}
+	}
+
+	eld->entries[eld->last_pkt_idx & PACKET_QUEUE_MASK] = -1;
+	return n_loss_total;
+}
+
+static uint32_t early_loss_detect_add(struct early_loss_detect *eld, uint32_t packet_index)
+{
+	uint32_t old_queue_id, queue_pos, n_loss;
+
+	eld->last_pkt_idx = packet_index;
+	queue_pos = packet_index & PACKET_QUEUE_MASK;
+	old_queue_id = eld->entries[queue_pos];
+	eld->entries[queue_pos] = packet_index >> PACKET_QUEUE_BITS;
+
+	return (eld->entries[queue_pos] - old_queue_id - 1) & QUEUE_ID_MASK;
+}
+
+#endif /* _ELD_H_ */
diff --git a/VNFs/DPPD-PROX/etypes.h b/VNFs/DPPD-PROX/etypes.h
new file mode 100644
index 00000000..97ce5c0d
--- /dev/null
+++ b/VNFs/DPPD-PROX/etypes.h
@@ -0,0 +1,30 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _ETYPES_H_
+#define _ETYPES_H_
+
+#define ETYPE_IPv4	0x0008	/* IPv4 in little endian */
+#define ETYPE_IPv6	0xDD86	/* IPv6 in little endian */
+#define ETYPE_ARP	0x0608	/* ARP in little endian */
+#define ETYPE_VLAN	0x0081	/* 802-1aq - VLAN */
+#define ETYPE_MPLSU	0x4788	/* MPLS unicast */
+#define ETYPE_MPLSM	0x4888	/* MPLS multicast */
+#define ETYPE_8021ad	0xA888	/* Q-in-Q */
+#define ETYPE_LLDP	0xCC88	/* Link Layer Discovery Protocol (LLDP) */
+#define ETYPE_EoGRE	0x5865	/* EoGRE in little endian */
+
+#endif /* _ETYPES_H_ */
diff --git a/VNFs/DPPD-PROX/expire_cpe.c b/VNFs/DPPD-PROX/expire_cpe.c
new file mode 100644
index 00000000..4f2f5cd8
--- /dev/null
+++ b/VNFs/DPPD-PROX/expire_cpe.c
@@ -0,0 +1,43 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+
+#include "hash_entry_types.h"
+#include "hash_utils.h"
+#include "expire_cpe.h"
+
+#define MAX_TSC	       __UINT64_C(0xFFFFFFFFFFFFFFFF)
+
+void check_expire_cpe(void* data)
+{
+	struct expire_cpe *um = (struct expire_cpe *)data;
+	uint64_t cur_tsc = rte_rdtsc();
+	struct cpe_data *entries[4] = {0};
+	void *key[4] = {0};
+	uint64_t n_buckets = get_bucket_key8(um->cpe_table, um->bucket_index, key, (void**)entries);
+
+	for (uint8_t i = 0; i < 4 && entries[i]; ++i) {
+		if (entries[i]->tsc < cur_tsc) {
+			int key_found = 0;
+			void* entry = 0;
+			rte_table_hash_key8_ext_dosig_ops.f_delete(um->cpe_table, key[i], &key_found, entry);
+		}
+	}
+
+        um->bucket_index++;
+        um->bucket_index &= (n_buckets - 1);
+}
diff --git a/VNFs/DPPD-PROX/expire_cpe.h b/VNFs/DPPD-PROX/expire_cpe.h
new file mode 100644
index 00000000..ad697f76
--- /dev/null
+++ b/VNFs/DPPD-PROX/expire_cpe.h
@@ -0,0 +1,30 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _EXPIRE_CPE_H_
+#define _EXPIRE_CPE_H_
+
+#include <rte_table_hash.h>
+
+struct expire_cpe {
+	struct rte_table_hash *cpe_table;
+	struct cpe_data *cpe_data;
+	uint32_t bucket_index;
+};
+
+void check_expire_cpe(void *data);
+
+#endif /* _EXPIRE_CPE_H_ */
diff --git a/VNFs/DPPD-PROX/file_utils.c b/VNFs/DPPD-PROX/file_utils.c
new file mode 100644
index 00000000..b3cf0846
--- /dev/null
+++ b/VNFs/DPPD-PROX/file_utils.c
@@ -0,0 +1,92 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <stdio.h>
+#include <limits.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "prox_args.h"
+#include "file_utils.h"
+
+static char file_error_string[128] = {0};
+
+const char *file_get_error(void)
+{
+	return file_error_string;
+}
+
+__attribute__((format(printf, 1 ,2))) static void file_set_error(const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	vsnprintf(file_error_string, sizeof(file_error_string), fmt, ap);
+	va_end(ap);
+}
+
+static void resolve_path_cfg_dir(char *file_name, size_t len, const char *path)
+{
+	if (path[0] != '/')
+		snprintf(file_name, len, "%s/%s", get_cfg_dir(), path);
+	else
+		strncpy(file_name, path, len);
+}
+
+long file_get_size(const char *path)
+{
+	char file_name[PATH_MAX];
+	struct stat s;
+
+	resolve_path_cfg_dir(file_name, sizeof(file_name), path);
+
+	if (stat(file_name, &s)) {
+		file_set_error("Stat failed on '%s': %s", path, strerror(errno));
+		return -1;
+	}
+
+	if ((s.st_mode & S_IFMT) != S_IFREG) {
+		snprintf(file_error_string, sizeof(file_error_string), "'%s' is not a file", path);
+		return -1;
+	}
+
+	return s.st_size;
+}
+
+int file_read_content(const char *path, uint8_t *mem, size_t beg, size_t len)
+{
+	char file_name[PATH_MAX];
+	FILE *f;
+
+	resolve_path_cfg_dir(file_name, sizeof(file_name), path);
+	f = fopen(file_name, "r");
+	if (!f) {
+		file_set_error("Failed to read '%s': %s", path, strerror(errno));
+		return -1;
+	}
+
+	fseek(f, beg, SEEK_SET);
+
+	size_t ret = fread(mem, 1, len, f);
+	if ((uint32_t)ret !=  len) {
+		file_set_error("Failed to read '%s:%zu' for %zu bytes: got %zu\n", file_name, beg, len, ret);
+		return -1;
+	}
+
+	fclose(f);
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/file_utils.h b/VNFs/DPPD-PROX/file_utils.h
new file mode 100644
index 00000000..2458dff8
--- /dev/null
+++ b/VNFs/DPPD-PROX/file_utils.h
@@ -0,0 +1,27 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _FILE_UTILS_H_
+#define _FILE_UTILS_H_
+
+#include <inttypes.h>
+#include <stddef.h>
+
+long file_get_size(const char *path);
+int file_read_content(const char *path, uint8_t *mem, size_t beg, size_t len);
+const char *file_get_error(void);
+
+#endif /* _FILE_UTILS_H_ */
diff --git a/VNFs/DPPD-PROX/flow_gen/README b/VNFs/DPPD-PROX/flow_gen/README
new file mode 100644
index 00000000..28f5d97c
--- /dev/null
+++ b/VNFs/DPPD-PROX/flow_gen/README
@@ -0,0 +1,47 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+While it is possible to manually run stateful traffic generation as
+described below, it is recommended to use the provided dpi scripts
+available in the help-scripts directory..
+
+Before running flow based generation, a traffic profile needs to be
+extracted and copied into this directory. This is done by running the
+flow extract tool. An example of running the tool is shown below. For
+more details on the flow extract tool, please read the provided help
+by running the tool with the -h argument.
+
+./build/flowextract2 -s 500000 -i input.pcap -o output_directory
+
+After the output has been copied to this directory, the configuration
+can be launched as shown below:
+
+./build/prox -f flow_gen/flow_gen_4ports.cfg -e \
+	     -q max_setup_rate=2000 \
+	     -q connections=50000 \
+	     -q ss=19.46 \
+	     -q test_system_id=0
+
+The parameters provided through -q depend on the traffic profile. The
+following command can be used to find the maximum value of ss:
+
+./build/prox -f flow_gen/flow_gen_4ports.cfg -e \
+	     -q max_ss_and_quit=true \
+	     -q test_system_id=0
+
+This will cause prox to read the traffic profile, calculate the maximum
+value and quit immediately. No packets will be sent and the value for
+ss will be printed on stdout.
diff --git a/VNFs/DPPD-PROX/flow_gen/bundle_maker.lua b/VNFs/DPPD-PROX/flow_gen/bundle_maker.lua
new file mode 100644
index 00000000..ca24d4bb
--- /dev/null
+++ b/VNFs/DPPD-PROX/flow_gen/bundle_maker.lua
@@ -0,0 +1,94 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+function get_client_bundles(bundles)
+   local client_bundles = {};
+
+   for i,b in ipairs(bundles) do
+      client_bundles[i] = {bundle = b, imix_fraction = 1}
+   end
+
+   return client_bundles;
+end
+
+function get_server_streams(bundles)
+   local server_streams = {}
+   n_listen = 0
+   for i, bundle in ipairs(bundles) do
+      for j, stream in ipairs(bundle) do
+	 n_listen = n_listen + 1
+	 server_streams[n_listen] = stream
+      end
+   end
+   return server_streams;
+end
+
+function setup_bundles(first_ip_byte, speed_scaling)
+   bundles = dofile("cfg.lua")
+
+   local client_bundles = get_client_bundles(bundles);
+   local server_streams = get_server_streams(bundles);
+
+   for i,e in ipairs(client_bundles) do
+      for j,stream in ipairs(e.bundle) do
+	 stream.clients.ip[1] = first_ip_byte
+	 stream.clients.port_mask = 0xffff
+      end
+   end
+
+   for i,stream in ipairs(server_streams) do
+      stream.servers.ip[1] = first_ip_byte
+   end
+
+   local highest_bps = 0;
+   for i,e in ipairs(client_bundles) do
+      for j,s in ipairs(e.bundle) do
+	 if (s.up_bps ~= 1250000000 and s.dn_bps ~= 1250000000) then
+	    if (highest_bps < s.up_bps) then
+	       highest_bps = s.up_bps
+	    end
+	    if (highest_bps < s.dn_bps) then
+	       highest_bps = s.dn_bps
+	    end
+	 end
+      end
+   end
+
+   if (highest_bps == 0) then
+      highest_bps = 1250000000
+   end
+   max_ss = 1250000000/highest_bps
+
+   if (max_ss_and_quit == not nil and max_ss_and_quit == true) then
+      print("max ss=" .. max_ss .. "")
+      os.exit(0);
+   end
+
+   if (speed_scaling > max_ss) then
+      error("Scaling too high (maximum scaling is " .. max_ss .. ")")
+   end
+
+   for i,e in ipairs(client_bundles) do
+      for j,s in ipairs(e.bundle) do
+	 if (s.up_bps ~= 1250000000 and s.dn_bps ~= 1250000000) then
+	    s.up_bps = s.up_bps * speed_scaling;
+	    s.dn_bps = s.dn_bps * speed_scaling;
+	 end
+      end
+   end
+
+   return client_bundles, server_streams
+end
diff --git a/VNFs/DPPD-PROX/flow_gen/flow_gen_4ports.cfg b/VNFs/DPPD-PROX/flow_gen/flow_gen_4ports.cfg
new file mode 100644
index 00000000..ccac3eb7
--- /dev/null
+++ b/VNFs/DPPD-PROX/flow_gen/flow_gen_4ports.cfg
@@ -0,0 +1,150 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 2]
+name=port_a
+mac=00:00:00:00:00:03
+rx desc=512
+tx desc=1024
+[port 3]
+name=port_b
+mac=00:00:00:00:00:04
+rx desc=512
+tx desc=1024
+
+[port 4]
+name=port_c
+mac=00:00:00:00:00:01
+rx desc=512
+tx desc=1024
+[port 5]
+name=port_d
+mac=00:00:00:00:00:02
+rx desc=512
+tx desc=1024
+
+[lua]
+dofile("flow_gen_4ports.lua")
+[variables]
+$drop=no
+
+[defaults]
+mempool size=$mempool_size
+
+[global]
+start time=5
+name=L4 Gen
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+task=0
+mode=lbpos
+tx cores=$port_a_clients
+rx port=port_a
+mempool size=32K
+mbuf size=2560
+byte offset=26
+drop=$drop
+ring size=16384
+
+[core 1s0h]
+task=0
+mode=lbpos
+tx cores=$port_b_servers
+rx port=port_b
+mbuf size=2560
+byte offset=26
+drop=$drop
+ring size=16384
+
+;;;------------------------------
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+[core $port_a_clients]
+name=p0
+task=0
+mode=genl4
+tx port=port_a
+rx ring=yes
+bps=$bps
+streams=c_${self}
+concur conn=$conn
+max setup rate=$msr
+
+[core $port_b_servers]
+name=p0
+task=0
+mode=genl4
+sub mode=server
+rx ring=yes
+tx port=port_b
+bps=$bps
+streams=s_${self}
+concur conn=$conn
+
+;;;;;;; socket 1 ;;;;;;;;;;;;;;;;;;;;;;;
+
+[core 1s1]
+name=ld
+task=0
+mode=lbpos
+tx cores=$port_c_clients
+rx port=port_c
+mempool size=32K
+mbuf size=2560
+byte offset=26
+drop=$drop
+ring size=16384
+
+[core 1s1h]
+name=ld
+task=0
+mode=lbpos
+tx cores=$port_d_servers
+rx port=port_d
+mbuf size=2560
+byte offset=26
+drop=$drop
+ring size=16384
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+[core $port_c_clients]
+name=p0
+task=0
+mode=genl4
+tx port=port_c
+rx ring=yes
+bps=$bps
+streams=c_${self}
+concur conn=$conn
+max setup rate=$msr
+
+[core $port_d_servers]
+name=p0
+task=0
+mode=genl4
+sub mode=server
+rx ring=yes
+tx port=port_d
+bps=$bps
+streams=s_${self}
+concur conn=$conn
diff --git a/VNFs/DPPD-PROX/flow_gen/flow_gen_4ports.lua b/VNFs/DPPD-PROX/flow_gen/flow_gen_4ports.lua
new file mode 100644
index 00000000..ed674ef6
--- /dev/null
+++ b/VNFs/DPPD-PROX/flow_gen/flow_gen_4ports.lua
@@ -0,0 +1,83 @@
+--
+-- Copyright (c) 2010-2017 Intel Corporation
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+dofile("bundle_maker.lua")
+
+if (test_system_id == nil) then
+   error("test_system_id not set")
+end
+
+offset = 8 * test_system_id
+
+c_2s0, s_3s0   = setup_bundles(128 + offset, ss)
+c_4s0, s_5s0   = setup_bundles(129 + offset, ss)
+c_2s0h, s_3s0h = setup_bundles(130 + offset, ss)
+c_4s0h, s_5s0h = setup_bundles(131 + offset, ss)
+
+c_6s0, s_7s0   = setup_bundles(132 + offset, ss)
+c_8s0, s_9s0   = setup_bundles(133 + offset, ss)
+c_6s0h, s_7s0h = setup_bundles(134 + offset, ss)
+c_8s0h, s_9s0h = setup_bundles(135 + offset, ss)
+
+----------------
+
+c_2s1, s_3s1   = setup_bundles(64 + offset, ss)
+c_4s1, s_5s1   = setup_bundles(65 + offset, ss)
+c_2s1h, s_3s1h = setup_bundles(66 + offset, ss)
+c_4s1h, s_5s1h = setup_bundles(67 + offset, ss)
+
+c_6s1, s_7s1   = setup_bundles(68 + offset, ss)
+c_8s1, s_9s1   = setup_bundles(69 + offset, ss)
+c_6s1h, s_7s1h = setup_bundles(70 + offset, ss)
+c_8s1h, s_9s1h = setup_bundles(71 + offset, ss)
+
+if (max_setup_rate == nil) then
+   error("max_setup_rate not set")
+end
+
+if (connections == nil) then
+   error("connections not set")
+end
+
+port_a_clients="2s0,4s0,2s0h,4s0h,6s0,8s0,6s0h,8s0h"
+port_b_servers="3s0,5s0,3s0h,5s0h,7s0,9s0,7s0h,9s0h"
+
+
+port_c_clients="2s1,4s1,2s1h,4s1h,6s1,8s1,6s1h,8s1h"
+port_d_servers="3s1,5s1,3s1h,5s1h,7s1,9s1,7s1h,9s1h"
+
+all_clients = port_a_clients
+   .. "," .. port_c_clients
+
+all_servers = port_b_servers
+   .. "," .. port_d_servers
+
+all_workers =  all_clients .. "," .. all_servers
+
+all_ld = "1s0,1s0h,1s1,1s1h"
+
+client_port_count = 2;
+
+bps = 1250000000/task_count(port_a_clients)
+msr = max_setup_rate/client_port_count/task_count(port_a_clients)
+conn = connections/client_port_count/task_count(port_a_clients)
+
+mempool_size = connections
+if (mempool_size > 100000) then
+   mempool_size = 100000
+elseif (mempool_size < 2048) then
+   mempool_size = 2048
+end
diff --git a/VNFs/DPPD-PROX/flow_iter.h b/VNFs/DPPD-PROX/flow_iter.h
new file mode 100644
index 00000000..1ff5eeeb
--- /dev/null
+++ b/VNFs/DPPD-PROX/flow_iter.h
@@ -0,0 +1,37 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _FLOW_ITER_H_
+#define _FLOW_ITER_H_
+
+struct task_args;
+
+struct flow_iter {
+	/* Returns a new iterator pointing to the beginning of the collection. */
+	void             (*beg)(struct flow_iter *iter, struct task_args *targ);
+	/* Returns non-zero when parameter is pointing past the end of the collection. */
+	int              (*is_end)(struct flow_iter *iter, struct task_args *targ);
+	/* Moves iterator parameter forward by one. */
+	void             (*next)(struct flow_iter *iter, struct task_args *targ);
+	/* Access data. */
+	uint16_t         (*get_svlan)(struct flow_iter *iter, struct task_args *targ);
+	uint16_t         (*get_cvlan)(struct flow_iter *iter, struct task_args *targ);
+	uint32_t         (*get_gre_id)(struct flow_iter *iter, struct task_args *targ);
+	int              idx;
+	uint8_t          data;
+};
+
+#endif /* _FLOW_ITER_H_ */
diff --git a/VNFs/DPPD-PROX/fqueue.h b/VNFs/DPPD-PROX/fqueue.h
new file mode 100644
index 00000000..ea38e85b
--- /dev/null
+++ b/VNFs/DPPD-PROX/fqueue.h
@@ -0,0 +1,86 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _FQUEUE_H_
+#define _FQUEUE_H_
+
+#include <rte_mbuf.h>
+
+#include <inttypes.h>
+
+struct fqueue {
+	uint32_t prod;
+	uint32_t cons;
+	uint32_t mask;
+	struct rte_mbuf *entries[0];
+};
+
+static uint32_t fqueue_put(struct fqueue *q, struct rte_mbuf **mbufs, uint32_t count)
+{
+	uint32_t free_entries = q->mask + q->cons - q->prod;
+	uint32_t beg = q->prod & q->mask;
+
+	count = count > free_entries? free_entries : count;
+
+	if ((q->prod & q->mask) + count <= q->mask) {
+		rte_memcpy(&q->entries[q->prod & q->mask], mbufs, sizeof(mbufs[0]) * count);
+		q->prod += count;
+	}
+	else {
+		for (uint32_t i = 0; i < count; ++i) {
+			q->entries[q->prod & q->mask] = mbufs[i];
+			q->prod++;
+		}
+	}
+	return count;
+}
+
+static uint32_t fqueue_get(struct fqueue *q, struct rte_mbuf **mbufs, uint32_t count)
+{
+	uint32_t entries = q->prod - q->cons;
+
+	count = count > entries? entries : count;
+
+	if ((q->cons & q->mask) + count <= q->mask) {
+		rte_memcpy(mbufs, &q->entries[q->cons & q->mask], sizeof(mbufs[0]) * count);
+		q->cons += count;
+	}
+	else {
+         	for (uint32_t i = 0; i < count; ++i) {
+			mbufs[i] = q->entries[q->cons & q->mask];
+			q->cons++;
+		}
+	}
+	return count;
+}
+
+static struct fqueue *fqueue_create(uint32_t size, int socket)
+{
+	size_t mem_size = 0;
+
+	mem_size += sizeof(struct fqueue);
+	mem_size += sizeof(((struct fqueue *)(0))->entries[0]) * size;
+
+	struct fqueue *ret = prox_zmalloc(mem_size, socket);
+
+	if (!ret)
+		return NULL;
+
+	ret->mask = size - 1;
+	return ret;
+}
+
+#endif /* _FQUEUE_H_ */
diff --git a/VNFs/DPPD-PROX/gen/bng-4ports-gen.cfg b/VNFs/DPPD-PROX/gen/bng-4ports-gen.cfg
new file mode 100644
index 00000000..ed0f0147
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/bng-4ports-gen.cfg
@@ -0,0 +1,162 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:00:00:00:01
+[port 1]
+name=inet0
+mac=00:00:00:00:00:02
+[port 2]
+name=cpe1
+mac=00:00:00:00:00:03
+[port 3]
+name=inet1
+mac=00:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=BNG gen
+shuffle=yes
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=arp
+task=0
+mode=gen
+tx port=cpe0
+
+bps=2138556
+
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000000XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+[core 2s0]
+name=cpe
+task=0
+mode=gen
+tx port=cpe0
+bps=1069289928
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+
+random=000000000XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+lat pos=42
+
+[core 3s0]
+name=arp
+task=0
+mode=gen
+tx port=cpe1
+
+bps=2138556
+
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000001XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+[core 4s0]
+name=cpe
+task=0
+mode=gen
+tx port=cpe1
+bps=1069289928
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+
+random=000000001XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+lat pos=42
+
+[core 5s0]
+name=inet0
+task=0
+mode=gen
+tx port=inet0
+bps=1250000000; "1250000000./98"
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+
+random=0000000000000000XXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 6s0]
+name=inet1
+task=0
+mode=gen
+tx port=inet1
+bps=1250000000; "1250000000./98"
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+random=0000000000000000XXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 7s0]
+name=CPE0
+task=0
+mode=lat
+rx port=cpe0
+lat pos=42
+
+[core 8s0]
+name=CPE1
+task=0
+mode=lat
+rx port=cpe1
+lat pos=42
+
+[core 9s0]
+name=INET0
+task=0
+mode=lat
+rx port=inet0
+lat pos=66
+
+[core 10s0]
+name=INET1
+task=0
+mode=lat
+rx port=inet1
+lat pos=66
diff --git a/VNFs/DPPD-PROX/gen/bng-8ports-gen-18cores.cfg b/VNFs/DPPD-PROX/gen/bng-8ports-gen-18cores.cfg
new file mode 100644
index 00000000..7135648b
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/bng-8ports-gen-18cores.cfg
@@ -0,0 +1,296 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=6 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:00:00:00:01
+[port 1]
+name=inet0
+mac=00:00:00:00:00:02
+[port 2]
+name=cpe1
+mac=00:00:00:00:00:03
+[port 3]
+name=inet1
+mac=00:00:00:00:00:04
+[port 4]
+name=cpe2
+mac=00:00:00:00:00:04
+[port 5]
+name=inet2
+mac=00:00:00:00:00:04
+[port 6]
+name=cpe3
+mac=00:00:00:00:00:04
+[port 7]
+name=inet3
+mac=00:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=BNG gen
+shuffle=yes
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=arp
+task=0
+mode=gen
+;rx port=cpe0
+tx port=cpe0
+
+bps=2138556
+
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000000XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+task=1
+mode=gen
+;rx port=cpe1
+tx port=cpe1
+
+bps=2138556
+
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000010XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+name=arp
+task=2
+mode=gen
+;rx port=cpe2
+tx port=cpe2
+bps=2138556
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000001XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+name=arp
+task=3
+mode=gen
+;rx port=cpe3
+tx port=cpe3
+bps=2138556
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000011XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+[core 2s0]
+name=cpe
+task=0
+mode=gen
+;rx port=cpe0
+tx port=cpe0
+bps=1069289928
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+
+random=000000000XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+lat pos=42
+
+[core 3s0]
+name=cpe
+task=0
+mode=gen
+;rx port=cpe1
+tx port=cpe1
+bps=1069289928
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+
+random=000000010XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+lat pos=42
+
+[core 4s0]
+name=cpe
+task=0
+mode=gen
+;rx port=cpe2
+tx port=cpe2
+bps=1069289928
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+random=000000001XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+lat pos=42
+
+[core 5s0]
+name=cpe
+task=0
+mode=gen
+;rx port=cpe3
+tx port=cpe3
+bps=1069289928
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+random=000000011XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+lat pos=42
+
+[core 6s0]
+name=inet0
+task=0
+mode=gen
+;rx port=inet0
+tx port=inet0
+bps=1250000000; "1250000000./98"
+pkt inline=ab cd ef 01 23 45 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+
+random=000000000000000XXXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 7s0]
+name=inet1
+task=0
+mode=gen
+;rx port=inet1
+tx port=inet1
+bps=1250000000; "1250000000./98"
+pkt inline=ab cd ef 01 23 45 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+random=000000000000000XXXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 8s0]
+name=inet2
+task=0
+mode=gen
+;rx port=inet2
+tx port=inet2
+bps=1250000000; "1250000000./98"
+pkt inline=ab cd ef 01 23 45 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+random=000000000000000XXXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 9s0]
+name=inet3
+task=0
+mode=gen
+;rx port=inet3
+tx port=inet3
+bps=1250000000; "1250000000./98"
+pkt inline=ab cd ef 01 23 45 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+random=000000000000000XXXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 10s0]
+name=CPE0
+task=0
+mode=lat
+rx port=cpe0
+lat pos=42
+
+[core 11s0]
+name=CPE1
+task=0
+mode=lat
+rx port=cpe1
+lat pos=42
+
+[core 12s0]
+name=CPE2
+task=0
+mode=lat
+rx port=cpe2
+lat pos=42
+
+[core 13s0]
+name=CPE3
+task=0
+mode=lat
+rx port=cpe3
+lat pos=42
+
+[core 14s0]
+name=INET0
+task=0
+mode=lat
+rx port=inet0
+lat pos=66
+
+[core 15s0]
+name=INET1
+task=0
+mode=lat
+rx port=inet1
+lat pos=66
+
+[core 16s0]
+name=INET2
+task=0
+mode=lat
+rx port=inet2
+lat pos=66
+
+[core 17s0]
+name=INET3
+task=0
+mode=lat
+rx port=inet3
+lat pos=66
diff --git a/VNFs/DPPD-PROX/gen/bng-8ports-gen.cfg b/VNFs/DPPD-PROX/gen/bng-8ports-gen.cfg
new file mode 100644
index 00000000..a988f65c
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/bng-8ports-gen.cfg
@@ -0,0 +1,300 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:00:00:00:01
+[port 1]
+name=inet0
+mac=00:00:00:00:00:02
+[port 2]
+name=cpe1
+mac=00:00:00:00:00:03
+[port 3]
+name=inet1
+mac=00:00:00:00:00:04
+[port 4]
+name=cpe2
+mac=00:00:00:00:00:04
+[port 5]
+name=inet2
+mac=00:00:00:00:00:04
+[port 6]
+name=cpe3
+mac=00:00:00:00:00:04
+[port 7]
+name=inet3
+mac=00:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=BNG gen
+shuffle=yes
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=arp
+task=0
+mode=gen
+;rx port=cpe0
+tx port=cpe0
+
+bps=2138556
+
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000000XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+[core 1s0h]
+name=cpe
+task=0
+mode=gen
+;rx port=cpe0
+tx port=cpe0
+bps=1069289928
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+
+random=000000000XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+lat pos=42
+
+[core 2s0]
+name=arp
+task=0
+mode=gen
+;rx port=cpe1
+tx port=cpe1
+
+bps=2138556
+
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000010XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+[core 2s0h]
+name=cpe
+task=0
+mode=gen
+;rx port=cpe1
+tx port=cpe1
+bps=1069289928
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+
+random=000000010XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+lat pos=42
+
+[core 3s0]
+name=arp
+task=0
+mode=gen
+;rx port=cpe2
+tx port=cpe2
+bps=2138556
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000001XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+[core 3s0h]
+name=cpe
+task=0
+mode=gen
+;rx port=cpe2
+tx port=cpe2
+bps=1069289928
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+random=000000001XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+lat pos=42
+
+[core 4s0]
+name=arp
+task=0
+mode=gen
+;rx port=cpe3
+tx port=cpe3
+bps=2138556
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 06 00 01 08 00 06 04 00 02 00 1e 67 3e b8 df c0 a8 01 01 00 00 00 00 00 00 c0 a8 01 01
+random=000000011XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+[core 4s0h]
+name=cpe
+task=0
+mode=gen
+;rx port=cpe3
+tx port=cpe3
+bps=1069289928
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 21
+random=000000011XXXXXXX
+rand_offset=14
+
+random=0000XXXX00XX00XX
+rand_offset=18
+
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+lat pos=42
+
+[core 5s0]
+name=inet0
+task=0
+mode=gen
+;rx port=inet0
+tx port=inet0
+bps=1250000000; "1250000000./98"
+pkt inline=ab cd ef 01 23 45 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+
+random=000000000000000XXXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 6s0]
+name=inet1
+task=0
+mode=gen
+;rx port=inet1
+tx port=inet1
+bps=1250000000; "1250000000./98"
+pkt inline=ab cd ef 01 23 45 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+random=000000000000000XXXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 7s0]
+name=inet2
+task=0
+mode=gen
+;rx port=inet2
+tx port=inet2
+bps=1250000000; "1250000000./98"
+pkt inline=ab cd ef 01 23 45 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+random=000000000000000XXXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 0s0h]
+name=inet3
+task=0
+mode=gen
+;rx port=inet3
+tx port=inet3
+bps=1250000000; "1250000000./98"
+pkt inline=ab cd ef 01 23 45 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 38 00 01 00 00 40 2f 7c 94 7f 00 00 01 7f 00 00 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 f6 b7 c0 a8 01 c7 c0 a8 01 01 00 35 00 35 00 08 7b 5b
+random=000000000000000XXXXXXXXXXXXXXXXX
+rand_offset=42 ; gre ID
+
+lat pos=66
+
+[core 0s1]
+name=CPE0
+task=0
+mode=lat
+rx port=cpe0
+lat pos=42
+
+[core 1s1]
+name=CPE1
+task=0
+mode=lat
+rx port=cpe1
+lat pos=42
+
+[core 2s1]
+name=CPE2
+task=0
+mode=lat
+rx port=cpe2
+lat pos=42
+
+[core 3s1]
+name=CPE3
+task=0
+mode=lat
+rx port=cpe3
+lat pos=42
+
+[core 4s1]
+name=INET0
+task=0
+mode=lat
+rx port=inet0
+lat pos=66
+
+[core 5s1]
+name=INET1
+task=0
+mode=lat
+rx port=inet1
+lat pos=66
+
+[core 6s1]
+name=INET2
+task=0
+mode=lat
+rx port=inet2
+lat pos=66
+
+[core 7s1]
+name=INET3
+task=0
+mode=lat
+rx port=inet3
+lat pos=66
diff --git a/VNFs/DPPD-PROX/gen/bng-ovs-usv-4ports-gen.cfg b/VNFs/DPPD-PROX/gen/bng-ovs-usv-4ports-gen.cfg
new file mode 100644
index 00000000..13f4472c
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/bng-ovs-usv-4ports-gen.cfg
@@ -0,0 +1,89 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=p0
+mac=00:00:00:00:00:01
+[port 1]
+name=p1
+mac=00:00:00:00:00:02
+[port 2]
+name=p2
+mac=00:00:00:00:00:03
+[port 3]
+name=p3
+mac=00:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=BNG OVS USV gen
+
+[core 0s1]
+mode=master
+
+[core 1s1]
+name=p0
+task=0
+mode=gen
+tx port=p0
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 05 00 00 05 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 13 88 13 88 00 08 55 7b
+random=0000000000000000000001XX00XX00XX
+rand_offset=26
+
+random=0000101X000000000XXX000000000000
+rand_offset=30
+
+[core 2s1]
+name=p1
+task=0
+mode=gen
+tx port=p1
+bps=1250000000
+pkt inline=00 00 02 00 00 02 00 00 06 00 00 06 08 00 45 00 00 38 00 01 00 00 40 2f f7 43 c0 a8 01 01 c0 a8 01 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 88 f5 17 18 19 1a c0 a8 01 01 13 88 13 88 00 08 e6 f2
+random=000000000XXXXXXX
+rand_offset=40
+
+[core 3s1]
+name=p2
+task=0
+mode=gen
+tx port=p2
+bps=1250000000
+pkt inline=00 00 03 00 00 03 00 00 07 00 00 07 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 13 88 13 88 00 08 55 7b
+
+random=0000000000000000000000XX00XX00XX
+rand_offset=26
+
+random=0000101X000000000XXX000000000000
+rand_offset=30
+
+[core 4s1]
+name=p3
+task=0
+mode=gen
+tx port=p3
+bps=1250000000
+pkt inline=00 00 04 00 00 04 00 00 08 00 00 08 08 00 45 00 00 38 00 01 00 00 40 2f f7 43 c0 a8 01 01 c0 a8 01 01 20 00 08 00 00 00 00 00 45 00 00 1c 00 01 00 00 40 11 88 f5 17 18 19 1a c0 a8 01 01 13 88 13 88 00 08 e6 f2
+random=000000000XXXXXXX
+rand_offset=40
diff --git a/VNFs/DPPD-PROX/gen/l3fwd-gen.cfg b/VNFs/DPPD-PROX/gen/l3fwd-gen.cfg
new file mode 100644
index 00000000..4d830043
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/l3fwd-gen.cfg
@@ -0,0 +1,82 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=p0
+mac=00:00:00:00:00:01
+[port 1]
+name=p1
+mac=00:00:00:00:00:02
+[port 2]
+name=p2
+mac=00:00:00:00:00:03
+[port 3]
+name=p3
+mac=00:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=Routing Gen
+
+[core 0s1]
+mode=master
+
+[core 1s1]
+name=p0
+task=0
+mode=gen
+tx port=p0
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 0a 00 00 00 13 88 13 88 00 08 55 7b
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=30
+
+[core 2s1]
+name=p1
+task=0
+mode=gen
+tx port=p1
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 0a 00 00 00 13 88 13 88 00 08 55 7b
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=30
+
+[core 3s1]
+name=p2
+task=0
+mode=gen
+tx port=p2
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 0a 00 00 00 13 88 13 88 00 08 55 7b
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=30
+
+[core 4s1]
+name=p3
+task=0
+mode=gen
+tx port=p3
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 0a 00 00 00 13 88 13 88 00 08 55 7b
+random=0000101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=30
diff --git a/VNFs/DPPD-PROX/gen/lb_5tuple-gen.cfg b/VNFs/DPPD-PROX/gen/lb_5tuple-gen.cfg
new file mode 100644
index 00000000..65d352a3
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/lb_5tuple-gen.cfg
@@ -0,0 +1,82 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=p0
+mac=00:00:00:00:00:01
+[port 1]
+name=p1
+mac=00:00:00:00:00:02
+[port 2]
+name=p2
+mac=00:00:00:00:00:03
+[port 3]
+name=p3
+mac=00:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=5-tuple Gen
+
+[core 0s1]
+mode=master
+
+[core 1s1]
+name=p0
+task=0
+mode=gen
+tx port=p0
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 08 00 45 00 00 1c 00 01 00 00 47 00 f7 7d 00 00 00 00 00 00 00 00 00 00 00 00 77 23 55 7b
+random=XXX00000
+rand_offset=23
+random=000000000000000000000000000XXXXX
+rand_offset=26
+random=000000000000000000000000000XXXXX
+rand_offset=30
+random=00000000000XXXXX00000000000XXXXX
+rand_offset=34
+
+[core 2s1]
+name=p0
+task=0
+mode=nop
+rx port=p0
+
+[core 3s1]
+name=p1
+task=0
+mode=nop
+rx port=p1
+
+[core 4s1]
+name=p2
+task=0
+mode=nop
+rx port=p2
+
+[core 5s1]
+name=p3
+task=0
+mode=nop
+rx port=p3
diff --git a/VNFs/DPPD-PROX/gen/lw_aftr-gen.cfg b/VNFs/DPPD-PROX/gen/lw_aftr-gen.cfg
new file mode 100644
index 00000000..a9aad397
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/lw_aftr-gen.cfg
@@ -0,0 +1,106 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=inet_0
+mac=00:00:00:00:01:01
+[port 2]
+name=lwB4_0
+mac=00:00:00:00:00:02
+[port 4]
+name=inet_1
+mac=00:00:00:00:01:03
+[port 6]
+name=lwB4_1
+mac=00:00:00:00:00:04
+
+[variables]
+$tun_pcap=./lwAFTR_tun_100k.pcap
+$inet_pcap=./lwAFTR_inet_100k.pcap
+
+[defaults]
+mempool size=16K
+
+[global]
+start time=20
+name=Gen lwAFTR
+
+[core 0s0]
+mode=master
+
+[core 1s0,2s0]
+name=tun_0
+task=0
+mode=gen
+tx port=lwB4_0
+pcap file=$tun_pcap
+lat pos=58
+
+[core 3s0,4s0]
+name=inet_0
+task=0
+mode=gen
+tx port=inet_0
+pcap file=$inet_pcap
+lat pos=18
+
+[core 1s1,2s1]
+name=tun_1
+task=0
+mode=gen
+tx port=lwB4_1
+pcap file=$tun_pcap
+lat pos=58
+
+[core 3s1,4s1]
+name=inet_1
+task=0
+mode=gen
+tx port=inet_1
+pcap file=$inet_pcap
+lat pos=18
+
+[core 5s0]
+name=lat_in0
+task=0
+mode=lat
+rx port=inet_0
+lat pos=18
+
+[core 6s0]
+name=lat_tun0
+task=0
+mode=lat
+rx port=lwB4_0
+lat pos=58
+
+[core 5s1]
+name=lat_in1
+task=0
+mode=lat
+rx port=inet_1
+lat pos=18
+
+[core 6s1]
+name=lat_tun1
+task=0
+mode=lat
+rx port=lwB4_1
+lat pos=58
diff --git a/VNFs/DPPD-PROX/gen/nop-gen.cfg b/VNFs/DPPD-PROX/gen/nop-gen.cfg
new file mode 100644
index 00000000..8c801034
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/nop-gen.cfg
@@ -0,0 +1,71 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=p0
+mac=00:00:00:00:00:01
+[port 1]
+name=p1
+mac=00:00:00:00:00:02
+[port 2]
+name=p2
+mac=00:00:00:00:00:03
+[port 3]
+name=p3
+mac=00:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=Basic Gen
+
+[core 0s0]
+mode=master
+
+[core 1s0]
+name=p0
+task=0
+mode=gen
+tx port=p0
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 13 88 13 88 00 08 55 7b
+[core 2s0]
+name=p1
+task=0
+mode=gen
+tx port=p1
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 13 88 13 88 00 08 55 7b
+[core 3s0]
+name=p2
+task=0
+mode=gen
+tx port=p2
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 13 88 13 88 00 08 55 7b
+[core 4s0]
+name=p3
+task=0
+mode=gen
+tx port=p3
+bps=1250000000
+pkt inline=00 00 01 00 00 01 00 00 02 00 00 02 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d c0 a8 01 01 c0 a8 01 01 13 88 13 88 00 08 55 7b
diff --git a/VNFs/DPPD-PROX/gen/nsh-gen.cfg b/VNFs/DPPD-PROX/gen/nsh-gen.cfg
new file mode 100644
index 00000000..8502d0ef
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/nsh-gen.cfg
@@ -0,0 +1,50 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=p0
+mac=00:00:00:00:00:01
+[port 1]
+name=p1
+mac=00:00:00:00:00:02
+[port 2]
+name=p2
+mac=00:00:00:00:00:03
+[port 3]
+name=p3
+mac=00:00:00:00:00:04
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=Basic Gen
+
+[core 0s1]
+mode=master
+
+[core 1s1]
+name=p0
+task=0
+mode=gen
+tx port=p0
+bps=1250000000
+pkt inline=68 05 ca 30 6b d0 68 05 ca 30 6c b0 08 00 45 00 04 20 00 00 40 00 40 11 a5 fd c8 02 00 65 c8 02 00 66 9c c4 12 b6 04 0c 00 00 0c 40 00 04 00 00 00 00 40 06 01 03 00 03 e9 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 07 00 00 00 01 00 06 00 08 00 45 00 03 d6 00 00 00 00 40 06 48 15 0a 00 00 01 c0 a8 64 64 00 00 00 00 00 00 00 00 00 00 00 00 50 00 00 00 d9 b0 00 00 00 01 02 03 04 05 06 07 08 09 0a
diff --git a/VNFs/DPPD-PROX/gen/pe-4ports-gen.cfg b/VNFs/DPPD-PROX/gen/pe-4ports-gen.cfg
new file mode 100644
index 00000000..c7a01615
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/pe-4ports-gen.cfg
@@ -0,0 +1,239 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:00:00:00:01
+[port 1]
+name=inet0
+mac=00:00:00:00:00:02
+[port 2]
+name=cpe1
+mac=00:00:00:00:00:03
+[port 3]
+name=inet1
+mac=00:00:00:00:00:04
+
+
+[variables]
+$up_size=60
+$dn_size=60
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=PE gen
+[core 0s1]
+mode=master
+
+[core 1s1]
+name=cpe0
+task=0
+mode=gen
+tx port=cpe0
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 f7 79 c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 1d
+random=000000000000000X
+rand_offset=14
+
+random=00000000XXXXXXXX
+rand_offset=18
+
+random=11000000101010000000XXXXXXXXXXXX
+rand_offset=34
+
+random=0X00101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+random=XXXXXX00
+rand_offset=23
+
+random=000000000000XXX0
+rand_offset=42
+
+random=0000000XXXXXXXXX
+rand_offset=44
+
+pkt size=$up_size
+lat pos=50
+
+
+[core 2s1]
+name=cpe1
+task=0
+mode=gen
+tx port=cpe1
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 f7 79 c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 1d
+
+random=000000000010000X
+rand_offset=14
+
+random=00000000XXXXXXXX
+rand_offset=18
+
+random=11000000101010000010XXXXXXXXXXXX
+rand_offset=34
+
+random=0X00101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+random=XXXXXX00
+rand_offset=23
+
+random=000000000000XXX0
+rand_offset=42
+
+random=0000000XXXXXXXXX
+rand_offset=44
+
+
+pkt size=$up_size
+lat pos=50
+
+[core 3s1]
+name=cpe0
+task=0
+mode=gen
+tx port=cpe0
+bps=625000000
+
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 f7 79 c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 1d
+
+random=000000000001000X
+rand_offset=14
+
+random=00000000XXXXXXXX
+rand_offset=18
+
+random=11000000101010000001XXXXXXXXXXXX
+rand_offset=34
+
+random=0X00101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+random=XXXXXX00
+rand_offset=23
+
+random=000000000000XXX0
+rand_offset=42
+
+random=0000000XXXXXXXXX
+rand_offset=44
+
+
+pkt size=$up_size
+lat pos=50
+
+[core 4s1]
+name=cpe1
+task=0
+mode=gen
+tx port=cpe1
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 f7 79 c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 1d
+
+random=000000000011000X
+rand_offset=14
+
+random=00000000XXXXXXXX
+rand_offset=18
+
+random=11000000101010000011XXXXXXXXXXXX
+rand_offset=34
+
+random=0X00101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+random=XXXXXX00
+rand_offset=23
+
+random=000000000000XXX0
+rand_offset=42
+
+random=0000000XXXXXXXXX
+rand_offset=44
+
+pkt size=$up_size
+lat pos=50
+
+
+[core 5s1]
+name=inet0
+task=0
+mode=gen
+tx port=inet0
+bps=1250000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 20 00 01 00 00 40 11 77 fa c0 a8 80 80 c0 a8 01 01 00 35 00 35 00 08 fc 9d
+
+random=110000001010100000XXXXXXXXXXXXXX
+rand_offset=34
+
+random=XXXXXX00
+rand_offset=19
+
+pkt size=$dn_size
+lat pos=46
+
+[core 6s1]
+name=inet1
+task=0
+mode=gen
+tx port=inet1
+bps=1250000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 20 00 01 00 00 40 11 77 fa c0 a8 80 80 c0 a8 01 01 00 35 00 35 00 08 fc 9d
+
+random=110000001010100000XXXXXXXXXXXXXX
+rand_offset=34
+
+random=XXXXXX00
+rand_offset=19
+
+pkt size=$dn_size
+lat pos=46
+
+[core 7s1]
+name=none
+task=0
+mode=lat
+rx port=cpe0
+lat pos=50
+
+[core 8s1]
+name=none
+task=0
+mode=lat
+rx port=cpe1
+lat pos=50
+
+[core 9s1]
+name=none
+task=0
+mode=lat
+rx port=inet0
+lat pos=46
+
+[core 10s1]
+name=none
+task=0
+mode=lat
+rx port=inet1
+lat pos=46
diff --git a/VNFs/DPPD-PROX/gen/pe-8ports-gen.cfg b/VNFs/DPPD-PROX/gen/pe-8ports-gen.cfg
new file mode 100644
index 00000000..461fd4b0
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/pe-8ports-gen.cfg
@@ -0,0 +1,314 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=cpe0
+mac=00:00:00:00:00:01
+[port 1]
+name=inet0
+mac=00:00:00:00:00:02
+[port 2]
+name=cpe1
+mac=00:00:00:00:00:03
+[port 3]
+name=inet1
+mac=00:00:00:00:00:04
+
+
+[port 4]
+name=cpe2
+mac=00:00:00:00:00:01
+[port 5]
+name=inet2
+mac=00:00:00:00:00:02
+[port 6]
+name=cpe3
+mac=00:00:00:00:00:03
+[port 7]
+name=inet3
+mac=00:00:00:00:00:04
+
+[variables]
+$up_size=60
+$dn_size=60
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=PE gen
+[core 0s1]
+mode=master
+
+[core 1s1,1s1h]
+name=cpe0
+task=0
+mode=gen
+tx port=cpe0
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 f7 79 c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 1d
+random=000000000000000X
+rand_offset=14
+
+random=00000000XXXXXXXX
+rand_offset=18
+
+random=11000000101010000000XXXXXXXXXXXX
+rand_offset=34
+
+random=0X00101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+random=XXXXXX00
+rand_offset=23
+
+random=000000000000XXX0
+rand_offset=42
+
+random=0000000XXXXXXXXX
+rand_offset=44
+
+pkt size=$up_size
+lat pos=50
+
+
+[core 2s1,2s1h]
+name=cpe1
+task=0
+mode=gen
+tx port=cpe1
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 f7 79 c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 1d
+
+random=000000000010000X
+rand_offset=14
+
+random=00000000XXXXXXXX
+rand_offset=18
+
+random=11000000101010000010XXXXXXXXXXXX
+rand_offset=34
+
+random=0X00101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+random=XXXXXX00
+rand_offset=23
+
+random=000000000000XXX0
+rand_offset=42
+
+random=0000000XXXXXXXXX
+rand_offset=44
+
+
+pkt size=$up_size
+lat pos=50
+
+[core 3s1,3s1h]
+name=inet0
+task=0
+mode=gen
+tx port=inet0
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 20 00 01 00 00 40 11 77 fa c0 a8 80 80 c0 a8 01 01 00 35 00 35 00 08 fc 9d
+
+random=110000001010100000XXXXXXXXXXXXXX
+rand_offset=34
+
+random=XXXXXX00
+rand_offset=19
+
+
+pkt size=$dn_size
+lat pos=46
+
+[core 4s1,4s1h]
+name=inet1
+task=0
+mode=gen
+tx port=inet1
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 20 00 01 00 00 40 11 77 fa c0 a8 80 80 c0 a8 01 01 00 35 00 35 00 08 fc 9d
+
+random=110000001010100000XXXXXXXXXXXXXX
+rand_offset=34
+
+random=XXXXXX00
+rand_offset=19
+
+pkt size=$dn_size
+lat pos=46
+
+[core 5s1]
+name=none
+task=0
+mode=lat
+rx port=cpe0
+lat pos=50
+
+[core 5s1h]
+name=none
+task=0
+mode=lat
+rx port=cpe1
+lat pos=50
+
+[core 6s1]
+name=none
+task=0
+mode=lat
+rx port=inet0
+lat pos=46
+
+[core 6s1h]
+name=none
+task=0
+mode=lat
+rx port=inet1
+lat pos=46
+
+[core 1s0,1s0h]
+name=cpe2
+task=0
+mode=gen
+tx port=cpe2
+bps=625000000
+
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 f7 79 c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 1d
+
+random=000000000001000X
+rand_offset=14
+
+random=00000000XXXXXXXX
+rand_offset=18
+
+random=11000000101010000001XXXXXXXXXXXX
+rand_offset=34
+
+random=0X00101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+random=XXXXXX00
+rand_offset=23
+
+random=000000000000XXX0
+rand_offset=42
+
+random=0000000XXXXXXXXX
+rand_offset=44
+
+
+pkt size=$up_size
+lat pos=50
+
+[core 2s0,2s0h]
+name=cpe3
+task=0
+mode=gen
+tx port=cpe3
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 a8 00 01 81 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 f7 79 c0 a8 01 01 c0 a8 01 01 00 35 00 35 00 08 7c 1d
+
+random=000000000011000X
+rand_offset=14
+
+random=00000000XXXXXXXX
+rand_offset=18
+
+random=11000000101010000011XXXXXXXXXXXX
+rand_offset=34
+
+random=0X00101XXXXXXXXXXXXX0000XXXXXXXX
+rand_offset=38
+
+random=XXXXXX00
+rand_offset=23
+
+random=000000000000XXX0
+rand_offset=42
+
+random=0000000XXXXXXXXX
+rand_offset=44
+
+pkt size=$up_size
+lat pos=50
+
+[core 3s0,3s0h]
+name=inet2
+task=0
+mode=gen
+tx port=inet2
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 20 00 01 00 00 40 11 77 fa c0 a8 80 80 c0 a8 01 01 00 35 00 35 00 08 fc 9d
+
+random=110000001010100000XXXXXXXXXXXXXX
+rand_offset=34
+
+random=XXXXXX00
+rand_offset=19
+
+pkt size=$dn_size
+lat pos=46
+
+[core 4s0,4s0h]
+name=inet3
+task=0
+mode=gen
+tx port=inet3
+bps=625000000
+pkt inline=ff ff ff ff ff ff 00 00 00 00 00 00 88 47 00 00 31 00 45 00 00 20 00 01 00 00 40 11 77 fa c0 a8 80 80 c0 a8 01 01 00 35 00 35 00 08 fc 9d
+
+random=110000001010100000XXXXXXXXXXXXXX
+rand_offset=34
+
+random=XXXXXX00
+rand_offset=19
+
+pkt size=$dn_size
+lat pos=46
+
+[core 5s0]
+name=none
+task=0
+mode=lat
+rx port=cpe2
+lat pos=50
+
+[core 5s0h]
+name=none
+task=0
+mode=lat
+rx port=cpe3
+lat pos=50
+
+[core 6s0]
+name=none
+task=0
+mode=lat
+rx port=inet2
+lat pos=46
+
+[core 6s0h]
+name=none
+task=0
+mode=lat
+rx port=inet3
+lat pos=46
diff --git a/VNFs/DPPD-PROX/gen/vRouter-gen-4ports.cfg b/VNFs/DPPD-PROX/gen/vRouter-gen-4ports.cfg
new file mode 100644
index 00000000..403ac7df
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/vRouter-gen-4ports.cfg
@@ -0,0 +1,179 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=p0
+mac=00:00:00:00:00:01
+rx desc=$rxd
+tx desc=$txd
+[port 1]
+name=p1
+mac=00:00:00:00:00:02
+rx desc=$rxd
+tx desc=$txd
+[port 2]
+name=p2
+mac=00:00:00:00:00:03
+rx desc=$rxd
+tx desc=$txd
+[port 3]
+name=p3
+mac=00:00:00:00:00:04
+rx desc=$rxd
+tx desc=$txd
+
+[variables]
+$bulk=8
+$rxd=1024
+$txd=256
+$c1=1s1,1s1h,9s1,9s1h
+$c2=2s1,2s1h,10s1,10s1h
+$c3=3s1,3s1h,11s1,11s1h
+$c4=4s1,4s1h,12s1,12s1h
+$r1=5s1
+$r2=6s1
+$r3=7s1
+$r4=8s1
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=Basic Gen
+
+[core 0s1]
+mode=master
+
+[core $c1]
+name=p0
+task=0
+mode=gen
+tx port=p0
+bps=1250000000
+pkt inline=90 e2 ba a5 a4 38 00 00 01 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 00 00 11 00 00 02 42 00 00 02 13 88 13 88 00 0c 00 00 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c2]
+name=p1
+task=0
+mode=gen
+tx port=p1
+bps=1250000000
+pkt inline=90 e2 ba a5 a4 39 00 00 02 00 00 02 08 00 45 00 00 20 00 01 00 00 40 11 00 00 19 00 00 02 43 00 00 02 13 88 13 88 00 0c 55 7b 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c3]
+name=p2
+task=0
+mode=gen
+tx port=p2
+bps=1250000000
+pkt inline=90 e2 ba a5 a4 44 00 00 02 00 00 02 08 00 45 00 00 20 00 01 00 00 40 11 00 00 01 00 00 02 40 00 00 02 13 88 13 88 00 0c 55 7b 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c4]
+name=p3
+task=0
+mode=gen
+tx port=p3
+bps=1250000000
+pkt inline=90 e2 ba a5 a4 45 00 00 02 00 00 02 08 00 45 00 00 20 00 01 00 00 40 11 00 00 09 00 00 02 41 00 00 02 13 88 13 88 00 0c 55 7b 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $r1]
+name=r1
+task=0
+mode=arp
+rx port=p0
+tx port=p0
+tx cores=(${r1})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r2]
+name=r2
+task=0
+mode=arp
+rx port=p1
+tx port=p1
+tx cores=(${r2})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r3]
+name=r3
+task=0
+mode=arp
+rx port=p2
+tx port=p2
+tx cores=(${r3})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r4]
+name=r4
+task=0
+mode=arp
+rx port=p3
+tx port=p3
+tx cores=(${r4})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
diff --git a/VNFs/DPPD-PROX/gen/vRouter-gen.cfg b/VNFs/DPPD-PROX/gen/vRouter-gen.cfg
new file mode 100644
index 00000000..c02183c0
--- /dev/null
+++ b/VNFs/DPPD-PROX/gen/vRouter-gen.cfg
@@ -0,0 +1,323 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[port 0]
+name=p0
+mac=00:00:00:00:00:01
+rx desc=$rxd
+tx desc=$txd
+[port 1]
+name=p1
+mac=00:00:00:00:00:02
+rx desc=$rxd
+tx desc=$txd
+[port 2]
+name=p2
+mac=00:00:00:00:00:03
+rx desc=$rxd
+tx desc=$txd
+[port 3]
+name=p3
+mac=00:00:00:00:00:04
+rx desc=$rxd
+tx desc=$txd
+[port 4]
+name=p4
+mac=00:00:00:00:00:05
+rx desc=$rxd
+tx desc=$txd
+[port 5]
+name=p5
+mac=00:00:00:00:00:06
+rx desc=$rxd
+tx desc=$txd
+[port 6]
+name=p6
+mac=00:00:00:00:00:07
+rx desc=$rxd
+tx desc=$txd
+[port 7]
+name=p7
+mac=00:00:00:00:00:08
+rx desc=$rxd
+tx desc=$txd
+
+[variables]
+$bulk=8
+$rxd=1024
+$txd=256
+$c1=1s1,1s1h,9s1,9s1h
+$c2=2s1,2s1h,10s1,10s1h
+$c3=3s1,3s1h,11s1,11s1h
+$c4=4s1,4s1h,12s1,12s1h
+$c5=5s1,5s1h,13s1,13s1h
+$c6=6s1,6s1h,14s1,14s1h
+$c7=7s1,7s1h,15s1,15s1h
+$c8=8s1,8s1h,16s1,16s1h
+$r1=1s0
+$r2=2s0
+$r3=3s0
+$r4=4s0
+$r5=5s0
+$r6=6s0
+$r7=7s0
+$r8=10s0
+
+[defaults]
+mempool size=4K
+
+[global]
+start time=5
+name=Basic Gen
+
+[core 0s1]
+mode=master
+
+[core $c1]
+name=p0
+task=0
+mode=gen
+tx port=p0
+bps=1250000000
+pkt inline=00 1b 21 b1 23 14 00 00 01 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 00 00 21 00 00 02 44 00 00 02 13 88 13 88 00 0c 00 00 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c2]
+name=p1
+task=0
+mode=gen
+tx port=p1
+bps=1250000000
+pkt inline=00 1b 21 b1 23 15 00 00 02 00 00 02 08 00 45 00 00 20 00 01 00 00 40 11 00 00 29 00 00 02 45 00 00 02 13 88 13 88 00 0c 55 7b 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c3]
+name=p2
+task=0
+mode=gen
+tx port=p2
+bps=1250000000
+pkt inline=90 e2 ba a7 64 44 00 00 02 00 00 02 08 00 45 00 00 20 00 01 00 00 40 11 00 00 31 00 00 02 46 00 00 02 13 88 13 88 00 0c 55 7b 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c4]
+name=p3
+task=0
+mode=gen
+tx port=p3
+bps=1250000000
+pkt inline=90 e2 ba a7 64 45 00 00 02 00 00 02 08 00 45 00 00 20 00 01 00 00 40 11 00 00 39 00 00 02 47 00 00 02 13 88 13 88 00 0c 55 7b 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c5]
+name=p4
+task=0
+mode=gen
+tx port=p4
+bps=1250000000
+pkt inline=90 e2 ba a5 a4 38 00 00 01 00 00 01 08 00 45 00 00 20 00 01 00 00 40 11 00 00 11 00 00 02 42 00 00 02 13 88 13 88 00 0c 00 00 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c6]
+name=p5
+task=0
+mode=gen
+tx port=p5
+bps=1250000000
+pkt inline=90 e2 ba a5 a4 39 00 00 02 00 00 02 08 00 45 00 00 20 00 01 00 00 40 11 00 00 19 00 00 02 43 00 00 02 13 88 13 88 00 0c 55 7b 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c7]
+name=p6
+task=0
+mode=gen
+tx port=p6
+bps=1250000000
+pkt inline=90 e2 ba a5 a4 44 00 00 02 00 00 02 08 00 45 00 00 20 00 01 00 00 40 11 00 00 01 00 00 02 40 00 00 02 13 88 13 88 00 0c 55 7b 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $c8]
+name=p7
+task=0
+mode=gen
+tx port=p7
+bps=1250000000
+pkt inline=90 e2 ba a5 a4 45 00 00 02 00 00 02 08 00 45 00 00 20 00 01 00 00 40 11 00 00 09 00 00 02 41 00 00 02 13 88 13 88 00 0c 55 7b 00 00 00 00 00 00 00 00 00
+min bulk size=$bulk
+max bulk size=$bulk
+random=0XXXXXXXXXXXXX10
+rand_offset=34
+random=0XXXXXXXXXXXXX10
+rand_offset=36
+lat pos=42
+packet id pos=46
+
+[core $r1]
+name=r1
+task=0
+mode=arp
+rx port=p0
+tx port=p0
+tx cores=(${r1})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r2]
+name=r2
+task=0
+mode=arp
+rx port=p1
+tx port=p1
+tx cores=(${r2})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r3]
+name=r3
+task=0
+mode=arp
+rx port=p2
+tx port=p2
+tx cores=(${r3})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r4]
+name=r4
+task=0
+mode=arp
+rx port=p3
+tx port=p3
+tx cores=(${r4})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r5]
+name=r5
+task=0
+mode=arp
+rx port=p4
+tx port=p4
+tx cores=(${r5})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r6]
+name=r6
+task=0
+mode=arp
+rx port=p5
+tx port=p5
+tx cores=(${r6})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r7]
+name=r7
+task=0
+mode=arp
+rx port=p6
+tx port=p6
+tx cores=(${r7})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
+
+[core $r8]
+name=r8
+task=0
+mode=arp
+rx port=p7
+tx port=p7
+tx cores=(${r8})t1
+task=1
+mode=lat
+rx ring=yes
+lat pos=42
+packet id pos=46
diff --git a/VNFs/DPPD-PROX/genl4_bundle.c b/VNFs/DPPD-PROX/genl4_bundle.c
new file mode 100644
index 00000000..7d4a0141
--- /dev/null
+++ b/VNFs/DPPD-PROX/genl4_bundle.c
@@ -0,0 +1,369 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <rte_hash.h>
+#include <rte_memory.h>
+#include <rte_hash_crc.h>
+#include <rte_cycles.h>
+#include <rte_version.h>
+
+#include "prox_malloc.h"
+#include "prox_assert.h"
+#include "cdf.h"
+#include "defines.h"
+#include "genl4_bundle.h"
+#include "log.h"
+#include "pkt_parser.h"
+#include "prox_lua_types.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#define RTE_CACHE_LINE_ROUNDUP CACHE_LINE_ROUNDUP
+#endif
+
+/* zero on success */
+int bundle_ctx_pool_create(const char *name, uint32_t n_elems, struct bundle_ctx_pool *ret, uint32_t *occur, uint32_t n_occur, struct bundle_cfg *cfg, int socket_id)
+{
+	size_t memsize;
+	uint8_t *mem;
+
+	const struct rte_hash_parameters params = {
+		.name = name,
+		.entries = rte_align32pow2(n_elems) * 8,
+		//.bucket_entries = 8,
+		.key_len = sizeof(struct pkt_tuple),
+		.hash_func = rte_hash_crc,
+		.hash_func_init_val = 0,
+		.socket_id = socket_id,
+	};
+
+	ret->hash = rte_hash_create(&params);
+	if (NULL == ret->hash)
+		return -1;
+
+	uint32_t rand_pool_size = 0, tot_occur = 0;
+
+	if (occur) {
+		for (uint32_t i = 0; i < n_occur; ++i) {
+			tot_occur += occur[i];
+		}
+
+		rand_pool_size = (n_elems + (tot_occur - 1))/tot_occur*tot_occur;
+	}
+
+	memsize = 0;
+	memsize += RTE_CACHE_LINE_ROUNDUP(params.entries * sizeof(ret->hash_entries[0]));
+	memsize += RTE_CACHE_LINE_ROUNDUP(n_elems * sizeof(ret->free_bundles[0]));
+	memsize += RTE_CACHE_LINE_ROUNDUP(n_elems * sizeof(ret->bundles[0]));
+	if (occur)
+		memsize += RTE_CACHE_LINE_ROUNDUP(rand_pool_size * sizeof(ret->occur));
+	mem = prox_zmalloc(memsize, socket_id);
+	if (NULL == mem)
+		return -1;
+
+	ret->hash_entries = (struct bundle_ctx **) mem;
+	mem += RTE_CACHE_LINE_ROUNDUP(params.entries * sizeof(ret->hash_entries[0]));
+	ret->free_bundles = (struct bundle_ctx **) mem;
+	mem += RTE_CACHE_LINE_ROUNDUP(n_elems * sizeof(ret->free_bundles[0]));
+	if (occur) {
+		ret->occur = (uint32_t *)mem;
+		mem += RTE_CACHE_LINE_ROUNDUP(rand_pool_size * sizeof(ret->occur));
+
+		ret->seed = rte_rdtsc();
+
+		size_t cur_occur = 0;
+		size_t j = 0;
+
+		for (uint32_t i = 0; i < rand_pool_size; ++i) {
+			while (j >= occur[cur_occur]) {
+				cur_occur++;
+				if (cur_occur == n_occur)
+					cur_occur = 0;
+				j = 0;
+			}
+			j++;
+			ret->occur[i] = cur_occur;
+		}
+		ret->n_occur = rand_pool_size;
+	}
+	ret->bundles = (struct bundle_ctx *) mem;
+
+	ret->bundle_cfg = cfg;
+	for (unsigned i = 0; i < n_elems; ++i) {
+		ret->free_bundles[i] = &ret->bundles[i];
+	}
+	ret->n_free_bundles = n_elems;
+	ret->tot_bundles    = n_elems;
+
+	return 0;
+}
+
+struct bundle_ctx *bundle_ctx_pool_get(struct bundle_ctx_pool *p)
+{
+	if (p->n_free_bundles > 0)
+		return p->free_bundles[--p->n_free_bundles];
+	return NULL;
+}
+
+static struct bundle_cfg *bundle_ctx_get_cfg(struct bundle_ctx_pool *p)
+{
+	uint32_t rand = 0;
+
+	/* get rand in [0, RAND_MAX rounded down] */
+	do {
+		rand = rand_r(&p->seed);
+	} while (rand >= RAND_MAX/p->n_occur*p->n_occur);
+
+	rand /= RAND_MAX/p->n_occur;
+
+	PROX_ASSERT(p->n_occur);
+	PROX_ASSERT(rand < p->n_occur);
+
+	uint32_t r = p->occur[rand];
+	p->occur[rand] = p->occur[--p->n_occur];
+
+	return &p->bundle_cfg[r];
+}
+
+static void bundle_ctx_put_cfg(struct bundle_ctx_pool *p, const struct bundle_cfg *cfg)
+{
+	if (p->occur) {
+		uint32_t r = cfg - p->bundle_cfg;
+		p->occur[p->n_occur++] = r;
+	}
+}
+
+struct bundle_ctx *bundle_ctx_pool_get_w_cfg(struct bundle_ctx_pool *p)
+{
+	if (p->n_free_bundles > 0) {
+		struct bundle_ctx *ret = p->free_bundles[--p->n_free_bundles];
+		ret->cfg = bundle_ctx_get_cfg(p);
+		return ret;
+	}
+
+	return NULL;
+}
+
+void bundle_ctx_pool_put(struct bundle_ctx_pool *p, struct bundle_ctx *bundle)
+{
+	bundle_ctx_put_cfg(p, bundle->cfg);
+	p->free_bundles[p->n_free_bundles++] = bundle;
+}
+
+static void bundle_cleanup(struct bundle_ctx *bundle)
+{
+	if (bundle->heap_ref.elem != NULL) {
+		heap_del(bundle->heap, &bundle->heap_ref);
+	}
+}
+
+static int bundle_iterate_streams(struct bundle_ctx *bundle, struct bundle_ctx_pool *pool, unsigned *seed, struct l4_stats *l4_stats)
+{
+	enum l4gen_peer peer;
+	int ret = 0, old;
+
+	while (bundle->ctx.stream_cfg->is_ended(&bundle->ctx)) {
+
+		if (bundle->ctx.stream_cfg->proto == IPPROTO_TCP) {
+			if (bundle->ctx.retransmits == 0)
+				l4_stats->tcp_finished_no_retransmit++;
+			else
+				l4_stats->tcp_finished_retransmit++;
+		}
+		else
+			l4_stats->udp_finished++;
+
+		if (bundle->stream_idx + 1 != bundle->cfg->n_stream_cfgs) {
+			ret = 1;
+			bundle->stream_idx++;
+
+			stream_ctx_reset_move(&bundle->ctx, bundle->cfg->stream_cfgs[bundle->stream_idx]);
+
+			/* Update tuple */
+			old = rte_hash_del_key(pool->hash, &bundle->tuple);
+			if (old < 0) {
+				plogx_err("Failed to delete key while trying to change tuple: %d (%s)\n",old, strerror(-old));
+			}
+			plogx_dbg("Moving to stream with idx %d\n", bundle->stream_idx);
+
+			/* In case there are multiple streams, clients
+			   randomized but ports fixed, it is still
+			   possible to hit an infinite loop here. The
+			   situations is hit if a client:port is
+			   connected to a server:port in one of the
+			   streams while client:port is regenerated
+			   for the first stream. There is no conflict
+			   yet since the server:port is
+			   different. Note that this is bug since a
+			   client:port can only have one open
+			   connection. */
+			int retries = 0;
+			do {
+				bundle_create_tuple(&bundle->tuple, &bundle->cfg->clients, bundle->ctx.stream_cfg, 0, seed);
+
+				ret = rte_hash_lookup(pool->hash, (const void *)&bundle->tuple);
+				if (++retries == 1000) {
+					plogx_warn("Already tried 1K times\n");
+					plogx_warn("Going from %d to %d\n", bundle->stream_idx -1, bundle->stream_idx);
+				}
+			} while (ret >= 0);
+
+			ret = rte_hash_add_key(pool->hash, &bundle->tuple);
+			if (ret < 0) {
+				plogx_err("Failed to add key while moving to next stream!\n");
+				return -1;
+			}
+			pool->hash_entries[ret] = pool->hash_entries[old];
+
+			if (bundle->ctx.stream_cfg->proto == IPPROTO_TCP)
+				l4_stats->tcp_created++;
+			else
+				l4_stats->udp_created++;
+		}
+		else {
+			int a = rte_hash_del_key(pool->hash, &bundle->tuple);
+			PROX_PANIC(a < 0, "Del failed (%d)! during finished all bundle (%d)\n", a, bundle->cfg->n_stream_cfgs);
+			bundle_cleanup(bundle);
+			bundle_ctx_pool_put(pool, bundle);
+
+			return -1;
+		}
+	}
+	return ret;
+}
+
+void bundle_create_tuple(struct pkt_tuple *tp, const struct host_set *clients, const struct stream_cfg *stream_cfg, int rnd_ip, unsigned  *seed)
+{
+	tp->dst_port = clients->port;
+	tp->dst_port &= ~clients->port_mask;
+	tp->dst_port |= rand_r(seed) & clients->port_mask;
+
+	if (rnd_ip) {
+		tp->dst_addr = clients->ip;
+		tp->dst_addr &= ~clients->ip_mask;
+		tp->dst_addr |= rand_r(seed) & clients->ip_mask;
+	}
+
+	tp->src_addr = stream_cfg->servers.ip;
+	tp->src_port = stream_cfg->servers.port;
+	plogx_dbg("bundle_create_tuple() with proto = %x, %d\n", stream_cfg->proto, rnd_ip);
+	tp->proto_id = stream_cfg->proto;
+
+	tp->l2_types[0] = 0x0008;
+}
+
+void bundle_init_w_cfg(struct bundle_ctx *bundle, const struct bundle_cfg *cfg, struct heap *heap, enum l4gen_peer peer, unsigned *seed)
+{
+	bundle->cfg = cfg;
+	bundle_init(bundle, heap, peer, seed);
+}
+
+void bundle_init(struct bundle_ctx *bundle, struct heap *heap, enum l4gen_peer peer, unsigned *seed)
+{
+	bundle->heap_ref.elem = NULL;
+	bundle->heap = heap;
+	memset(&bundle->ctx, 0, sizeof(bundle->ctx));
+	// TODO; assert that there is at least one stream
+	bundle->stream_idx = 0;
+
+	stream_ctx_init(&bundle->ctx, peer, bundle->cfg->stream_cfgs[bundle->stream_idx], &bundle->tuple);
+	bundle_create_tuple(&bundle->tuple, &bundle->cfg->clients, bundle->ctx.stream_cfg, peer == PEER_CLIENT, seed);
+}
+
+void bundle_expire(struct bundle_ctx *bundle, struct bundle_ctx_pool *pool, struct l4_stats *l4_stats)
+{
+	struct pkt_tuple *pt = &bundle->tuple;
+
+	plogx_dbg("Client = "IPv4_BYTES_FMT":%d, Server = "IPv4_BYTES_FMT":%d\n",
+		  IPv4_BYTES(((uint8_t*)&pt->dst_addr)),
+		  rte_bswap16(pt->dst_port),
+		  IPv4_BYTES(((uint8_t*)&pt->src_addr)),
+		  rte_bswap16(pt->src_port));
+
+	int a = rte_hash_del_key(pool->hash, bundle);
+	if (a < 0) {
+		plogx_err("Del failed with error %d: '%s'\n", a, strerror(-a));
+		plogx_err("ended = %d\n", bundle->ctx.flags & STREAM_CTX_F_TCP_ENDED);
+	}
+
+	if (bundle->ctx.stream_cfg->proto == IPPROTO_TCP)
+		l4_stats->tcp_expired++;
+	else
+		l4_stats->udp_expired++;
+
+	bundle_cleanup(bundle);
+	bundle_ctx_pool_put(pool, bundle);
+}
+
+int bundle_proc_data(struct bundle_ctx *bundle, struct rte_mbuf *mbuf, struct l4_meta *l4_meta, struct bundle_ctx_pool *pool, unsigned *seed, struct l4_stats *l4_stats)
+{
+	int ret;
+	uint64_t next_tsc;
+
+	if (bundle->heap_ref.elem != NULL) {
+		heap_del(bundle->heap, &bundle->heap_ref);
+	}
+
+	if (bundle_iterate_streams(bundle, pool, seed, l4_stats) < 0)
+		return -1;
+
+	uint32_t retx_before = bundle->ctx.retransmits;
+	next_tsc = UINT64_MAX;
+	ret = bundle->ctx.stream_cfg->proc(&bundle->ctx, mbuf, l4_meta, &next_tsc);
+
+	if (bundle->ctx.flags & STREAM_CTX_F_EXPIRED) {
+		bundle_expire(bundle, pool, l4_stats);
+		return -1;
+	}
+	else if (next_tsc != UINT64_MAX) {
+		heap_add(bundle->heap, &bundle->heap_ref, rte_rdtsc() + next_tsc);
+	}
+	l4_stats->tcp_retransmits += bundle->ctx.retransmits - retx_before;
+
+	if (bundle_iterate_streams(bundle, pool, seed, l4_stats) > 0) {
+		if (bundle->heap_ref.elem != NULL) {
+			heap_del(bundle->heap, &bundle->heap_ref);
+		}
+		heap_add(bundle->heap, &bundle->heap_ref, rte_rdtsc());
+	}
+
+	return ret;
+}
+
+uint32_t bundle_cfg_length(struct bundle_cfg *cfg)
+{
+	uint32_t ret = 0;
+
+	for (uint32_t i = 0; i < cfg->n_stream_cfgs; ++i) {
+		ret += cfg->stream_cfgs[i]->n_bytes;
+	}
+
+	return ret;
+}
+
+uint32_t bundle_cfg_max_n_segments(struct bundle_cfg *cfg)
+{
+	uint32_t ret = 0;
+	uint32_t cur;
+
+	for (uint32_t i = 0; i < cfg->n_stream_cfgs; ++i) {
+		cur = stream_cfg_max_n_segments(cfg->stream_cfgs[i]);
+		ret = ret > cur? ret: cur;
+	}
+
+	return ret;
+}
diff --git a/VNFs/DPPD-PROX/genl4_bundle.h b/VNFs/DPPD-PROX/genl4_bundle.h
new file mode 100644
index 00000000..94ceed91
--- /dev/null
+++ b/VNFs/DPPD-PROX/genl4_bundle.h
@@ -0,0 +1,89 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _GENL4_BUNDLE_H_
+#define _GENL4_BUNDLE_H_
+
+#include "heap.h"
+#include "genl4_stream.h"
+#include "lconf.h"
+
+/* Configured once and used during packet generation. The structure
+   describes a single set of consecutive streams. When used at the
+   server side, it only contains a simple stream to represent a
+   service. */
+struct bundle_cfg {
+	struct host_set   clients;
+	uint32_t          n_stream_cfgs;
+	struct stream_cfg **stream_cfgs;
+};
+
+/* A bundle_ctx represents a an active stream between a client and a
+   server of servers. */
+struct bundle_ctx {
+	struct pkt_tuple        tuple;      /* Client IP/PORT generated once at bundle creation time, client PORT and server IP/PORT created when stream_idx++ */
+	struct heap_ref         heap_ref;   /* Back reference into heap */
+	struct heap             *heap;      /* timer management */
+
+	const struct bundle_cfg *cfg;       /* configuration time read only structure */
+
+	struct stream_ctx       ctx;        /* state management info for stream_cfg (reset when stream_idx++) */
+	uint32_t                stream_idx; /* iterate through cfg->straem_cfgs */
+};
+
+#define BUNDLE_CTX_UPCAST(r) ((struct bundle_ctx *)((uint8_t *)r - offsetof(struct bundle_ctx, heap_ref)))
+
+struct bundle_ctx_pool {
+	struct rte_hash   *hash;
+	struct bundle_ctx **hash_entries;
+	struct bundle_ctx **free_bundles;
+	struct bundle_ctx *bundles; /* Memory containing all communications */
+	uint32_t          *occur;
+	struct bundle_cfg *bundle_cfg;
+	uint32_t          n_occur;
+	uint32_t          seed;
+	uint32_t          n_free_bundles;
+	uint32_t          tot_bundles;
+};
+
+struct l4_stats {
+	uint64_t bundles_created;
+	uint64_t tcp_finished_no_retransmit;
+	uint64_t tcp_finished_retransmit;
+	uint64_t udp_finished;
+	uint64_t tcp_created;
+	uint64_t udp_created;
+	uint64_t tcp_expired;
+	uint64_t tcp_retransmits;
+	uint64_t udp_expired;
+};
+
+struct cdf;
+int bundle_ctx_pool_create(const char *name, uint32_t n_elems, struct bundle_ctx_pool *ret, uint32_t *occur, uint32_t n_occur, struct bundle_cfg *cfg, int socket_id);
+
+struct bundle_ctx *bundle_ctx_pool_get(struct bundle_ctx_pool *p);
+struct bundle_ctx *bundle_ctx_pool_get_w_cfg(struct bundle_ctx_pool *p);
+void bundle_ctx_pool_put(struct bundle_ctx_pool *p, struct bundle_ctx *bundle);
+
+void bundle_create_tuple(struct pkt_tuple *tp, const struct host_set *clients, const struct stream_cfg *stream_cfg, int rnd_ip, unsigned *seed);
+void bundle_init(struct bundle_ctx *bundle, struct heap *heap, enum l4gen_peer peer, unsigned *seed);
+void bundle_init_w_cfg(struct bundle_ctx *bundle, const struct bundle_cfg *cfg, struct heap *heap, enum l4gen_peer peer, unsigned *seed);
+void bundle_expire(struct bundle_ctx *bundle, struct bundle_ctx_pool *pool, struct l4_stats *l4_stats);
+int bundle_proc_data(struct bundle_ctx *bundle, struct rte_mbuf *mbuf, struct l4_meta *l4_meta, struct bundle_ctx_pool *pool, unsigned *seed, struct l4_stats *l4_stats);
+uint32_t bundle_cfg_length(struct bundle_cfg *cfg);
+uint32_t bundle_cfg_max_n_segments(struct bundle_cfg *cfg);
+
+#endif /* _GENL4_BUNDLE_H_ */
diff --git a/VNFs/DPPD-PROX/genl4_stream.h b/VNFs/DPPD-PROX/genl4_stream.h
new file mode 100644
index 00000000..b180765d
--- /dev/null
+++ b/VNFs/DPPD-PROX/genl4_stream.h
@@ -0,0 +1,201 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _GENL4_STREAM_H_
+#define _GENL4_STREAM_H_
+
+#include "prox_lua_types.h"
+#include "pkt_parser.h"
+#include "token_time.h"
+#include "quit.h"
+
+enum tcp_state {
+	CLOSED,
+	LISTEN,
+	SYN_SENT,
+	SYN_RECEIVED,
+	ESTABLISHED,
+	CLOSE_WAIT,
+	LAST_ACK,
+	FIN_WAIT,
+	TIME_WAIT
+};
+
+static const char *tcp_state_to_str(const enum tcp_state s)
+{
+	switch(s) {
+	case CLOSED:
+		return "CLOSED";
+	case LISTEN:
+		return "LISTEN";
+	case SYN_SENT:
+		return "SYN_SENT";
+	case SYN_RECEIVED:
+		return "SYN_RECEIVED";
+	case ESTABLISHED:
+		return "ESTABLISHED";
+	case CLOSE_WAIT:
+		return "CLOSE_WAIT";
+	case LAST_ACK:
+		return "LAST_ACK";
+	case FIN_WAIT:
+		return "FIN_WAIT";
+	case TIME_WAIT:
+		return "TIME_WAIT";
+	default:
+		return "INVALID_STATE";
+	}
+}
+
+#define STREAM_CTX_F_EXPIRED       0x01
+#define STREAM_CTX_F_NEW_DATA      0x02 /* Set on recv to track first ACK of data */
+#define STREAM_CTX_F_TCP_ENDED     0x04
+#define STREAM_CTX_F_TCP_GOT_SYN   0x08 /* Set only once when syn has been received */
+#define STREAM_CTX_F_TCP_GOT_FIN   0x10 /* Set only once when fin has been received */
+#define STREAM_CTX_F_MORE_DATA     0x20
+#define STREAM_CTX_F_LAST_RX_PKT_MADE_PROGRESS  0x40
+
+/* Run-time structure to management state information associated with current stream_cfg. */
+struct stream_ctx {
+	enum l4gen_peer         peer;
+	uint32_t                cur_action;
+	uint32_t                cur_pos[2];
+	enum tcp_state          tcp_state;
+	struct token_time       token_time;
+	struct token_time       token_time_other;
+	uint16_t                flags;
+	uint16_t                same_state;
+	uint32_t                next_seq;
+	uint32_t                ackd_seq;
+	uint32_t                recv_seq;
+	uint32_t                ackable_data_seq;
+	uint32_t                seq_first_byte;       /* seq number - seq_first_byte gives offset within content. */
+	uint32_t                other_seq_first_byte; /* seq number - seq_first_byte gives offset within content. */
+	uint32_t                other_mss;
+	uint64_t                sched_tsc;
+	uint32_t                retransmits;
+	const struct stream_cfg *stream_cfg;          /* Current active steam_cfg */
+	struct pkt_tuple        *tuple;
+};
+
+struct host_set {
+	uint32_t ip;
+	uint32_t ip_mask;
+	uint16_t port;
+	uint16_t port_mask;
+};
+
+struct stream_cfg {
+	struct peer_data   data[2];
+	struct host_set    servers; // Current implementation only allows mask == 0. (i.e. single server)
+	struct token_time_cfg tt_cfg[2]; // bytes per period rate
+	uint16_t           proto;
+	uint64_t           tsc_timeout;
+	uint64_t           tsc_timeout_time_wait;
+	uint32_t           n_actions;
+	uint32_t           n_pkts;
+	uint32_t           n_bytes;
+	int                (*proc)(struct stream_ctx *meta, struct rte_mbuf *mbuf, struct l4_meta *l4_meta, uint64_t *next_tsc);
+	int                (*is_ended)(struct stream_ctx *meta);
+	struct peer_action actions[0];
+};
+
+static void scale_for_jitter(uint64_t *to_scale)
+{
+	(*to_scale) *= 2;
+}
+
+static void reset_token_times(struct stream_ctx *ctx)
+{
+	const uint64_t now = rte_rdtsc();
+	const struct stream_cfg *cfg = ctx->stream_cfg;
+	enum l4gen_peer peer = ctx->peer;
+
+	token_time_init(&ctx->token_time, &cfg->tt_cfg[peer]);
+	token_time_reset_full(&ctx->token_time, now);
+
+	token_time_init(&ctx->token_time_other, &cfg->tt_cfg[!peer]);
+	scale_for_jitter(&ctx->token_time_other.cfg.bytes_max);
+	token_time_reset_full(&ctx->token_time_other, now);
+}
+
+static void stream_ctx_init(struct stream_ctx *ctx, enum l4gen_peer peer, struct stream_cfg *cfg, struct pkt_tuple *tuple)
+{
+	ctx->stream_cfg = cfg;
+	ctx->peer = peer;
+	ctx->tuple = tuple;
+
+	/* Server's initial state is different from client for
+	   TCP. For now, don't use a specific init function for
+	   TCP/UDP since there is not a lot of difference and to avoid
+	   an additional function pointer. */
+	ctx->tcp_state = PEER_CLIENT == peer? CLOSED : LISTEN;
+	ctx->other_mss = 536; /* default 536 as per RFC 879 */
+
+	reset_token_times(ctx);
+}
+
+static void stream_ctx_reset_move(struct stream_ctx *ctx, struct stream_cfg *cfg)
+{
+	enum l4gen_peer peer = ctx->peer;
+	struct pkt_tuple *tuple = ctx->tuple;
+
+	memset(ctx, 0, sizeof(*ctx));
+	stream_ctx_init(ctx, peer, cfg, tuple);
+}
+
+static int stream_cfg_calc_max_payload_len(struct stream_cfg *cfg, enum l4gen_peer peer)
+{
+	const uint32_t l4_hdr_len = cfg->proto == IPPROTO_UDP?
+		sizeof(struct udp_hdr) : sizeof(struct tcp_hdr);
+
+	return ETHER_MAX_LEN - ETHER_CRC_LEN - cfg->data[peer].hdr_len - l4_hdr_len;
+}
+
+static int stream_cfg_max_n_segments(struct stream_cfg *cfg)
+{
+	if (cfg->proto == IPPROTO_UDP)
+		return 1;
+
+	uint32_t ret = 1;
+	uint32_t cur;
+
+	const uint32_t mss = stream_cfg_calc_max_payload_len(cfg, PEER_CLIENT);
+
+	for (uint32_t i = 0; i < cfg->n_actions; ++i) {
+		cur = (cfg->actions[i].len + (mss - 1)) / mss;
+		ret = ret > cur? ret: cur;
+	}
+
+	return ret;
+}
+
+static int stream_cfg_verify_action(struct stream_cfg *cfg, struct peer_action *action)
+{
+	if (cfg->proto == IPPROTO_TCP)
+		return 0;
+
+	uint16_t max_payload_len = stream_cfg_calc_max_payload_len(cfg, action->peer);
+
+	PROX_PANIC(action->len > max_payload_len,
+		   "Action %zu has length %u while for the maximum action length for UDP connections is limited to %u\n",
+		   action - cfg->actions,
+		   action->len,
+		   max_payload_len);
+	return 0;
+}
+
+#endif /* _GENL4_STREAM_H_ */
diff --git a/VNFs/DPPD-PROX/genl4_stream_tcp.c b/VNFs/DPPD-PROX/genl4_stream_tcp.c
new file mode 100644
index 00000000..d05455b7
--- /dev/null
+++ b/VNFs/DPPD-PROX/genl4_stream_tcp.c
@@ -0,0 +1,965 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+#include <rte_ether.h>
+#include <rte_eth_ctrl.h>
+
+#include "log.h"
+#include "genl4_stream_tcp.h"
+#include "prox_assert.h"
+#include "mbuf_utils.h"
+
+static uint64_t tcp_retx_timeout(const struct stream_ctx *ctx)
+{
+	uint64_t delay = token_time_tsc_until_full(&ctx->token_time_other);
+
+	return delay + ctx->stream_cfg->tsc_timeout;
+}
+
+static uint64_t tcp_resched_timeout(const struct stream_ctx *ctx)
+{
+	uint64_t delay = token_time_tsc_until_full(&ctx->token_time);
+
+	return delay;
+}
+
+static void tcp_retx_timeout_start(struct stream_ctx *ctx, uint64_t *next_tsc)
+{
+	uint64_t now = rte_rdtsc();
+
+	*next_tsc = tcp_retx_timeout(ctx);
+	ctx->sched_tsc = now + *next_tsc;
+}
+
+static int tcp_retx_timeout_occured(const struct stream_ctx *ctx, uint64_t now)
+{
+	return ctx->sched_tsc < now;
+}
+
+static void tcp_retx_timeout_resume(const struct stream_ctx *ctx, uint64_t now, uint64_t *next_tsc)
+{
+	*next_tsc = ctx->sched_tsc - now;
+}
+
+static void tcp_set_retransmit(struct stream_ctx *ctx)
+{
+	ctx->retransmits++;
+}
+
+struct tcp_option {
+	uint8_t kind;
+	uint8_t len;
+} __attribute__((packed));
+
+void stream_tcp_create_rst(struct rte_mbuf *mbuf, struct l4_meta *l4_meta, struct pkt_tuple *tuple)
+{
+	struct tcp_hdr *tcp = (struct tcp_hdr *)l4_meta->l4_hdr;
+	struct ipv4_hdr *ip = ((struct ipv4_hdr *)tcp) - 1;
+
+	ip->src_addr = tuple->dst_addr;
+	ip->dst_addr = tuple->src_addr;
+
+	tcp->dst_port = tuple->src_port;
+	tcp->src_port = tuple->dst_port;
+
+	ip->total_length = rte_bswap16(sizeof(struct ipv4_hdr) + sizeof(struct tcp_hdr));
+	tcp->tcp_flags = TCP_RST_FLAG;
+	tcp->data_off = ((sizeof(struct tcp_hdr) / 4) << 4);
+	rte_pktmbuf_pkt_len(mbuf) = l4_meta->payload - rte_pktmbuf_mtod(mbuf, uint8_t *);
+	rte_pktmbuf_data_len(mbuf) = l4_meta->payload - rte_pktmbuf_mtod(mbuf, uint8_t *);
+}
+
+static void create_tcp_pkt(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint8_t tcp_flags, int data_beg, int data_len)
+{
+	uint8_t *pkt;
+
+	const struct peer_action *act = &ctx->stream_cfg->actions[ctx->cur_action];
+	const struct stream_cfg *stream_cfg = ctx->stream_cfg;
+
+	pkt = rte_pktmbuf_mtod(mbuf, uint8_t *);
+	rte_memcpy(pkt, stream_cfg->data[act->peer].hdr, stream_cfg->data[act->peer].hdr_len);
+
+	struct ipv4_hdr *l3_hdr = (struct ipv4_hdr*)&pkt[stream_cfg->data[act->peer].hdr_len - sizeof(struct ipv4_hdr)];
+	struct tcp_hdr *l4_hdr = (struct tcp_hdr *)&pkt[stream_cfg->data[act->peer].hdr_len];
+
+	l3_hdr->src_addr = ctx->tuple->dst_addr;
+	l3_hdr->dst_addr = ctx->tuple->src_addr;
+	l3_hdr->next_proto_id = IPPROTO_TCP;
+
+	l4_hdr->src_port = ctx->tuple->dst_port;
+	l4_hdr->dst_port = ctx->tuple->src_port;
+
+	uint32_t tcp_len = sizeof(struct tcp_hdr);
+	uint32_t tcp_payload_len = 0;
+	uint32_t seq_len = 0;
+	struct tcp_option *tcp_op;
+
+	if (tcp_flags & TCP_RST_FLAG) {
+		tcp_flags |= TCP_RST_FLAG;
+		seq_len = 1;
+	}
+	else if (tcp_flags & TCP_SYN_FLAG) {
+		tcp_flags |= TCP_SYN_FLAG;
+		/* Window scaling */
+
+		/* TODO: make options come from the stream. */
+		tcp_op = (struct tcp_option *)(l4_hdr + 1);
+
+		tcp_op->kind = 2;
+		tcp_op->len = 4;
+		*(uint16_t *)(tcp_op + 1) = rte_bswap16(1460); /* TODO: Save this in this_mss */
+
+		tcp_len += 4;
+		seq_len = 1;
+
+		ctx->seq_first_byte = ctx->ackd_seq + 1;
+	}
+	else if (tcp_flags & TCP_FIN_FLAG) {
+		tcp_flags |= TCP_FIN_FLAG;
+		seq_len = 1;
+	}
+
+	if (tcp_flags & TCP_ACK_FLAG) {
+		l4_hdr->recv_ack = rte_bswap32(ctx->recv_seq);
+		tcp_flags |= TCP_ACK_FLAG;
+	}
+	else
+		l4_hdr->recv_ack = 0;
+
+	uint16_t l4_payload_offset = stream_cfg->data[act->peer].hdr_len + tcp_len;
+
+	if (data_len) {
+		seq_len = data_len;
+		plogx_dbg("l4 payload offset = %d\n", l4_payload_offset);
+		rte_memcpy(pkt + l4_payload_offset, stream_cfg->data[act->peer].content + data_beg, data_len);
+	}
+
+	l4_hdr->sent_seq = rte_bswap32(ctx->next_seq);
+	l4_hdr->tcp_flags = tcp_flags; /* SYN */
+	l4_hdr->rx_win = rte_bswap16(0x3890); // TODO: make this come from stream (config)
+	//l4_hdr->cksum = ...;
+	l4_hdr->tcp_urp = 0;
+	l4_hdr->data_off = ((tcp_len / 4) << 4); /* Highest 4 bits are TCP header len in units of 32 bit words */
+
+	/* ctx->next_seq = ctx->ackd_seq + seq_len; */
+	ctx->next_seq += seq_len;
+
+	/* No payload after TCP header. */
+	rte_pktmbuf_pkt_len(mbuf)  = l4_payload_offset + data_len;
+	rte_pktmbuf_data_len(mbuf) = l4_payload_offset + data_len;
+
+	l3_hdr->total_length = rte_bswap16(sizeof(struct ipv4_hdr) + tcp_len + data_len);
+	plogdx_dbg(mbuf, NULL);
+
+	plogx_dbg("put tcp packet with flags: %s%s%s, (len = %d, seq = %d, ack =%d)\n",
+		  tcp_flags & TCP_SYN_FLAG? "SYN ":"",
+		  tcp_flags & TCP_ACK_FLAG? "ACK ":"",
+		  tcp_flags & TCP_FIN_FLAG? "FIN ":"",
+		  data_len, rte_bswap32(l4_hdr->sent_seq), rte_bswap32(l4_hdr->recv_ack));
+}
+
+/* Get the length of the reply associated for the next packet. Note
+   that the packet will come from the other peer. In case the next
+   packet belongs to the current peer (again), the reply length will
+   be that of an empty TCP packet (i.e. the ACK). */
+uint16_t stream_tcp_reply_len(struct stream_ctx *ctx)
+{
+	if (stream_tcp_is_ended(ctx))
+		return 0;
+	else if (ctx->tcp_state != ESTABLISHED) {
+		if (ctx->tcp_state == SYN_SENT || ctx->tcp_state == LISTEN) {
+			/* First packet received is a SYN packet. In
+			   the current implementation this packet
+			   contains the TCP option field to set the
+			   MSS. For this, add 4 bytes. */
+			return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(struct tcp_hdr) + 4;
+		}
+		return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+	}
+	else if (ctx->stream_cfg->actions[ctx->cur_action].peer == ctx->peer) {
+		/* The reply _could_ (due to races, still possibly
+		   receive an old ack) contain data. This means that
+		   in some cases, the prediction of the reply size
+		   will be an overestimate. */
+		uint32_t data_beg = ctx->next_seq - ctx->seq_first_byte;
+		const struct peer_action *act = &ctx->stream_cfg->actions[ctx->cur_action];
+
+		uint32_t remaining_len = act->len - (data_beg - act->beg);
+
+		if (remaining_len == 0) {
+			if (ctx->cur_action + 1 != ctx->stream_cfg->n_actions) {
+				if (ctx->stream_cfg->actions[ctx->cur_action + 1].peer == ctx->peer)
+					return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+				else {
+					uint32_t seq_beg = ctx->recv_seq - ctx->other_seq_first_byte;
+					uint32_t end = ctx->stream_cfg->actions[ctx->cur_action + 1].beg +
+						ctx->stream_cfg->actions[ctx->cur_action + 1].len;
+					uint32_t remaining = end - seq_beg;
+					uint16_t data_len = remaining > 1460? 1460: remaining;
+
+					return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(struct tcp_hdr) + data_len;
+				}
+			}
+			else {
+				return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+			}
+		}
+		else {
+			return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+		}
+	}
+	else if (ctx->stream_cfg->actions[ctx->cur_action].peer != ctx->peer) {
+		uint32_t seq_beg = ctx->recv_seq - ctx->other_seq_first_byte;
+		uint32_t end = ctx->stream_cfg->actions[ctx->cur_action].beg +
+			ctx->stream_cfg->actions[ctx->cur_action].len;
+		uint32_t remaining = end - seq_beg;
+		uint16_t data_len = remaining > 1460? 1460: remaining;
+
+		return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(struct tcp_hdr) + data_len;
+	}
+	else
+		return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+}
+
+static void stream_tcp_proc_in_order_data(struct stream_ctx *ctx, struct l4_meta *l4_meta, int *progress_seq)
+{
+	plogx_dbg("Got data with seq %d (as expected), with len %d\n", ctx->recv_seq, l4_meta->len);
+
+	if (!l4_meta->len)
+		return;
+
+	const struct peer_action *act = &ctx->stream_cfg->actions[ctx->cur_action];
+	enum l4gen_peer peer = act->peer;
+	/* Since we have received the expected sequence number, the start address will not exceed the cfg memory buffer. */
+	uint8_t *content = ctx->stream_cfg->data[peer].content;
+	uint32_t seq_beg = ctx->recv_seq - ctx->other_seq_first_byte;
+	uint32_t end = ctx->stream_cfg->actions[ctx->cur_action].beg + ctx->stream_cfg->actions[ctx->cur_action].len;
+	uint32_t remaining = end - seq_beg;
+
+	if (l4_meta->len > remaining) {
+		plogx_err("Provided data is too long:\n");
+		plogx_err("action.beg = %d, action.len = %d", act->beg, act->len);
+		plogx_err("tcp seq points at %d in action, l4_meta->len = %d\n", seq_beg, l4_meta->len);
+	}
+	else {
+		if (memcmp(content + seq_beg, l4_meta->payload, l4_meta->len) == 0) {
+			plogx_dbg("Good payload in %d: %u -> %u\n", ctx->cur_action, ctx->recv_seq, l4_meta->len);
+			ctx->recv_seq += l4_meta->len;
+			ctx->cur_pos[peer] += l4_meta->len;
+			/* Move forward only when this was the last piece of data within current action (i.e. end of received data == end of action data). */
+			if (seq_beg + l4_meta->len == act->beg + act->len) {
+				plogx_dbg("Got last piece in action %d\n", ctx->cur_action);
+				ctx->cur_action++;
+			}
+			else {
+				plogx_dbg("Got data from %d with len %d, but waiting for more (tot len = %d)!\n", seq_beg, l4_meta->len, act->len);
+			}
+			*progress_seq = 1;
+			ctx->flags |= STREAM_CTX_F_NEW_DATA;
+		}
+		else {
+			plogx_err("ackable = %d, ackd = %d\n", ctx->ackable_data_seq ,ctx->ackd_seq);
+			plogx_err("Bad payload action[%d]{.len = %d, .peer  = %s}\n", ctx->cur_action, act->len, peer == PEER_SERVER? "s" : "c");
+			plogx_err("   pkt payload len = %d, beginning at %u\n", l4_meta->len, seq_beg);
+			/* plogx_err("   Payload starts %zu bytes after beginning of l4_hdr\n", l4_meta->payload - l4_meta->l4_hdr); */
+
+			plogx_err("   payload[0-3] = %02x %02x %02x %02x\n",
+				  l4_meta->payload[0],
+				  l4_meta->payload[1],
+				  l4_meta->payload[2],
+				  l4_meta->payload[3]);
+			plogx_err("   expect[0-3]  = %02x %02x %02x %02x\n",
+				  content[seq_beg + 0],
+				  content[seq_beg + 1],
+				  content[seq_beg + 2],
+				  content[seq_beg + 3]);
+		}
+	}
+}
+
+static int stream_tcp_proc_in(struct stream_ctx *ctx, struct l4_meta *l4_meta)
+{
+	struct tcp_hdr *tcp = NULL;
+	int got_syn = 0;
+	int got_ack = 0;
+	int got_fin = 0;
+	int got_rst = 0;
+
+	tcp = (struct tcp_hdr *)l4_meta->l4_hdr;
+
+	got_syn = tcp->tcp_flags & TCP_SYN_FLAG;
+	got_ack = tcp->tcp_flags & TCP_ACK_FLAG;
+	got_fin = tcp->tcp_flags & TCP_FIN_FLAG;
+	got_rst = tcp->tcp_flags & TCP_RST_FLAG;
+	plogx_dbg("TCP, flags: %s%s%s, (len = %d, seq = %d, ack =%d)\n", got_syn? "SYN ":"", got_ack? "ACK ":"", got_fin? "FIN " : "", l4_meta->len, rte_bswap32(tcp->sent_seq), rte_bswap32(tcp->recv_ack));
+
+	if (got_syn)
+		ctx->flags |= STREAM_CTX_F_TCP_GOT_SYN;
+	if (got_fin)
+		ctx->flags |= STREAM_CTX_F_TCP_GOT_FIN;
+
+	int progress_ack = 0, progress_seq = 0;
+
+	/* RST => other side wants to terminate due to
+	   inconsitent state (example: delay of retransmit of
+	   last ACK while other side already closed the
+	   connection. The other side will accept the packet
+	   as a beginning of a new connection but there will
+	   be no SYN. ) */
+	if (got_rst) {
+		plogx_dbg("got rst\n");
+		ctx->flags |= STREAM_CTX_F_TCP_ENDED;
+		return -1;
+	}
+
+	if (got_ack) {
+		uint32_t ackd_seq = rte_bswap32(tcp->recv_ack);
+
+		if (ackd_seq > ctx->ackd_seq) {
+			plogx_dbg("Got ACK for outstanding data, from %d to %d\n", ctx->ackd_seq, ackd_seq);
+			ctx->ackd_seq = ackd_seq;
+			plogx_dbg("ackable data = %d\n", ctx->ackable_data_seq);
+			/* Ackable_data_seq set to byte after
+			   current action. */
+			if (ctx->ackable_data_seq == ctx->ackd_seq) {
+				/* Due to retransmit in
+				   combination with late acks,
+				   is is possible to ack
+				   future data. In this case,
+				   the assumption that data
+				   was lost is not true and
+				   the next seq is moved
+				   forward. */
+				if (ctx->next_seq < ctx->ackable_data_seq) {
+					ctx->next_seq = ctx->ackable_data_seq;
+				}
+
+				ctx->ackable_data_seq = 0;
+				const struct stream_cfg *stream_cfg = ctx->stream_cfg;
+				const struct peer_action *act = &stream_cfg->actions[ctx->cur_action];
+
+				ctx->cur_pos[act->peer] += act->len;
+				ctx->cur_action++;
+				plogx_dbg("Moving to next action %u\n", ctx->ackd_seq);
+			}
+			progress_ack = 1;
+		}
+		else {
+			plogx_dbg("Old data acked: acked = %d, ackable =%d\n", ackd_seq, ctx->ackd_seq);
+		}
+	}
+
+	uint32_t seq = rte_bswap32(tcp->sent_seq);
+
+	/* update recv_seq. */
+	if (got_syn) {
+		/* When a syn is received, immediately reset recv_seq based on seq from packet. */
+		ctx->recv_seq = seq + 1;
+		/* Syn packets have length 1, so the first real data will start after that. */
+		ctx->other_seq_first_byte = seq + 1;
+		progress_seq = 1;
+	}
+	else if (got_fin) {
+		if (ctx->recv_seq == seq) {
+			plogx_dbg("Got fin with correct seq\n");
+			ctx->recv_seq = seq + 1;
+			progress_seq = 1;
+		}
+		else {
+			plogx_dbg("Got fin but incorrect seq\n");
+		}
+	}
+	else {
+		/* Only expect in-order packets. */
+		if (ctx->recv_seq == seq) {
+			stream_tcp_proc_in_order_data(ctx, l4_meta, &progress_seq);
+		}
+		else if (ctx->recv_seq < seq) {
+			plogx_dbg("Future data received (got = %d, expected = %d), missing data! (data ignored)\n", seq, ctx->recv_seq);
+		}
+		else {
+			plogx_dbg("Old data received again (state = %s)\n", tcp_state_to_str(ctx->tcp_state));
+			plogx_dbg("expecting seq %d, got seq %d, len = %d\n",ctx->recv_seq, seq, l4_meta->len);
+			plogx_dbg("ackd_seq = %d, next_seq = %d, action = %d\n", ctx->ackd_seq, ctx->next_seq, ctx->cur_action);
+		}
+	}
+
+	/* parse options */
+	if (((tcp->data_off >> 4)*4) > sizeof(struct tcp_hdr)) {
+		struct tcp_option *tcp_op = (struct tcp_option *)(tcp + 1);
+		uint8_t *payload = (uint8_t *)tcp + ((tcp->data_off >> 4)*4);
+
+		do {
+			if (tcp_op->kind == 2 && tcp_op->len == 4) {
+				uint16_t mss = rte_bswap16(*(uint16_t *)(tcp_op + 1));
+				ctx->other_mss = mss;
+			}
+
+			tcp_op = (struct tcp_option *)(((uint8_t*)tcp_op) + tcp_op->len);
+		} while (((uint8_t*)tcp_op) < payload);
+	}
+
+	if (progress_ack || progress_seq) {
+		ctx->same_state = 0;
+		ctx->flags |= STREAM_CTX_F_LAST_RX_PKT_MADE_PROGRESS;
+	}
+	else {
+		ctx->flags &= ~STREAM_CTX_F_LAST_RX_PKT_MADE_PROGRESS;
+	}
+	return 0;
+}
+
+static int stream_tcp_proc_out_closed(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	/* create SYN packet in mbuf, return 0. goto SYN_SENT, set timeout */
+	ctx->tcp_state = SYN_SENT;
+
+	/* Initialize: */
+	ctx->next_seq = 99;
+	ctx->ackd_seq = 99;
+
+	create_tcp_pkt(ctx, mbuf, TCP_SYN_FLAG, 0, 0);
+	token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+	*next_tsc = tcp_retx_timeout(ctx);
+	return 0;
+}
+
+static int stream_tcp_proc_out_listen(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	if (!(ctx->flags & STREAM_CTX_F_TCP_GOT_SYN)) {
+		// TODO: keep connection around at end to catch retransmits from client
+		plogx_dbg("Got packet while listening without SYN (will send RST)\n");
+		pkt_tuple_debug(ctx->tuple);
+
+		ctx->flags |= STREAM_CTX_F_TCP_ENDED;
+		create_tcp_pkt(ctx, mbuf, TCP_RST_FLAG, 0, 0);
+		token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+		*next_tsc = tcp_retx_timeout(ctx);
+		return 0;
+	}
+
+	/* if syn received _now_, send ack + syn. goto SYN_RECEIVED. */
+	plogx_dbg("Got packet while listen\n");
+
+	ctx->next_seq = 200;
+	ctx->ackd_seq = 200;
+
+	ctx->tcp_state = SYN_RECEIVED;
+
+	create_tcp_pkt(ctx, mbuf, TCP_SYN_FLAG | TCP_ACK_FLAG, 0, 0);
+	token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+	*next_tsc = tcp_retx_timeout(ctx);
+	return 0;
+}
+
+static int stream_tcp_proc_out_syn_sent(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	if (ctx->ackd_seq < ctx->next_seq || !(ctx->flags & STREAM_CTX_F_TCP_GOT_SYN)) {
+		plogx_dbg("Retransmit SYN\n");
+		/* Did not get packet, send syn again and keep state (waiting for ACK). */
+		++ctx->same_state;
+		tcp_set_retransmit(ctx);
+		return stream_tcp_proc_out_closed(ctx, mbuf, next_tsc);
+	}
+
+	plogx_dbg("SYN_SENT and everything ACK'ed\n");
+	plogx_dbg("ackd_seq = %d, next_seq = %d\n", ctx->ackd_seq, ctx->next_seq);
+
+	/* If syn received for this stream, send ack and goto
+	   ESTABLISHED. If first peer is this peer to send actual
+	   data, schedule immediately. */
+
+	ctx->same_state = 0;
+	ctx->tcp_state = ESTABLISHED;
+
+	/* third packet of three-way handshake will also contain
+	   data. Don't send separate ACK yet. TODO: only send ACK if
+	   data has not yet been ACK'ed. */
+	if (ctx->stream_cfg->actions[ctx->cur_action].peer == ctx->peer) {
+		*next_tsc = tcp_resched_timeout(ctx);
+		plogx_dbg("immediately resched (%d)\n", ctx->cur_action);
+		return -1;
+	}
+	else {
+		create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+		token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+		*next_tsc = tcp_retx_timeout(ctx);
+	}
+	return 0;
+}
+
+static int stream_tcp_proc_out_syn_recv(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	if (ctx->ackd_seq == ctx->next_seq) {
+		/* Possible from server side with ctx->cur_action == 1
+		   if the current packet received had ACK for syn from
+		   server to client and also data completing the first
+		   action. */
+
+		ctx->same_state = 0;
+		ctx->tcp_state = ESTABLISHED;
+		if (ctx->stream_cfg->actions[ctx->cur_action].peer != ctx->peer) {
+			create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+			token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+			*next_tsc = tcp_retx_timeout(ctx);
+			return 0;
+		}
+		else {
+			/* While at this point, an ACK without data
+			   any could be sent by the server, it is not
+			   really required because the next pacekt
+			   after reschedule will also contain an ACK
+			   along with new data.
+
+			   In this implementation, if this is the
+			   case, the client is not only expecting an
+			   ACK, but also actual data. For this reason,
+			   the empty ACK packet should not be sent,
+			   otherwise the client will retransmit its
+			   data.
+			*/
+
+			/* create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0); */
+			/* token_time_take(&ctx->token_time, mbuf_wire_size(mbuf)); */
+			*next_tsc = tcp_resched_timeout(ctx);
+			return -1;
+		}
+	}
+	else {
+		/* Either this portion is executed due to a time-out
+		   or due to packet reception, the SYN that has been
+		   sent is not yet ACK'ed. So, retransmit the SYN/ACK. */
+		plogx_dbg("Retransmit SYN/ACK\n");
+		++ctx->same_state;
+		tcp_set_retransmit(ctx);
+		ctx->next_seq = ctx->ackd_seq;
+		create_tcp_pkt(ctx, mbuf, TCP_SYN_FLAG | TCP_ACK_FLAG, 0, 0);
+		token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+		*next_tsc = tcp_retx_timeout(ctx);
+		return 0;
+	}
+}
+
+static int stream_tcp_proc_out_estab_tx(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	const struct peer_action *act = &ctx->stream_cfg->actions[ctx->cur_action];
+
+	if (act->len == 0) {
+		plogx_dbg("Closing connection\n");
+		/* This would be an ACK combined with FIN. To
+		   send a separate ack. keep the state in
+		   established, put_ack and expire
+		   immediately*/
+		plogx_dbg("Moving to FIN_WAIT\n");
+		ctx->tcp_state = FIN_WAIT;
+		ctx->same_state = 0;
+		create_tcp_pkt(ctx, mbuf, TCP_FIN_FLAG | TCP_ACK_FLAG, 0, 0);
+		token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+		*next_tsc = tcp_retx_timeout(ctx);
+		return 0;
+	}
+	/* remaining_len2 will be zero, while in case of
+	   act->len == 0, the connection can be closed
+	   immediately. */
+
+	plogx_dbg("This peer to send!\n");
+	uint32_t outstanding_bytes = ctx->next_seq - ctx->ackd_seq;
+
+	uint32_t data_beg2 = ctx->next_seq - ctx->seq_first_byte;
+	uint32_t remaining_len2 = act->len - (data_beg2 - act->beg);
+
+	const uint32_t rx_win = 300000;
+	/* If still data to be sent and allowed by outstanding amount */
+	if (outstanding_bytes <= rx_win && remaining_len2) {
+		plogx_dbg("Outstanding bytes = %d, and remaining_len = %d, next_seq = %d\n", outstanding_bytes, remaining_len2, ctx->next_seq);
+
+		if (ctx->ackable_data_seq == 0) {
+			PROX_ASSERT(outstanding_bytes == 0);
+
+			ctx->ackable_data_seq = ctx->next_seq + act->len;
+		}
+		else
+			plogx_dbg("This will not be the first part of the data within an action\n");
+	}
+	/* still data yet to be acked || still data to be sent but blocked by RX win. */
+	else {
+		if (ctx->flags & STREAM_CTX_F_MORE_DATA) {
+			/* Don't send any packet. */
+			ctx->flags &= ~STREAM_CTX_F_MORE_DATA;
+			*next_tsc = tcp_retx_timeout(ctx);
+			ctx->sched_tsc = rte_rdtsc() + *next_tsc;
+			return -1;
+		}
+		else {
+			uint64_t now = rte_rdtsc();
+
+			if ((ctx->flags & STREAM_CTX_F_LAST_RX_PKT_MADE_PROGRESS) && token_time_tsc_until_full(&ctx->token_time_other) != 0) {
+				tcp_retx_timeout_start(ctx, next_tsc);
+				ctx->flags &= ~STREAM_CTX_F_LAST_RX_PKT_MADE_PROGRESS;
+				return -1;
+			}
+			/* This function might be called due to packet
+			   reception. In that case, cancel here and
+			   wait until the timeout really occurs before
+			   reTX. */
+			if (!tcp_retx_timeout_occured(ctx, now)) {
+				tcp_retx_timeout_resume(ctx, now, next_tsc);
+				return -1;
+			}
+
+			ctx->same_state++;
+			tcp_set_retransmit(ctx);
+			/* This possibly means that now retransmit is resumed half-way in the action. */
+			plogx_dbg("Retransmit: outstanding = %d\n", outstanding_bytes);
+			plogx_dbg("Assuming %d->%d lost\n", ctx->ackd_seq, ctx->next_seq);
+			ctx->next_seq = ctx->ackd_seq;
+			plogx_dbg("highest seq from other side = %d\n", ctx->recv_seq);
+		}
+		/* When STREAM_CTX_F_MORE_DATA is set, real timeouts
+		   can't occur. If this is needed, timeouts
+		   need to carry additional information. */
+	}
+
+	/* The following code will retransmit the same data if next_seq is not moved forward. */
+	uint32_t data_beg = ctx->next_seq - ctx->seq_first_byte;
+	uint32_t remaining_len = act->len - (data_beg - act->beg);
+	uint32_t data_len = remaining_len > ctx->other_mss? ctx->other_mss: remaining_len;
+	if (data_len == 0)
+		plogx_warn("data_len == 0\n");
+
+	if (remaining_len > ctx->other_mss)
+		ctx->flags |= STREAM_CTX_F_MORE_DATA;
+	else
+		ctx->flags &= ~STREAM_CTX_F_MORE_DATA;
+
+	create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, data_beg, data_len);
+	token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+	if (ctx->flags & STREAM_CTX_F_MORE_DATA)
+		*next_tsc = tcp_resched_timeout(ctx);
+	else
+		tcp_retx_timeout_start(ctx, next_tsc);
+
+	return 0;
+}
+
+static int stream_tcp_proc_out_estab_rx(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	if (ctx->flags & STREAM_CTX_F_TCP_GOT_FIN) {
+		plogx_dbg("Got fin!\n");
+		if (1) {
+			ctx->tcp_state = LAST_ACK;
+			create_tcp_pkt(ctx, mbuf, TCP_FIN_FLAG | TCP_ACK_FLAG, 0, 0);
+			token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+			*next_tsc = tcp_retx_timeout(ctx);
+			return 0;
+		}
+		else {
+			ctx->tcp_state = CLOSE_WAIT;
+			create_tcp_pkt(ctx, mbuf, TCP_FIN_FLAG, 0, 0);
+			token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+			*next_tsc = tcp_resched_timeout(ctx);
+			return 0;
+		}
+	}
+
+	if (ctx->flags & STREAM_CTX_F_NEW_DATA)
+		ctx->flags &= ~STREAM_CTX_F_NEW_DATA;
+	else {
+		ctx->same_state++;
+		tcp_set_retransmit(ctx);
+		plogx_dbg("state++ (ack = %d)\n", ctx->recv_seq);
+	}
+
+	create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+	token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+	*next_tsc = tcp_retx_timeout(ctx);
+	return 0;
+}
+
+static int stream_tcp_proc_out_estab(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	if (ctx->stream_cfg->actions[ctx->cur_action].peer == ctx->peer) {
+		return stream_tcp_proc_out_estab_tx(ctx, mbuf, next_tsc);
+	}
+	else {
+		return stream_tcp_proc_out_estab_rx(ctx, mbuf, next_tsc);
+	}
+}
+
+static int stream_tcp_proc_out_close_wait(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	/* CLOSE_WAIT is an intermediary stage that is only visited
+	   when the FIN is sent after ACK'ing the incoming FIN. In any
+	   case, it does not matter if there was a packet or not. */
+	ctx->tcp_state = LAST_ACK;
+	create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG | TCP_FIN_FLAG, 0, 0);
+	token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+	*next_tsc = tcp_retx_timeout(ctx);
+	return 0;
+}
+
+static int stream_tcp_proc_out_last_ack(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	if (ctx->ackd_seq == ctx->next_seq) {
+		plogx_dbg("Last ACK received\n");
+		ctx->flags |= STREAM_CTX_F_TCP_ENDED;
+		return -1;
+	}
+	else {
+		uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+		if (wait_tsc != 0) {
+			*next_tsc = wait_tsc;
+			return -1;
+		}
+		if (ctx->flags & STREAM_CTX_F_LAST_RX_PKT_MADE_PROGRESS) {
+			ctx->flags &= ~STREAM_CTX_F_LAST_RX_PKT_MADE_PROGRESS;
+			*next_tsc = tcp_retx_timeout(ctx);
+			return -1;
+		}
+
+		plogx_dbg("Retransmit!\n");
+		ctx->next_seq = ctx->ackd_seq;
+		ctx->same_state++;
+		tcp_set_retransmit(ctx);
+		create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG | TCP_FIN_FLAG, 0, 0);
+		token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+		*next_tsc = tcp_retx_timeout(ctx);
+		return 0;
+	}
+}
+
+static int stream_tcp_proc_out_fin_wait(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	if (ctx->ackd_seq == ctx->next_seq) {
+		if (ctx->flags & STREAM_CTX_F_TCP_GOT_FIN) {
+			ctx->same_state = 0;
+			ctx->tcp_state = TIME_WAIT;
+			ctx->sched_tsc = rte_rdtsc() + ctx->stream_cfg->tsc_timeout_time_wait;
+			plogx_dbg("from FIN_WAIT to TIME_WAIT\n");
+			create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+			token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+			*next_tsc = ctx->stream_cfg->tsc_timeout_time_wait;
+			return 0;
+		}
+		else {
+			/* FIN will still need to come */
+			*next_tsc = tcp_retx_timeout(ctx);
+			return -1;
+		}
+	}
+	else {
+		if (ctx->flags & STREAM_CTX_F_LAST_RX_PKT_MADE_PROGRESS) {
+			ctx->flags &= ~STREAM_CTX_F_LAST_RX_PKT_MADE_PROGRESS;
+			*next_tsc = tcp_retx_timeout(ctx);
+			return -1;
+		}
+
+		plogx_dbg("Retransmit!\n");
+		ctx->same_state++;
+		tcp_set_retransmit(ctx);
+		ctx->next_seq = ctx->ackd_seq;
+		create_tcp_pkt(ctx, mbuf, TCP_FIN_FLAG | TCP_ACK_FLAG, 0, 0);
+		token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+		*next_tsc = tcp_retx_timeout(ctx);
+		return 0;
+	}
+}
+
+static int stream_tcp_proc_out_time_wait(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	if (ctx->sched_tsc < rte_rdtsc()) {
+		plogx_dbg("TIME_WAIT expired! for %#x\n", ctx->tuple->dst_addr);
+		ctx->flags |= STREAM_CTX_F_TCP_ENDED;
+		return -1;
+	}
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	plogx_dbg("Got packet while in TIME_WAIT (pkt ACK reTX)\n");
+	ctx->sched_tsc = rte_rdtsc() + ctx->stream_cfg->tsc_timeout_time_wait;
+	create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+	token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+	*next_tsc = ctx->stream_cfg->tsc_timeout_time_wait;
+	return 0;
+}
+
+static int stream_tcp_proc_out(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint64_t *next_tsc)
+{
+	if (ctx->same_state == 10) {
+		ctx->flags |= STREAM_CTX_F_EXPIRED;
+		return -1;
+	}
+
+	switch (ctx->tcp_state) {
+	case CLOSED: /* Client initial state */
+		return stream_tcp_proc_out_closed(ctx, mbuf, next_tsc);
+	case LISTEN: /* Server starts in this state. */
+		return stream_tcp_proc_out_listen(ctx, mbuf, next_tsc);
+	case SYN_SENT:
+		return stream_tcp_proc_out_syn_sent(ctx, mbuf, next_tsc);
+	case SYN_RECEIVED:
+		return stream_tcp_proc_out_syn_recv(ctx, mbuf, next_tsc);
+	case ESTABLISHED:
+		return stream_tcp_proc_out_estab(ctx, mbuf, next_tsc);
+	case CLOSE_WAIT:
+		return stream_tcp_proc_out_close_wait(ctx, mbuf, next_tsc);
+	case LAST_ACK:
+		return stream_tcp_proc_out_last_ack(ctx, mbuf, next_tsc);
+	case FIN_WAIT:
+		return stream_tcp_proc_out_fin_wait(ctx, mbuf, next_tsc);
+	case TIME_WAIT:
+		return stream_tcp_proc_out_time_wait(ctx, mbuf, next_tsc);
+	}
+
+	return -1;
+}
+
+/* Return: zero: packet in mbuf is the reply, non-zero: data consumed,
+   nothing to send. The latter case might mean that the connection has
+   ended, or that a future event has been scheduled. l4_meta =>
+   mbuf contains packet to be processed. */
+int stream_tcp_proc(struct stream_ctx *ctx, struct rte_mbuf *mbuf, struct l4_meta *l4_meta, uint64_t *next_tsc)
+{
+	token_time_update(&ctx->token_time, rte_rdtsc());
+	token_time_update(&ctx->token_time_other, rte_rdtsc());
+	if (l4_meta) {
+		int ret;
+
+		token_time_take_clamp(&ctx->token_time_other, mbuf_wire_size(mbuf));
+		ret = stream_tcp_proc_in(ctx, l4_meta);
+		if (ret)
+			return ret;
+	}
+
+	return stream_tcp_proc_out(ctx, mbuf, next_tsc);
+}
+
+int stream_tcp_is_ended(struct stream_ctx *ctx)
+{
+	return ctx->flags & STREAM_CTX_F_TCP_ENDED;
+}
+
+static void add_pkt_bytes(uint32_t *n_pkts, uint32_t *n_bytes, uint32_t len)
+{
+	len = (len < 60? 60 : len) + 20 + ETHER_CRC_LEN;
+
+	(*n_pkts)++;
+	*n_bytes += len;
+}
+
+void stream_tcp_calc_len(struct stream_cfg *cfg, uint32_t *n_pkts, uint32_t *n_bytes)
+{
+	const uint32_t client_hdr_len = cfg->data[PEER_CLIENT].hdr_len;
+	const uint32_t server_hdr_len = cfg->data[PEER_SERVER].hdr_len;
+
+	*n_pkts = 0;
+	*n_bytes = 0;
+
+	/* Connection setup */
+	add_pkt_bytes(n_pkts, n_bytes, client_hdr_len + sizeof(struct tcp_hdr) + 4); /* SYN */
+	add_pkt_bytes(n_pkts, n_bytes, server_hdr_len + sizeof(struct tcp_hdr) + 4); /* SYN/ACK */
+	add_pkt_bytes(n_pkts, n_bytes, client_hdr_len + sizeof(struct tcp_hdr)); /* ACK */
+
+	for (uint32_t i = 0; i < cfg->n_actions; ++i) {
+		const uint32_t mss = 1440; /* TODO: should come from peer's own mss. */
+		uint32_t remaining = cfg->actions[i].len;
+		const uint32_t send_hdr_len = cfg->actions[i].peer == PEER_CLIENT? client_hdr_len : server_hdr_len;
+		const uint32_t reply_hdr_len = cfg->actions[i].peer == PEER_CLIENT? server_hdr_len : client_hdr_len;
+
+		if (remaining == 0)
+			break;
+
+		while (remaining) {
+			uint32_t seg = remaining > mss? mss: remaining;
+			add_pkt_bytes(n_pkts, n_bytes, send_hdr_len + sizeof(struct tcp_hdr) + seg);
+			remaining -= seg;
+		}
+
+		add_pkt_bytes(n_pkts, n_bytes, reply_hdr_len + sizeof(struct tcp_hdr));
+	}
+
+	/* Connection Tear-down */
+	enum l4gen_peer last_peer = cfg->actions[cfg->n_actions - 1].peer;
+
+	const uint32_t init_hdr_len = last_peer == PEER_CLIENT? client_hdr_len : server_hdr_len;
+	const uint32_t resp_hdr_len = last_peer == PEER_CLIENT? server_hdr_len : client_hdr_len;
+
+	add_pkt_bytes(n_pkts, n_bytes, init_hdr_len + sizeof(struct tcp_hdr)); /* FIN */
+	add_pkt_bytes(n_pkts, n_bytes, resp_hdr_len + sizeof(struct tcp_hdr)); /* FIN/ACK */
+	add_pkt_bytes(n_pkts, n_bytes, init_hdr_len + sizeof(struct tcp_hdr)); /* ACK */
+}
diff --git a/VNFs/DPPD-PROX/genl4_stream_tcp.h b/VNFs/DPPD-PROX/genl4_stream_tcp.h
new file mode 100644
index 00000000..f7b04d51
--- /dev/null
+++ b/VNFs/DPPD-PROX/genl4_stream_tcp.h
@@ -0,0 +1,29 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _GENL4_STREAM_TCP_H_
+#define _GENL4_STREAM_TCP_H_
+
+#include "genl4_stream.h"
+
+int stream_tcp_proc(struct stream_ctx *ctx, struct rte_mbuf *mbuf, struct l4_meta *l4_meta, uint64_t *next_tsc);
+int stream_tcp_is_ended(struct stream_ctx *ctx);
+uint16_t stream_tcp_reply_len(struct stream_ctx *ctx);
+void stream_tcp_calc_len(struct stream_cfg *cfg, uint32_t *n_pkts, uint32_t *n_bytes);
+
+void stream_tcp_create_rst(struct rte_mbuf *mbuf, struct l4_meta *l4_meta, struct pkt_tuple *tuple);
+
+#endif /* _GENL4_STREAM_TCP_H_ */
diff --git a/VNFs/DPPD-PROX/genl4_stream_udp.c b/VNFs/DPPD-PROX/genl4_stream_udp.c
new file mode 100644
index 00000000..3de2db09
--- /dev/null
+++ b/VNFs/DPPD-PROX/genl4_stream_udp.c
@@ -0,0 +1,165 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "genl4_stream_udp.h"
+#include "mbuf_utils.h"
+
+int stream_udp_is_ended(struct stream_ctx *ctx)
+{
+	return ctx->cur_action == ctx->stream_cfg->n_actions;
+}
+
+static void update_token_times(struct stream_ctx *ctx)
+{
+	uint64_t now = rte_rdtsc();
+
+	token_time_update(&ctx->token_time_other, now);
+	token_time_update(&ctx->token_time, now);
+}
+
+int stream_udp_proc(struct stream_ctx *ctx, struct rte_mbuf *mbuf, struct l4_meta *l4_meta, uint64_t *next_tsc)
+{
+	update_token_times(ctx);
+
+	if (l4_meta) {
+		enum l4gen_peer peer = ctx->stream_cfg->actions[ctx->cur_action].peer;
+		plogx_dbg("Consuming UDP data\n");
+		/* data should come from the other side */
+		if (peer == ctx->peer) {
+			plogx_err("Wrong peer\n");
+			return -1;
+		}
+		/* Fixed length data expected */
+		if (ctx->stream_cfg->actions[ctx->cur_action].len != l4_meta->len) {
+			plogx_dbg("unexpected UDP len (expected = %u, got = %u, action = %u)\n",
+				  ctx->stream_cfg->actions[ctx->cur_action].len,
+				  l4_meta->len,
+				  ctx->cur_action);
+
+			return -1;
+		}
+		/* With specific payload */
+		if (memcmp(ctx->stream_cfg->data[peer].content + ctx->stream_cfg->actions[ctx->cur_action].beg, l4_meta->payload, l4_meta->len) != 0) {
+			plogx_dbg("Bad payload at action_id %d, with peer = %d and pos = %d and len=%d\n", ctx->cur_action, peer, ctx->cur_pos[peer], l4_meta->len);
+			return -1;
+		}
+		ctx->cur_pos[peer] += l4_meta->len;
+		ctx->cur_action++;
+
+		if (stream_udp_is_ended(ctx))
+			return -1;
+
+		token_time_take(&ctx->token_time_other, mbuf_wire_size(mbuf));
+		/* Time before next packet is expected to
+		   arrive. Note, addition amount of time is accounted
+		   for due to rate limiting. */
+		uint64_t wait = token_time_tsc_until_full(&ctx->token_time_other);
+		*next_tsc = wait + ctx->stream_cfg->tsc_timeout;
+	}
+
+	if (ctx->stream_cfg->actions[ctx->cur_action].peer != ctx->peer) {
+		const char *other_peer_str = ctx->peer != PEER_SERVER? "server" : "client";
+
+		plogx_dbg("Expecting more UDP data from %s, will expire = %s\n", other_peer_str, l4_meta == NULL? "yes" : "no");
+		if (!l4_meta) {
+			ctx->flags |= STREAM_CTX_F_EXPIRED;
+		}
+		return -1;
+	}
+
+	uint64_t wait_tsc = token_time_tsc_until_full(&ctx->token_time);
+
+	if (wait_tsc != 0) {
+		plogx_dbg("Wait = %"PRIu64"\n", wait_tsc);
+		*next_tsc = wait_tsc;
+		return -1;
+	}
+
+	const struct stream_cfg *stream_cfg = ctx->stream_cfg;
+
+	uint8_t *pkt = rte_pktmbuf_mtod(mbuf, uint8_t *);
+	const struct peer_action *act = &stream_cfg->actions[ctx->cur_action];
+
+	uint16_t pkt_len = stream_cfg->data[act->peer].hdr_len + sizeof(struct udp_hdr) + act->len;
+
+	rte_pktmbuf_pkt_len(mbuf) = pkt_len;
+	rte_pktmbuf_data_len(mbuf) = pkt_len;
+	plogx_dbg("Creating UDP data (peer = %s, payload len = %u)\n", act->peer == PEER_CLIENT? "client" : "server", act->len);
+	/* Construct the packet. The template is used up to L4 header,
+	   a gap of sizeof(l4_hdr) is skipped, followed by the payload. */
+	rte_memcpy(pkt, stream_cfg->data[act->peer].hdr, stream_cfg->data[act->peer].hdr_len);
+	rte_memcpy(pkt + stream_cfg->data[act->peer].hdr_len + sizeof(struct udp_hdr), stream_cfg->data[act->peer].content + act->beg, act->len);
+
+	struct ipv4_hdr *l3_hdr = (struct ipv4_hdr*)&pkt[stream_cfg->data[act->peer].hdr_len - sizeof(struct ipv4_hdr)];
+	struct udp_hdr *l4_hdr = (struct udp_hdr*)&pkt[stream_cfg->data[act->peer].hdr_len];
+
+	l3_hdr->src_addr = ctx->tuple->dst_addr;
+	l3_hdr->dst_addr = ctx->tuple->src_addr;
+	l3_hdr->next_proto_id = IPPROTO_UDP;
+	l4_hdr->src_port = ctx->tuple->dst_port;
+	l4_hdr->dst_port = ctx->tuple->src_port;
+	l4_hdr->dgram_len = rte_bswap16(sizeof(struct udp_hdr) + act->len);
+	/* TODO: UDP checksum calculation */
+	l3_hdr->total_length = rte_bswap16(sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + act->len);
+	ctx->cur_pos[ctx->peer] += act->len;
+	ctx->cur_action++;
+
+	/* When the stream has ended, there is no need to schedule
+	   another timeout (which will be unscheduled at the end of
+	   the stream). */
+	if (stream_udp_is_ended(ctx))
+		return 0;
+
+	token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
+
+	/* Send next packet as soon as possible */
+	if (ctx->stream_cfg->actions[ctx->cur_action].peer == ctx->peer) {
+		*next_tsc = token_time_tsc_until_full(&ctx->token_time);
+	}
+	else {
+		uint64_t wait = token_time_tsc_until_full(&ctx->token_time_other);
+		*next_tsc = wait + ctx->stream_cfg->tsc_timeout;
+	}
+
+	return 0;
+}
+
+uint16_t stream_udp_reply_len(struct stream_ctx *ctx)
+{
+	if (stream_udp_is_ended(ctx))
+		return 0;
+	else if (ctx->stream_cfg->actions[ctx->cur_action].peer == ctx->peer)
+		return 0;
+	else
+		return ctx->stream_cfg->data[ctx->stream_cfg->actions[ctx->cur_action].peer].hdr_len + sizeof(struct udp_hdr) +
+			ctx->stream_cfg->actions[ctx->cur_action].len;
+}
+
+void stream_udp_calc_len(struct stream_cfg *cfg, uint32_t *n_pkts, uint32_t *n_bytes)
+{
+	const uint32_t client_hdr_len = cfg->data[PEER_CLIENT].hdr_len;
+	const uint32_t server_hdr_len = cfg->data[PEER_SERVER].hdr_len;
+
+	*n_pkts = 0;
+	*n_bytes = 0;
+
+	for (uint32_t i = 0; i < cfg->n_actions; ++i) {
+		const uint32_t send_hdr_len = cfg->actions[i].peer == PEER_CLIENT? client_hdr_len : server_hdr_len;
+		uint32_t len = send_hdr_len + sizeof(struct udp_hdr) + cfg->actions[i].len;
+		*n_bytes += (len < 60? 60 : len) + 24;
+		(*n_pkts)++;
+	}
+}
diff --git a/VNFs/DPPD-PROX/genl4_stream_udp.h b/VNFs/DPPD-PROX/genl4_stream_udp.h
new file mode 100644
index 00000000..c82d7951
--- /dev/null
+++ b/VNFs/DPPD-PROX/genl4_stream_udp.h
@@ -0,0 +1,28 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _GENL4_STREAM_UDP_H_
+#define _GENL4_STREAM_UDP_H_
+
+#include "genl4_stream.h"
+
+int stream_udp_is_ended(struct stream_ctx *ctx);
+
+int stream_udp_proc(struct stream_ctx *ctx, struct rte_mbuf *mbuf, struct l4_meta *l4_meta, uint64_t *next_tsc);
+uint16_t stream_udp_reply_len(struct stream_ctx *ctx);
+void stream_udp_calc_len(struct stream_cfg *cfg, uint32_t *n_pkts, uint32_t *n_bytes);
+
+#endif /* _GENL4_STREAM_UDP_H_ */
diff --git a/VNFs/DPPD-PROX/gre.h b/VNFs/DPPD-PROX/gre.h
new file mode 100644
index 00000000..23f68b62
--- /dev/null
+++ b/VNFs/DPPD-PROX/gre.h
@@ -0,0 +1,35 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _GRE_H_
+#define _GRE_H_
+
+#define GRE_CRC_PRESENT     0x10
+#define GRE_ROUTING_PRESENT 0x08
+#define GRE_KEY_PRESENT     0x04
+#define GRE_SEQNUM_PRESENT  0x02
+#define GRE_STRICT_ROUTE    0x01
+
+struct gre_hdr {
+	uint8_t   recur: 3;   /* recur */
+	uint8_t   bits: 5;    /* bits: Checksum, Routing, Key, Sequence Number, strict Route */
+	uint8_t   version: 3; /* Version: must be 0 */
+	uint8_t   flags: 5;   /* Flags: must be 0 */
+	uint16_t  type;       /* Protocol type */
+	uint32_t  gre_id;     /* Key ID */
+} __attribute__((__packed__));
+
+#endif /* _GRE_H_ */
diff --git a/VNFs/DPPD-PROX/handle_acl.c b/VNFs/DPPD-PROX/handle_acl.c
new file mode 100644
index 00000000..03949360
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_acl.c
@@ -0,0 +1,314 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mbuf.h>
+#include <rte_acl.h>
+#include <rte_ip.h>
+#include <rte_cycles.h>
+#include <rte_version.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+
+#include "log.h"
+#include "quit.h"
+#include "parse_utils.h"
+#include "ip_subnet.h"
+#include "handle_acl.h"
+#include "acl_field_def.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "lconf.h"
+#include "prefetch.h"
+#include "etypes.h"
+
+struct task_acl {
+	struct task_base base;
+	struct rte_acl_ctx *context;
+	const uint8_t *ptuples[64];
+
+	uint32_t       n_rules;
+	uint32_t       n_max_rules;
+
+	void           *field_defs;
+	size_t         field_defs_size;
+	uint32_t       n_field_defs;
+};
+
+static void set_tc(struct rte_mbuf *mbuf, uint32_t tc)
+{
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+	uint32_t subport, pipe, traffic_class, queue;
+	enum rte_meter_color color;
+
+	rte_sched_port_pkt_read_tree_path(mbuf, &subport, &pipe, &traffic_class, &queue);
+	color = rte_sched_port_pkt_read_color(mbuf);
+
+	rte_sched_port_pkt_write(mbuf, subport, pipe, tc, queue, color);
+#else
+	struct rte_sched_port_hierarchy *sched =
+		(struct rte_sched_port_hierarchy *) &mbuf->pkt.hash.sched;
+	sched->traffic_class = tc;
+#endif
+}
+
+static int handle_acl_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_acl *task = (struct task_acl *)tbase;
+	uint32_t results[64];
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+#ifdef PROX_PREFETCH_OFFSET
+	for (j = 0; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		PREFETCH0(mbufs[j]);
+	}
+	for (j = 1; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j - 1], void *));
+	}
+#endif
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		/* TODO: detect version_ihl != 0x45. Extract relevant
+		   fields of that packet and point ptuples[j] to the
+		   extracted verion. Note that this is very unlikely. */
+		task->ptuples[j] = rte_pktmbuf_mtod(mbufs[j], uint8_t *);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		task->ptuples[j] = rte_pktmbuf_mtod(mbufs[j], uint8_t *);
+	}
+#endif
+
+	rte_acl_classify(task->context, (const uint8_t **)task->ptuples, results, n_pkts, 1);
+
+	for (uint8_t i = 0; i < n_pkts; ++i) {
+		switch (results[i]) {
+		default:
+		case ACL_NOT_SET:
+		case ACL_DROP:
+			out[i] = OUT_DISCARD;
+			break;
+		case ACL_ALLOW:
+			out[i] = 0;
+		case ACL_RATE_LIMIT:
+			set_tc(mbufs[i], 3);
+			break;
+		};
+	}
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static void acl_msg(struct task_base *tbase, void **data, uint16_t n_msgs)
+{
+	struct task_acl *task = (struct task_acl *)tbase;
+	struct acl4_rule **new_rules = (struct acl4_rule **)data;
+	uint16_t i;
+
+	for (i = 0; i < n_msgs; ++i) {
+		if (task->n_rules == task->n_max_rules) {
+			plog_err("Failed to add %d rule%s (already at maximum number of rules (%d))",
+				n_msgs - i, (n_msgs - i)? "s" : "", task->n_max_rules);
+			break;
+		}
+
+		new_rules[i]->data.priority = ++task->n_rules;
+		rte_acl_add_rules(task->context, (struct rte_acl_rule*) new_rules[i], 1);
+	}
+
+	/* No need to rebuild if no rules have been added */
+	if (!i) {
+		return ;
+	}
+
+	struct rte_acl_config acl_build_param;
+	/* Perform builds */
+	acl_build_param.num_categories = 1;
+
+	acl_build_param.num_fields = task->n_field_defs;
+	rte_memcpy(&acl_build_param.defs, task->field_defs, task->field_defs_size);
+
+	int ret;
+	PROX_PANIC((ret = rte_acl_build(task->context, &acl_build_param)),
+		   "Failed to build ACL trie (%d)\n", ret);
+}
+
+static void init_task_acl(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_acl *task = (struct task_acl *)tbase;
+	int use_qinq = targ->flags & TASK_ARG_QINQ_ACL;
+
+	char name[PATH_MAX];
+	struct rte_acl_param acl_param;
+
+	/* Create ACL contexts */
+	snprintf(name, sizeof(name), "acl-%d-%d", targ->lconf->id, targ->task);
+
+	if (use_qinq) {
+		task->n_field_defs    = RTE_DIM(pkt_qinq_ipv4_udp_defs);
+		task->field_defs      = pkt_qinq_ipv4_udp_defs;
+		task->field_defs_size = sizeof(pkt_qinq_ipv4_udp_defs);
+	} else {
+		task->n_field_defs    = RTE_DIM(pkt_eth_ipv4_udp_defs);
+		task->field_defs      = pkt_eth_ipv4_udp_defs;
+		task->field_defs_size = sizeof(pkt_eth_ipv4_udp_defs);
+	}
+
+	acl_param.name = name;
+	acl_param.socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	acl_param.rule_size = RTE_ACL_RULE_SZ(task->n_field_defs);
+	acl_param.max_rule_num = targ->n_max_rules;
+
+	task->n_max_rules = targ->n_max_rules;
+	task->context = rte_acl_create(&acl_param);
+
+	PROX_PANIC(task->context == NULL, "Failed to create ACL context\n");
+	uint32_t free_rules = targ->n_max_rules;
+
+	PROX_PANIC(!strcmp(targ->rules, ""), "No rule specified for ACL\n");
+
+	int ret = lua_to_rules(prox_lua(), GLOBAL, targ->rules, task->context, &free_rules, use_qinq, targ->qinq_tag);
+	PROX_PANIC(ret, "Failed to read rules from config:\n%s\n", get_lua_to_errors());
+	task->n_rules = targ->n_max_rules - free_rules;
+
+	plog_info("Configured %d rules\n", task->n_rules);
+
+	if (task->n_rules) {
+		struct rte_acl_config acl_build_param;
+		/* Perform builds */
+		acl_build_param.num_categories = 1;
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
+		acl_build_param.max_size = 0;
+#endif
+
+		acl_build_param.num_fields = task->n_field_defs;
+		rte_memcpy(&acl_build_param.defs, task->field_defs, task->field_defs_size);
+
+		plog_info("Building trie structure\n");
+		PROX_PANIC(rte_acl_build(task->context, &acl_build_param),
+			   "Failed to build ACL trie\n");
+	}
+
+	targ->lconf->ctrl_timeout = freq_to_tsc(targ->ctrl_freq);
+	targ->lconf->ctrl_func_m[targ->task] = acl_msg;
+}
+
+int str_to_rule(struct acl4_rule *rule, char** fields, int n_rules, int use_qinq)
+{
+	uint32_t svlan, svlan_mask;
+	uint32_t cvlan, cvlan_mask;
+
+	uint32_t ip_proto, ip_proto_mask;
+
+	struct ip4_subnet ip_src;
+	struct ip4_subnet ip_dst;
+
+	uint32_t sport_lo, sport_hi;
+	uint32_t dport_lo, dport_hi;
+
+	enum acl_action class = ACL_NOT_SET;
+	char class_str[24];
+
+	PROX_PANIC(parse_int_mask(&svlan, &svlan_mask, fields[0]), "Error parsing svlan: %s\n", get_parse_err());
+	PROX_PANIC(parse_int_mask(&cvlan, &cvlan_mask, fields[1]), "Error parsing cvlan: %s\n", get_parse_err());
+	PROX_PANIC(parse_int_mask(&ip_proto, &ip_proto_mask, fields[2]), "Error parsing ip protocol: %s\n", get_parse_err());
+	PROX_PANIC(parse_ip4_cidr(&ip_src, fields[3]), "Error parsing source IP subnet: %s\n", get_parse_err());
+	PROX_PANIC(parse_ip4_cidr(&ip_dst, fields[4]), "Error parsing dest IP subnet: %s\n", get_parse_err());
+
+	PROX_PANIC(parse_range(&sport_lo, &sport_hi, fields[5]), "Error parsing source port range: %s\n", get_parse_err());
+	PROX_PANIC(parse_range(&dport_lo, &dport_hi, fields[6]), "Error parsing destination port range: %s\n", get_parse_err());
+
+	PROX_PANIC(parse_str(class_str, fields[7], sizeof(class_str)), "Error parsing action: %s\n", get_parse_err());
+
+	if (!strcmp(class_str, "drop")) {
+		class = ACL_DROP;
+	}
+	else if (!strcmp(class_str, "allow")) {
+		class = ACL_ALLOW;
+	}
+	else if (!strcmp(class_str, "rate limit")) {
+		class = ACL_RATE_LIMIT;
+	}
+	else {
+		plog_err("unknown class type: %s\n", class_str);
+	}
+
+	rule->data.userdata = class; /* allow, drop or ratelimit */
+	rule->data.category_mask = 1;
+	rule->data.priority = n_rules;
+
+	/* Configuration for rules is done in little-endian so no bswap is needed here.. */
+
+	rule->fields[0].value.u8 = ip_proto;
+	rule->fields[0].mask_range.u8 = ip_proto_mask;
+	rule->fields[1].value.u32 = ip_src.ip;
+	rule->fields[1].mask_range.u32 = ip_src.prefix;
+
+	rule->fields[2].value.u32 = ip_dst.ip;
+	rule->fields[2].mask_range.u32 = ip_dst.prefix;
+
+	rule->fields[3].value.u16 = sport_lo;
+	rule->fields[3].mask_range.u16 = sport_hi;
+
+	rule->fields[4].value.u16 = dport_lo;
+	rule->fields[4].mask_range.u16 = dport_hi;
+
+	if (use_qinq) {
+		rule->fields[5].value.u16 = rte_bswap16(ETYPE_8021ad);
+		rule->fields[5].mask_range.u16 = 0xffff;
+
+		/* To mask out the TCI and only keep the VID, the mask should be 0x0fff */
+		rule->fields[6].value.u16 = svlan;
+		rule->fields[6].mask_range.u16 = svlan_mask;
+
+		rule->fields[7].value.u16 = rte_bswap16(ETYPE_VLAN);
+		rule->fields[7].mask_range.u16 = 0xffff;
+
+		rule->fields[8].value.u16 = cvlan;
+		rule->fields[8].mask_range.u16 = cvlan_mask;
+	}
+	else {
+		/* Reuse first ethertype from vlan to check if packet is IPv4 packet */
+		rule->fields[5].value.u16 =  rte_bswap16(ETYPE_IPv4);
+		rule->fields[5].mask_range.u16 = 0xffff;
+
+		/* Other fields are ignored */
+		rule->fields[6].value.u16 = 0;
+		rule->fields[6].mask_range.u16 = 0;
+		rule->fields[7].value.u16 = 0;
+		rule->fields[7].mask_range.u16 = 0;
+		rule->fields[8].value.u16 = 0;
+		rule->fields[8].mask_range.u16 = 0;
+	}
+	return 0;
+}
+
+static struct task_init task_init_acl = {
+	.mode_str = "acl",
+	.init = init_task_acl,
+	.handle = handle_acl_bulk,
+	.size = sizeof(struct task_acl)
+};
+
+__attribute__((constructor)) static void reg_task_acl(void)
+{
+	reg_task(&task_init_acl);
+}
diff --git a/VNFs/DPPD-PROX/handle_acl.h b/VNFs/DPPD-PROX/handle_acl.h
new file mode 100644
index 00000000..8e4c140c
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_acl.h
@@ -0,0 +1,29 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_ACL_H_
+#define _HANDLE_ACL_H_
+
+#include <rte_acl.h>
+
+struct acl4_rule {
+	struct rte_acl_rule_data data;
+	struct rte_acl_field fields[9];
+};
+
+int str_to_rule(struct acl4_rule *rule, char** fields, int n_rules, int use_qinq);
+
+#endif /* _HANDLE_ACL_H_ */
diff --git a/VNFs/DPPD-PROX/handle_aggregator.c b/VNFs/DPPD-PROX/handle_aggregator.c
new file mode 100644
index 00000000..6434d759
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_aggregator.c
@@ -0,0 +1,229 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ip.h>
+#include <stdio.h>
+#include <string.h>
+#include <rte_version.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+
+#include "lconf.h"
+#include "task_base.h"
+#include "task_init.h"
+#include "defines.h"
+#include "prefetch.h"
+#include "qinq.h"
+#include "prox_cfg.h"
+#include "log.h"
+#include "quit.h"
+#include "prox_shared.h"
+#include "mbuf_utils.h"
+#include "handle_aggregator.h"
+
+#define PRIORITY_DHCP	(HIGH_PRIORITY)
+
+#define TASK_STATS_ADD_DROP_TX_FAIL_PRIO(stats, ntx, prio) do {    \
+	(stats)->drop_tx_fail_prio[prio] += ntx;           \
+	} while(0)
+#define TASK_STATS_ADD_TX_PRIO(stats, ntx, prio) do {    \
+                (stats)->rx_prio[prio] += ntx;           \
+        } while(0)                                      \
+
+static inline uint8_t detect_l4_priority(uint8_t l3_priority, const struct ipv4_hdr *ipv4_hdr)
+{
+	if (ipv4_hdr->next_proto_id == IPPROTO_UDP) {
+		const struct udp_hdr *udp = (const struct udp_hdr *)((const uint8_t *)ipv4_hdr + sizeof(struct ipv4_hdr));
+		if (((udp->src_port == 0x67) && (udp->dst_port == 0x68)) || ((udp->src_port == 0x68) && (udp->dst_port == 0x67))) {
+			return PRIORITY_DHCP;
+		}
+	}
+	return l3_priority;
+}
+
+static inline uint8_t detect_l3_priority(uint8_t l2_priority, const struct ipv4_hdr *ipv4_hdr)
+{
+	uint8_t dscp;
+	if ((ipv4_hdr->version_ihl >> 4) == 4) {
+	} else if ((ipv4_hdr->version_ihl >> 4) == 6) {
+		plog_warn("IPv6 Not implemented\n");
+		return OUT_DISCARD;
+	} else {
+		plog_warn("Unexpected IP version\n");
+		return OUT_DISCARD;
+	}
+	dscp = ipv4_hdr->type_of_service >> 2;
+	if (dscp)
+		return MAX_PRIORITIES - dscp - 1;
+	else
+		return l2_priority;
+}
+
+static inline uint8_t detect_l2_priority(const struct qinq_hdr *pqinq)
+{
+	if (pqinq->cvlan.eth_proto != ETYPE_VLAN) {
+		plog_warn("Unexpected proto in QinQ = %#04x\n", pqinq->cvlan.eth_proto);
+		return OUT_DISCARD;
+	}
+	uint16_t svlan_priority = ntohs(pqinq->svlan.vlan_tci >> 13);
+	uint16_t cvlan_priority = ntohs(pqinq->cvlan.vlan_tci >> 13);
+	if (svlan_priority)
+		return svlan_priority;
+	else
+		return cvlan_priority;
+}
+
+static inline void buffer_packet(struct task_aggregator *task, struct rte_mbuf *mbuf, uint8_t priority)
+{
+	struct task_base *tbase = (struct task_base *)task;
+
+	struct task_buffer *prio = &task->priority[priority];
+	if (prio->pkt_nb < BUFFER_LENGTH) {
+		prio->buffer[prio->pkt_pos] = mbuf;
+		prio->pkt_pos++;
+		if (prio->pkt_pos == BUFFER_LENGTH)
+			prio->pkt_pos = 0;
+		prio->pkt_nb++;
+	} else {
+		task->drop.buffer[task->drop.pkt_nb] = mbuf;
+		task->drop.pkt_nb++;
+		TASK_STATS_ADD_DROP_TX_FAIL_PRIO(&task->stats, 1, priority);
+	}
+}
+
+static inline void handle_aggregator(struct task_aggregator *task, struct rte_mbuf *mbuf)
+{
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	uint8_t priority = 0;
+	const struct qinq_hdr *pqinq;
+	const struct ipv4_hdr *ipv4_hdr;
+
+	const uint16_t eth_type = peth->ether_type;
+	switch (eth_type) {
+	case ETYPE_MPLSU:
+	case ETYPE_MPLSM:
+		break;
+	case ETYPE_8021ad:
+		pqinq = rte_pktmbuf_mtod(mbuf, const struct qinq_hdr *);
+		if ((priority = detect_l2_priority(pqinq)) == OUT_DISCARD)
+			break;
+		ipv4_hdr = (const struct ipv4_hdr *)(pqinq + 1);
+		if ((priority = detect_l3_priority(priority, ipv4_hdr)) == OUT_DISCARD)
+			break;
+		if ((priority = detect_l4_priority(priority, ipv4_hdr)) == OUT_DISCARD)
+			break;
+		break;
+	case ETYPE_VLAN:
+		break;
+	case ETYPE_IPv4:
+		ipv4_hdr = (const struct ipv4_hdr *)(peth+1);
+		if ((priority = detect_l3_priority(LOW_PRIORITY, ipv4_hdr)) == OUT_DISCARD)
+			break;
+		if ((priority = detect_l4_priority(priority, ipv4_hdr)) == OUT_DISCARD)
+			break;
+		break;
+	case ETYPE_IPv6:
+		break;
+	case ETYPE_ARP:
+		break;
+	default:
+		break;
+	}
+	if (priority == OUT_DISCARD) {
+		task->drop.buffer[task->drop.pkt_nb] = mbuf;
+		task->drop.pkt_nb++;
+		return;
+	}
+	buffer_packet(task, mbuf, priority);
+}
+
+static int handle_aggregator_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_aggregator *task = (struct task_aggregator *)tbase;
+
+	uint16_t j;
+	uint32_t drop_bytes = 0;
+#ifdef PROX_PREFETCH_OFFSET
+	for (j = 0; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		prefetch_nta(mbufs[j]);
+	}
+	for (j = 1; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		prefetch_nta(rte_pktmbuf_mtod(mbufs[j - 1], void *));
+	}
+#endif
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		prefetch_nta(mbufs[j + PREFETCH_OFFSET]);
+		prefetch_nta(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		handle_aggregator(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	prefetch_nta(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		handle_aggregator(task, mbufs[j]);
+	}
+#endif
+
+	for (int i = 0 ; i < task->drop.pkt_nb; i++) {
+		drop_bytes += mbuf_wire_size(task->drop.buffer[i]);
+		rte_pktmbuf_free(task->drop.buffer[i]);
+	}
+	TASK_STATS_ADD_DROP_TX_FAIL(&tbase->aux->stats, task->drop.pkt_nb);
+	TASK_STATS_ADD_DROP_BYTES(&tbase->aux->stats, drop_bytes);
+	task->drop.pkt_nb = 0;
+
+	for (int priority = 0; priority < MAX_PRIORITIES; priority++) {
+		struct task_buffer *prio = &task->priority[priority];
+		if (prio->pkt_nb) {
+			uint8_t n = 0;
+			if (prio->pkt_pos > prio->pkt_nb) {
+				struct rte_mbuf **buf = prio->buffer + prio->pkt_pos - prio->pkt_nb;
+				n = tbase->aux->tx_pkt_try(&task->base, buf, prio->pkt_nb);
+			} else {
+				struct rte_mbuf **buf = prio->buffer + BUFFER_LENGTH + prio->pkt_pos - prio->pkt_nb;
+				n = tbase->aux->tx_pkt_try(&task->base, buf, prio->pkt_nb - prio->pkt_pos);
+				if (n == (prio->pkt_nb - prio->pkt_pos))
+					n += tbase->aux->tx_pkt_try(&task->base, prio->buffer, prio->pkt_pos);
+			}
+			prio->pkt_nb -=n;
+			TASK_STATS_ADD_TX_PRIO(&task->stats, n, priority);
+			if (prio->pkt_nb)
+				break;
+		}
+	}
+	return 0;
+}
+
+static void init_task_aggregator(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_aggregator *task = (struct task_aggregator *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+}
+
+static struct task_init task_init_aggregator = {
+	.mode_str = "aggreg",
+	.init = init_task_aggregator,
+	.handle = handle_aggregator_bulk,
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS,
+	.size = sizeof(struct task_aggregator)
+};
+
+__attribute__((constructor)) static void reg_task_aggregator(void)
+{
+	reg_task(&task_init_aggregator);
+}
diff --git a/VNFs/DPPD-PROX/handle_aggregator.h b/VNFs/DPPD-PROX/handle_aggregator.h
new file mode 100644
index 00000000..1d5cd6c9
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_aggregator.h
@@ -0,0 +1,42 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_AGGREGATOR_H_
+#define _HANDLE_AGGREGATOR_H_
+
+#include "task_base.h"
+#include "task_init.h"
+#include "stats_prio_task.h"
+
+#define MAX_PRIORITIES  8
+#define LOW_PRIORITY  (MAX_PRIORITIES - 1)
+#define HIGH_PRIORITY  0
+#define BUFFER_LENGTH   256
+
+struct task_buffer {
+	struct rte_mbuf *buffer[BUFFER_LENGTH];
+	uint16_t pkt_pos;
+	uint16_t pkt_nb;
+};
+
+struct task_aggregator {
+	struct task_base    base;
+	struct prio_task_rt_stats stats;
+	struct task_buffer  priority[MAX_PRIORITIES];
+	struct task_buffer  drop;
+};
+
+#endif /* _HANDLE_AGGREGATOR_H_ */
diff --git a/VNFs/DPPD-PROX/handle_arp.c b/VNFs/DPPD-PROX/handle_arp.c
new file mode 100644
index 00000000..106e19e5
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_arp.c
@@ -0,0 +1,181 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "task_init.h"
+#include "task_base.h"
+#include "stats.h"
+#include "arp.h"
+#include "etypes.h"
+#include "quit.h"
+#include "log.h"
+#include "prox_port_cfg.h"
+#include "lconf.h"
+#include "cmd_parser.h"
+#include "handle_arp.h"
+
+struct task_arp {
+	struct task_base   base;
+	struct ether_addr  src_mac;
+	uint32_t           seed;
+	uint32_t           flags;
+	uint32_t           ip;
+	uint32_t           tmp_ip;
+	uint8_t	           arp_replies_ring;
+	uint8_t            other_pkts_ring;
+	uint8_t            send_arp_requests;
+};
+
+static void task_update_config(struct task_arp *task)
+{
+	if (unlikely(task->ip != task->tmp_ip))
+		task->ip = task->tmp_ip;
+}
+
+static void handle_arp(struct task_arp *task, struct ether_hdr_arp *hdr, struct ether_addr *s_addr)
+{
+	prepare_arp_reply(hdr, s_addr);
+	memcpy(hdr->ether_hdr.d_addr.addr_bytes, hdr->ether_hdr.s_addr.addr_bytes, 6);
+	memcpy(hdr->ether_hdr.s_addr.addr_bytes, s_addr, 6);
+}
+
+static int handle_arp_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct ether_hdr_arp *hdr;
+	struct task_arp *task = (struct task_arp *)tbase;
+	uint8_t out[MAX_PKT_BURST] = {0};
+	struct rte_mbuf *replies_mbufs[64] = {0}, *arp_pkt_mbufs[64] = {0};
+	int n_arp_reply_pkts = 0, n_other_pkts = 0,n_arp_pkts = 0;
+	struct ether_addr s_addr;
+
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr_arp *);
+		if (hdr->ether_hdr.ether_type == ETYPE_ARP) {
+			if (arp_is_gratuitous(hdr)) {
+				out[n_other_pkts] = OUT_DISCARD;
+				n_other_pkts++;
+				plog_info("Received gratuitous packet \n");
+			} else if (hdr->arp.oper == 0x100) {
+				if (task->arp_replies_ring != OUT_DISCARD) {
+					arp_pkt_mbufs[n_arp_pkts] = mbufs[j];
+					out[n_arp_pkts] = task->arp_replies_ring;
+					n_arp_pkts++;
+				} else if (task->ip == 0) {
+					create_mac(hdr, &s_addr);
+					handle_arp(task, hdr, &s_addr);
+					replies_mbufs[n_arp_reply_pkts] = mbufs[j];
+					out[n_arp_reply_pkts] = 0;
+					n_arp_reply_pkts++;
+				} else if (hdr->arp.data.tpa == task->ip) {
+					handle_arp(task, hdr, &task->src_mac);
+					replies_mbufs[n_arp_reply_pkts] = mbufs[j];
+					out[n_arp_reply_pkts] = 0;
+					n_arp_reply_pkts++;
+				} else {
+					out[n_other_pkts] = OUT_DISCARD;
+					mbufs[n_other_pkts] = mbufs[j];
+					n_other_pkts++;
+					plogx_dbg("Received ARP on unexpected IP %x, expecting %x\n", rte_be_to_cpu_32(hdr->arp.data.tpa), rte_be_to_cpu_32(task->ip));
+				}
+			} else if (hdr->arp.oper == 0x200) {
+				arp_pkt_mbufs[n_arp_pkts] = mbufs[j];
+				out[n_arp_pkts] = task->arp_replies_ring;
+				n_arp_pkts++;
+			} else {
+				out[n_other_pkts] = task->other_pkts_ring;
+				mbufs[n_other_pkts] = mbufs[j];
+				n_other_pkts++;
+			}
+		} else {
+			out[n_other_pkts] = task->other_pkts_ring;
+			mbufs[n_other_pkts] = mbufs[j];
+			n_other_pkts++;
+		}
+	}
+	int ret = 0;
+
+	if (n_arp_reply_pkts) {
+		ret+=task->base.aux->tx_pkt_hw(&task->base, replies_mbufs, n_arp_reply_pkts, out);
+	}
+	if (n_arp_pkts)
+		ret+= task->base.tx_pkt(&task->base, arp_pkt_mbufs, n_arp_pkts, out);
+	ret+= task->base.tx_pkt(&task->base, mbufs, n_other_pkts, out);
+	task_update_config(task);
+	return ret;
+}
+
+void task_arp_set_local_ip(struct task_base *tbase, uint32_t ip)
+{
+	struct task_arp *task = (struct task_arp *)tbase;
+	task->tmp_ip = ip;
+}
+
+static void init_task_arp(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_arp *task = (struct task_arp *)tbase;
+	struct task_args *dtarg;
+	struct core_task ct;
+	int port_found = 0;
+	task->other_pkts_ring = OUT_DISCARD;
+	task->arp_replies_ring = OUT_DISCARD;
+
+	task->seed = rte_rdtsc();
+	memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw_sw.tx_port_queue.port].eth_addr, sizeof(struct ether_addr));
+
+	task->ip = rte_cpu_to_be_32(targ->local_ipv4);
+	task->tmp_ip = task->ip;
+
+	PROX_PANIC(targ->nb_txrings > targ->core_task_set[0].n_elems, "%d txrings but %d elems in task_set\n", targ->nb_txrings, targ->core_task_set[0].n_elems);
+	for (uint32_t i = 0; i < targ->nb_txrings; ++i) {
+		ct = targ->core_task_set[0].core_task[i];
+		plog_info("ARP mode checking whether core %d task %d (i.e. ring %d) can handle arp\n", ct.core, ct.task, i);
+		dtarg = core_targ_get(ct.core, ct.task);
+		dtarg = find_reachable_task_sending_to_port(dtarg);
+		if ((dtarg != NULL) && (task_is_sub_mode(dtarg->lconf->id, dtarg->id, "l3"))) {
+			plog_info("ARP task sending ARP replies to core %d and task %d to handle them\n", ct.core, ct.task);
+			task->arp_replies_ring = i;
+		} else {
+			plog_info("ARP task sending (potentially other) packets to core %d and task %d\n", ct.core, ct.task);
+			task->other_pkts_ring = i;
+		}
+	}
+
+	if ((targ->nb_txports == 0) && (task->arp_replies_ring == OUT_DISCARD)) {
+		PROX_PANIC(1, "arp mode must have a tx_port or a ring able to a task in l3 reaching tx port");
+	}
+}
+
+// Reply to ARP requests with random MAC addresses
+static struct task_init task_init_cpe_arp = {
+	.mode_str = "arp",
+	.init = init_task_arp,
+	.handle = handle_arp_bulk,
+	.size = sizeof(struct task_arp)
+};
+
+// Reply to ARP requests with MAC address of the interface
+static struct task_init task_init_arp = {
+	.mode_str = "arp",
+	.sub_mode_str = "local",
+	.init = init_task_arp,
+	.handle = handle_arp_bulk,
+	.size = sizeof(struct task_arp)
+};
+
+__attribute__((constructor)) static void reg_task_arp(void)
+{
+	reg_task(&task_init_cpe_arp);
+	reg_task(&task_init_arp);
+}
diff --git a/VNFs/DPPD-PROX/handle_arp.h b/VNFs/DPPD-PROX/handle_arp.h
new file mode 100644
index 00000000..0cde22ae
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_arp.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_ARP_H_
+#define _HANDLE_ARP_H_
+
+struct task_base;
+void task_arp_set_local_ip(struct task_base *tbase, uint32_t ip);
+
+#endif /* _HANDLE_ARP_H_ */
diff --git a/VNFs/DPPD-PROX/handle_blockudp.c b/VNFs/DPPD-PROX/handle_blockudp.c
new file mode 100644
index 00000000..04c945e5
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_blockudp.c
@@ -0,0 +1,61 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ip.h>
+#include <rte_ether.h>
+
+#include "task_base.h"
+#include "task_init.h"
+#include "defines.h"
+#include "etypes.h"
+#include "prefetch.h"
+#include "log.h"
+
+struct task_blockudp {
+	struct task_base    base;
+};
+
+static int handle_blockudp_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_blockudp *task = (struct task_blockudp *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	for (j = 0; j < n_pkts; ++j) {
+		struct ether_hdr *peth = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *);
+		struct ipv4_hdr *pip = (struct ipv4_hdr *) (peth + 1);
+		out[j] = peth->ether_type == ETYPE_IPv4 && pip->next_proto_id == 0x11 ? OUT_DISCARD : 0;
+	}
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static void init_task_blockudp(__attribute__((unused)) struct task_base *tbase,
+			   __attribute__((unused)) struct task_args *targ)
+{
+}
+
+static struct task_init task_init_blockudp = {
+	.mode_str = "blockudp",
+	.init = init_task_blockudp,
+	.handle = handle_blockudp_bulk,
+	.size = sizeof(struct task_blockudp)
+};
+
+__attribute__((constructor)) static void reg_task_blockudp(void)
+{
+	reg_task(&task_init_blockudp);
+}
diff --git a/VNFs/DPPD-PROX/handle_cgnat.c b/VNFs/DPPD-PROX/handle_cgnat.c
new file mode 100644
index 00000000..6f176c08
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_cgnat.c
@@ -0,0 +1,987 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mbuf.h>
+#include <rte_hash.h>
+#include <rte_hash_crc.h>
+#include <rte_ether.h>
+#include <rte_ip.h>
+#include <rte_version.h>
+#include <rte_byteorder.h>
+#include <rte_lpm.h>
+
+#include "prox_lua_types.h"
+#include "prox_lua.h"
+#include "prox_malloc.h"
+#include "prox_cksum.h"
+#include "prefetch.h"
+#include "etypes.h"
+#include "log.h"
+#include "quit.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "lconf.h"
+#include "log.h"
+#include "prox_port_cfg.h"
+#include "hash_entry_types.h"
+#include "prox_shared.h"
+#include "handle_cgnat.h"
+
+#define ALL_32_BITS 0xffffffff
+#define BIT_16_TO_31 0xffff0000
+#define BIT_8_TO_15 0x0000ff00
+#define BIT_0_TO_15 0x0000ffff
+
+#define IP4(x) x & 0xff, (x >> 8) & 0xff, (x >> 16) & 0xff, x >> 24
+
+struct private_key {
+		uint32_t ip_addr;
+		uint16_t l4_port;
+} __attribute__((packed));
+
+struct private_flow_entry {
+	uint64_t flow_time;
+	uint32_t ip_addr;
+	uint32_t private_ip_idx;
+	uint16_t l4_port;
+};
+
+struct public_key {
+	uint32_t ip_addr;
+	uint16_t l4_port;
+} __attribute__((packed));
+
+struct public_entry {
+	uint32_t ip_addr;
+	uint16_t l4_port;
+	uint32_t private_ip_idx;
+	uint8_t dpdk_port;
+};
+
+struct public_ip_config_info {
+	uint32_t public_ip;
+	uint32_t max_port_count;
+	uint32_t port_free_count;
+	uint16_t *port_list;
+};
+
+struct private_ip_info {
+	uint64_t mac_aging_time;
+	uint32_t public_ip;
+	uint32_t public_ip_idx;
+	struct rte_ether *private_mac;
+	uint8_t static_entry;
+};
+
+struct task_nat {
+	struct task_base base;
+	struct rte_hash  *private_ip_hash;
+	struct rte_hash  *private_ip_port_hash;
+	struct rte_hash  *public_ip_port_hash;
+	struct private_flow_entry *private_flow_entries;
+	struct public_entry *public_entries;
+	struct next_hop *next_hops;
+	struct lcore_cfg *lconf;
+	struct rte_lpm *ipv4_lpm;
+	uint32_t total_free_port_count;
+	uint32_t number_free_rules;
+	int    private;
+	uint32_t public_ip_count;
+	uint32_t last_ip;
+	struct public_ip_config_info *public_ip_config_info;
+	struct private_ip_info *private_ip_info;
+	uint8_t runtime_flags;
+	int offload_crc;
+	uint64_t src_mac[PROX_MAX_PORTS];
+	uint64_t src_mac_from_dpdk_port[PROX_MAX_PORTS];
+	volatile int dump_public_hash;
+	volatile int dump_private_hash;
+};
+static __m128i proto_ipsrc_portsrc_mask;
+static __m128i proto_ipdst_portdst_mask;
+struct pkt_eth_ipv4 {
+	struct ether_hdr ether_hdr;
+	struct ipv4_hdr  ipv4_hdr;
+	struct udp_hdr  udp_hdr;
+} __attribute__((packed));
+
+void task_cgnat_dump_public_hash(struct task_nat *task)
+{
+	task->dump_public_hash = 1;
+}
+
+void task_cgnat_dump_private_hash(struct task_nat *task)
+{
+	task->dump_private_hash = 1;
+}
+
+static void set_l2(struct task_nat *task, struct rte_mbuf *mbuf, uint8_t nh_idx)
+{
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	*((uint64_t *)(&peth->d_addr)) = task->next_hops[nh_idx].mac_port_8bytes;
+	*((uint64_t *)(&peth->s_addr)) = task->src_mac[task->next_hops[nh_idx].mac_port.out_idx];
+}
+
+static uint8_t route_ipv4(struct task_nat *task, struct rte_mbuf *mbuf)
+{
+	struct pkt_eth_ipv4 *pkt = rte_pktmbuf_mtod(mbuf, struct pkt_eth_ipv4 *);
+	struct ipv4_hdr *ip = &pkt->ipv4_hdr;
+	struct ether_hdr *peth_out;
+	uint8_t tx_port;
+	uint32_t dst_ip;
+
+	switch(ip->next_proto_id) {
+	case IPPROTO_TCP:
+	case IPPROTO_UDP:
+		dst_ip = ip->dst_addr;
+		break;
+	default:
+		/* Routing for other protocols is not implemented */
+		plogx_info("Routing nit implemented for this protocol\n");
+		return OUT_DISCARD;
+	}
+
+#if RTE_VERSION >= RTE_VERSION_NUM(16,4,0,1)
+	uint32_t next_hop_index;
+#else
+	uint8_t next_hop_index;
+#endif
+	if (unlikely(rte_lpm_lookup(task->ipv4_lpm, rte_bswap32(dst_ip), &next_hop_index) != 0)) {
+		uint8_t* dst_ipp = (uint8_t*)&dst_ip;
+		plog_warn("lpm_lookup failed for ip %d.%d.%d.%d: rc = %d\n",
+			dst_ipp[0], dst_ipp[1], dst_ipp[2], dst_ipp[3], -ENOENT);
+		return OUT_DISCARD;
+	}
+
+	tx_port = task->next_hops[next_hop_index].mac_port.out_idx;
+	set_l2(task, mbuf, next_hop_index);
+	return tx_port;
+}
+
+static int release_ip(struct task_nat *task, uint32_t *ip_addr, int public_ip_idx)
+{
+	return 0;
+}
+
+static int release_port(struct task_nat *task, uint32_t public_ip_idx, uint16_t udp_src_port)
+{
+	struct public_ip_config_info *public_ip_config_info = &task->public_ip_config_info[public_ip_idx];
+	if (public_ip_config_info->max_port_count > public_ip_config_info->port_free_count) {
+		public_ip_config_info->port_list[public_ip_config_info->port_free_count] = udp_src_port;
+		public_ip_config_info->port_free_count++;
+		task->total_free_port_count ++;
+		plogx_dbg("Now %d free ports for IP %d.%d.%d.%d\n", public_ip_config_info->port_free_count, IP4(public_ip_config_info->public_ip));
+	} else {
+		plogx_err("Unable to release port for ip index %d: max_port_count = %d, port_free_count = %d", public_ip_idx, public_ip_config_info->max_port_count, public_ip_config_info->port_free_count);
+		return -1;
+	}
+	return 0;
+}
+
+static int get_new_ip(struct task_nat *task, uint32_t *ip_addr)
+{
+	struct public_ip_config_info *ip_info;
+	if (++task->last_ip >= task->public_ip_count)
+		task->last_ip = 0;
+	for (uint32_t ip_idx = task->last_ip; ip_idx < task->public_ip_count; ip_idx++) {
+		ip_info = &task->public_ip_config_info[ip_idx];
+		plogx_dbg("Checking public IP index %d\n", ip_idx);
+		if ((ip_info->port_free_count) > 0) {
+			plogx_dbg("Public IP index %d (IP %d.%d.%d.%d) has %d free ports\n", ip_idx, IP4(ip_info->public_ip), ip_info->port_free_count);
+			*ip_addr = ip_info->public_ip;
+			task->last_ip = ip_idx;
+			return ip_idx;
+		}
+	}
+	for (uint32_t ip_idx = 0; ip_idx < task->last_ip; ip_idx++) {
+		ip_info = &task->public_ip_config_info[ip_idx];
+		if ((ip_info->port_free_count) > 0) {
+			plogx_dbg("Public IP index %d (IP %d.%d.%d.%d) has %d free ports\n", ip_idx, IP4(ip_info->public_ip), ip_info->port_free_count);
+			*ip_addr = ip_info->public_ip;
+			task->last_ip = ip_idx;
+			return ip_idx;
+		}
+	}
+	return -1;
+}
+
+static int get_new_port(struct task_nat *task, uint32_t ip_idx, uint16_t *udp_src_port)
+{
+	int ret;
+	struct public_ip_config_info *public_ip_config_info = &task->public_ip_config_info[ip_idx];
+	if (public_ip_config_info->port_free_count > 0) {
+		public_ip_config_info->port_free_count--;
+		*udp_src_port = public_ip_config_info->port_list[public_ip_config_info->port_free_count];
+		task->total_free_port_count --;
+		plogx_info("Now %d free ports for IP %d.%d.%d.%d\n", public_ip_config_info->port_free_count, IP4(public_ip_config_info->public_ip));
+	} else
+		return -1;
+	return 0;
+}
+
+static int delete_port_entry(struct task_nat *task, uint8_t proto, uint32_t private_ip, uint16_t private_port,  uint32_t public_ip, uint16_t public_port, int public_ip_idx)
+{
+	int ret;
+	struct private_key private_key;
+	struct public_key public_key;
+//	private_key.proto = proto;
+	private_key.ip_addr = private_ip;
+	private_key.l4_port = private_port;
+	ret = rte_hash_del_key(task->private_ip_port_hash, (const void *)&private_key);
+	if (ret < 0) {
+		plogx_info("Unable delete key ip %d.%d.%d.%d / port %x in private ip_port hash\n", IP4(private_ip), private_port);
+		return -1;
+	} else {
+		plogx_dbg("Deleted ip %d.%d.%d.%d / port %x from private ip_port hash\n", IP4(private_ip), private_port);
+	}
+	public_key.ip_addr = public_ip;
+	public_key.l4_port = public_port;
+	ret = rte_hash_del_key(task->public_ip_port_hash, (const void *)&public_key);
+	if (ret < 0) {
+		plogx_info("Unable delete key ip %d.%d.%d.%d / port %x in public ip_port hash\n", IP4(public_ip), public_port);
+		return -1;
+	} else {
+		plogx_dbg("Deleted ip %d.%d.%d.%d / port %x (hash index %d) from public ip_port hash\n", IP4(public_ip), public_port, ret);
+		release_port(task, public_ip_idx, public_port);
+	}
+	return 0;
+}
+
+static int add_new_port_entry(struct task_nat *task, uint8_t proto, int public_ip_idx, int private_ip_idx, uint32_t private_src_ip, uint16_t private_udp_port, struct rte_mbuf *mbuf, uint64_t tsc, uint16_t *port)
+{
+	struct private_key private_key;
+	struct public_key public_key;
+	uint32_t ip = task->public_ip_config_info[public_ip_idx].public_ip;
+	int ret;
+	if (get_new_port(task, public_ip_idx, port) < 0) {
+		plogx_info("Unable to find new port for IP %x\n", private_src_ip);
+		return -1;
+	}
+//	private_key.proto = proto;
+	private_key.ip_addr = private_src_ip;
+	private_key.l4_port = private_udp_port;
+	ret = rte_hash_add_key(task->private_ip_port_hash, (const void *)&private_key);
+	if (ret < 0) {
+		plogx_info("Unable add ip %d.%d.%d.%d / port %x in private ip_port hash\n", IP4(private_src_ip), private_udp_port);
+		release_port(task, public_ip_idx, *port);
+		return -1;
+	} else if (task->private_flow_entries[ret].ip_addr) {
+		plogx_dbg("Race condition properly handled: port alrerady added\n");
+		release_port(task, public_ip_idx, *port);
+		return ret;
+	} else {
+		plogx_dbg("Added ip %d.%d.%d.%d / port %x in private ip_port hash => %d.%d.%d.%d / %d - index = %d\n", IP4(private_src_ip), private_udp_port, IP4(ip), *port, ret);
+	}
+	task->private_flow_entries[ret].ip_addr = ip;
+	task->private_flow_entries[ret].l4_port = *port;
+	task->private_flow_entries[ret].flow_time = tsc;
+       	task->private_flow_entries[ret].private_ip_idx = private_ip_idx;
+
+	public_key.ip_addr = ip;
+	public_key.l4_port = *port;
+	plogx_dbg("Adding key ip %d.%d.%d.%d / port %x in public ip_port hash\n", IP4(ip), *port);
+	ret = rte_hash_add_key(task->public_ip_port_hash, (const void *)&public_key);
+	if (ret < 0) {
+		plogx_info("Unable add ip %x / port %x in public ip_port hash\n", ip, *port);
+		// TODO: remove from private_ip_port_hash
+		release_port(task, public_ip_idx, *port);
+		return -1;
+	} else {
+		plogx_dbg("Added ip %d.%d.%d.%d / port %x in public ip_port hash\n", IP4(ip), *port);
+	}
+	task->public_entries[ret].ip_addr = private_src_ip;
+	task->public_entries[ret].l4_port = private_udp_port;
+	task->public_entries[ret].dpdk_port = mbuf->port;
+       	task->public_entries[ret].private_ip_idx = private_ip_idx;
+	return ret;
+}
+
+static int handle_nat_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+        struct task_nat *task = (struct task_nat *)tbase;
+        uint8_t out[MAX_PKT_BURST];
+        uint16_t j;
+	uint32_t *ip_addr, public_ip, private_ip;
+	uint16_t *udp_src_port, port, private_port, public_port;
+	struct pkt_eth_ipv4 *pkt[MAX_PKT_BURST];
+	int ret, private_ip_idx, public_ip_idx = -1, port_idx;
+	int new_entry = 0;
+	uint8_t proto;
+	uint64_t tsc = rte_rdtsc();
+	void *keys[MAX_PKT_BURST];
+	int32_t positions[MAX_PKT_BURST];
+	int map[MAX_PKT_BURST] = {0};
+
+	if (unlikely(task->dump_public_hash)) {
+		const struct public_key *next_key;
+		void *next_data;
+		uint32_t iter = 0;
+		int i = 0;
+		int ret;
+
+		while ((ret = rte_hash_iterate(task->public_ip_port_hash, (const void **)&next_key, &next_data, &iter)) >= 0) {
+			plogx_info("Public entry %d (index %d): ip = %d.%d.%d.%d, port = %d ===> private entry: ip = %d.%d.%d.%d, port = %d\n", i++, ret, IP4(next_key->ip_addr), next_key->l4_port, IP4(task->public_entries[ret].ip_addr),task->public_entries[ret].l4_port);
+		}
+		task->dump_public_hash = 0;
+	}
+	if (unlikely(task->dump_private_hash)) {
+		const struct private_key *next_key;
+		void *next_data;
+		uint32_t iter = 0;
+		int i = 0;
+		int ret;
+
+		while ((ret = rte_hash_iterate(task->private_ip_port_hash, (const void **)&next_key, &next_data, &iter)) >= 0) {
+			plogx_info("Private entry %d (index %d): ip = %d.%d.%d.%d, port = %d ===> public entry: ip = %d.%d.%d.%d, port = %d\n", i++, ret, IP4(next_key->ip_addr), next_key->l4_port, IP4(task->private_flow_entries[ret].ip_addr),task->private_flow_entries[ret].l4_port);
+		}
+		task->dump_private_hash = 0;
+	}
+
+       	for (j = 0; j < n_pkts; ++j) {
+               	PREFETCH0(mbufs[j]);
+	}
+       	for (j = 0; j < n_pkts; ++j) {
+		pkt[j] = rte_pktmbuf_mtod(mbufs[j], struct pkt_eth_ipv4 *);
+               	PREFETCH0(pkt[j]);
+	}
+	if (task->private) {
+       		struct private_key key[MAX_PKT_BURST];
+        	for (j = 0; j < n_pkts; ++j) {
+			/* Currently, only support eth/ipv4 packets */
+			if (pkt[j]->ether_hdr.ether_type != ETYPE_IPv4) {
+				plogx_info("Currently, only support eth/ipv4 packets\n");
+				out[j] = OUT_DISCARD;
+				keys[j] = (void *)NULL;
+				continue;
+			}
+       			key[j].ip_addr = pkt[j]->ipv4_hdr.src_addr;
+			key[j].l4_port = pkt[j]->udp_hdr.src_port;
+			keys[j] = &key[j];
+		}
+		ret = rte_hash_lookup_bulk(task->private_ip_port_hash, (const void **)&keys, n_pkts, positions);
+		if (unlikely(ret < 0)) {
+			plogx_info("lookup_bulk failed in private_ip_port_hash\n");
+			return -1;
+		}
+		int n_new_mapping = 0;
+        	for (j = 0; j < n_pkts; ++j) {
+			port_idx = positions[j];
+			if (unlikely(port_idx < 0)) {
+				plogx_dbg("ip %d.%d.%d.%d / port %x not found in private ip/port hash\n", IP4(pkt[j]->ipv4_hdr.src_addr), pkt[j]->udp_hdr.src_port);
+				map[n_new_mapping] = j;
+				keys[n_new_mapping++] = (void *)&(pkt[j]->ipv4_hdr.src_addr);
+			} else {
+				ip_addr = &(pkt[j]->ipv4_hdr.src_addr);
+				udp_src_port = &(pkt[j]->udp_hdr.src_port);
+				plogx_dbg("ip/port %d.%d.%d.%d / %x found in private ip/port hash\n", IP4(pkt[j]->ipv4_hdr.src_addr), pkt[j]->udp_hdr.src_port);
+       				*ip_addr = task->private_flow_entries[port_idx].ip_addr;
+       				*udp_src_port = task->private_flow_entries[port_idx].l4_port;
+				uint64_t flow_time = task->private_flow_entries[port_idx].flow_time;
+				if (flow_time + tsc_hz < tsc) {
+					task->private_flow_entries[port_idx].flow_time = tsc;
+				}
+				private_ip_idx = task->private_flow_entries[port_idx].private_ip_idx;
+				if (task->private_ip_info[private_ip_idx].mac_aging_time + tsc_hz < tsc)
+					task->private_ip_info[private_ip_idx].mac_aging_time = tsc;
+				prox_ip_udp_cksum(mbufs[j], &pkt[j]->ipv4_hdr, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+				out[j] =  route_ipv4(task, mbufs[j]);
+			}
+		}
+
+		if (n_new_mapping) {
+			// Find whether at least IP is already known...
+			ret = rte_hash_lookup_bulk(task->private_ip_hash, (const void **)&keys, n_new_mapping, positions);
+			if (unlikely(ret < 0)) {
+				plogx_info("lookup_bulk failed for private_ip_hash\n");
+				for (int k = 0; k < n_new_mapping; ++k) {
+					j = map[k];
+					out[j] = OUT_DISCARD;
+				}
+				n_new_mapping = 0;
+			}
+       			for (int k = 0; k < n_new_mapping; ++k) {
+				private_ip_idx = positions[k];
+				j = map[k];
+				ip_addr = &(pkt[j]->ipv4_hdr.src_addr);
+				proto = pkt[j]->ipv4_hdr.next_proto_id;
+				udp_src_port = &(pkt[j]->udp_hdr.src_port);
+				int new_ip_entry = 0;
+
+				if (unlikely(private_ip_idx < 0)) {
+					private_ip = *ip_addr;
+					private_port = *udp_src_port;
+					plogx_dbg("Did not find private ip %d.%d.%d.%d in ip hash table, looking for new public ip\n", IP4(*ip_addr));
+					// IP not found, need to get a new IP/port mapping
+					public_ip_idx = get_new_ip(task, &public_ip);
+					if (public_ip_idx < 0) {
+						plogx_info("Unable to find new ip/port\n");
+						out[j] = OUT_DISCARD;
+						continue;
+					} else {
+						plogx_dbg("found new public ip %d.%d.%d.%d at public IP index %d\n", IP4(public_ip), public_ip_idx);
+					}
+					private_ip_idx = rte_hash_add_key(task->private_ip_hash, (const void *)ip_addr);
+					// The key might be added multiple time - in case the same key was present in the bulk_lookup multiple times
+					// As such this is not an issue - the add_key will returns the index as for a new key
+					// This scenario should not happen often in real time use case
+					// as a for a new flow (flow renewal), probably only one packet will be sent (e.g. TCP SYN)
+					if (private_ip_idx < 0) {
+						release_ip(task, &public_ip, public_ip_idx);
+						plogx_info("Unable add ip %d.%d.%d.%d in private ip hash\n", IP4(*ip_addr));
+						out[j] = OUT_DISCARD;
+						continue;
+					} else if (task->private_ip_info[private_ip_idx].public_ip) {
+						plogx_info("race condition properly handled : ip %d.%d.%d.%d already in private ip hash\n", IP4(*ip_addr));
+						release_ip(task, &public_ip, public_ip_idx);
+						public_ip = task->private_ip_info[private_ip_idx].public_ip;
+						public_ip_idx = task->private_ip_info[private_ip_idx].public_ip_idx;
+					} else {
+						plogx_dbg("Added ip %d.%d.%d.%d in private ip hash\n", IP4(*ip_addr));
+						rte_memcpy(&task->private_ip_info[private_ip_idx].private_mac, ((uint8_t *)pkt) + 6, 6);
+						task->private_ip_info[private_ip_idx].public_ip = public_ip;
+						task->private_ip_info[private_ip_idx].static_entry = 0;
+						task->private_ip_info[private_ip_idx].public_ip_idx = public_ip_idx;
+						new_ip_entry = 1;
+					}
+				} else {
+					public_ip = task->private_ip_info[private_ip_idx].public_ip;
+					public_ip_idx = task->private_ip_info[private_ip_idx].public_ip_idx;
+				}
+				port_idx = add_new_port_entry(task, proto, public_ip_idx, private_ip_idx, *ip_addr, *udp_src_port, mbufs[j], tsc, &public_port);
+				if (port_idx < 0) {
+					// TODO: delete IP in ip_hash
+					if ((new_ip_entry) && (task->last_ip != 0)) {
+						release_ip(task, &public_ip, public_ip_idx);
+						task->last_ip--;
+					} else if (new_ip_entry) {
+						release_ip(task, &public_ip, public_ip_idx);
+						task->last_ip = task->public_ip_count-1;
+					}
+					plogx_info("Failed to add new port entry\n");
+					out[j] = OUT_DISCARD;
+					continue;
+				} else {
+					private_ip = *ip_addr;
+					private_port = *udp_src_port;
+					plogx_info("Added new ip/port: private ip/port = %d.%d.%d.%d/%x public ip/port = %d.%d.%d.%d/%x, index = %d\n", IP4(private_ip), private_port, IP4(public_ip), public_port, port_idx);
+				}
+       				// task->private_flow_entries[port_idx].ip_addr = task->private_ip_info[private_ip_idx].public_ip;
+				plogx_info("Added new port: private ip/port = %d.%d.%d.%d/%x, public ip/port = %d.%d.%d.%d/%x\n", IP4(private_ip), private_port, IP4(task->private_ip_info[private_ip_idx].public_ip), public_port);
+       				*ip_addr = public_ip ;
+       				*udp_src_port = public_port;
+				uint64_t flow_time = task->private_flow_entries[port_idx].flow_time;
+				if (flow_time + tsc_hz < tsc) {
+					task->private_flow_entries[port_idx].flow_time = tsc;
+				}
+				if (task->private_ip_info[private_ip_idx].mac_aging_time + tsc_hz < tsc)
+					task->private_ip_info[private_ip_idx].mac_aging_time = tsc;
+				prox_ip_udp_cksum(mbufs[j], &pkt[j]->ipv4_hdr, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+				// TODO: if route fails while just added new key in table, should we delete the key from the table?
+				out[j] =  route_ipv4(task, mbufs[j]);
+				if (out[j] && new_entry) {
+					delete_port_entry(task, proto, private_ip, private_port, *ip_addr, *udp_src_port, public_ip_idx);
+					plogx_info("Deleted port: private ip/port = %d.%d.%d.%d/%x, public ip/port = %d.%d.%d.%d/%x\n", IP4(private_ip), private_port, IP4(*ip_addr), *udp_src_port);
+				}
+			}
+		}
+        	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+	} else {
+		struct public_key public_key[MAX_PKT_BURST];
+        	for (j = 0; j < n_pkts; ++j) {
+			/* Currently, only support eth/ipv4 packets */
+			if (pkt[j]->ether_hdr.ether_type != ETYPE_IPv4) {
+				plogx_info("Currently, only support eth/ipv4 packets\n");
+				out[j] = OUT_DISCARD;
+				keys[j] = (void *)NULL;
+				continue;
+			}
+       			public_key[j].ip_addr = pkt[j]->ipv4_hdr.dst_addr;
+			public_key[j].l4_port = pkt[j]->udp_hdr.dst_port;
+			keys[j] = &public_key[j];
+		}
+		ret = rte_hash_lookup_bulk(task->public_ip_port_hash, (const void **)&keys, n_pkts, positions);
+		if (ret < 0) {
+			plogx_err("Failed lookup bulk public_ip_port_hash\n");
+			return -1;
+		}
+        	for (j = 0; j < n_pkts; ++j) {
+			port_idx = positions[j];
+       			ip_addr = &(pkt[j]->ipv4_hdr.dst_addr);
+			udp_src_port = &(pkt[j]->udp_hdr.dst_port);
+			if (port_idx < 0) {
+				plogx_err("Failed to find ip/port %d.%d.%d.%d/%x in public_ip_port_hash\n", IP4(*ip_addr), *udp_src_port);
+				out[j] = OUT_DISCARD;
+			} else {
+				plogx_dbg("Found ip/port %d.%d.%d.%d/%x in public_ip_port_hash\n", IP4(*ip_addr), *udp_src_port);
+        			*ip_addr = task->public_entries[port_idx].ip_addr;
+				*udp_src_port = task->public_entries[port_idx].l4_port;
+				private_ip_idx = task->public_entries[port_idx].private_ip_idx;
+				plogx_dbg("Found private IP info for ip %d.%d.%d.%d\n", IP4(*ip_addr));
+				rte_memcpy(((uint8_t *)(pkt[j])) + 0, &task->private_ip_info[private_ip_idx].private_mac, 6);
+				rte_memcpy(((uint8_t *)(pkt[j])) + 6, &task->src_mac_from_dpdk_port[task->public_entries[port_idx].dpdk_port], 6);
+				out[j] = task->public_entries[port_idx].dpdk_port;
+			}
+			prox_ip_udp_cksum(mbufs[j], &pkt[j]->ipv4_hdr, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+		}
+        	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+	}
+
+}
+
+static int lua_to_hash_nat(struct task_args *targ, struct lua_State *L, enum lua_place from, const char *name, uint8_t socket)
+{
+	struct rte_hash *tmp_priv_ip_hash, *tmp_priv_hash, *tmp_pub_hash;
+	struct private_flow_entry *tmp_priv_flow_entries;
+	struct public_entry *tmp_pub_entries;
+	uint32_t n_entries = 0;;
+	uint32_t ip_from, ip_to;
+	uint16_t port_from, port_to;
+	int ret, idx, pop, pop2, pop3, n_static_entries = 0;
+	uint32_t dst_ip1, dst_ip2;
+	struct val_range dst_port;
+	struct public_ip_config_info *ip_info;
+	struct public_ip_config_info *tmp_public_ip_config_info;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+        if (!lua_istable(L, -1)) {
+                plogx_err("Can't read cgnat since data is not a table\n");
+                return -1;
+        }
+
+	struct tmp_public_ip {
+        	uint32_t ip_beg;
+		uint32_t ip_end;
+        	uint16_t port_beg;
+		uint16_t port_end;
+	};
+	struct tmp_static_ip {
+		uint32_t private_ip;
+		uint32_t public_ip;
+	};
+	struct tmp_static_ip_port {
+		uint32_t private_ip;
+		uint32_t public_ip;
+		uint32_t n_ports;
+		uint16_t private_port;
+		uint16_t public_port;
+		int ip_found;
+		uint8_t port_found;
+	};
+	uint32_t n_public_groups = 0;
+	uint32_t n_public_ip = 0;
+	uint32_t n_static_ip = 0;
+	uint32_t n_static_ip_port = 0;
+	unsigned int i = 0;
+	struct tmp_public_ip *tmp_public_ip = NULL;
+	struct tmp_static_ip *tmp_static_ip = NULL;
+	struct tmp_static_ip_port *tmp_static_ip_port = NULL;
+
+	// Look for Dynamic entries configuration
+	plogx_info("Reading dynamic NAT table\n");
+	if ((pop2 = lua_getfrom(L, TABLE, "dynamic")) < 0) {
+		plogx_info("No dynamic table found\n");
+	} else {
+		uint64_t n_ip, n_port;
+        	if (!lua_istable(L, -1)) {
+                	plogx_err("Can't read cgnat since data is not a table\n");
+                	return -1;
+        	}
+		lua_len(L, -1);
+		n_public_groups = lua_tointeger(L, -1);
+		plogx_info("%d groups of public IP\n", n_public_groups);
+		tmp_public_ip = (struct tmp_public_ip *)malloc(n_public_groups * sizeof(struct tmp_public_ip));
+		PROX_PANIC(tmp_public_ip == NULL, "Failed to allocated tmp_public_ip\n");
+		lua_pop(L, 1);
+		lua_pushnil(L);
+
+		while (lua_next(L, -2)) {
+			if (lua_to_ip(L, TABLE, "public_ip_range_start", &dst_ip1) ||
+		    		lua_to_ip(L, TABLE, "public_ip_range_stop", &dst_ip2) ||
+		    		lua_to_val_range(L, TABLE, "public_port", &dst_port))
+					return -1;
+			PROX_PANIC(dst_ip2 < dst_ip1, "public_ip_range error: %d.%d.%d.%d < %d.%d.%d.%d\n", (dst_ip2 >> 24), (dst_ip2 >> 16) & 0xFF, (dst_ip2 >> 8) & 0xFF, dst_ip2 & 0xFF, dst_ip1 >> 24, (dst_ip1 >> 16) & 0xFF, (dst_ip1 >> 8) & 0xFF, dst_ip1 & 0xFF);
+			PROX_PANIC(dst_port.end < dst_port.beg, "public_port error: %d < %d\n", dst_port.end, dst_port.beg);
+			n_ip = dst_ip2 - dst_ip1 + 1;
+			n_port =  dst_port.end - dst_port.beg + 1;
+			n_public_ip += n_ip;
+			plogx_info("Found IP from %d.%d.%d.%d to %d.%d.%d.%d and port from %d to %d\n", dst_ip1 >> 24, (dst_ip1 >> 16) & 0xFF, (dst_ip1 >> 8) & 0xFF, dst_ip1 & 0xFF, (dst_ip2 >> 24), (dst_ip2 >> 16) & 0xFF, (dst_ip2 >> 8) & 0xFF, dst_ip2 & 0xFF, dst_port.beg, dst_port.end);
+			tmp_public_ip[i].ip_beg = dst_ip1;
+			tmp_public_ip[i].ip_end = dst_ip2;
+			tmp_public_ip[i].port_beg = dst_port.beg;
+			tmp_public_ip[i++].port_end = dst_port.end;
+			n_entries += n_ip * n_port;
+			lua_pop(L, 1);
+		}
+		lua_pop(L, pop2);
+
+	}
+	i = 0;
+	if ((pop2 = lua_getfrom(L, TABLE, "static_ip")) < 0) {
+		plogx_info("No static ip table found\n");
+	} else {
+        	if (!lua_istable(L, -1)) {
+                	plogx_err("Can't read cgnat since data is not a table\n");
+                	return -1;
+		}
+
+		lua_len(L, -1);
+		n_static_ip = lua_tointeger(L, -1);
+		plogx_info("%d entries in static ip table\n", n_static_ip);
+		lua_pop(L, 1);
+		tmp_static_ip = (struct tmp_static_ip *)malloc(n_static_ip * sizeof(struct tmp_static_ip));
+		PROX_PANIC(tmp_static_ip == NULL, "Failed to allocated tmp_static_ip\n");
+		lua_pushnil(L);
+		while (lua_next(L, -2)) {
+			if (lua_to_ip(L, TABLE, "src_ip", &ip_from) ||
+		    		lua_to_ip(L, TABLE, "dst_ip", &ip_to))
+					return -1;
+			ip_from = rte_bswap32(ip_from);
+			ip_to = rte_bswap32(ip_to);
+			tmp_static_ip[i].private_ip = ip_from;
+			tmp_static_ip[i++].public_ip = ip_to;
+			for (unsigned int j = 0; j < n_public_groups; j++) {
+				if ((tmp_public_ip[j].ip_beg <= ip_to) && (ip_to <= tmp_public_ip[j].ip_end)) {
+					PROX_PANIC(1, "list of static ip mapping overlap with list of dynamic IP => not supported yet\n");
+				}
+			}
+			n_public_ip++;
+			lua_pop(L, 1);
+		}
+		lua_pop(L, pop2);
+	}
+
+	i = 0;
+	if ((pop2 = lua_getfrom(L, TABLE, "static_ip_port")) < 0) {
+		plogx_info("No static table found\n");
+	} else {
+        	if (!lua_istable(L, -1)) {
+                	plogx_err("Can't read cgnat since data is not a table\n");
+                	return -1;
+		}
+
+		lua_len(L, -1);
+		n_static_ip_port = lua_tointeger(L, -1);
+		plogx_info("%d entries in static table\n", n_static_ip_port);
+		lua_pop(L, 1);
+		tmp_static_ip_port = (struct tmp_static_ip_port *)malloc(n_static_ip_port * sizeof(struct tmp_static_ip_port));
+		PROX_PANIC(tmp_static_ip_port == NULL, "Failed to allocated tmp_static_ip_port\n");
+		lua_pushnil(L);
+
+		while (lua_next(L, -2)) {
+			if (lua_to_ip(L, TABLE, "src_ip", &ip_from) ||
+		    		lua_to_ip(L, TABLE, "dst_ip", &ip_to) ||
+		    		lua_to_port(L, TABLE, "src_port", &port_from) ||
+		    		lua_to_port(L, TABLE, "dst_port", &port_to))
+					return -1;
+
+			ip_from = rte_bswap32(ip_from);
+			ip_to = rte_bswap32(ip_to);
+			port_from = rte_bswap16(port_from);
+			port_to = rte_bswap16(port_to);
+			tmp_static_ip_port[i].private_ip = ip_from;
+			tmp_static_ip_port[i].public_ip = ip_to;
+			tmp_static_ip_port[i].private_port = port_from;
+			tmp_static_ip_port[i].public_port = port_to;
+			tmp_static_ip_port[i].n_ports = 1;
+			for (unsigned int j = 0; j < n_public_groups; j++) {
+				if ((tmp_public_ip[j].ip_beg <= rte_bswap32(ip_to)) && (rte_bswap32(ip_to) <= tmp_public_ip[j].ip_end)) {
+					tmp_static_ip_port[i].ip_found = j + 11;
+					PROX_PANIC(1, "list of static ip/port mapping overlap with list of dynamic IP => not supported yet\n");
+				}
+			}
+			for (unsigned int j = 0; j < n_static_ip; j++) {
+				if ((tmp_static_ip[j].public_ip == ip_to) ) {
+					tmp_static_ip_port[i].ip_found = j + 1;
+					PROX_PANIC(1, "list of static ip/port mapping overlap with list of static ip => not supported yet\n");
+				}
+			}
+			for (unsigned int j = 0; j <= i; j++) {
+				if (ip_to == tmp_static_ip_port[j].public_ip) {
+					tmp_static_ip_port[i].ip_found = j + 1;
+					tmp_static_ip_port[j].n_ports++;
+					tmp_static_ip_port[i].n_ports = 0;
+				}
+			}
+			i++;
+			if (!tmp_static_ip_port[i].ip_found) {
+				n_public_ip++;
+				n_entries++;
+			}
+			lua_pop(L, 1);
+		}
+		lua_pop(L, pop2);
+	}
+	lua_pop(L, pop);
+
+	tmp_public_ip_config_info = (struct public_ip_config_info *)prox_zmalloc(n_public_ip * sizeof(struct public_ip_config_info), socket);
+	PROX_PANIC(tmp_public_ip_config_info == NULL, "Failed to allocate PUBLIC IP INFO\n");
+	plogx_info("%d PUBLIC IP INFO allocated\n", n_public_ip);
+
+	struct private_ip_info *tmp_priv_ip_info = (struct private_ip_info *)prox_zmalloc(4 * n_public_ip * sizeof(struct public_ip_config_info), socket);
+	PROX_PANIC(tmp_priv_ip_info == NULL, "Failed to allocate PRIVATE IP INFO\n");
+	plogx_info("%d PRIVATE IP INFO allocated\n", 4 * n_public_ip);
+
+	uint32_t ip_free_count = 0;
+	for (i = 0; i < n_public_groups; i++) {
+		for (uint32_t ip = tmp_public_ip[i].ip_beg; ip <= tmp_public_ip[i].ip_end; ip++) {
+			ip_info = &tmp_public_ip_config_info[ip_free_count];
+			ip_info->public_ip = rte_bswap32(ip);
+			ip_info->port_list = (uint16_t *)prox_zmalloc((dst_port.end - dst_port.beg) * sizeof(uint16_t), socket);
+                       	PROX_PANIC(ip_info->port_list == NULL, "Failed to allocate list of ports for ip %x\n", ip);
+			for (uint32_t port = tmp_public_ip[i].port_beg; port <= tmp_public_ip[i].port_end; port++) {
+				ip_info->port_list[ip_info->port_free_count] = rte_bswap16(port);
+				ip_info->port_free_count++;
+			}
+			ip_info->max_port_count = ip_info->port_free_count;
+			plogx_dbg("Added IP %d.%d.%d.%d with ports from %x to %x at index %x\n", IP4(ip_info->public_ip), tmp_public_ip[i].port_beg, tmp_public_ip[i].port_end, ip_free_count);
+			ip_free_count++;
+		}
+	}
+	uint32_t public_ip_count = ip_free_count;
+	for (i = 0; i < n_static_ip; i++) {
+		ip_info = &tmp_public_ip_config_info[ip_free_count];
+		ip_info->public_ip = tmp_static_ip[i].public_ip;
+		ip_info->port_list = NULL;
+		ip_info->max_port_count = 0;
+		ip_free_count++;
+	}
+	for (i = 0; i < n_static_ip_port; i++) {
+		if (!tmp_static_ip_port[i].ip_found) {
+			ip_info = &tmp_public_ip_config_info[ip_free_count];
+			ip_info->public_ip = tmp_static_ip_port[i].public_ip;
+			ip_info->port_list = (uint16_t *)prox_zmalloc(tmp_static_ip_port[i].n_ports * sizeof(uint16_t), socket);
+                	PROX_PANIC(ip_info->port_list == NULL, "Failed to allocate list of ports for ip %x\n", tmp_static_ip_port[i].public_ip);
+			ip_info->port_list[ip_info->port_free_count] = tmp_static_ip_port[i].public_port;
+			ip_info->port_free_count++;
+			ip_info->max_port_count = ip_info->port_free_count;
+			ip_free_count++;
+		} else {
+			for (unsigned j = 0; j < ip_free_count; j++) {
+				ip_info = &tmp_public_ip_config_info[j];
+				if (ip_info->public_ip == tmp_static_ip_port[i].public_ip) {
+					ip_info = &tmp_public_ip_config_info[j];
+					ip_info->port_list[ip_info->port_free_count] = tmp_static_ip_port[i].public_port;
+					ip_info->port_free_count++;
+					ip_info->max_port_count = ip_info->port_free_count;
+					break;
+				}
+			}
+		}
+	}
+	plogx_info("%d entries in dynamic table\n", n_entries);
+
+	n_entries = n_entries * 4;
+	static char hash_name[30];
+	sprintf(hash_name, "A%03d_hash_nat_table", targ->lconf->id);
+	struct rte_hash_parameters hash_params = {
+		.name = hash_name,
+		.entries = n_entries,
+		.key_len = sizeof(struct private_key),
+		.hash_func = rte_hash_crc,
+		.hash_func_init_val = 0,
+	};
+	plogx_info("hash table name = %s\n", hash_params.name);
+	struct private_key private_key;
+	struct public_key public_key;
+	tmp_priv_hash = rte_hash_create(&hash_params);
+	PROX_PANIC(tmp_priv_hash == NULL, "Failed to set up private hash table for NAT\n");
+	plogx_info("private hash table allocated, with %d entries of size %d\n", hash_params.entries, hash_params.key_len);
+
+	tmp_priv_flow_entries = (struct private_flow_entry *)prox_zmalloc(n_entries * sizeof(struct private_flow_entry), socket);
+	PROX_PANIC(tmp_priv_flow_entries == NULL, "Failed to allocate memory for private NAT %u entries\n", n_entries);
+	plogx_info("private data allocated, with %d entries of size %ld\n", n_entries, sizeof(struct private_flow_entry));
+
+	hash_name[0]++;
+	//hash_params.name[0]++;
+	plogx_info("hash table name = %s\n", hash_params.name);
+	hash_params.key_len = sizeof(uint32_t);
+	hash_params.entries = 4 * ip_free_count;
+	tmp_priv_ip_hash = rte_hash_create(&hash_params);
+	PROX_PANIC(tmp_priv_ip_hash == NULL, "Failed to set up private ip hash table for NAT\n");
+	plogx_info("private ip hash table allocated, with %d entries of size %d\n", hash_params.entries, hash_params.key_len);
+
+	hash_name[0]++;
+	//hash_params.name[0]++;
+	plogx_info("hash table name = %s\n", hash_params.name);
+	hash_params.entries = n_entries;
+	hash_params.key_len = sizeof(struct public_key),
+	tmp_pub_hash = rte_hash_create(&hash_params);
+	PROX_PANIC(tmp_pub_hash == NULL, "Failed to set up public hash table for NAT\n");
+	plogx_info("public hash table allocated, with %d entries of size %d\n", hash_params.entries, hash_params.key_len);
+
+	hash_name[0]++;
+	//hash_params.name[0]++;
+	tmp_pub_entries = (struct public_entry *)prox_zmalloc(n_entries * sizeof(struct public_entry), socket);
+	PROX_PANIC(tmp_pub_entries == NULL, "Failed to allocate memory for public NAT %u entries\n", n_entries);
+	plogx_info("public data allocated, with %d entries of size %ld\n", n_entries, sizeof(struct private_flow_entry));
+
+	for (i = 0; i < n_static_ip_port; i++) {
+		ip_to = tmp_static_ip_port[i].public_ip;
+		ip_from = tmp_static_ip_port[i].private_ip;
+		port_to = tmp_static_ip_port[i].public_port;
+		port_from = tmp_static_ip_port[i].private_port;
+		private_key.ip_addr = ip_from;
+		private_key.l4_port = port_from;
+		ret = rte_hash_lookup(tmp_priv_hash, (const void *)&private_key);
+		PROX_PANIC(ret >= 0, "Key %x %x already exists in NAT private hash table\n", ip_from, port_from);
+
+		idx = rte_hash_add_key(tmp_priv_ip_hash, (const void *)&ip_from);
+		PROX_PANIC(idx < 0, "Failed to add ip %x to NAT private hash table\n", ip_from);
+		ret = rte_hash_add_key(tmp_priv_hash, (const void *)&private_key);
+		PROX_PANIC(ret < 0, "Failed to add Key %x %x to NAT private hash table\n", ip_from, port_from);
+		tmp_priv_flow_entries[ret].ip_addr = ip_to;
+		tmp_priv_flow_entries[ret].flow_time = -1;
+		tmp_priv_flow_entries[ret].private_ip_idx = idx;
+		tmp_priv_flow_entries[ret].l4_port = port_to;
+
+		public_key.ip_addr = ip_to;
+		public_key.l4_port = port_to;
+		ret = rte_hash_lookup(tmp_pub_hash, (const void *)&public_key);
+		PROX_PANIC(ret >= 0, "Key %d.%d.%d.%d port %x (for private IP %d.%d.%d.%d port %x) already exists in NAT public hash table fir IP %d.%d.%d.%d port %x\n", IP4(ip_to), port_to, IP4(ip_from), port_from, IP4(tmp_pub_entries[ret].ip_addr), tmp_pub_entries[ret].l4_port);
+
+		ret = rte_hash_add_key(tmp_pub_hash, (const void *)&public_key);
+		PROX_PANIC(ret < 0, "Failed to add Key %x %x to NAT public hash table\n", ip_to, port_to);
+		tmp_pub_entries[ret].ip_addr = ip_from;
+		tmp_pub_entries[ret].l4_port = port_from;
+		tmp_pub_entries[ret].private_ip_idx = idx;
+	}
+
+	for (uint8_t task_id = 0; task_id < targ->lconf->n_tasks_all; ++task_id) {
+		struct task_args *target_targ = (struct task_args *)&(targ->lconf->targs[task_id]);
+		enum task_mode smode = target_targ->mode;
+		if (CGNAT == smode) {
+			target_targ->public_ip_count = public_ip_count;
+			target_targ->private_ip_hash = tmp_priv_ip_hash;
+			target_targ->private_ip_port_hash = tmp_priv_hash;
+			target_targ->private_ip_info = tmp_priv_ip_info;
+			target_targ->private_flow_entries = tmp_priv_flow_entries;
+			target_targ->public_ip_port_hash = tmp_pub_hash;
+			target_targ->public_entries = tmp_pub_entries;
+			target_targ->public_ip_config_info = tmp_public_ip_config_info;
+		}
+	}
+	return 0;
+}
+
+static void early_init_task_nat(struct task_args *targ)
+{
+	int ret;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	if (!targ->private_ip_hash) {
+		ret = lua_to_hash_nat(targ, prox_lua(), GLOBAL, targ->nat_table, socket_id);
+		PROX_PANIC(ret != 0, "Failed to load NAT table from lua:\n%s\n", get_lua_to_errors());
+	}
+}
+
+static void init_task_nat(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_nat *task = (struct task_nat *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	/* Use destination IP by default. */
+	task->private = targ->use_src;
+
+	PROX_PANIC(!strcmp(targ->nat_table, ""), "No nat table specified\n");
+	task->lconf = targ->lconf;
+	task->runtime_flags = targ->runtime_flags;
+
+	task->public_ip_count = targ->public_ip_count;
+	task->last_ip = targ->public_ip_count;
+	task->private_ip_hash = targ->private_ip_hash;
+	task->private_ip_port_hash = targ->private_ip_port_hash;
+	task->private_ip_info = targ->private_ip_info;
+	task->private_flow_entries = targ->private_flow_entries;
+	task->public_ip_port_hash = targ->public_ip_port_hash;
+	task->public_entries = targ->public_entries;
+	task->public_ip_config_info = targ->public_ip_config_info;
+
+	proto_ipsrc_portsrc_mask = _mm_set_epi32(BIT_0_TO_15, 0, ALL_32_BITS, BIT_8_TO_15);
+	proto_ipdst_portdst_mask = _mm_set_epi32(BIT_16_TO_31, ALL_32_BITS, 0, BIT_8_TO_15);
+
+	struct lpm4 *lpm;
+
+	PROX_PANIC(!strcmp(targ->route_table, ""), "route table not specified\n");
+	if (targ->flags & TASK_ARG_LOCAL_LPM) {
+		int ret = lua_to_lpm4(prox_lua(), GLOBAL, targ->route_table, socket_id, &lpm);
+		PROX_PANIC(ret, "Failed to load IPv4 LPM:\n%s\n", get_lua_to_errors());
+		prox_sh_add_socket(socket_id, targ->route_table, lpm);
+		task->number_free_rules = lpm->n_free_rules;
+	} else {
+		lpm = prox_sh_find_socket(socket_id, targ->route_table);
+		if (!lpm) {
+			int ret = lua_to_lpm4(prox_lua(), GLOBAL, targ->route_table, socket_id, &lpm);
+			PROX_PANIC(ret, "Failed to load IPv4 LPM:\n%s\n", get_lua_to_errors());
+			prox_sh_add_socket(socket_id, targ->route_table, lpm);
+		}
+	}
+	task->ipv4_lpm = lpm->rte_lpm;
+	task->next_hops = lpm->next_hops;
+	task->number_free_rules = lpm->n_free_rules;
+
+	for (uint32_t i = 0; i < MAX_HOP_INDEX; i++) {
+		int tx_port = task->next_hops[i].mac_port.out_idx;
+		if ((tx_port > targ->nb_txports - 1) && (tx_port > targ->nb_txrings - 1)) {
+			PROX_PANIC(1, "Routing Table contains port %d but only %d tx port/ %d ring:\n", tx_port, targ->nb_txports, targ->nb_txrings);
+		}
+	}
+
+	if (targ->nb_txrings) {
+		struct task_args *dtarg;
+		struct core_task ct;
+		for (uint32_t i = 0; i < targ->nb_txrings; ++i) {
+			ct = targ->core_task_set[0].core_task[i];
+			dtarg = core_targ_get(ct.core, ct.task);
+			dtarg = find_reachable_task_sending_to_port(dtarg);
+			task->src_mac[i] = (0x0000ffffffffffff & ((*(uint64_t*)&prox_port_cfg[dtarg->tx_port_queue[0].port].eth_addr))) | ((uint64_t)ETYPE_IPv4 << (64 - 16));
+			task->src_mac_from_dpdk_port[dtarg->tx_port_queue[0].port] = task->src_mac[i];
+			plogx_dbg("src_mac = %lx for port %d %d\n", task->src_mac[i], i, dtarg->tx_port_queue[0].port);
+		}
+	} else {
+		for (uint32_t i = 0; i < targ->nb_txports; ++i) {
+			task->src_mac[i] = (0x0000ffffffffffff & ((*(uint64_t*)&prox_port_cfg[targ->tx_port_queue[i].port].eth_addr))) | ((uint64_t)ETYPE_IPv4 << (64 - 16));
+			task->src_mac_from_dpdk_port[targ->tx_port_queue[0].port] = task->src_mac[i];
+			plogx_dbg("src_mac = %lx for port %d %d\n", task->src_mac[i], i, targ->tx_port_queue[i].port);
+		}
+	}
+
+	struct prox_port_cfg *port = find_reachable_port(targ);
+	if (port) {
+		task->offload_crc = port->capabilities.tx_offload_cksum;
+	}
+}
+
+/* Basic static nat. */
+static struct task_init task_init_nat = {
+	.mode = CGNAT,
+	.mode_str = "cgnat",
+	.early_init = early_init_task_nat,
+	.init = init_task_nat,
+	.handle = handle_nat_bulk,
+#ifdef SOFT_CRC
+	.flag_features = TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS|TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS|TASK_FEATURE_ROUTING|TASK_FEATURE_ZERO_RX,
+#else
+	.flag_features = TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS|TASK_FEATURE_ROUTING|TASK_FEATURE_ZERO_RX,
+#endif
+	.size = sizeof(struct task_nat),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+__attribute__((constructor)) static void reg_task_nat(void)
+{
+	reg_task(&task_init_nat);
+}
diff --git a/VNFs/DPPD-PROX/handle_cgnat.h b/VNFs/DPPD-PROX/handle_cgnat.h
new file mode 100644
index 00000000..ab26be34
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_cgnat.h
@@ -0,0 +1,25 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_CGNAT_H_
+#define _HANDLE_CGNAT_H_
+
+struct task_nat;
+
+void task_cgnat_dump_public_hash(struct task_nat *task);
+void task_cgnat_dump_private_hash(struct task_nat *task);
+
+#endif
diff --git a/VNFs/DPPD-PROX/handle_classify.c b/VNFs/DPPD-PROX/handle_classify.c
new file mode 100644
index 00000000..f4f96aaf
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_classify.c
@@ -0,0 +1,133 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ip.h>
+#include <stdio.h>
+#include <string.h>
+#include <rte_version.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+
+#include "lconf.h"
+#include "task_base.h"
+#include "task_init.h"
+#include "defines.h"
+#include "prefetch.h"
+#include "qinq.h"
+#include "prox_cfg.h"
+#include "log.h"
+#include "quit.h"
+#include "prox_shared.h"
+
+struct task_classify {
+	struct task_base    base;
+	uint16_t           *user_table;
+	uint8_t             *dscp;
+};
+
+static inline void handle_classify(struct task_classify *task, struct rte_mbuf *mbuf)
+{
+	const struct qinq_hdr *pqinq = rte_pktmbuf_mtod(mbuf, const struct qinq_hdr *);
+
+	uint32_t qinq = PKT_TO_LUTQINQ(pqinq->svlan.vlan_tci, pqinq->cvlan.vlan_tci);
+
+	/* Traffic class can be set by ACL task. If this is the case,
+	   don't overwrite it using dscp. Instead, use the
+	   traffic class that had been set. */
+
+	uint32_t prev_tc;
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+	uint32_t dummy;
+	rte_sched_port_pkt_read_tree_path(mbuf, &dummy, &dummy, &prev_tc, &dummy);
+#else
+	struct rte_sched_port_hierarchy *sched = (struct rte_sched_port_hierarchy *) &mbuf->pkt.hash.sched;
+	prev_tc = sched->traffic_class;
+#endif
+
+	const struct ipv4_hdr *ipv4_hdr = (const struct ipv4_hdr *)(pqinq + 1);
+	uint8_t dscp = task->dscp[ipv4_hdr->type_of_service >> 2];
+
+	uint8_t queue = dscp & 0x3;
+	uint8_t tc = prev_tc? prev_tc : dscp >> 2;
+
+	rte_sched_port_pkt_write(mbuf, 0, task->user_table[qinq], tc, queue, 0);
+}
+
+static int handle_classify_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_classify *task = (struct task_classify *)tbase;
+
+	uint16_t j;
+#ifdef PROX_PREFETCH_OFFSET
+	for (j = 0; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		prefetch_nta(mbufs[j]);
+	}
+	for (j = 1; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		prefetch_nta(rte_pktmbuf_mtod(mbufs[j - 1], void *));
+	}
+#endif
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		prefetch_nta(mbufs[j + PREFETCH_OFFSET]);
+		prefetch_nta(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		handle_classify(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	prefetch_nta(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		handle_classify(task, mbufs[j]);
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, NULL);
+}
+
+static void init_task_classify(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_classify *task = (struct task_classify *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->user_table = prox_sh_find_socket(socket_id, "user_table");
+	if (!task->user_table) {
+		PROX_PANIC(!strcmp(targ->user_table, ""), "No user table defined\n");
+		int ret = lua_to_user_table(prox_lua(), GLOBAL, targ->user_table, socket_id, &task->user_table);
+		PROX_PANIC(ret, "Failed to create user table from config:\n%s\n", get_lua_to_errors());
+		prox_sh_add_socket(socket_id, "user_table", task->user_table);
+	}
+
+	PROX_PANIC(!strcmp(targ->dscp, ""), "DSCP table not specified\n");
+	task->dscp = prox_sh_find_socket(socket_id, targ->dscp);
+	if (!task->dscp) {
+		int ret = lua_to_dscp(prox_lua(), GLOBAL, targ->dscp, socket_id, &task->dscp);
+		PROX_PANIC(ret, "Failed to create dscp table from config\n");
+		prox_sh_add_socket(socket_id, targ->dscp, task->dscp);
+	}
+}
+
+static struct task_init task_init_classify = {
+	.mode_str = "classify",
+	.init = init_task_classify,
+	.handle = handle_classify_bulk,
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS,
+	.size = sizeof(struct task_classify)
+};
+
+__attribute__((constructor)) static void reg_task_classify(void)
+{
+	reg_task(&task_init_classify);
+}
diff --git a/VNFs/DPPD-PROX/handle_dump.c b/VNFs/DPPD-PROX/handle_dump.c
new file mode 100644
index 00000000..c35a6e9e
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_dump.c
@@ -0,0 +1,131 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+#include <pcap.h>
+
+#include "prox_malloc.h"
+#include "clock.h"
+#include "log.h"
+#include "lconf.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "stats.h"
+
+struct task_dump {
+	struct task_base base;
+	uint32_t n_mbufs;
+        struct rte_mbuf **mbufs;
+	uint32_t n_pkts;
+	char pcap_file[128];
+};
+
+static uint16_t buffer_packets(struct task_dump *task, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	uint16_t j = 0;
+
+	if (task->n_mbufs == task->n_pkts)
+		return 0;
+
+	for (j = 0; j < n_pkts && task->n_mbufs < task->n_pkts; ++j) {
+		mbufs[j]->udata64 = rte_rdtsc();
+		task->mbufs[task->n_mbufs++] = mbufs[j];
+	}
+
+	return j;
+}
+
+static int handle_dump_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_dump *task = (struct task_dump *)tbase;
+	const uint16_t ofs = buffer_packets(task, mbufs, n_pkts);
+
+	for (uint16_t j = ofs; j < n_pkts; ++j)
+		rte_pktmbuf_free(mbufs[j]);
+	TASK_STATS_ADD_DROP_DISCARD(&tbase->aux->stats, n_pkts - ofs);
+	return n_pkts;
+}
+
+static void init_task_dump(struct task_base *tbase, __attribute__((unused)) struct task_args *targ)
+{
+	struct task_dump *task = (struct task_dump *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->mbufs = prox_zmalloc(sizeof(*task->mbufs) * targ->n_pkts, socket_id);
+	task->n_pkts = targ->n_pkts;
+	if (!strcmp(targ->pcap_file, "")) {
+		strcpy(targ->pcap_file, "out.pcap");
+	}
+	strncpy(task->pcap_file, targ->pcap_file, sizeof(task->pcap_file));
+}
+
+static void stop(struct task_base *tbase)
+{
+	struct task_dump *task = (struct task_dump *)tbase;
+	static pcap_dumper_t *pcap_dump_handle;
+	pcap_t *handle;
+	uint32_t n_pkts = 65536;
+	struct pcap_pkthdr header = {{0}, 0, 0};
+	static int once = 0;
+	char err_str[PCAP_ERRBUF_SIZE];
+	const uint64_t hz = rte_get_tsc_hz();
+	struct timeval tv = {0};
+	uint64_t tsc, beg = 0;
+
+	plogx_info("Dumping %d packets to '%s'\n", task->n_mbufs, task->pcap_file);
+	handle = pcap_open_dead(DLT_EN10MB, n_pkts);
+	pcap_dump_handle = pcap_dump_open(handle, task->pcap_file);
+
+	if (task->n_mbufs) {
+		beg = task->mbufs[0]->udata64;
+	}
+	for (uint32_t j = 0; j < task->n_mbufs; ++j) {
+		tsc = task->mbufs[j]->udata64 - beg;
+		header.len = rte_pktmbuf_pkt_len(task->mbufs[j]);
+		header.caplen = header.len;
+		tsc_to_tv(&header.ts, tsc);
+		pcap_dump((unsigned char *)pcap_dump_handle, &header, rte_pktmbuf_mtod(task->mbufs[j], void *));
+	}
+
+	pcap_dump_close(pcap_dump_handle);
+	pcap_close(handle);
+	plogx_info("Dump complete, releasing mbufs\n");
+
+	uint32_t j = 0;
+
+	while (j + 64 < task->n_mbufs) {
+		tbase->tx_pkt(tbase, &task->mbufs[j], 64, NULL);
+		j += 64;
+	}
+	if (j < task->n_mbufs) {
+		tbase->tx_pkt(tbase, &task->mbufs[j], task->n_mbufs - j, NULL);
+	}
+	task->n_mbufs = 0;
+}
+
+static struct task_init task_init_dump = {
+	.mode_str = "dump",
+	.init = init_task_dump,
+	.handle = handle_dump_bulk,
+	.stop = stop,
+	.flag_features = TASK_FEATURE_ZERO_RX,
+	.size = sizeof(struct task_dump)
+};
+
+__attribute__((constructor)) static void reg_task_dump(void)
+{
+	reg_task(&task_init_dump);
+}
diff --git a/VNFs/DPPD-PROX/handle_fm.c b/VNFs/DPPD-PROX/handle_fm.c
new file mode 100644
index 00000000..c4a10e67
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_fm.c
@@ -0,0 +1,373 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <dlfcn.h>
+
+#include <rte_ip.h>
+#include <rte_udp.h>
+#include <rte_tcp.h>
+#include <rte_cycles.h>
+#include <rte_ether.h>
+#include <rte_eth_ctrl.h>
+
+#include "log.h"
+#include "quit.h"
+#include "lconf.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "kv_store_expire.h"
+#include "stats.h"
+#include "prox_shared.h"
+#include "etypes.h"
+#include "prox_cfg.h"
+#include "dpi/dpi.h"
+
+struct task_dpi_per_core {
+	void     *dpi_opaque;
+};
+
+struct task_fm {
+	struct task_base          base;
+	/* FM related fields */
+	struct kv_store_expire   *kv_store_expire;
+	void                     *dpi_opaque;
+
+	struct dpi_engine        dpi_engine;
+	struct task_dpi_per_core *dpi_shared; /* Used only during init */
+};
+
+struct eth_ip4_udp {
+	struct ether_hdr l2;
+	struct ipv4_hdr  l3;
+	union {
+		struct udp_hdr   udp;
+		struct tcp_hdr   tcp;
+	} l4;
+} __attribute__((packed));
+
+union pkt_type {
+	struct {
+		uint16_t etype;
+		uint8_t  ip_byte;
+		uint8_t  next_proto;
+	} __attribute__((packed));
+	uint32_t val;
+};
+
+static union pkt_type pkt_type_udp = {
+	.next_proto = IPPROTO_UDP,
+	.ip_byte    = 0x45,
+	.etype      = ETYPE_IPv4,
+};
+
+static union pkt_type pkt_type_tcp = {
+	.next_proto = IPPROTO_TCP,
+	.ip_byte    = 0x45,
+	.etype      = ETYPE_IPv4,
+};
+
+static int extract_flow_info(struct eth_ip4_udp *p, struct flow_info *fi, struct flow_info *fi_flipped, uint32_t *len, uint8_t **payload)
+{
+	union pkt_type pkt_type = {
+		.next_proto = p->l3.next_proto_id,
+		.ip_byte    = p->l3.version_ihl,
+		.etype      = p->l2.ether_type,
+	};
+
+	memset(fi->reservered, 0, sizeof(fi->reservered));
+	memset(fi_flipped->reservered, 0, sizeof(fi_flipped->reservered));
+
+	if (pkt_type.val == pkt_type_udp.val) {
+		fi->ip_src = p->l3.src_addr;
+		fi->ip_dst = p->l3.dst_addr;
+		fi->ip_proto = p->l3.next_proto_id;
+		fi->port_src = p->l4.udp.src_port;
+		fi->port_dst = p->l4.udp.dst_port;
+
+		fi_flipped->ip_src = p->l3.dst_addr;
+		fi_flipped->ip_dst = p->l3.src_addr;
+		fi_flipped->ip_proto = p->l3.next_proto_id;
+		fi_flipped->port_src = p->l4.udp.dst_port;
+		fi_flipped->port_dst = p->l4.udp.src_port;
+
+		*len = rte_be_to_cpu_16(p->l4.udp.dgram_len) - sizeof(struct udp_hdr);
+		*payload = (uint8_t*)(&p->l4.udp) + sizeof(struct udp_hdr);
+		return 0;
+	}
+	else if (pkt_type.val == pkt_type_tcp.val) {
+		fi->ip_src = p->l3.src_addr;
+		fi->ip_dst = p->l3.dst_addr;
+		fi->ip_proto = p->l3.next_proto_id;
+		fi->port_src = p->l4.tcp.src_port;
+		fi->port_dst = p->l4.tcp.dst_port;
+
+		fi_flipped->ip_src = p->l3.dst_addr;
+		fi_flipped->ip_dst = p->l3.src_addr;
+		fi_flipped->ip_proto = p->l3.next_proto_id;
+		fi_flipped->port_src = p->l4.tcp.dst_port;
+		fi_flipped->port_dst = p->l4.tcp.src_port;
+
+		*len = rte_be_to_cpu_16(p->l3.total_length) - sizeof(struct ipv4_hdr) - ((p->l4.tcp.data_off >> 4)*4);
+		*payload = ((uint8_t*)&p->l4.tcp) + ((p->l4.tcp.data_off >> 4)*4);
+		return 0;
+	}
+
+	return -1;
+}
+
+static int is_flow_beg(const struct flow_info *fi, const struct eth_ip4_udp *p)
+{
+	return fi->ip_proto == IPPROTO_UDP ||
+		(fi->ip_proto == IPPROTO_TCP && p->l4.tcp.tcp_flags & TCP_SYN_FLAG);
+}
+
+static void *lookup_flow(struct task_fm *task, struct flow_info *fi, uint64_t now_tsc)
+{
+	struct kv_store_expire_entry *entry;
+
+	entry = kv_store_expire_get(task->kv_store_expire, fi, now_tsc);
+
+	return entry ? entry_value(task->kv_store_expire, entry) : NULL;
+}
+
+static void *lookup_or_insert_flow(struct task_fm *task, struct flow_info *fi, uint64_t now_tsc)
+{
+	struct kv_store_expire_entry *entry;
+
+	entry = kv_store_expire_get_or_put(task->kv_store_expire, fi, now_tsc);
+
+	return entry ? entry_value(task->kv_store_expire, entry) : NULL;
+}
+
+static int handle_fm(struct task_fm *task, struct rte_mbuf *mbuf, uint64_t now_tsc)
+{
+	struct eth_ip4_udp *p;
+	struct flow_info fi, fi_flipped;
+	void *flow_data;
+	uint32_t len;
+	uint8_t *payload;
+	uint32_t res[2];
+	size_t res_len = 2;
+	int flow_beg;
+	struct dpi_payload dpi_payload;
+	int is_upstream = 0;
+
+	p = rte_pktmbuf_mtod(mbuf, struct eth_ip4_udp *);
+
+	if (0 != extract_flow_info(p, &fi, &fi_flipped, &len, &payload)) {
+		plogx_err("Unknown packet type\n");
+		return OUT_DISCARD;
+	}
+
+	/* First, try to see if the flow already exists where the
+	   current packet is sent by the server. */
+	if (!(flow_data = lookup_flow(task, &fi_flipped, now_tsc))) {
+		/* Insert a new flow, only if this is the first packet
+		   in the flow. */
+		is_upstream = 1;
+		if (is_flow_beg(&fi, p))
+			flow_data = lookup_or_insert_flow(task, &fi, now_tsc);
+		else
+			flow_data = lookup_flow(task, &fi, now_tsc);
+	}
+
+	if (!flow_data)
+		return OUT_DISCARD;
+	else if (!len)
+		return 0;
+
+	dpi_payload.payload = payload;
+	dpi_payload.len = len;
+	dpi_payload.client_to_server = is_upstream;
+	gettimeofday(&dpi_payload.tv, NULL);
+	task->dpi_engine.dpi_process(task->dpi_opaque, is_upstream? &fi : &fi_flipped, flow_data, &dpi_payload, res, &res_len);
+	return OUT_HANDLED;
+}
+
+static int handle_fm_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_fm *task = (struct task_fm *)tbase;
+	uint64_t now_tsc = rte_rdtsc();
+	uint16_t handled = 0;
+	uint16_t discard = 0;
+	int ret;
+
+	for (uint16_t i = 0; i < n_pkts; ++i) {
+		ret = handle_fm(task, mbufs[i], now_tsc);
+		if (ret == OUT_DISCARD)
+			discard++;
+		else if (ret == OUT_HANDLED)
+			handled++;
+	}
+
+	for (uint16_t i = 0; i < n_pkts; ++i)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TASK_STATS_ADD_DROP_HANDLED(&tbase->aux->stats, handled);
+	TASK_STATS_ADD_DROP_DISCARD(&tbase->aux->stats, discard);
+	return 0;
+}
+
+static void load_dpi_engine(const char *dpi_engine_path, struct dpi_engine *dst)
+{
+	void *handle = prox_sh_find_system(dpi_engine_path);
+
+	if (handle == NULL) {
+		plogx_info("Loading DPI engine from '%s'\n", dpi_engine_path);
+		handle = dlopen(dpi_engine_path, RTLD_NOW | RTLD_GLOBAL);
+
+		PROX_PANIC(handle == NULL, "Failed to load dpi engine from '%s' with error:\n\t\t%s\n", dpi_engine_path, dlerror());
+		prox_sh_add_system(dpi_engine_path, handle);
+	}
+
+	struct dpi_engine *(*get_dpi_engine)(void) = dlsym(handle, "get_dpi_engine");
+
+	PROX_PANIC(get_dpi_engine == NULL, "Failed to find get_dpi_engine function from '%s'\n", dpi_engine_path);
+	struct dpi_engine *dpi_engine = get_dpi_engine();
+
+	dpi_engine->dpi_print = plog_info;
+	rte_memcpy(dst, dpi_engine, sizeof(*dst));
+}
+
+static uint32_t count_fm_cores(void)
+{
+	uint32_t n_cores = 0;
+	uint32_t lcore_id = -1;
+	struct lcore_cfg *lconf;
+
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			if (!strcmp(lconf->targs[task_id].task_init->mode_str, "fm")) {
+				n_cores++;
+				/* Only intersted in number of cores
+				   so break here. */
+				break;
+			}
+		}
+	}
+
+	return n_cores;
+}
+
+static struct kv_store_expire *get_shared_flow_table(struct task_args *targ, struct dpi_engine *de)
+{
+	struct kv_store_expire *ret = prox_sh_find_core(targ->lconf->id, "flow_table");
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	if (!ret) {
+		ret = kv_store_expire_create(rte_align32pow2(targ->flow_table_size) * 4,
+					     sizeof(struct flow_info),
+					     de->dpi_get_flow_entry_size(),
+					     socket_id,
+					     de->dpi_flow_expire,
+					     rte_get_tsc_hz() * 60);
+		PROX_PANIC(ret == NULL, "Failed to allocate KV store\n");
+		prox_sh_add_core(targ->lconf->id, "flow_table", ret);
+	}
+	return ret;
+}
+
+static struct task_dpi_per_core *get_shared_dpi_shared(struct task_args *targ)
+{
+	static const char *name = "dpi_shared";
+	struct task_dpi_per_core *ret = prox_sh_find_core(targ->lconf->id, name);
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	if (!ret) {
+		ret = prox_zmalloc(sizeof(*ret), socket_id);
+		prox_sh_add_core(targ->lconf->id, name, ret);
+	}
+	return ret;
+}
+
+static void init_task_fm(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_fm *task = (struct task_fm *)tbase;
+	static int dpi_inited = 0;
+
+	load_dpi_engine(targ->dpi_engine_path, &task->dpi_engine);
+
+	task->kv_store_expire = get_shared_flow_table(targ, &task->dpi_engine);
+	task->dpi_shared = get_shared_dpi_shared(targ);
+
+	if (!dpi_inited) {
+		uint32_t n_threads = count_fm_cores();
+		const char *dpi_params[16];
+
+		plogx_info("Initializing DPI with %u threads\n", n_threads);
+		dpi_inited = 1;
+
+		PROX_PANIC(targ->n_dpi_engine_args > 16, "Too many DPI arguments");
+		for (size_t i = 0; i < targ->n_dpi_engine_args && i < 16; ++i)
+			dpi_params[i] = targ->dpi_engine_args[i];
+
+		int ret = task->dpi_engine.dpi_init(n_threads, targ->n_dpi_engine_args, dpi_params);
+
+		PROX_PANIC(ret, "Failed to initialize DPI engine\n");
+	}
+}
+
+static void start_first(struct task_base *tbase)
+{
+	struct task_fm *task = (struct task_fm *)tbase;
+	void *ret = task->dpi_engine.dpi_thread_start();
+
+	task->dpi_shared->dpi_opaque = ret;
+	PROX_PANIC(ret == NULL, "dpi_thread_init failed\n");
+}
+
+static void start(struct task_base *tbase)
+{
+	struct task_fm *task = (struct task_fm *)tbase;
+
+	task->dpi_opaque = task->dpi_shared->dpi_opaque;
+	PROX_PANIC(task->dpi_opaque == NULL, "dpi_opaque == NULL");
+}
+
+static void stop(struct task_base *tbase)
+{
+	struct task_fm *task = (struct task_fm *)tbase;
+
+	size_t expired = kv_store_expire_expire_all(task->kv_store_expire);
+	size_t size = kv_store_expire_size(task->kv_store_expire);
+
+	plogx_info("%zu/%zu\n", expired, size);
+}
+
+static void stop_last(struct task_base *tbase)
+{
+	struct task_fm *task = (struct task_fm *)tbase;
+
+	task->dpi_engine.dpi_thread_stop(task->dpi_shared->dpi_opaque);
+	task->dpi_shared->dpi_opaque = NULL;
+}
+
+static struct task_init task_init_fm = {
+	.mode_str = "fm",
+	.init = init_task_fm,
+	.handle = handle_fm_bulk,
+	.start = start,
+	.stop = stop,
+	.start_first = start_first,
+	.stop_last = stop_last,
+	.size = sizeof(struct task_fm)
+};
+
+__attribute__((constructor)) static void reg_task_fm(void)
+{
+	reg_task(&task_init_fm);
+}
diff --git a/VNFs/DPPD-PROX/handle_gen.c b/VNFs/DPPD-PROX/handle_gen.c
new file mode 100644
index 00000000..e5e43fca
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_gen.c
@@ -0,0 +1,1481 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mbuf.h>
+#include <pcap.h>
+#include <string.h>
+#include <stdlib.h>
+#include <rte_cycles.h>
+#include <rte_version.h>
+#include <rte_byteorder.h>
+#include <rte_ether.h>
+
+#include "prox_shared.h"
+#include "random.h"
+#include "prox_malloc.h"
+#include "handle_gen.h"
+#include "handle_lat.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "prox_port_cfg.h"
+#include "lconf.h"
+#include "log.h"
+#include "quit.h"
+#include "prox_cfg.h"
+#include "mbuf_utils.h"
+#include "qinq.h"
+#include "prox_cksum.h"
+#include "etypes.h"
+#include "prox_assert.h"
+#include "prefetch.h"
+#include "token_time.h"
+#include "local_mbuf.h"
+#include "arp.h"
+#include "tx_pkt.h"
+#include <rte_hash_crc.h>
+
+struct pkt_template {
+	uint64_t dst_mac;
+	uint32_t ip_src;
+	uint32_t ip_dst_pos;
+	uint16_t len;
+	uint16_t l2_len;
+	uint16_t l3_len;
+	uint8_t  buf[ETHER_MAX_LEN];
+};
+
+#define FLAG_DST_MAC_KNOWN	1
+#define FLAG_L3_GEN		2
+#define FLAG_RANDOM_IPS		4
+
+#define MAX_TEMPLATE_INDEX	65536
+#define TEMPLATE_INDEX_MASK	(MAX_TEMPLATE_INDEX - 1)
+#define MBUF_ARP		MAX_TEMPLATE_INDEX
+
+#define IP4(x) x & 0xff, (x >> 8) & 0xff, (x >> 16) & 0xff, x >> 24
+
+static void pkt_template_init_mbuf(struct pkt_template *pkt_template, struct rte_mbuf *mbuf, uint8_t *pkt)
+{
+	const uint32_t pkt_size = pkt_template->len;
+
+	rte_pktmbuf_pkt_len(mbuf) = pkt_size;
+	rte_pktmbuf_data_len(mbuf) = pkt_size;
+	init_mbuf_seg(mbuf);
+	rte_memcpy(pkt, pkt_template->buf, pkt_template->len);
+}
+
+struct task_gen_pcap {
+	struct task_base base;
+	uint64_t hz;
+	struct local_mbuf local_mbuf;
+	uint32_t pkt_idx;
+	struct pkt_template *proto;
+	uint32_t loop;
+	uint32_t n_pkts;
+	uint64_t last_tsc;
+	uint64_t *proto_tsc;
+};
+
+struct task_gen {
+	struct task_base base;
+	uint64_t hz;
+	uint64_t link_speed;
+	struct token_time token_time;
+	struct local_mbuf local_mbuf;
+	struct pkt_template *pkt_template; /* packet templates used at runtime */
+	uint64_t write_duration_estimate; /* how long it took previously to write the time stamps in the packets */
+	uint64_t earliest_tsc_next_pkt;
+	uint64_t new_rate_bps;
+	uint64_t pkt_queue_index;
+	uint32_t n_pkts; /* number of packets in pcap */
+	uint32_t pkt_idx; /* current packet from pcap */
+	uint32_t pkt_count; /* how many pakets to generate */
+	uint32_t runtime_flags;
+	uint16_t lat_pos;
+	uint16_t packet_id_pos;
+	uint16_t accur_pos;
+	uint16_t sig_pos;
+	uint32_t sig;
+	uint8_t generator_id;
+	uint8_t n_rands; /* number of randoms */
+	uint8_t min_bulk_size;
+	uint8_t max_bulk_size;
+	uint8_t lat_enabled;
+	uint8_t runtime_checksum_needed;
+	struct {
+		struct random state;
+		uint32_t rand_mask; /* since the random vals are uniform, masks don't introduce bias  */
+		uint32_t fixed_bits; /* length of each random (max len = 4) */
+		uint16_t rand_offset; /* each random has an offset*/
+		uint8_t rand_len; /* # bytes to take from random (no bias introduced) */
+	} rand[64];
+	uint64_t accur[64];
+	uint64_t pkt_tsc_offset[64];
+	struct pkt_template *pkt_template_orig; /* packet templates (from inline or from pcap) */
+	struct ether_addr gw_mac;
+	struct ether_addr  src_mac;
+	struct rte_hash  *mac_hash;
+	uint64_t *dst_mac;
+	uint32_t gw_ip;
+	uint32_t src_ip;
+	uint8_t flags;
+	uint8_t cksum_offload;
+} __rte_cache_aligned;
+
+static inline uint8_t ipv4_get_hdr_len(struct ipv4_hdr *ip)
+{
+	/* Optimize for common case of IPv4 header without options. */
+	if (ip->version_ihl == 0x45)
+		return sizeof(struct ipv4_hdr);
+	if (unlikely(ip->version_ihl >> 4 != 4)) {
+		plog_warn("IPv4 ether_type but IP version = %d != 4", ip->version_ihl >> 4);
+		return 0;
+	}
+	return (ip->version_ihl & 0xF) * 4;
+}
+
+static void parse_l2_l3_len(uint8_t *pkt, uint16_t *l2_len, uint16_t *l3_len, uint16_t len)
+{
+	*l2_len = sizeof(struct ether_hdr);
+	*l3_len = 0;
+	struct vlan_hdr *vlan_hdr;
+	struct ether_hdr *eth_hdr = (struct ether_hdr*)pkt;
+	struct ipv4_hdr *ip;
+	uint16_t ether_type = eth_hdr->ether_type;
+
+	// Unstack VLAN tags
+	while (((ether_type == ETYPE_8021ad) || (ether_type == ETYPE_VLAN)) && (*l2_len + sizeof(struct vlan_hdr) < len)) {
+		vlan_hdr = (struct vlan_hdr *)(pkt + *l2_len);
+		*l2_len +=4;
+		ether_type = vlan_hdr->eth_proto;
+	}
+
+	// No L3 cksum offload for IPv6, but TODO L4 offload
+	// ETYPE_EoGRE CRC not implemented yet
+
+	switch (ether_type) {
+	case ETYPE_MPLSU:
+	case ETYPE_MPLSM:
+		*l2_len +=4;
+		break;
+	case ETYPE_IPv4:
+		break;
+	case ETYPE_EoGRE:
+	case ETYPE_ARP:
+	case ETYPE_IPv6:
+		*l2_len = 0;
+		break;
+	default:
+		*l2_len = 0;
+		plog_warn("Unsupported packet type %x - CRC might be wrong\n", ether_type);
+		break;
+	}
+
+	if (*l2_len) {
+		struct ipv4_hdr *ip = (struct ipv4_hdr *)(pkt + *l2_len);
+		*l3_len = ipv4_get_hdr_len(ip);
+	}
+}
+
+static void checksum_packet(uint8_t *hdr, struct rte_mbuf *mbuf, struct pkt_template *pkt_template, int cksum_offload)
+{
+	uint16_t l2_len = pkt_template->l2_len;
+	uint16_t l3_len = pkt_template->l3_len;
+
+	if (l2_len) {
+		struct ipv4_hdr *ip = (struct ipv4_hdr*)(hdr + l2_len);
+		prox_ip_udp_cksum(mbuf, ip, l2_len, l3_len, cksum_offload);
+	}
+}
+
+static void task_gen_reset_token_time(struct task_gen *task)
+{
+	token_time_set_bpp(&task->token_time, task->new_rate_bps);
+	token_time_reset(&task->token_time, rte_rdtsc(), 0);
+}
+
+static void start(struct task_base *tbase)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+	task->pkt_queue_index = 0;
+
+	task_gen_reset_token_time(task);
+}
+
+static void start_pcap(struct task_base *tbase)
+{
+	struct task_gen_pcap *task = (struct task_gen_pcap *)tbase;
+	/* When we start, the first packet is sent immediately. */
+	task->last_tsc = rte_rdtsc() - task->proto_tsc[0];
+	task->pkt_idx = 0;
+}
+
+static void task_gen_take_count(struct task_gen *task, uint32_t send_bulk)
+{
+	if (task->pkt_count == (uint32_t)-1)
+		return ;
+	else {
+		if (task->pkt_count >= send_bulk)
+			task->pkt_count -= send_bulk;
+		else
+			task->pkt_count = 0;
+	}
+}
+
+static int handle_gen_pcap_bulk(struct task_base *tbase, struct rte_mbuf **mbuf, uint16_t n_pkts)
+{
+	struct task_gen_pcap *task = (struct task_gen_pcap *)tbase;
+	uint64_t now = rte_rdtsc();
+	uint64_t send_bulk = 0;
+	uint32_t pkt_idx_tmp = task->pkt_idx;
+
+	if (pkt_idx_tmp == task->n_pkts) {
+		PROX_ASSERT(task->loop);
+		return 0;
+	}
+
+	for (uint16_t j = 0; j < 64; ++j) {
+		uint64_t tsc = task->proto_tsc[pkt_idx_tmp];
+		if (task->last_tsc + tsc <= now) {
+			task->last_tsc += tsc;
+			send_bulk++;
+			pkt_idx_tmp++;
+			if (pkt_idx_tmp == task->n_pkts) {
+				if (task->loop)
+					pkt_idx_tmp = 0;
+				else
+					break;
+			}
+		}
+		else
+			break;
+	}
+
+	struct rte_mbuf **new_pkts = local_mbuf_refill_and_take(&task->local_mbuf, send_bulk);
+	if (new_pkts == NULL)
+		return 0;
+
+	for (uint16_t j = 0; j < send_bulk; ++j) {
+		struct rte_mbuf *next_pkt = new_pkts[j];
+		struct pkt_template *pkt_template = &task->proto[task->pkt_idx];
+		uint8_t *hdr = rte_pktmbuf_mtod(next_pkt, uint8_t *);
+
+		pkt_template_init_mbuf(pkt_template, next_pkt, hdr);
+
+		task->pkt_idx++;
+		if (task->pkt_idx == task->n_pkts) {
+			if (task->loop)
+				task->pkt_idx = 0;
+			else
+				break;
+		}
+	}
+
+	return task->base.tx_pkt(&task->base, new_pkts, send_bulk, NULL);
+}
+
+static uint64_t bytes_to_tsc(struct task_gen *task, uint32_t bytes)
+{
+	const uint64_t hz = task->hz;
+	const uint64_t bytes_per_hz = task->link_speed;
+
+	if (bytes_per_hz == UINT64_MAX)
+		return 0;
+
+	return hz * bytes / bytes_per_hz;
+}
+
+static uint32_t task_gen_next_pkt_idx(const struct task_gen *task, uint32_t pkt_idx)
+{
+	return pkt_idx + 1 == task->n_pkts? 0 : pkt_idx + 1;
+}
+
+static uint32_t task_gen_offset_pkt_idx(const struct task_gen *task, uint32_t offset)
+{
+	return (task->pkt_idx + offset) % task->n_pkts;
+}
+
+static uint32_t task_gen_calc_send_bulk(const struct task_gen *task, uint32_t *total_bytes)
+{
+	/* The biggest bulk we allow to send is task->max_bulk_size
+	   packets. The max bulk size can also be limited by the
+	   pkt_count field.  At the same time, we are rate limiting
+	   based on the specified speed (in bytes per second) so token
+	   bucket based rate limiting must also be applied. The
+	   minimum bulk size is also constrained. If the calculated
+	   bulk size is less then the minimum, then don't send
+	   anything. */
+
+	const uint32_t min_bulk = task->min_bulk_size;
+	uint32_t max_bulk = task->max_bulk_size;
+
+	if (task->pkt_count != (uint32_t)-1 && task->pkt_count < max_bulk) {
+		max_bulk = task->pkt_count;
+	}
+
+	uint32_t send_bulk = 0;
+	uint32_t pkt_idx_tmp = task->pkt_idx;
+	uint32_t would_send_bytes = 0;
+	uint32_t pkt_size;
+
+	/*
+	 * TODO - this must be improved to take into account the fact that, after applying randoms
+	 * The packet can be replaced by an ARP
+	 */
+	for (uint16_t j = 0; j < max_bulk; ++j) {
+		struct pkt_template *pktpl = &task->pkt_template[pkt_idx_tmp];
+		if (unlikely((task->flags & (FLAG_L3_GEN | FLAG_DST_MAC_KNOWN)) == FLAG_L3_GEN))  {
+			// Generator is supposed to get MAC address - MAC is still unknown for this template
+			// generate ARP Request to gateway instead of the intended packet
+			pkt_size = 60;
+		} else {
+			pkt_size = pktpl->len;
+		}
+		uint32_t pkt_len = pkt_len_to_wire_size(pkt_size);
+		if (pkt_len + would_send_bytes > task->token_time.bytes_now)
+			break;
+
+		pkt_idx_tmp = task_gen_next_pkt_idx(task, pkt_idx_tmp);
+
+		send_bulk++;
+		would_send_bytes += pkt_len;
+	}
+
+	if (send_bulk < min_bulk)
+		return 0;
+	*total_bytes = would_send_bytes;
+	return send_bulk;
+}
+
+static inline void create_arp(struct rte_mbuf *mbuf, uint8_t *pkt_hdr, uint64_t *src_mac, uint32_t ip_dst, uint32_t ip_src)
+{
+	uint64_t mac_bcast = 0xFFFFFFFFFFFF;
+	rte_pktmbuf_pkt_len(mbuf) = 42;
+	rte_pktmbuf_data_len(mbuf) = 42;
+	init_mbuf_seg(mbuf);
+	struct ether_hdr_arp *hdr_arp = (struct ether_hdr_arp *)pkt_hdr;
+
+	memcpy(&hdr_arp->ether_hdr.d_addr.addr_bytes, &mac_bcast, 6);
+	memcpy(&hdr_arp->ether_hdr.s_addr.addr_bytes, src_mac, 6);
+	hdr_arp->ether_hdr.ether_type = ETYPE_ARP;
+	hdr_arp->arp.htype = 0x100,
+	hdr_arp->arp.ptype = 0x0008;
+	hdr_arp->arp.hlen = 6;
+	hdr_arp->arp.plen = 4;
+	hdr_arp->arp.oper = 0x100;
+	hdr_arp->arp.data.spa = ip_src;
+	hdr_arp->arp.data.tpa = ip_dst;
+	memset(&hdr_arp->arp.data.tha, 0, sizeof(struct ether_addr));
+	memcpy(&hdr_arp->arp.data.sha, src_mac, sizeof(struct ether_addr));
+}
+
+static int task_gen_write_dst_mac(struct task_gen *task, struct rte_mbuf **mbufs, uint8_t **pkt_hdr, uint32_t count)
+{
+	uint32_t ip_dst_pos, ip_src_pos, ip_dst, ip_src;
+	uint16_t i;
+	int ret;
+
+	if (task->flags & FLAG_L3_GEN) {
+		if (task->gw_ip) {
+			if (unlikely((task->flags & FLAG_DST_MAC_KNOWN) == 0))  {
+				for (i = 0; i < count; ++i) {
+					struct pkt_template *pktpl = &task->pkt_template[mbufs[i]->udata64 & TEMPLATE_INDEX_MASK];
+					create_arp(mbufs[i], pkt_hdr[i], (uint64_t *)&pktpl->buf[6], task->gw_ip, pktpl->ip_src);
+					mbufs[i]->udata64 |= MBUF_ARP;
+				}
+			} else {
+				for (i = 0; i < count; ++i) {
+					struct ether_hdr *hdr = (struct ether_hdr *)pkt_hdr[i];
+					memcpy(&hdr->d_addr.addr_bytes, &task->gw_mac, 6);
+				}
+			}
+		} else if (unlikely((task->flags & FLAG_RANDOM_IPS) != 0) || (task->n_pkts >= 4)){
+			// Find mac in lookup table. Send ARP if not found
+			int32_t positions[MAX_PKT_BURST], idx;
+			void *keys[MAX_PKT_BURST];
+			uint32_t key[MAX_PKT_BURST];
+			for (i = 0; i < count; ++i) {
+				uint8_t *hdr = (uint8_t *)pkt_hdr[i];
+				struct pkt_template *pktpl = &task->pkt_template[mbufs[i]->udata64 & TEMPLATE_INDEX_MASK];
+				ip_dst_pos = pktpl->ip_dst_pos;
+				ip_dst = *(uint32_t *)(hdr + ip_dst_pos);
+				key[i] = ip_dst;
+				keys[i] = &key[i];
+			}
+			ret = rte_hash_lookup_bulk(task->mac_hash, (const void **)&keys, count, positions);
+			if (unlikely(ret < 0)) {
+				plogx_err("lookup_bulk failed in mac_hash\n");
+				tx_pkt_drop_all((struct task_base *)task, mbufs, count, NULL);
+				return -1;
+			}
+			for (i = 0; i < count; ++i) {
+				idx = positions[i];
+				if (unlikely(idx < 0)) {
+					// mac not found for this IP
+					struct pkt_template *pktpl = &task->pkt_template[mbufs[i]->udata64 & TEMPLATE_INDEX_MASK];
+					uint8_t *hdr = (uint8_t *)pkt_hdr[i];
+					ip_src_pos = pktpl->ip_dst_pos - 4;
+					ip_src = *(uint32_t *)(hdr + ip_src_pos);
+					create_arp(mbufs[i], pkt_hdr[i], (uint64_t *)&hdr[6], key[i], ip_src);
+					mbufs[i]->udata64 |= MBUF_ARP;
+				} else {
+					// mac found for this IP
+					struct ether_hdr_arp *hdr_arp = (struct ether_hdr_arp *)pkt_hdr[i];
+					memcpy(&hdr_arp->ether_hdr.d_addr.addr_bytes, &task->dst_mac[idx], 6);
+				}
+			}
+		} else {
+			for (i = 0; i < count; ++i) {
+				uint8_t *hdr = (uint8_t *)pkt_hdr[i];
+				struct pkt_template *pktpl = &task->pkt_template[mbufs[i]->udata64 & TEMPLATE_INDEX_MASK];
+
+				// Check if packet template already has the mac
+				if (unlikely(pktpl->dst_mac == 0)) {
+					// no random_ip, can take from from packet template but no mac (yet)
+					uint32_t ip_dst_pos = pktpl->ip_dst_pos;
+					ip_dst = *(uint32_t *)(hdr + ip_dst_pos);
+					create_arp(mbufs[i], pkt_hdr[i], (uint64_t *)&pktpl->buf[6], ip_dst, pktpl->ip_src);
+					mbufs[i]->udata64 |= MBUF_ARP;
+				} else {
+					// no random ip, mac known
+					struct ether_hdr_arp *hdr_arp = (struct ether_hdr_arp *)pkt_hdr[i];
+					memcpy(&hdr_arp->ether_hdr.d_addr.addr_bytes, &pktpl->dst_mac, 6);
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+static void task_gen_apply_random_fields(struct task_gen *task, uint8_t *hdr)
+{
+	uint32_t ret, ret_tmp;
+
+	for (uint16_t i = 0; i < task->n_rands; ++i) {
+		ret = random_next(&task->rand[i].state);
+		ret_tmp = (ret & task->rand[i].rand_mask) | task->rand[i].fixed_bits;
+
+		ret_tmp = rte_bswap32(ret_tmp);
+		/* At this point, the lower order bytes (BE) contain
+		   the generated value. The address where the values
+		   of interest starts is at ret_tmp + 4 - rand_len. */
+		uint8_t *pret_tmp = (uint8_t*)&ret_tmp;
+		rte_memcpy(hdr + task->rand[i].rand_offset, pret_tmp + 4 - task->rand[i].rand_len, task->rand[i].rand_len);
+	}
+}
+
+static void task_gen_apply_all_random_fields(struct task_gen *task, uint8_t **pkt_hdr, uint32_t count)
+{
+	if (!task->n_rands)
+		return;
+
+	for (uint16_t i = 0; i < count; ++i)
+		task_gen_apply_random_fields(task, pkt_hdr[i]);
+}
+
+static void task_gen_apply_accur_pos(struct task_gen *task, uint8_t *pkt_hdr, uint32_t accuracy)
+{
+	*(uint32_t *)(pkt_hdr + task->accur_pos) = accuracy;
+}
+
+static void task_gen_apply_sig(struct task_gen *task, uint8_t *pkt_hdr)
+{
+	*(uint32_t *)(pkt_hdr + task->sig_pos) = task->sig;
+}
+
+static void task_gen_apply_all_accur_pos(struct task_gen *task, struct rte_mbuf **mbufs, uint8_t **pkt_hdr, uint32_t count)
+{
+	if (!task->accur_pos)
+		return;
+
+	/* The accuracy of task->pkt_queue_index - 64 is stored in
+	   packet task->pkt_queue_index. The ID modulo 64 is the
+	   same. */
+	for (uint16_t j = 0; j < count; ++j) {
+		if ((mbufs[j]->udata64 & MBUF_ARP) == 0) {
+			uint32_t accuracy = task->accur[(task->pkt_queue_index + j) & 63];
+			task_gen_apply_accur_pos(task, pkt_hdr[j], accuracy);
+		}
+	}
+}
+
+static void task_gen_apply_all_sig(struct task_gen *task, struct rte_mbuf **mbufs, uint8_t **pkt_hdr, uint32_t count)
+{
+	if (!task->sig_pos)
+		return;
+
+	for (uint16_t j = 0; j < count; ++j) {
+		if ((mbufs[j]->udata64 & MBUF_ARP) == 0) {
+			task_gen_apply_sig(task, pkt_hdr[j]);
+		}
+	}
+}
+
+static void task_gen_apply_unique_id(struct task_gen *task, uint8_t *pkt_hdr, const struct unique_id *id)
+{
+	struct unique_id *dst = (struct unique_id *)(pkt_hdr + task->packet_id_pos);
+
+	*dst = *id;
+}
+
+static void task_gen_apply_all_unique_id(struct task_gen *task, struct rte_mbuf **mbufs, uint8_t **pkt_hdr, uint32_t count)
+{
+	if (!task->packet_id_pos)
+		return;
+
+	for (uint16_t i = 0; i < count; ++i) {
+		if ((mbufs[i]->udata64 & MBUF_ARP) == 0) {
+			struct unique_id id;
+			unique_id_init(&id, task->generator_id, task->pkt_queue_index++);
+			task_gen_apply_unique_id(task, pkt_hdr[i], &id);
+		}
+	}
+}
+
+static void task_gen_checksum_packets(struct task_gen *task, struct rte_mbuf **mbufs, uint8_t **pkt_hdr, uint32_t count)
+{
+	if (!(task->runtime_flags & TASK_TX_CRC))
+		return;
+
+	if (!task->runtime_checksum_needed)
+		return;
+
+	uint32_t pkt_idx = task_gen_offset_pkt_idx(task, - count);
+	for (uint16_t i = 0; i < count; ++i) {
+		if ((mbufs[i]->udata64 & MBUF_ARP) == 0) {
+			struct pkt_template *pkt_template = &task->pkt_template[pkt_idx];
+			checksum_packet(pkt_hdr[i], mbufs[i], pkt_template, task->cksum_offload);
+			pkt_idx = task_gen_next_pkt_idx(task, pkt_idx);
+		}
+	}
+}
+
+static void task_gen_consume_tokens(struct task_gen *task, uint32_t tokens, uint32_t send_count)
+{
+	/* If max burst has been sent, we can't keep up so just assume
+	   that we can (leaving a "gap" in the packet stream on the
+	   wire) */
+	task->token_time.bytes_now -= tokens;
+	if (send_count == task->max_bulk_size && task->token_time.bytes_now > tokens) {
+		task->token_time.bytes_now = tokens;
+	}
+}
+
+static uint64_t task_gen_calc_bulk_duration(struct task_gen *task, uint32_t count)
+{
+	uint32_t pkt_idx = task_gen_offset_pkt_idx(task, - 1);
+	struct pkt_template *last_pkt_template = &task->pkt_template[pkt_idx];
+	uint32_t last_pkt_len = pkt_len_to_wire_size(last_pkt_template->len);
+	uint64_t last_pkt_duration = bytes_to_tsc(task, last_pkt_len);
+	uint64_t bulk_duration = task->pkt_tsc_offset[count - 1] + last_pkt_duration;
+
+	return bulk_duration;
+}
+
+static uint64_t task_gen_write_latency(struct task_gen *task, uint8_t **pkt_hdr, uint32_t count)
+{
+	if (!task->lat_enabled)
+		return 0;
+
+	uint64_t tx_tsc, delta_t;
+	uint64_t tsc_before_tx = 0;
+
+	/* Just before sending the packets, apply the time stamp
+	   relative to when the first packet will be sent. The first
+	   packet will be sent now. The time is read for each packet
+	   to reduce the error towards the actual time the packet will
+	   be sent. */
+	uint64_t write_tsc_after, write_tsc_before;
+
+	write_tsc_before = rte_rdtsc();
+
+	/* The time it took previously to write the time stamps in the
+	   packets is used as an estimate for how long it will take to
+	   write the time stamps now.  The estimated time at which the
+	   packets will actually be sent will be at tx_tsc. */
+	tx_tsc = write_tsc_before + task->write_duration_estimate;
+
+	/* The offset delta_t tracks the difference between the actual
+	   time and the time written in the packets. Adding the offset
+	   to the actual time insures that the time written in the
+	   packets is monotonically increasing. At the same time,
+	   simply sleeping until delta_t is zero would leave a period
+	   of silence on the line. The error has been introduced
+	   earlier, but the packets have already been sent. */
+	if (tx_tsc < task->earliest_tsc_next_pkt)
+		delta_t = task->earliest_tsc_next_pkt - tx_tsc;
+	else
+		delta_t = 0;
+
+	for (uint16_t i = 0; i < count; ++i) {
+		uint32_t *pos = (uint32_t *)(pkt_hdr[i] + task->lat_pos);
+		const uint64_t pkt_tsc = tx_tsc + delta_t + task->pkt_tsc_offset[i];
+
+		*pos = pkt_tsc >> LATENCY_ACCURACY;
+	}
+
+	uint64_t bulk_duration = task_gen_calc_bulk_duration(task, count);
+
+	task->earliest_tsc_next_pkt = tx_tsc + delta_t + bulk_duration;
+	write_tsc_after = rte_rdtsc();
+	task->write_duration_estimate = write_tsc_after - write_tsc_before;
+
+	/* Make sure that the time stamps that were written
+	   are valid. The offset must be taken into account */
+	do {
+		tsc_before_tx = rte_rdtsc();
+	} while (tsc_before_tx < tx_tsc);
+	return tsc_before_tx;
+}
+
+static void task_gen_store_accuracy(struct task_gen *task, uint32_t count, uint64_t tsc_before_tx)
+{
+	if (!task->accur_pos)
+		return;
+
+	uint64_t accur = rte_rdtsc() - tsc_before_tx;
+	uint64_t first_accuracy_idx = task->pkt_queue_index - count;
+
+	for (uint32_t i = 0; i < count; ++i) {
+		uint32_t accuracy_idx = (first_accuracy_idx + i) & 63;
+
+		task->accur[accuracy_idx] = accur;
+	}
+}
+
+static void task_gen_load_and_prefetch(struct rte_mbuf **mbufs, uint8_t **pkt_hdr, uint32_t count)
+{
+	for (uint16_t i = 0; i < count; ++i)
+		rte_prefetch0(mbufs[i]);
+	for (uint16_t i = 0; i < count; ++i)
+		pkt_hdr[i] = rte_pktmbuf_mtod(mbufs[i], uint8_t *);
+	for (uint16_t i = 0; i < count; ++i)
+		rte_prefetch0(pkt_hdr[i]);
+}
+
+static void task_gen_build_packets(struct task_gen *task, struct rte_mbuf **mbufs, uint8_t **pkt_hdr, uint32_t count)
+{
+	uint64_t will_send_bytes = 0;
+
+	for (uint16_t i = 0; i < count; ++i) {
+		struct pkt_template *pktpl = &task->pkt_template[task->pkt_idx];
+		struct pkt_template *pkt_template = &task->pkt_template[task->pkt_idx];
+		pkt_template_init_mbuf(pkt_template, mbufs[i], pkt_hdr[i]);
+		mbufs[i]->udata64 = task->pkt_idx & TEMPLATE_INDEX_MASK;
+		struct ether_hdr *hdr = (struct ether_hdr *)pkt_hdr[i];
+		if (task->lat_enabled) {
+			task->pkt_tsc_offset[i] = bytes_to_tsc(task, will_send_bytes);
+			will_send_bytes += pkt_len_to_wire_size(pkt_template->len);
+		}
+		task->pkt_idx = task_gen_next_pkt_idx(task, task->pkt_idx);
+	}
+}
+
+static void task_gen_update_config(struct task_gen *task)
+{
+	if (task->token_time.cfg.bpp != task->new_rate_bps)
+		task_gen_reset_token_time(task);
+}
+
+static inline void handle_arp_pkts(struct task_gen *task, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	int j;
+	int ret;
+	struct ether_hdr_arp *hdr;
+	uint8_t out[MAX_PKT_BURST];
+	static struct my_arp_t arp_reply = {
+		.htype = 0x100,
+		.ptype = 8,
+		.hlen = 6,
+		.plen = 4,
+		.oper = 0x200
+	};
+	static struct my_arp_t arp_request = {
+		.htype = 0x100,
+		.ptype = 8,
+		.hlen = 6,
+		.plen = 4,
+		.oper = 0x100
+	};
+
+	for (j = 0; j < n_pkts; ++j) {
+		PREFETCH0(mbufs[j]);
+	}
+	for (j = 0; j < n_pkts; ++j) {
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j], void *));
+	}
+	for (j = 0; j < n_pkts; ++j) {
+		hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr_arp *);
+		if (hdr->ether_hdr.ether_type == ETYPE_ARP) {
+			if (memcmp(&hdr->arp, &arp_reply, 8) == 0) {
+				uint32_t ip = hdr->arp.data.spa;
+				// plog_info("Received ARP Reply for IP %x\n",ip);
+				if (ip == task->gw_ip) {
+					memcpy(&task->gw_mac, &hdr->arp.data.sha, 6);;
+					task->flags |= FLAG_DST_MAC_KNOWN;
+					out[j] = OUT_HANDLED;
+					continue;
+				} else if ((task->n_pkts >= 4) || (task->flags & FLAG_RANDOM_IPS)) {
+					// Ideally, we should add the key when making the arp request,
+					// We should only store the mac address key was created.
+					// Here we are storing MAC we did not asked for...
+					ret = rte_hash_add_key(task->mac_hash, (const void *)&ip);
+					if (ret < 0) {
+						plogx_info("Unable add ip %d.%d.%d.%d in mac_hash\n", IP4(ip));
+						out[j] = OUT_DISCARD;
+					} else {
+						task->dst_mac[ret] = *(uint64_t *)&(hdr->arp.data.sha);
+						out[j] = OUT_HANDLED;
+					}
+					continue;
+				}
+				// Need to find template back...
+				// Only try this if there are few templates
+				for (unsigned int idx = 0; idx < task->n_pkts; idx++) {
+					struct pkt_template *pktpl = &task->pkt_template[idx];
+					uint32_t ip_dst_pos = pktpl->ip_dst_pos;
+					uint32_t *ip_dst = (uint32_t *)(((uint8_t *)pktpl->buf) + ip_dst_pos);
+					if (*ip_dst == ip) {
+						pktpl->dst_mac = *(uint64_t *)&(hdr->arp.data.sha);
+					}
+					out[j] = OUT_HANDLED;
+				}
+			} else if (memcmp(&hdr->arp, &arp_request, 8) == 0) {
+				struct ether_addr s_addr;
+				if (!task->src_ip) {
+					create_mac(hdr, &s_addr);
+					prepare_arp_reply(hdr, &s_addr);
+					memcpy(hdr->ether_hdr.d_addr.addr_bytes, hdr->ether_hdr.s_addr.addr_bytes, 6);
+					memcpy(hdr->ether_hdr.s_addr.addr_bytes, &s_addr, 6);
+					out[j] = 0;
+				} else if (hdr->arp.data.tpa == task->src_ip) {
+					prepare_arp_reply(hdr, &task->src_mac);
+					memcpy(hdr->ether_hdr.d_addr.addr_bytes, hdr->ether_hdr.s_addr.addr_bytes, 6);
+					memcpy(hdr->ether_hdr.s_addr.addr_bytes, &task->src_mac, 6);
+					out[j] = 0;
+				} else {
+					out[j] = OUT_DISCARD;
+					plogx_dbg("Received ARP on unexpected IP %x, expecting %x\n", rte_be_to_cpu_32(hdr->arp.data.tpa), rte_be_to_cpu_32(task->src_ip));
+				}
+			}
+		} else {
+			out[j] = OUT_DISCARD;
+		}
+	}
+	ret = task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static int handle_gen_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+	uint8_t out[MAX_PKT_BURST] = {0};
+	int ret;
+
+	int i, j;
+
+	if (unlikely((task->flags & FLAG_L3_GEN) && (n_pkts != 0))) {
+		handle_arp_pkts(task, mbufs, n_pkts);
+	}
+
+	task_gen_update_config(task);
+
+	if (task->pkt_count == 0) {
+		task_gen_reset_token_time(task);
+		return 0;
+	}
+	if (!task->token_time.cfg.bpp)
+		return 0;
+
+	token_time_update(&task->token_time, rte_rdtsc());
+
+	uint32_t would_send_bytes;
+	const uint32_t send_bulk = task_gen_calc_send_bulk(task, &would_send_bytes);
+
+	if (send_bulk == 0)
+		return 0;
+	task_gen_take_count(task, send_bulk);
+	task_gen_consume_tokens(task, would_send_bytes, send_bulk);
+
+	struct rte_mbuf **new_pkts = local_mbuf_refill_and_take(&task->local_mbuf, send_bulk);
+	if (new_pkts == NULL)
+		return 0;
+	uint8_t *pkt_hdr[MAX_RING_BURST];
+
+	task_gen_load_and_prefetch(new_pkts, pkt_hdr, send_bulk);
+	task_gen_build_packets(task, new_pkts, pkt_hdr, send_bulk);
+	task_gen_apply_all_random_fields(task, pkt_hdr, send_bulk);
+	if (task_gen_write_dst_mac(task, new_pkts, pkt_hdr, send_bulk) < 0)
+		return 0;
+	task_gen_apply_all_accur_pos(task, new_pkts, pkt_hdr, send_bulk);
+	task_gen_apply_all_sig(task, new_pkts, pkt_hdr, send_bulk);
+	task_gen_apply_all_unique_id(task, new_pkts, pkt_hdr, send_bulk);
+
+	uint64_t tsc_before_tx;
+
+	tsc_before_tx = task_gen_write_latency(task, pkt_hdr, send_bulk);
+	task_gen_checksum_packets(task, new_pkts, pkt_hdr, send_bulk);
+	ret = task->base.tx_pkt(&task->base, new_pkts, send_bulk, out);
+	task_gen_store_accuracy(task, send_bulk, tsc_before_tx);
+	return ret;
+}
+
+static void init_task_gen_seeds(struct task_gen *task)
+{
+	for (size_t i = 0; i < sizeof(task->rand)/sizeof(task->rand[0]); ++i)
+		random_init_seed(&task->rand[i].state);
+}
+
+static uint32_t pcap_count_pkts(pcap_t *handle)
+{
+	struct pcap_pkthdr header;
+	const uint8_t *buf;
+	uint32_t ret = 0;
+	long pkt1_fpos = ftell(pcap_file(handle));
+
+	while ((buf = pcap_next(handle, &header))) {
+		ret++;
+	}
+	int ret2 = fseek(pcap_file(handle), pkt1_fpos, SEEK_SET);
+	PROX_PANIC(ret2 != 0, "Failed to reset reading pcap file\n");
+	return ret;
+}
+
+static uint64_t avg_time_stamp(uint64_t *time_stamp, uint32_t n)
+{
+	uint64_t tot_inter_pkt = 0;
+
+	for (uint32_t i = 0; i < n; ++i)
+		tot_inter_pkt += time_stamp[i];
+	return (tot_inter_pkt + n / 2)/n;
+}
+
+static int pcap_read_pkts(pcap_t *handle, const char *file_name, uint32_t n_pkts, struct pkt_template *proto, uint64_t *time_stamp)
+{
+	struct pcap_pkthdr header;
+	const uint8_t *buf;
+	size_t len;
+
+	for (uint32_t i = 0; i < n_pkts; ++i) {
+		buf = pcap_next(handle, &header);
+
+		PROX_PANIC(buf == NULL, "Failed to read packet %d from pcap %s\n", i, file_name);
+		proto[i].len = header.len;
+		len = RTE_MIN(header.len, sizeof(proto[i].buf));
+		if (header.len > len)
+			plogx_warn("Packet truncated from %u to %zu bytes\n", header.len, len);
+
+		if (time_stamp) {
+			static struct timeval beg;
+			struct timeval tv;
+
+			if (i == 0)
+				beg = header.ts;
+
+			tv = tv_diff(&beg, &header.ts);
+			tv_to_tsc(&tv, time_stamp + i);
+		}
+		rte_memcpy(proto[i].buf, buf, len);
+	}
+
+	if (time_stamp && n_pkts) {
+		for (uint32_t i = n_pkts - 1; i > 0; --i)
+			time_stamp[i] -= time_stamp[i - 1];
+		/* Since the handle function will loop the packets,
+		   there is one time-stamp that is not provided by the
+		   pcap file. This is the time between the last and
+		   the first packet. This implementation takes the
+		   average of the inter-packet times here. */
+		if (n_pkts > 1)
+			time_stamp[0] = avg_time_stamp(time_stamp + 1, n_pkts - 1);
+	}
+
+	return 0;
+}
+
+static int check_pkt_size(struct task_gen *task, uint32_t pkt_size, int do_panic)
+{
+	const uint16_t min_len = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr);
+	const uint16_t max_len = ETHER_MAX_LEN - 4;
+
+	if (do_panic) {
+		PROX_PANIC(pkt_size == 0, "Invalid packet size length (no packet defined?)\n");
+		PROX_PANIC(pkt_size > max_len, "pkt_size out of range (must be <= %u)\n", max_len);
+		PROX_PANIC(pkt_size < min_len, "pkt_size out of range (must be >= %u)\n", min_len);
+		return 0;
+	} else {
+		if (pkt_size == 0) {
+			plog_err("Invalid packet size length (no packet defined?)\n");
+			return -1;
+		}
+		if (pkt_size > max_len) {
+			plog_err("pkt_size out of range (must be <= %u)\n", max_len);
+			return -1;
+		}
+		if (pkt_size < min_len) {
+			plog_err("pkt_size out of range (must be >= %u)\n", min_len);
+			return -1;
+		}
+		return 0;
+	}
+}
+
+static int check_all_pkt_size(struct task_gen *task, int do_panic)
+{
+	int rc;
+	for (uint32_t i = 0; i < task->n_pkts;++i) {
+		if ((rc = check_pkt_size(task, task->pkt_template[i].len, do_panic)) != 0)
+			return rc;
+	}
+	return 0;
+}
+
+static void check_fields_in_bounds(struct task_gen *task)
+{
+	const uint32_t pkt_size = task->pkt_template[0].len;
+
+	if (task->lat_enabled) {
+		uint32_t pos_beg = task->lat_pos;
+		uint32_t pos_end = task->lat_pos + 3U;
+
+		PROX_PANIC(pkt_size <= pos_end, "Writing latency at %u-%u, but packet size is %u bytes\n",
+			   pos_beg, pos_end, pkt_size);
+	}
+	if (task->packet_id_pos) {
+		uint32_t pos_beg = task->packet_id_pos;
+		uint32_t pos_end = task->packet_id_pos + 4U;
+
+		PROX_PANIC(pkt_size <= pos_end, "Writing packet at %u-%u, but packet size is %u bytes\n",
+			   pos_beg, pos_end, pkt_size);
+	}
+	if (task->accur_pos) {
+		uint32_t pos_beg = task->accur_pos;
+		uint32_t pos_end = task->accur_pos + 3U;
+
+		PROX_PANIC(pkt_size <= pos_end, "Writing accuracy at %u%-u, but packet size is %u bytes\n",
+			   pos_beg, pos_end, pkt_size);
+	}
+}
+
+static void task_gen_pkt_template_recalc_metadata(struct task_gen *task)
+{
+	struct pkt_template *template;
+
+	for (size_t i = 0; i < task->n_pkts; ++i) {
+		template = &task->pkt_template[i];
+		parse_l2_l3_len(template->buf, &template->l2_len, &template->l3_len, template->len);
+	}
+}
+
+static void task_gen_pkt_template_recalc_checksum(struct task_gen *task)
+{
+	struct pkt_template *template;
+	struct ipv4_hdr *ip;
+
+	task->runtime_checksum_needed = 0;
+	for (size_t i = 0; i < task->n_pkts; ++i) {
+		template = &task->pkt_template[i];
+		if (template->l2_len == 0)
+			continue;
+		ip = (struct ipv4_hdr *)(template->buf + template->l2_len);
+
+		ip->hdr_checksum = 0;
+		prox_ip_cksum_sw(ip);
+		uint32_t l4_len = rte_bswap16(ip->total_length) - template->l3_len;
+
+		if (ip->next_proto_id == IPPROTO_UDP) {
+			struct udp_hdr *udp = (struct udp_hdr *)(((uint8_t *)ip) + template->l3_len);
+			prox_udp_cksum_sw(udp, l4_len, ip->src_addr, ip->dst_addr);
+		} else if (ip->next_proto_id == IPPROTO_TCP) {
+			struct tcp_hdr *tcp = (struct tcp_hdr *)(((uint8_t *)ip) + template->l3_len);
+			prox_tcp_cksum_sw(tcp, l4_len, ip->src_addr, ip->dst_addr);
+		}
+
+		/* The current implementation avoids checksum
+		   calculation by determining that at packet
+		   construction time, no fields are applied that would
+		   require a recalculation of the checksum. */
+		if (task->lat_enabled && task->lat_pos > template->l2_len)
+			task->runtime_checksum_needed = 1;
+		if (task->accur_pos > template->l2_len)
+			task->runtime_checksum_needed = 1;
+		if (task->packet_id_pos > template->l2_len)
+			task->runtime_checksum_needed = 1;
+	}
+}
+
+static void task_gen_pkt_template_recalc_all(struct task_gen *task)
+{
+	task_gen_pkt_template_recalc_metadata(task);
+	task_gen_pkt_template_recalc_checksum(task);
+}
+
+static void task_gen_reset_pkt_templates_len(struct task_gen *task)
+{
+	struct pkt_template *src, *dst;
+
+	for (size_t i = 0; i < task->n_pkts; ++i) {
+		src = &task->pkt_template_orig[i];
+		dst = &task->pkt_template[i];
+		dst->len = src->len;
+	}
+}
+
+static void task_gen_reset_pkt_templates_content(struct task_gen *task)
+{
+	struct pkt_template *src, *dst;
+
+	for (size_t i = 0; i < task->n_pkts; ++i) {
+		src = &task->pkt_template_orig[i];
+		dst = &task->pkt_template[i];
+		memcpy(dst->buf, src->buf, dst->len);
+	}
+}
+
+static void task_gen_reset_pkt_templates(struct task_gen *task)
+{
+	task_gen_reset_pkt_templates_len(task);
+	task_gen_reset_pkt_templates_content(task);
+	task_gen_pkt_template_recalc_all(task);
+}
+
+static void task_init_gen_load_pkt_inline(struct task_gen *task, struct task_args *targ)
+{
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	if (targ->pkt_size > sizeof(task->pkt_template[0].buf))
+		targ->pkt_size = sizeof(task->pkt_template[0].buf);
+	task->n_pkts = 1;
+
+	size_t mem_size = task->n_pkts * sizeof(*task->pkt_template);
+	task->pkt_template = prox_zmalloc(mem_size, socket_id);
+	task->pkt_template_orig = prox_zmalloc(mem_size, socket_id);
+
+	PROX_PANIC(task->pkt_template == NULL ||
+		   task->pkt_template_orig == NULL,
+		   "Failed to allocate %lu bytes (in huge pages) for pcap file\n", mem_size);
+
+	rte_memcpy(task->pkt_template_orig[0].buf, targ->pkt_inline, targ->pkt_size);
+	task->pkt_template_orig[0].len = targ->pkt_size;
+	task_gen_reset_pkt_templates(task);
+	check_all_pkt_size(task, 1);
+	check_fields_in_bounds(task);
+}
+
+static void task_init_gen_load_pcap(struct task_gen *task, struct task_args *targ)
+{
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	char err[PCAP_ERRBUF_SIZE];
+	pcap_t *handle = pcap_open_offline(targ->pcap_file, err);
+	PROX_PANIC(handle == NULL, "Failed to open PCAP file: %s\n", err);
+
+	task->n_pkts = pcap_count_pkts(handle);
+	plogx_info("%u packets in pcap file '%s'\n", task->n_pkts, targ->pcap_file);
+
+	if (targ->n_pkts)
+		task->n_pkts = RTE_MIN(task->n_pkts, targ->n_pkts);
+	PROX_PANIC(task->n_pkts > MAX_TEMPLATE_INDEX, "Too many packets specified in pcap - increase MAX_TEMPLATE_INDEX\n");
+	plogx_info("Loading %u packets from pcap\n", task->n_pkts);
+	size_t mem_size = task->n_pkts * sizeof(*task->pkt_template);
+	task->pkt_template = prox_zmalloc(mem_size, socket_id);
+	task->pkt_template_orig = prox_zmalloc(mem_size, socket_id);
+	PROX_PANIC(task->pkt_template == NULL ||
+		   task->pkt_template_orig == NULL,
+		   "Failed to allocate %lu bytes (in huge pages) for pcap file\n", mem_size);
+
+	pcap_read_pkts(handle, targ->pcap_file, task->n_pkts, task->pkt_template_orig, NULL);
+	pcap_close(handle);
+	task_gen_reset_pkt_templates(task);
+}
+
+static struct rte_mempool *task_gen_create_mempool(struct task_args *targ)
+{
+	static char name[] = "gen_pool";
+	struct rte_mempool *ret;
+	const int sock_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	name[0]++;
+	ret = rte_mempool_create(name, targ->nb_mbuf - 1, MBUF_SIZE,
+				 targ->nb_cache_mbuf, sizeof(struct rte_pktmbuf_pool_private),
+				 rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, 0,
+				 sock_id, 0);
+	PROX_PANIC(ret == NULL, "Failed to allocate dummy memory pool on socket %u with %u elements\n",
+		   sock_id, targ->nb_mbuf - 1);
+	return ret;
+}
+
+void task_gen_set_pkt_count(struct task_base *tbase, uint32_t count)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+
+	task->pkt_count = count;
+}
+
+int task_gen_set_pkt_size(struct task_base *tbase, uint32_t pkt_size)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+	int rc;
+
+	task->pkt_template[0].len = pkt_size;
+	if ((rc = check_all_pkt_size(task, 0)) != 0)
+		return rc;
+	check_fields_in_bounds(task);
+	return rc;
+}
+
+void task_gen_set_gateway_ip(struct task_base *tbase, uint32_t ip)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+	task->gw_ip = ip;
+	task->flags &= ~FLAG_DST_MAC_KNOWN;
+}
+
+void task_gen_set_rate(struct task_base *tbase, uint64_t bps)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+
+	task->new_rate_bps = bps;
+}
+
+void task_gen_reset_randoms(struct task_base *tbase)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+
+	for (uint32_t i = 0; i < task->n_rands; ++i) {
+		task->rand[i].rand_mask = 0;
+		task->rand[i].fixed_bits = 0;
+		task->rand[i].rand_offset = 0;
+	}
+	task->n_rands = 0;
+	task->flags &= ~FLAG_RANDOM_IPS;
+}
+
+int task_gen_set_value(struct task_base *tbase, uint32_t value, uint32_t offset, uint32_t len)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+
+	for (size_t i = 0; i < task->n_pkts; ++i) {
+		uint32_t to_write = rte_cpu_to_be_32(value) >> ((4 - len) * 8);
+		uint8_t *dst = task->pkt_template[i].buf;
+
+		rte_memcpy(dst + offset, &to_write, len);
+	}
+
+	task_gen_pkt_template_recalc_all(task);
+
+	return 0;
+}
+
+void task_gen_reset_values(struct task_base *tbase)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+
+	task_gen_reset_pkt_templates_content(task);
+}
+
+uint32_t task_gen_get_n_randoms(struct task_base *tbase)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+
+	return task->n_rands;
+}
+
+static void init_task_gen_pcap(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_gen_pcap *task = (struct task_gen_pcap *)tbase;
+	const uint32_t sockid = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->loop = targ->loop;
+	task->pkt_idx = 0;
+	task->hz = rte_get_tsc_hz();
+
+	task->local_mbuf.mempool = task_gen_create_mempool(targ);
+
+	PROX_PANIC(!strcmp(targ->pcap_file, ""), "No pcap file defined\n");
+
+	char err[PCAP_ERRBUF_SIZE];
+	pcap_t *handle = pcap_open_offline(targ->pcap_file, err);
+	PROX_PANIC(handle == NULL, "Failed to open PCAP file: %s\n", err);
+
+	task->n_pkts = pcap_count_pkts(handle);
+	plogx_info("%u packets in pcap file '%s'\n", task->n_pkts, targ->pcap_file);
+
+	if (targ->n_pkts) {
+		plogx_info("Configured to load %u packets\n", targ->n_pkts);
+		if (task->n_pkts > targ->n_pkts)
+			task->n_pkts = targ->n_pkts;
+	}
+	PROX_PANIC(task->n_pkts > MAX_TEMPLATE_INDEX, "Too many packets specified in pcap - increase MAX_TEMPLATE_INDEX\n");
+
+	plogx_info("Loading %u packets from pcap\n", task->n_pkts);
+
+	size_t mem_size = task->n_pkts * (sizeof(*task->proto) + sizeof(*task->proto_tsc));
+	uint8_t *mem = prox_zmalloc(mem_size, sockid);
+
+	PROX_PANIC(mem == NULL, "Failed to allocate %lu bytes (in huge pages) for pcap file\n", mem_size);
+	task->proto = (struct pkt_template *) mem;
+	task->proto_tsc = (uint64_t *)(mem + task->n_pkts * sizeof(*task->proto));
+
+	pcap_read_pkts(handle, targ->pcap_file, task->n_pkts, task->proto, task->proto_tsc);
+	pcap_close(handle);
+}
+
+static int task_gen_find_random_with_offset(struct task_gen *task, uint32_t offset)
+{
+	for (uint32_t i = 0; i < task->n_rands; ++i) {
+		if (task->rand[i].rand_offset == offset) {
+			return i;
+		}
+	}
+
+	return UINT32_MAX;
+}
+
+int task_gen_add_rand(struct task_base *tbase, const char *rand_str, uint32_t offset, uint32_t rand_id)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+	uint32_t existing_rand;
+
+	if (rand_id == UINT32_MAX && task->n_rands == 64) {
+		plog_err("Too many randoms\n");
+		return -1;
+	}
+	uint32_t mask, fixed, len;
+
+	if (parse_random_str(&mask, &fixed, &len, rand_str)) {
+		plog_err("%s\n", get_parse_err());
+		return -1;
+	}
+	task->runtime_checksum_needed = 1;
+
+	existing_rand = task_gen_find_random_with_offset(task, offset);
+	if (existing_rand != UINT32_MAX) {
+		plog_warn("Random at offset %d already set => overwriting len = %d %s\n", offset, len, rand_str);
+		rand_id = existing_rand;
+		task->rand[rand_id].rand_len = len;
+		task->rand[rand_id].rand_offset = offset;
+		task->rand[rand_id].rand_mask = mask;
+		task->rand[rand_id].fixed_bits = fixed;
+		return 0;
+	}
+
+	task->rand[task->n_rands].rand_len = len;
+	task->rand[task->n_rands].rand_offset = offset;
+	task->rand[task->n_rands].rand_mask = mask;
+	task->rand[task->n_rands].fixed_bits = fixed;
+
+	struct pkt_template *pktpl = &task->pkt_template[0];
+	if (!((offset >= pktpl->ip_dst_pos + 4) || (offset + len < pktpl->ip_dst_pos))) {
+		plog_info("\tUsing randoms IP destinations\n");
+		task->flags |= FLAG_RANDOM_IPS;
+	}
+
+	task->n_rands++;
+	return 0;
+}
+
+static void init_task_gen_early(struct task_args *targ)
+{
+	uint8_t *generator_count = prox_sh_find_system("generator_count");
+
+	if (generator_count == NULL) {
+		generator_count = prox_zmalloc(sizeof(*generator_count), 0);
+		prox_sh_add_system("generator_count", generator_count);
+	}
+	targ->generator_id = *generator_count;
+	(*generator_count)++;
+}
+
+static void init_task_gen(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_gen *task = (struct task_gen *)tbase;
+
+	task->packet_id_pos = targ->packet_id_pos;
+
+	task->local_mbuf.mempool = task_gen_create_mempool(targ);
+	PROX_PANIC(task->local_mbuf.mempool == NULL, "Failed to create mempool\n");
+	task->pkt_idx = 0;
+	task->hz = rte_get_tsc_hz();
+	task->lat_pos = targ->lat_pos;
+	task->accur_pos = targ->accur_pos;
+	task->sig_pos = targ->sig_pos;
+	task->sig = targ->sig;
+	task->new_rate_bps = targ->rate_bps;
+
+	struct token_time_cfg tt_cfg = token_time_cfg_create(1250000000, rte_get_tsc_hz(), -1);
+
+	token_time_init(&task->token_time, &tt_cfg);
+	init_task_gen_seeds(task);
+
+	task->min_bulk_size = targ->min_bulk_size;
+	task->max_bulk_size = targ->max_bulk_size;
+	if (task->min_bulk_size < 1)
+		task->min_bulk_size = 1;
+	if (task->max_bulk_size < 1)
+		task->max_bulk_size = 64;
+	PROX_PANIC(task->max_bulk_size > 64, "max_bulk_size higher than 64\n");
+	PROX_PANIC(task->max_bulk_size < task->min_bulk_size, "max_bulk_size must be > than min_bulk_size\n");
+
+	task->pkt_count = -1;
+	task->lat_enabled = targ->lat_enabled;
+	task->runtime_flags = targ->runtime_flags;
+	PROX_PANIC((task->lat_pos || task->accur_pos) && !task->lat_enabled, "lat not enabled by lat pos or accur pos configured\n");
+
+	task->generator_id = targ->generator_id;
+	task->link_speed = UINT64_MAX;
+	if (targ->nb_txrings == 0 && targ->nb_txports == 1)
+		task->link_speed = 1250000000;
+
+	if (!strcmp(targ->pcap_file, "")) {
+		plog_info("\tUsing inline definition of a packet\n");
+		task_init_gen_load_pkt_inline(task, targ);
+	} else {
+		plog_info("Loading from pcap %s\n", targ->pcap_file);
+		task_init_gen_load_pcap(task, targ);
+	}
+
+	if ((targ->flags & DSF_KEEP_SRC_MAC) == 0 && (targ->nb_txrings || targ->nb_txports)) {
+		uint8_t *src_addr = prox_port_cfg[tbase->tx_params_hw.tx_port_queue->port].eth_addr.addr_bytes;
+		for (uint32_t i = 0; i < task->n_pkts; ++i) {
+			rte_memcpy(&task->pkt_template[i].buf[6], src_addr, 6);
+		}
+	}
+	memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw.tx_port_queue->port].eth_addr, sizeof(struct ether_addr));
+	if (!strcmp(targ->task_init->sub_mode_str, "l3")) {
+		// In L3 GEN, we need to receive ARP replies
+		task->flags = FLAG_L3_GEN;
+		task->gw_ip = rte_cpu_to_be_32(targ->gateway_ipv4);
+		uint32_t n_entries;
+
+		if (targ->number_gen_ip == 0)
+			n_entries = 1048576;
+		else
+			n_entries = targ->number_gen_ip;
+
+		static char hash_name[30];
+		sprintf(hash_name, "A%03d_mac_table", targ->lconf->id);
+
+		struct rte_hash_parameters hash_params = {
+			.name = hash_name,
+			.entries = n_entries,
+			.key_len = sizeof(uint32_t),
+			.hash_func = rte_hash_crc,
+			.hash_func_init_val = 0,
+		};
+		task->mac_hash = rte_hash_create(&hash_params);
+		PROX_PANIC(task->mac_hash == NULL, "Failed to set up mac hash table for %d IP\n", n_entries);
+
+		const uint32_t socket = rte_lcore_to_socket_id(targ->lconf->id);
+		task->dst_mac = (uint64_t *)prox_zmalloc(n_entries * sizeof(uint64_t), socket);
+		PROX_PANIC(task->dst_mac == NULL, "Failed to allocate mac table for %d IP\n", n_entries);
+
+		for (uint32_t i = 0; i < task->n_pkts; ++i) {
+			// For all destination IP, ARP request will need to be sent
+			// Store position of Destination IP in template
+			int ip_dst_pos = 0;
+			int maybe_ipv4 = 0;
+			int l2_len = sizeof(struct ether_hdr);
+			struct vlan_hdr *vlan_hdr;
+			uint8_t *pkt = task->pkt_template[i].buf;
+			struct ether_hdr *eth_hdr = (struct ether_hdr*)pkt;
+			struct ipv4_hdr *ip;
+			uint16_t ether_type = eth_hdr->ether_type;
+
+			// Unstack VLAN tags
+			while (((ether_type == ETYPE_8021ad) || (ether_type == ETYPE_VLAN)) && (l2_len + sizeof(struct vlan_hdr) < task->pkt_template[i].len)) {
+				vlan_hdr = (struct vlan_hdr *)(pkt + l2_len);
+				l2_len +=4;
+				ether_type = vlan_hdr->eth_proto;
+			}
+			if ((ether_type == ETYPE_MPLSU) || (ether_type == ETYPE_MPLSM)) {
+				l2_len +=4;
+				maybe_ipv4 = 1;
+			}
+			if ((ether_type == ETYPE_IPv4) || maybe_ipv4) {
+				struct ipv4_hdr *ip = (struct ipv4_hdr *)(pkt + l2_len);
+				PROX_PANIC(ip->version_ihl >> 4 != 4, "IPv4 ether_type but IP version = %d != 4", ip->version_ihl >> 4);
+				// Even if IPv4 header contains options, options are after ip src and dst
+				ip_dst_pos = l2_len + sizeof(struct ipv4_hdr) - sizeof(uint32_t);
+				uint32_t *p = ((uint32_t *)(task->pkt_template[i].buf + ip_dst_pos - sizeof(uint32_t)));
+				task->pkt_template[i].ip_dst_pos = ip_dst_pos;
+				task->pkt_template[i].ip_src = *p;
+				uint32_t *p1 = ((uint32_t *)(task->pkt_template[i].buf + ip_dst_pos));
+				plog_info("\tip_dst_pos = %d, ip_dst = %x\n", ip_dst_pos, *p1);
+			}
+		}
+		task->src_ip = rte_cpu_to_be_32(targ->local_ipv4);
+	}
+	for (uint32_t i = 0; i < targ->n_rand_str; ++i) {
+		PROX_PANIC(task_gen_add_rand(tbase, targ->rand_str[i], targ->rand_offset[i], UINT32_MAX),
+			   "Failed to add random\n");
+	}
+
+	struct prox_port_cfg *port = find_reachable_port(targ);
+	if (port) {
+		task->cksum_offload = port->capabilities.tx_offload_cksum;
+	}
+}
+
+static struct task_init task_init_gen = {
+	.mode_str = "gen",
+	.init = init_task_gen,
+	.handle = handle_gen_bulk,
+	.start = start,
+#ifdef SOFT_CRC
+	// For SOFT_CRC, no offload is needed. If both NOOFFLOADS and NOMULTSEGS flags are set the
+	// vector mode is used by DPDK, resulting (theoretically) in higher performance.
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS | TASK_FEATURE_NO_RX | TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS | TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS,
+#else
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS | TASK_FEATURE_NO_RX,
+#endif
+	.size = sizeof(struct task_gen)
+};
+
+static struct task_init task_init_gen_l3 = {
+	.mode_str = "gen",
+	.sub_mode_str = "l3",
+	.init = init_task_gen,
+	.handle = handle_gen_bulk,
+	.start = start,
+#ifdef SOFT_CRC
+	// For SOFT_CRC, no offload is needed. If both NOOFFLOADS and NOMULTSEGS flags are set the
+	// vector mode is used by DPDK, resulting (theoretically) in higher performance.
+	.flag_features = TASK_FEATURE_ZERO_RX | TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS | TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS|TASK_FEATURE_ZERO_RX,
+#else
+	.flag_features = TASK_FEATURE_ZERO_RX,
+#endif
+	.size = sizeof(struct task_gen)
+};
+
+static struct task_init task_init_gen_pcap = {
+	.mode_str = "gen",
+	.sub_mode_str = "pcap",
+	.init = init_task_gen_pcap,
+	.handle = handle_gen_pcap_bulk,
+	.start = start_pcap,
+#ifdef SOFT_CRC
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS | TASK_FEATURE_NO_RX | TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS | TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS,
+#else
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS | TASK_FEATURE_NO_RX,
+#endif
+	.size = sizeof(struct task_gen_pcap)
+};
+
+__attribute__((constructor)) static void reg_task_gen(void)
+{
+	reg_task(&task_init_gen);
+	reg_task(&task_init_gen_l3);
+	reg_task(&task_init_gen_pcap);
+}
diff --git a/VNFs/DPPD-PROX/handle_gen.h b/VNFs/DPPD-PROX/handle_gen.h
new file mode 100644
index 00000000..6f00ca12
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_gen.h
@@ -0,0 +1,51 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_GEN_H_
+#define _HANDLE_GEN_H_
+
+struct unique_id {
+	uint8_t  generator_id;
+	uint32_t packet_id;
+} __attribute__((packed));
+
+static void unique_id_init(struct unique_id *unique_id, uint8_t generator_id, uint32_t packet_id)
+{
+	unique_id->generator_id = generator_id;
+	unique_id->packet_id = packet_id;
+}
+
+static void unique_id_get(struct unique_id *unique_id, uint8_t *generator_id, uint32_t *packet_id)
+{
+	*generator_id = unique_id->generator_id;
+	*packet_id = unique_id->packet_id;
+}
+
+struct task_base;
+
+void task_gen_set_pkt_count(struct task_base *tbase, uint32_t count);
+int task_gen_set_pkt_size(struct task_base *tbase, uint32_t pkt_size);
+void task_gen_set_rate(struct task_base *tbase, uint64_t bps);
+void task_gen_set_gateway_ip(struct task_base *tbase, uint32_t ip);
+void task_gen_reset_randoms(struct task_base *tbase);
+void task_gen_reset_values(struct task_base *tbase);
+int task_gen_set_value(struct task_base *tbase, uint32_t value, uint32_t offset, uint32_t len);
+int task_gen_add_rand(struct task_base *tbase, const char *rand_str, uint32_t offset, uint32_t rand_id);
+
+uint32_t task_gen_get_n_randoms(struct task_base *tbase);
+uint32_t task_gen_get_n_values(struct task_base *tbase);
+
+#endif /* _HANDLE_GEN_H_ */
diff --git a/VNFs/DPPD-PROX/handle_genl4.c b/VNFs/DPPD-PROX/handle_genl4.c
new file mode 100644
index 00000000..4c62c641
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_genl4.c
@@ -0,0 +1,1139 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mbuf.h>
+#include <pcap.h>
+#include <string.h>
+#include <stdlib.h>
+#include <rte_cycles.h>
+#include <rte_version.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+#include <rte_tcp.h>
+#include <rte_hash.h>
+#include <rte_hash_crc.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+#include "prox_malloc.h"
+#include "file_utils.h"
+#include "hash_set.h"
+#include "prox_assert.h"
+#include "prox_args.h"
+#include "defines.h"
+#include "pkt_parser.h"
+#include "handle_lat.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "prox_port_cfg.h"
+#include "lconf.h"
+#include "log.h"
+#include "quit.h"
+#include "heap.h"
+#include "mbuf_utils.h"
+#include "genl4_bundle.h"
+#include "genl4_stream_udp.h"
+#include "genl4_stream_tcp.h"
+#include "cdf.h"
+#include "fqueue.h"
+#include "token_time.h"
+#include "commands.h"
+#include "prox_shared.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#endif
+
+struct new_tuple {
+	uint32_t dst_addr;
+	uint8_t proto_id;
+	uint16_t dst_port;
+	uint16_t l2_types[4];
+} __attribute__((packed));
+
+enum handle_state {HANDLE_QUEUED, HANDLE_SCHEDULED};
+
+struct task_gen_server {
+	struct task_base base;
+	struct l4_stats l4_stats;
+	struct rte_mempool *mempool;
+	struct rte_hash *listen_hash;
+	/* Listening bundles contain only 1 part since the state of a
+	   multi_part comm is kept mostly at the client side*/
+	struct bundle_cfg     **listen_entries;
+	struct bundle_ctx_pool bundle_ctx_pool;
+	struct bundle_cfg *bundle_cfgs; /* Loaded configurations */
+	struct token_time token_time;
+	enum handle_state handle_state;
+	struct heap *heap;
+	struct fqueue *fqueue;
+	struct rte_mbuf *cur_mbufs[MAX_PKT_BURST];
+	uint32_t cur_mbufs_beg;
+	uint32_t cur_mbufs_end;
+	uint32_t cancelled;
+	uint8_t  out_saved;
+	struct rte_mbuf *mbuf_saved;
+	uint64_t last_tsc;
+	unsigned seed;
+	/* Handle scheduled events */
+	struct rte_mbuf *new_mbufs[MAX_PKT_BURST];
+	uint32_t n_new_mbufs;
+};
+
+struct task_gen_client {
+	struct task_base base;
+	struct l4_stats l4_stats;
+	struct rte_mempool *mempool;
+	struct bundle_ctx_pool bundle_ctx_pool;
+	struct bundle_cfg *bundle_cfgs; /* Loaded configurations */
+	struct token_time token_time;
+	/* Create new connections and handle scheduled events */
+	struct rte_mbuf *new_mbufs[MAX_PKT_BURST];
+	uint32_t new_conn_cost;
+	uint32_t new_conn_tokens;
+	uint64_t new_conn_last_tsc;
+	uint32_t n_new_mbufs;
+	uint64_t last_tsc;
+	struct cdf *cdf;
+	unsigned seed;
+	struct heap *heap;
+};
+
+static int refill_mbufs(uint32_t *n_new_mbufs, struct rte_mempool *mempool, struct rte_mbuf **mbufs)
+{
+	if (*n_new_mbufs == MAX_PKT_BURST)
+		return 0;
+
+	if (rte_mempool_get_bulk(mempool, (void **)mbufs, MAX_PKT_BURST - *n_new_mbufs) < 0) {
+		plogx_err("4Mempool alloc failed for %d mbufs\n", MAX_PKT_BURST - *n_new_mbufs);
+		return -1;
+	}
+
+	for (uint32_t i = 0; i < MAX_PKT_BURST - *n_new_mbufs; ++i) {
+		init_mbuf_seg(mbufs[i]);
+	}
+
+	*n_new_mbufs = MAX_PKT_BURST;
+
+	return 0;
+}
+
+static const struct bundle_cfg *server_accept(struct task_gen_server *task, struct new_tuple *nt)
+{
+	int ret = rte_hash_lookup(task->listen_hash, nt);
+
+	if (ret < 0)
+		return NULL;
+	else
+		return task->listen_entries[ret];
+}
+
+static int handle_gen_bulk_client(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_gen_client *task = (struct task_gen_client *)tbase;
+	uint8_t out[MAX_PKT_BURST] = {0};
+	struct bundle_ctx *conn;
+	int ret;
+
+	if (n_pkts) {
+		for (int i = 0; i < n_pkts; ++i) {
+			struct pkt_tuple pt;
+			struct l4_meta l4_meta;
+
+			if (parse_pkt(mbufs[i], &pt, &l4_meta)) {
+				plogdx_err(mbufs[i], "Parsing failed\n");
+				out[i] = OUT_DISCARD;
+				continue;
+			}
+
+			ret = rte_hash_lookup(task->bundle_ctx_pool.hash, (const void *)&pt);
+
+			if (ret < 0) {
+				plogx_dbg("Client: packet RX that does not belong to connection:"
+					  "Client = "IPv4_BYTES_FMT":%d, Server = "IPv4_BYTES_FMT":%d\n",
+					  IPv4_BYTES(((uint8_t*)&pt.dst_addr)),
+					  rte_bswap16(pt.dst_port),
+					  IPv4_BYTES(((uint8_t*)&pt.src_addr)),
+					  rte_bswap16(pt.src_port));
+
+				plogdx_dbg(mbufs[i], NULL);
+
+				if (pt.proto_id == IPPROTO_TCP) {
+					stream_tcp_create_rst(mbufs[i], &l4_meta, &pt);
+					out[i] = 0;
+					continue;
+				}
+				else {
+					out[i] = OUT_DISCARD;
+					continue;
+				}
+			}
+
+			conn = task->bundle_ctx_pool.hash_entries[ret];
+			ret = bundle_proc_data(conn, mbufs[i], &l4_meta, &task->bundle_ctx_pool, &task->seed, &task->l4_stats);
+			out[i] = ret == 0? 0: OUT_HANDLED;
+		}
+		task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+	}
+
+	/* If there is at least one callback to handle, handle at most MAX_PKT_BURST */
+	if (heap_top_is_lower(task->heap, rte_rdtsc())) {
+		if (0 != refill_mbufs(&task->n_new_mbufs, task->mempool, task->new_mbufs))
+			return 0;
+
+		uint16_t n_called_back = 0;
+		while (heap_top_is_lower(task->heap, rte_rdtsc()) && n_called_back < MAX_PKT_BURST) {
+			conn = BUNDLE_CTX_UPCAST(heap_pop(task->heap));
+
+			/* handle packet TX (retransmit or delayed transmit) */
+			ret = bundle_proc_data(conn, task->new_mbufs[n_called_back], NULL, &task->bundle_ctx_pool, &task->seed, &task->l4_stats);
+
+			if (ret == 0) {
+				out[n_called_back] = 0;
+				n_called_back++;
+			}
+		}
+		plogx_dbg("During callback, will send %d packets\n", n_called_back);
+
+		task->base.tx_pkt(&task->base, task->new_mbufs, n_called_back, out);
+		task->n_new_mbufs -= n_called_back;
+	}
+
+	uint32_t n_new = task->bundle_ctx_pool.n_free_bundles;
+	n_new = n_new > MAX_PKT_BURST? MAX_PKT_BURST : n_new;
+
+	uint64_t diff = (rte_rdtsc() - task->new_conn_last_tsc)/task->new_conn_cost;
+	task->new_conn_last_tsc += diff * task->new_conn_cost;
+	task->new_conn_tokens += diff;
+
+	if (task->new_conn_tokens > 16)
+		task->new_conn_tokens = 16;
+	if (n_new > task->new_conn_tokens)
+		n_new = task->new_conn_tokens;
+	task->new_conn_tokens -= n_new;
+	if (n_new == 0)
+		return 0;
+
+	if (0 != refill_mbufs(&task->n_new_mbufs, task->mempool, task->new_mbufs))
+		return 0;
+
+	for (uint32_t i = 0; i < n_new; ++i) {
+		struct bundle_ctx *bundle_ctx = bundle_ctx_pool_get_w_cfg(&task->bundle_ctx_pool);
+		PROX_ASSERT(bundle_ctx);
+
+		struct pkt_tuple *pt = &bundle_ctx->tuple;
+
+		int n_retries = 0;
+		do {
+			/* Note that the actual packet sent will
+			   contain swapped addresses and ports
+			   (i.e. pkt.src <=> tuple.dst). The incoming
+			   packet will match this struct. */
+			bundle_init(bundle_ctx, task->heap, PEER_CLIENT, &task->seed);
+
+			ret = rte_hash_lookup(task->bundle_ctx_pool.hash, (const void *)pt);
+			if (ret >= 0) {
+				if (n_retries++ == 1000) {
+					plogx_err("Already tried 1K times\n");
+				}
+			}
+		} while (ret >= 0);
+
+		ret = rte_hash_add_key(task->bundle_ctx_pool.hash, (const void *)pt);
+
+		if (ret < 0) {
+			plogx_err("Failed to add key ret = %d, n_free = %d\n", ret, task->bundle_ctx_pool.n_free_bundles);
+			bundle_ctx_pool_put(&task->bundle_ctx_pool, bundle_ctx);
+
+			pkt_tuple_debug2(pt);
+			out[i] = OUT_DISCARD;
+			continue;
+		}
+
+		task->bundle_ctx_pool.hash_entries[ret] = bundle_ctx;
+
+		if (bundle_ctx->ctx.stream_cfg->proto == IPPROTO_TCP)
+			task->l4_stats.tcp_created++;
+		else
+			task->l4_stats.udp_created++;
+
+		task->l4_stats.bundles_created++;
+
+		ret = bundle_proc_data(bundle_ctx, task->new_mbufs[i], NULL, &task->bundle_ctx_pool, &task->seed, &task->l4_stats);
+		out[i] = ret == 0? 0: OUT_HANDLED;
+	}
+
+	int ret2 = task->base.tx_pkt(&task->base, task->new_mbufs, n_new, out);
+	task->n_new_mbufs -= n_new;
+	return ret2;
+}
+
+static int handle_gen_queued(struct task_gen_server *task)
+{
+	uint8_t out[MAX_PKT_BURST];
+	struct bundle_ctx *conn;
+	struct pkt_tuple pkt_tuple;
+	struct l4_meta l4_meta;
+	uint16_t j;
+	uint16_t cancelled = 0;
+	int ret;
+
+	if (task->cur_mbufs_beg == task->cur_mbufs_end) {
+		task->cur_mbufs_end = fqueue_get(task->fqueue, task->cur_mbufs, MAX_PKT_BURST);
+		task->cur_mbufs_beg = 0;
+	}
+	uint16_t n_pkts = task->cur_mbufs_end - task->cur_mbufs_beg;
+	struct rte_mbuf **mbufs = task->cur_mbufs + task->cur_mbufs_beg;
+
+	j = task->cancelled;
+	if (task->cancelled) {
+		uint16_t pkt_len = mbuf_wire_size(mbufs[0]);
+
+		if (token_time_take(&task->token_time, pkt_len) != 0)
+			return -1;
+
+		out[0] = task->out_saved;
+		task->cancelled = 0;
+	}
+
+	/* Main proc loop */
+	for (; j < n_pkts; ++j) {
+
+		if (parse_pkt(mbufs[j], &pkt_tuple, &l4_meta)) {
+			plogdx_err(mbufs[j], "Unknown packet, parsing failed\n");
+			out[j] = OUT_DISCARD;
+		}
+
+		conn = NULL;
+		ret = rte_hash_lookup(task->bundle_ctx_pool.hash, (const void *)&pkt_tuple);
+
+		if (ret >= 0)
+			conn = task->bundle_ctx_pool.hash_entries[ret];
+		else {
+			/* If not part of existing connection, try to create a connection */
+			struct new_tuple nt;
+			nt.dst_addr = pkt_tuple.dst_addr;
+			nt.proto_id = pkt_tuple.proto_id;
+			nt.dst_port = pkt_tuple.dst_port;
+			rte_memcpy(nt.l2_types, pkt_tuple.l2_types, sizeof(nt.l2_types));
+			const struct bundle_cfg *n;
+
+			if (NULL != (n = server_accept(task, &nt))) {
+				conn = bundle_ctx_pool_get(&task->bundle_ctx_pool);
+				if (!conn) {
+					out[j] = OUT_DISCARD;
+					plogx_err("No more free bundles to accept new connection\n");
+					continue;
+				}
+				ret = rte_hash_add_key(task->bundle_ctx_pool.hash, (const void *)&pkt_tuple);
+				if (ret < 0) {
+					out[j] = OUT_DISCARD;
+					bundle_ctx_pool_put(&task->bundle_ctx_pool, conn);
+					plog_err("Adding key failed while trying to accept connection\n");
+					continue;
+				}
+
+				task->bundle_ctx_pool.hash_entries[ret] = conn;
+
+				bundle_init_w_cfg(conn, n, task->heap, PEER_SERVER, &task->seed);
+				conn->tuple = pkt_tuple;
+
+				if (conn->ctx.stream_cfg->proto == IPPROTO_TCP)
+					task->l4_stats.tcp_created++;
+				else
+					task->l4_stats.udp_created++;
+			}
+			else {
+				plog_err("Packet received for service that does not exist :\n"
+					 "source ip = %0x:%u\n"
+					 "dst ip    = %0x:%u\n",
+					 pkt_tuple.src_addr, rte_bswap16(pkt_tuple.src_port),
+					 pkt_tuple.dst_addr, rte_bswap16(pkt_tuple.dst_port));
+			}
+		}
+
+		/* bundle contains either an active connection or a
+		   newly created connection. If it is NULL, then not
+		   listening. */
+		if (NULL != conn) {
+			ret = bundle_proc_data(conn, mbufs[j], &l4_meta, &task->bundle_ctx_pool, &task->seed, &task->l4_stats);
+
+			out[j] = ret == 0? 0: OUT_HANDLED;
+
+			if (ret == 0) {
+				uint16_t pkt_len = mbuf_wire_size(mbufs[j]);
+
+				if (token_time_take(&task->token_time, pkt_len) != 0) {
+					task->out_saved = out[j];
+					task->cancelled = 1;
+					task->base.tx_pkt(&task->base, mbufs, j, out);
+					task->cur_mbufs_beg += j;
+					return -1;
+				}
+			}
+		}
+		else {
+			pkt_tuple_debug(&pkt_tuple);
+			plogd_dbg(mbufs[j], NULL);
+			out[j] = OUT_DISCARD;
+		}
+	}
+
+	task->base.tx_pkt(&task->base, mbufs, j, out);
+
+	task->cur_mbufs_beg += j;
+	return 0;
+}
+
+static int handle_gen_scheduled(struct task_gen_server *task)
+{
+	struct bundle_ctx *conn;
+	uint8_t out[MAX_PKT_BURST];
+	int ret;
+	uint16_t n_called_back = 0;
+
+	if (task->cancelled) {
+		struct rte_mbuf *mbuf = task->mbuf_saved;
+
+		uint16_t pkt_len = mbuf_wire_size(mbuf);
+		if (token_time_take(&task->token_time, pkt_len) == 0) {
+			task->cancelled = 0;
+			out[0] = 0;
+			task->base.tx_pkt(&task->base, &mbuf, 1, out);
+		}
+		else {
+			return -1;
+		}
+	}
+
+	if (0 != refill_mbufs(&task->n_new_mbufs, task->mempool, task->new_mbufs))
+		return -1;
+
+	conn = NULL;
+	while (heap_top_is_lower(task->heap, rte_rdtsc()) && n_called_back < task->n_new_mbufs) {
+		conn = BUNDLE_CTX_UPCAST(heap_pop(task->heap));
+
+		/* handle packet TX (retransmit or delayed transmit) */
+		ret = bundle_proc_data(conn, task->new_mbufs[n_called_back], NULL, &task->bundle_ctx_pool, &task->seed, &task->l4_stats);
+
+		if (ret == 0) {
+			struct rte_mbuf *mbuf = task->new_mbufs[n_called_back];
+			uint16_t pkt_len = mbuf_wire_size(mbuf);
+
+			if (token_time_take(&task->token_time, pkt_len) == 0) {
+				out[n_called_back] = 0;
+				n_called_back++;
+			}
+			else {
+
+				struct ether_hdr *eth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+				struct ipv4_hdr *ip = (struct ipv4_hdr*)(eth + 1);
+				struct tcp_hdr *tcp = (struct tcp_hdr*)(ip + 1);
+
+				task->out_saved = 0;
+				task->cancelled = 1;
+				task->mbuf_saved = mbuf;
+				task->base.tx_pkt(&task->base, task->new_mbufs, n_called_back, out);
+				/* The mbuf that is currently been
+				   processed (and which has been
+				   cancelled) is saved in
+				   task->mbuf_saved. It will be
+				   restored as the first mbuf when
+				   this function is called again. */
+				task->n_new_mbufs -= (n_called_back + 1);
+				return -1;
+			}
+		}
+	}
+
+	task->base.tx_pkt(&task->base, task->new_mbufs, n_called_back, out);
+	task->n_new_mbufs -= n_called_back;
+
+	return 0;
+}
+
+static int handle_gen_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_gen_server *task = (struct task_gen_server *)tbase;
+	struct bundle_ctx *conn;
+	int ret, ret2 = 0;
+
+	token_time_update(&task->token_time, rte_rdtsc());
+
+	if ((ret = fqueue_put(task->fqueue, mbufs, n_pkts)) != n_pkts) {
+		uint8_t out[MAX_PKT_BURST];
+		for (uint16_t j = 0; j < n_pkts - ret; ++j)
+			out[j] = OUT_DISCARD;
+
+		ret2 = task->base.tx_pkt(&task->base, mbufs + ret, n_pkts - ret, out);
+	}
+	if (task->handle_state == HANDLE_QUEUED) {
+		if (handle_gen_queued(task) == 0) {
+			if (handle_gen_scheduled(task) != 0)
+				task->handle_state = HANDLE_SCHEDULED;
+		}
+	}
+	else {
+		if (handle_gen_scheduled(task) == 0) {
+			if (handle_gen_queued(task) != 0)
+				task->handle_state = HANDLE_QUEUED;
+		}
+	}
+	return ret2;
+}
+
+static int lua_to_host_set(struct lua_State *L, enum lua_place from, const char *name, struct host_set *h)
+{
+	int pop;
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1))
+		return -1;
+
+	uint32_t port = 0, port_mask = 0;
+
+	if (lua_to_ip(L, TABLE, "ip", &h->ip) || lua_to_int(L, TABLE, "port", &port))
+		return -1;
+
+	if (lua_to_int(L, TABLE, "ip_mask", &h->ip_mask))
+		h->ip_mask = 0;
+	if (lua_to_int(L, TABLE, "port_mask", &port_mask))
+		h->port_mask = 0;
+
+	h->port = rte_bswap16(port);
+	h->port_mask = rte_bswap16(port_mask);
+	h->ip = rte_bswap32(h->ip);
+	h->ip_mask = rte_bswap32(h->ip_mask);
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+static int file_read_cached(const char *file_name, uint8_t **mem, uint32_t beg, uint32_t len, uint32_t socket, struct hash_set *hs)
+{
+	if (len == 0) {
+		*mem = 0;
+		return 0;
+	}
+
+	uint8_t *data_mem;
+
+	/* Since the configuration can reference the same file from
+	   multiple places, use prox_shared infrastructure to detect
+	   this and return previously loaded data. */
+	char name[256];
+
+	snprintf(name, sizeof(name), "%u-%u:%s", beg, len, file_name);
+	*mem = prox_sh_find_socket(socket, name);
+	if (*mem)
+		return 0;
+
+	/* check if the file has been loaded on the other socket. */
+	if (socket == 1 && (data_mem = prox_sh_find_socket(0, name))) {
+		uint8_t *data_find = hash_set_find(hs, data_mem, len);
+		if (!data_find) {
+			data_find = prox_zmalloc(len, socket);
+			PROX_PANIC(data_find == NULL, "Failed to allocate memory (%u bytes) to hold header for peer\n", len);
+
+			rte_memcpy(data_find, data_mem, len);
+			hash_set_add(hs, data_find, len);
+		}
+		*mem = data_find;
+		prox_sh_add_socket(socket, name, *mem);
+		return 0;
+	}
+
+	/* It is possible that a file with a different name contains
+	   the same data. In that case, search all loaded files and
+	   compare the data to reduce memory utilization.*/
+	data_mem = malloc(len);
+	PROX_PANIC(data_mem == NULL, "Failed to allocate temporary memory to hold data\n");
+
+	if (file_read_content(file_name, data_mem, beg, len)) {
+		plog_err("%s\n", file_get_error());
+		return -1;
+	}
+
+	uint8_t *data_find = hash_set_find(hs, data_mem, len);
+	if (!data_find) {
+		data_find = prox_zmalloc(len, socket);
+		PROX_PANIC(data_find == NULL, "Failed to allocate memory (%u bytes) to hold header for peer\n", len);
+
+		rte_memcpy(data_find, data_mem, len);
+		hash_set_add(hs, data_find, len);
+	}
+
+	free(data_mem);
+
+	*mem = data_find;
+	prox_sh_add_socket(socket, name, *mem);
+	return 0;
+}
+
+static int lua_to_peer_data(struct lua_State *L, enum lua_place from, const char *name, uint32_t socket, struct peer_data *peer_data, size_t *cl, struct hash_set *hs)
+{
+	uint32_t hdr_len, hdr_beg, content_len, content_beg;
+	char hdr_file[256], content_file[256];
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1))
+		return -1;
+
+	if (lua_getfrom(L, TABLE, "header") < 0)
+		return -1;
+	if (lua_to_int(L, TABLE, "len", &hdr_len) < 0)
+		return -1;
+	if (lua_to_int(L, TABLE, "beg", &hdr_beg) < 0)
+		return -1;
+	if (lua_to_string(L, TABLE, "file_name", hdr_file, sizeof(hdr_file)) < 0)
+		return -1;
+	lua_pop(L, 1);
+
+	if (lua_getfrom(L, TABLE, "content") < 0)
+		return -1;
+	if (lua_to_int(L, TABLE, "len", &content_len) < 0)
+		return -1;
+	if (lua_to_int(L, TABLE, "beg", &content_beg) < 0)
+		return -1;
+	if (lua_to_string(L, TABLE, "file_name", content_file, sizeof(content_file)) < 0)
+		return -1;
+	lua_pop(L, 1);
+
+	if (hdr_len == UINT32_MAX) {
+		long ret = file_get_size(hdr_file);
+
+		if (ret < 0) {
+			plog_err("%s", file_get_error());
+			return -1;
+		}
+		hdr_len = ret - hdr_beg;
+	}
+
+	if (content_len == UINT32_MAX) {
+		long ret = file_get_size(content_file);
+
+		if (ret < 0) {
+			plog_err("%s", file_get_error());
+			return -1;
+		}
+		content_len = ret - content_beg;
+	}
+	*cl = content_len;
+	peer_data->hdr_len = hdr_len;
+
+	if (file_read_cached(hdr_file, &peer_data->hdr, hdr_beg, hdr_len, socket, hs))
+		return -1;
+	if (file_read_cached(content_file, &peer_data->content, content_beg, content_len, socket, hs))
+		return -1;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+static int lua_to_peer_action(struct lua_State *L, enum lua_place from, const char *name, struct peer_action *action, size_t client_contents_len, size_t server_contents_len)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1))
+		return -1;
+
+	uint32_t peer, beg, len;
+	if (lua_to_int(L, TABLE, "peer", &peer) ||
+	    lua_to_int(L, TABLE, "beg", &beg) ||
+	    lua_to_int(L, TABLE, "len", &len)) {
+		return -1;
+	}
+	size_t data_len = (peer == PEER_CLIENT? client_contents_len : server_contents_len);
+	if (len == (uint32_t)-1)
+		len = data_len - beg;
+
+	PROX_PANIC(beg + len > data_len, "Accessing data past the end (starting at %u for %u bytes) while total length is %zu\n", beg, len, data_len);
+
+	action->peer = peer;
+	action->beg = beg;
+	action->len = len;
+	lua_pop(L, pop);
+	return 0;
+}
+
+static int lua_to_stream_cfg(struct lua_State *L, enum lua_place from, const char *name, uint32_t socket, struct stream_cfg **stream_cfg, struct hash_set *hs)
+{
+	int pop;
+	struct stream_cfg *ret;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (lua_getfrom(L, TABLE, "actions") < 0)
+		return -1;
+
+	lua_len(prox_lua(), -1);
+	uint32_t n_actions = lua_tointeger(prox_lua(), -1);
+	lua_pop(prox_lua(), 1);
+
+	lua_pop(L, 1);
+
+	size_t mem_size = 0;
+	mem_size += sizeof(*ret);
+	/* one additional action is allocated to allow inserting an
+	   additional "default" action to close down TCP sessions from
+	   the client side. */
+	mem_size += sizeof(ret->actions[0]) * (n_actions + 1);
+
+	ret = prox_zmalloc(sizeof(*ret) + mem_size, socket);
+	ret->n_actions = n_actions;
+
+	size_t client_contents_len, server_contents_len;
+	char proto[16];
+	uint32_t timeout_us, timeout_time_wait_us;
+	plogx_dbg("loading stream\n");
+	if (lua_to_host_set(L, TABLE, "servers", &ret->servers))
+		return -1;
+	if (lua_to_string(L, TABLE, "l4_proto", proto, sizeof(proto)))
+		return -1;
+	if (lua_to_peer_data(L, TABLE, "client_data", socket, &ret->data[PEER_CLIENT], &client_contents_len, hs))
+		return -1;
+	if (lua_to_peer_data(L, TABLE, "server_data", socket, &ret->data[PEER_SERVER], &server_contents_len, hs))
+		return -1;
+
+	if (lua_to_int(L, TABLE, "timeout", &timeout_us)) {
+		timeout_us = 1000000;
+	}
+
+	ret->tsc_timeout = usec_to_tsc(timeout_us);
+
+	double up, dn;
+
+	if (lua_to_double(L, TABLE, "up_bps", &up))
+		up = 5000;// Default rate is 40 Mbps
+
+	if (lua_to_double(L, TABLE, "dn_bps", &dn))
+		dn = 5000;// Default rate is 40 Mbps
+
+	const uint64_t hz = rte_get_tsc_hz();
+
+	ret->tt_cfg[PEER_CLIENT] = token_time_cfg_create(up, hz, ETHER_MAX_LEN + 20);
+	ret->tt_cfg[PEER_SERVER] = token_time_cfg_create(dn, hz, ETHER_MAX_LEN + 20);
+
+	if (!strcmp(proto, "tcp")) {
+		ret->proto = IPPROTO_TCP;
+		ret->proc = stream_tcp_proc;
+		ret->is_ended = stream_tcp_is_ended;
+
+		if (lua_to_int(L, TABLE, "timeout_time_wait", &timeout_time_wait_us)) {
+			timeout_time_wait_us = 2000000;
+		}
+
+		ret->tsc_timeout_time_wait = usec_to_tsc(timeout_time_wait_us);
+	}
+	else if (!strcmp(proto, "udp")) {
+		plogx_dbg("loading UDP\n");
+		ret->proto = IPPROTO_UDP;
+		ret->proc = stream_udp_proc;
+		ret->is_ended = stream_udp_is_ended;
+	}
+	else
+		return -1;
+
+	/* get all actions */
+	if (lua_getfrom(L, TABLE, "actions") < 0)
+		return -1;
+
+	uint32_t idx = 0;
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_peer_action(L, STACK, NULL, &ret->actions[idx], client_contents_len, server_contents_len))
+			return -1;
+
+		stream_cfg_verify_action(ret, &ret->actions[idx]);
+
+		idx++;
+
+		lua_pop(L, 1);
+	}
+	lua_pop(L, 1);
+
+	/* For TCP, one of the peers initiates closing down the
+	   connection. This is signified by the last action having
+	   with zero length. If such an action is not specified in the
+	   configuration file, the default is for the client to close
+	   the connection. This means that the TCP connection at the
+	   client will go into a TIME_WAIT state and the server
+	   releases all the resources avoiding resource starvation at
+	   the server. */
+	if (ret->proto == IPPROTO_TCP && ret->actions[ret->n_actions - 1].len != 0) {
+		ret->actions[ret->n_actions].len = 0;
+		ret->actions[ret->n_actions].beg = 0;
+		ret->actions[ret->n_actions].peer = PEER_CLIENT;
+		ret->n_actions++;
+	}
+
+	if (IPPROTO_TCP == ret->proto)
+		stream_tcp_calc_len(ret, &ret->n_pkts, &ret->n_bytes);
+	else
+		stream_udp_calc_len(ret, &ret->n_pkts, &ret->n_bytes);
+
+	lua_pop(L, pop);
+	*stream_cfg = ret;
+	return 0;
+}
+
+static int lua_to_bundle_cfg(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct bundle_cfg *bundle, struct hash_set *hs)
+{
+	int pop, pop2, idx;
+	int clients_loaded = 0;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1))
+		return -1;
+
+	lua_len(prox_lua(), -1);
+	bundle->n_stream_cfgs = lua_tointeger(prox_lua(), -1);
+	lua_pop(prox_lua(), 1);
+
+	bundle->stream_cfgs = prox_zmalloc(sizeof(*bundle->stream_cfgs) * bundle->n_stream_cfgs, socket);
+
+	plogx_dbg("loading bundle cfg with %d streams\n", bundle->n_stream_cfgs);
+	idx = 0;
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (!clients_loaded) {
+			if (lua_to_host_set(L, TABLE, "clients", &bundle->clients)) {
+				return -1;
+			}
+			clients_loaded = 1;
+		}
+		if (lua_to_stream_cfg(L, STACK, NULL, socket, &bundle->stream_cfgs[idx], hs)) {
+			return -1;
+		}
+
+		++idx;
+		lua_pop(L, 1);
+	}
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+static void init_task_gen(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_gen_server *task = (struct task_gen_server *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	static char name[] = "server_mempool";
+	name[0]++;
+	task->mempool = rte_mempool_create(name,
+					   4*1024 - 1, MBUF_SIZE,
+					   targ->nb_cache_mbuf,
+					   sizeof(struct rte_pktmbuf_pool_private),
+					   rte_pktmbuf_pool_init, NULL,
+					   rte_pktmbuf_init, 0,
+					   socket_id, 0);
+	PROX_PANIC(task->mempool == NULL, "Failed to allocate memory pool with %u elements\n", 4*1024 - 1);
+	int pop = lua_getfrom(prox_lua(), GLOBAL, targ->streams);
+	PROX_PANIC(pop < 0, "Failed to find '%s' in lua\n", targ->streams);
+
+	lua_len(prox_lua(), -1);
+	uint32_t n_listen = lua_tointeger(prox_lua(), -1);
+	lua_pop(prox_lua(), 1);
+	PROX_PANIC(n_listen == 0, "No services specified to listen on\n");
+
+	task->bundle_cfgs = prox_zmalloc(n_listen * sizeof(task->bundle_cfgs[0]), socket_id);
+
+	plogx_info("n_listen = %d\n", n_listen);
+
+	struct hash_set *hs = prox_sh_find_socket(socket_id, "genl4_streams");
+	if (hs == NULL) {
+		/* Expected number of streams per bundle = 1, hash_set
+		   will grow if full. */
+		hs = hash_set_create(n_listen, socket_id);
+		prox_sh_add_socket(socket_id, "genl4_streams", hs);
+	}
+
+	const struct rte_hash_parameters listen_table = {
+		.name = name,
+		.entries = n_listen * 4,
+		.key_len = sizeof(struct new_tuple),
+		.hash_func = rte_hash_crc,
+		.hash_func_init_val = 0,
+		.socket_id = socket_id,
+	};
+	name[0]++;
+
+	task->listen_hash = rte_hash_create(&listen_table);
+	task->listen_entries = prox_zmalloc(listen_table.entries * sizeof(task->listen_entries[0]), socket_id);
+
+	int idx = 0;
+	lua_pushnil(prox_lua());
+	while (lua_next(prox_lua(), -2)) {
+		task->bundle_cfgs[idx].n_stream_cfgs = 1;
+		task->bundle_cfgs[idx].stream_cfgs = prox_zmalloc(sizeof(*task->bundle_cfgs[idx].stream_cfgs), socket_id);
+		int ret = lua_to_stream_cfg(prox_lua(), STACK, NULL, socket_id, &task->bundle_cfgs[idx].stream_cfgs[0], hs);
+		PROX_PANIC(ret, "Failed to load stream cfg\n");
+		struct stream_cfg *stream = task->bundle_cfgs[idx].stream_cfgs[0];
+
+		// TODO: check mask and add to hash for each host
+		struct new_tuple nt = {
+			.dst_addr = stream->servers.ip,
+			.proto_id = stream->proto,
+			.dst_port = stream->servers.port,
+			.l2_types[0] = 0x0008,
+		};
+
+		ret = rte_hash_add_key(task->listen_hash, &nt);
+		PROX_PANIC(ret < 0, "Failed to add\n");
+
+		task->listen_entries[ret] = &task->bundle_cfgs[idx];
+
+		plogx_dbg("Server = "IPv4_BYTES_FMT":%d\n", IPv4_BYTES(((uint8_t*)&nt.dst_addr)), rte_bswap16(nt.dst_port));
+		++idx;
+		lua_pop(prox_lua(), 1);
+	}
+
+	static char name2[] = "task_gen_hash2";
+
+	name2[0]++;
+	plogx_dbg("Creating bundle ctx pool\n");
+	if (bundle_ctx_pool_create(name2, targ->n_concur_conn * 2, &task->bundle_ctx_pool, NULL, 0, NULL, socket_id)) {
+		cmd_mem_stats();
+		PROX_PANIC(1, "Failed to create conn_ctx_pool\n");
+	}
+
+	task->heap = heap_create(targ->n_concur_conn * 2, socket_id);
+	task->seed = rte_rdtsc();
+
+	/* TODO: calculate the CDF of the reply distribution and the
+	   number of replies as the number to cover for 99% of the
+	   replies. For now, assume that this is number is 2. */
+	uint32_t queue_size = rte_align32pow2(targ->n_concur_conn * 2);
+
+	PROX_PANIC(queue_size == 0, "Overflow resulted in queue size 0\n");
+	task->fqueue = fqueue_create(queue_size, socket_id);
+	PROX_PANIC(task->fqueue == NULL, "Failed to allocate local queue\n");
+
+	uint32_t n_descriptors;
+
+	if (targ->nb_txports) {
+		PROX_PANIC(targ->nb_txports != 1, "Need exactly one TX port for L4 generation\n");
+		n_descriptors = prox_port_cfg[targ->tx_port_queue[0].port].n_txd;
+	} else {
+		PROX_PANIC(targ->nb_txrings != 1, "Need exactly one TX ring for L4 generation\n");
+		n_descriptors = 256;
+	}
+
+	struct token_time_cfg tt_cfg = {
+		.bpp = targ->rate_bps,
+		.period = rte_get_tsc_hz(),
+		.bytes_max = n_descriptors * (ETHER_MIN_LEN + 20),
+	};
+
+	token_time_init(&task->token_time, &tt_cfg);
+}
+
+static void init_task_gen_client(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_gen_client *task = (struct task_gen_client *)tbase;
+	static char name[] = "gen_pool";
+	const uint32_t socket = rte_lcore_to_socket_id(targ->lconf->id);
+	name[0]++;
+	task->mempool = rte_mempool_create(name,
+					   4*1024 - 1, MBUF_SIZE,
+					   targ->nb_cache_mbuf,
+					   sizeof(struct rte_pktmbuf_pool_private),
+					   rte_pktmbuf_pool_init, NULL,
+					   rte_pktmbuf_init, 0,
+					   socket, 0);
+	PROX_PANIC(task->mempool == NULL, "Failed to allocate memory pool with %u elements\n", 4*1024 - 1);
+
+	/* streams contains a lua table. Go through it and read each
+	   stream with associated imix_fraction. */
+	uint32_t imix;
+	uint32_t i = 0;
+
+	int pop = lua_getfrom(prox_lua(), GLOBAL, targ->streams);
+	PROX_PANIC(pop < 0, "Failed to find '%s' in lua\n", targ->streams);
+
+	lua_len(prox_lua(), -1);
+	uint32_t n_bundle_cfgs = lua_tointeger(prox_lua(), -1);
+	lua_pop(prox_lua(), 1);
+	PROX_PANIC(n_bundle_cfgs == 0, "No configs specified\n");
+	plogx_info("loading %d bundle_cfgs\n", n_bundle_cfgs);
+
+	struct hash_set *hs = prox_sh_find_socket(socket, "genl4_streams");
+	if (hs == NULL) {
+		/* Expected number of streams per bundle = 8, hash_set
+		   will grow if full. */
+		hs = hash_set_create(n_bundle_cfgs * 8, socket);
+		prox_sh_add_socket(socket, "genl4_streams", hs);
+	}
+
+	task->bundle_cfgs = prox_zmalloc(n_bundle_cfgs * sizeof(task->bundle_cfgs[0]), socket);
+	lua_pushnil(prox_lua());
+
+	int total_imix = 0;
+
+	uint32_t *occur = prox_zmalloc(n_bundle_cfgs * sizeof(*occur), socket);
+	struct cdf *cdf = cdf_create(n_bundle_cfgs, socket);
+
+	while (lua_next(prox_lua(), -2)) {
+		PROX_PANIC(lua_to_int(prox_lua(), TABLE, "imix_fraction", &imix) ||
+			   lua_to_bundle_cfg(prox_lua(), TABLE, "bundle", socket, &task->bundle_cfgs[i], hs),
+			   "Failed to load bundle cfg:\n%s\n", get_lua_to_errors());
+		cdf_add(cdf, imix);
+		occur[i] = imix;
+		total_imix += imix;
+		++i;
+		lua_pop(prox_lua(), 1);
+	}
+
+	lua_pop(prox_lua(), pop);
+	cdf_setup(cdf);
+
+	PROX_PANIC(targ->max_setup_rate == 0, "Max setup rate not set\n");
+
+	task->new_conn_cost = rte_get_tsc_hz()/targ->max_setup_rate;
+
+	static char name2[] = "task_gen_hash";
+	name2[0]++;
+	plogx_dbg("Creating bundle ctx pool\n");
+	if (bundle_ctx_pool_create(name2, targ->n_concur_conn, &task->bundle_ctx_pool, occur, n_bundle_cfgs, task->bundle_cfgs, socket)) {
+		cmd_mem_stats();
+		PROX_PANIC(1, "Failed to create conn_ctx_pool\n");
+	}
+
+	task->heap = heap_create(targ->n_concur_conn, socket);
+	task->seed = rte_rdtsc();
+	/* task->token_time.bytes_max = MAX_PKT_BURST * (ETHER_MAX_LEN + 20); */
+
+	/* To avoid overflowing the tx descriptors, the token bucket
+	   size needs to be limited. The descriptors are filled most
+	   quickly with the smallest packets. For that reason, the
+	   token bucket size is given by "number of tx descriptors" *
+	   "smallest Ethernet packet". */
+	PROX_ASSERT(targ->nb_txports == 1);
+
+	struct token_time_cfg tt_cfg = {
+		.bpp = targ->rate_bps,
+		.period = rte_get_tsc_hz(),
+		.bytes_max = prox_port_cfg[targ->tx_port_queue[0].port].n_txd * (ETHER_MIN_LEN + 20),
+	};
+
+	token_time_init(&task->token_time, &tt_cfg);
+}
+
+static void start_task_gen_client(struct task_base *tbase)
+{
+	struct task_gen_client *task = (struct task_gen_client *)tbase;
+
+	token_time_reset(&task->token_time, rte_rdtsc(), 0);
+
+	task->new_conn_tokens = 0;
+	task->new_conn_last_tsc = rte_rdtsc();
+}
+
+static void stop_task_gen_client(struct task_base *tbase)
+{
+	struct task_gen_client *task = (struct task_gen_client *)tbase;
+	struct bundle_ctx *bundle;
+
+	while (!heap_is_empty(task->heap)) {
+		bundle = BUNDLE_CTX_UPCAST(heap_pop(task->heap));
+		bundle_expire(bundle, &task->bundle_ctx_pool, &task->l4_stats);
+	}
+}
+
+static void start_task_gen_server(struct task_base *tbase)
+{
+	struct task_gen_server *task = (struct task_gen_server *)tbase;
+
+	token_time_reset(&task->token_time, rte_rdtsc(), 0);
+}
+
+static void stop_task_gen_server(struct task_base *tbase)
+{
+	struct task_gen_server *task = (struct task_gen_server *)tbase;
+	struct bundle_ctx *bundle;
+	uint8_t out[MAX_PKT_BURST];
+
+	while (!heap_is_empty(task->heap)) {
+		bundle = BUNDLE_CTX_UPCAST(heap_pop(task->heap));
+		bundle_expire(bundle, &task->bundle_ctx_pool, &task->l4_stats);
+	}
+
+	if (task->cancelled) {
+		struct rte_mbuf *mbuf = task->mbuf_saved;
+
+		out[0] = OUT_DISCARD;
+		task->cancelled = 0;
+		task->base.tx_pkt(&task->base, &mbuf, 1, out);
+	}
+
+	do {
+		if (task->cur_mbufs_beg == task->cur_mbufs_end) {
+			task->cur_mbufs_end = fqueue_get(task->fqueue, task->cur_mbufs, MAX_PKT_BURST);
+			task->cur_mbufs_beg = 0;
+			if (task->cur_mbufs_end == 0)
+				break;
+		}
+		uint16_t n_pkts = task->cur_mbufs_end - task->cur_mbufs_beg;
+		struct rte_mbuf **mbufs = task->cur_mbufs + task->cur_mbufs_beg;
+
+		if (n_pkts) {
+			for (uint16_t j = 0; j < n_pkts; ++j) {
+				out[j] = OUT_DISCARD;
+			}
+			task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+		}
+	} while (1);
+}
+
+static struct task_init task_init_gen1 = {
+	.mode_str = "genl4",
+	.sub_mode_str = "server",
+	.init = init_task_gen,
+	.handle = handle_gen_bulk,
+	.start = start_task_gen_server,
+	.stop = stop_task_gen_server,
+	.flag_features = TASK_FEATURE_ZERO_RX,
+	.size = sizeof(struct task_gen_server),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+static struct task_init task_init_gen2 = {
+	.mode_str = "genl4",
+	.init = init_task_gen_client,
+	.handle = handle_gen_bulk_client,
+	.start = start_task_gen_client,
+	.stop = stop_task_gen_client,
+	.flag_features = TASK_FEATURE_ZERO_RX,
+	.size = sizeof(struct task_gen_client),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+__attribute__((constructor)) static void reg_task_gen(void)
+{
+	reg_task(&task_init_gen1);
+	reg_task(&task_init_gen2);
+}
diff --git a/VNFs/DPPD-PROX/handle_gre_decap_encap.c b/VNFs/DPPD-PROX/handle_gre_decap_encap.c
new file mode 100644
index 00000000..41f6dd33
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_gre_decap_encap.c
@@ -0,0 +1,462 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_byteorder.h>
+#include <rte_cycles.h>
+#include <rte_hash.h>
+#include <rte_ip.h>
+
+#include "prox_malloc.h"
+#include "task_init.h"
+#include "lconf.h"
+#include "defines.h"
+#include "stats.h"
+#include "tx_pkt.h"
+#include "hash_entry_types.h"
+#include "prefetch.h"
+#include "prox_cksum.h"
+#include "gre.h"
+#include "etypes.h"
+#include "log.h"
+#include "quit.h"
+#include "prox_assert.h"
+#include "pkt_prototypes.h"
+#include "quit.h"
+
+struct cpe_gre_key {
+	struct ether_addr clt_mac;
+	uint16_t          pad;
+} __attribute__((__packed__));
+
+struct cpe_gre_data {
+	uint32_t gre_id;
+	uint32_t cpe_ip;
+	uint64_t tsc;
+#ifdef GRE_TP
+	uint64_t tp_tsc;
+	double tp_tbsize;
+#endif
+} __attribute__((__packed__));
+
+struct task_gre_decap {
+	struct task_base base;
+	struct rte_hash *cpe_gre_hash;
+	struct cpe_gre_data *cpe_gre_data;
+	struct lcore_cfg *lconf;
+	uint8_t runtime_flags;
+	uint8_t mapping[PROX_MAX_PORTS];
+	uint32_t bucket_index;
+	int     offload_crc;
+	const void* key_ptr[16];
+	struct cpe_gre_key key[16];
+	uint64_t           cpe_timeout;
+#ifdef GRE_TP
+	double cycles_per_byte;
+	uint32_t tb_size;
+#endif
+};
+
+static void handle_gre_decap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+static void handle_gre_encap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+
+static inline uint8_t handle_gre_encap(struct task_gre_decap *task, struct rte_mbuf *mbuf, struct cpe_gre_data *table);
+static inline void handle_gre_encap16(struct task_gre_decap *task, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+static inline uint8_t handle_gre_decap(struct task_gre_decap *tbase, struct rte_mbuf *mbuf);
+
+void update_arp_entries_gre(void *data);
+
+static void init_cpe_gre_hash(struct task_args *targ)
+{
+	char name[64];
+	uint8_t socket_id;
+	uint8_t lcore_id;
+	uint8_t table_part;
+
+	/* Already set up by other task */
+	if (targ->cpe_gre_hash) {
+		return;
+	}
+
+	lcore_id = targ->lconf->id;
+	socket_id = rte_lcore_to_socket_id(lcore_id);
+	sprintf(name, "core_%u_CPE_GRE_Table", targ->lconf->id);
+	table_part = targ->nb_slave_threads;
+
+	if (table_part == 0)
+		table_part = 1;
+	if (!rte_is_power_of_2(table_part)) {
+		table_part = rte_align32pow2(table_part) >> 1;
+	}
+
+	struct rte_hash_parameters hash_params = {
+		.name = name,
+		.entries = MAX_GRE / table_part,
+		.bucket_entries = GRE_BUCKET_ENTRIES,
+		.key_len = sizeof(struct cpe_gre_key),
+		.hash_func_init_val = 0,
+		.socket_id = socket_id
+	};
+
+	struct rte_hash* phash = rte_hash_create(&hash_params);
+	struct cpe_gre_data *cpe_gre_data = prox_zmalloc(MAX_GRE / table_part, socket_id);
+
+	PROX_PANIC(phash == NULL, "Unable to allocate memory for IPv4 hash table on core %u\n", lcore_id);
+
+	for (uint8_t task_id = 0; task_id < targ->lconf->n_tasks_all; ++task_id) {
+		enum task_mode smode = targ->lconf->targs[task_id].mode;
+		if (smode == GRE_DECAP || smode == GRE_ENCAP) {
+			targ->lconf->targs[task_id].cpe_gre_hash = phash;
+			targ->lconf->targs[task_id].cpe_gre_data = cpe_gre_data;
+		}
+	}
+}
+
+static void init_task_gre_decap(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_gre_decap *task = (struct task_gre_decap *)tbase;
+
+	init_cpe_gre_hash(targ);
+	task->cpe_gre_hash = targ->cpe_gre_hash;
+	task->cpe_gre_data = targ->cpe_gre_data;
+	task->runtime_flags = targ->runtime_flags;
+	task->lconf = targ->lconf;
+	task->cpe_timeout = msec_to_tsc(targ->cpe_table_timeout_ms);
+
+	targ->lconf->period_func = update_arp_entries_gre;
+	targ->lconf->period_data = tbase;
+	targ->lconf->period_timeout = msec_to_tsc(500) / NUM_VCPES;
+
+	for (uint8_t i = 0; i < 16; ++i) {
+		task->key_ptr[i] = &task->key[i];
+	}
+}
+
+static void init_task_gre_encap(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_gre_decap *task = (struct task_gre_decap *)tbase;
+
+	init_cpe_gre_hash(targ);
+	task->cpe_gre_hash = targ->cpe_gre_hash;
+	task->cpe_gre_data = targ->cpe_gre_data;
+	task->runtime_flags = targ->runtime_flags;
+	task->lconf = targ->lconf;
+
+	struct port_cfg *port = find_reachable_task_sending_to_port(targ);
+	if (port) {
+		task->offload_crc = port->capabilities.tx_offload_cksum;
+	}
+
+#ifdef GRE_TP
+	if (targ->tb_rate) {
+		task->cycles_per_byte = ((double)rte_get_tsc_hz()) / ((double)targ->tb_rate);
+		task->tb_size = targ->tb_size != 0 ? targ->tb_size : 1520;
+	}
+	else {
+		/* traffic policing disabled */
+		task->cycles_per_byte = 0;
+	}
+#endif
+}
+
+static struct task_init task_init_gre_decap = {
+	.mode = GRE_DECAP,
+	.mode_str = "gredecap",
+	.init = init_task_gre_decap,
+	.handle = handle_gre_decap_bulk,
+	.size = sizeof(struct task_gre_decap)
+};
+
+static struct task_init task_init_gre_encap = {
+	.mode = GRE_ENCAP,
+	.mode_str = "greencap",
+	.init = init_task_gre_encap,
+	.handle = handle_gre_encap_bulk,
+	.size = sizeof(struct task_gre_decap)
+};
+
+__attribute__((constructor)) static void reg_task_gre(void)
+{
+	reg_task(&task_init_gre_decap);
+	reg_task(&task_init_gre_encap);
+}
+
+void handle_gre_decap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_gre_decap *task = (struct task_gre_decap *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_gre_decap(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_gre_decap(task, mbufs[j]);
+	}
+#endif
+
+	task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+struct gre_packet {
+	struct ether_hdr eth;
+	struct ipv4_hdr ip;
+	struct gre_hdr gre;
+	union {
+		struct ether_hdr eth2;
+		struct ipv4_hdr ip2;
+	};
+} __attribute__((__packed__));
+
+/* Handle ipv4 over GRE and Ethernet over GRE. In case of ipv4 over
+   GRE remove gre and ipv4 header and retain space for ethernet
+   header. In case of Eth over GRE remove external eth, gre and ipv4
+   headers and return pointer to payload */
+static inline struct ether_hdr *gre_decap(struct gre_hdr *pgre, struct rte_mbuf *mbuf)
+{
+	int16_t hsize = 0;
+	if (pgre->type == ETYPE_EoGRE) {
+		hsize = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr);
+	}
+	else if (pgre->type == ETYPE_IPv4) {
+		/* retain sizeof(struct ether_hdr) */
+		hsize = sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr);
+	}
+	else {
+		return NULL;
+	}
+
+	return (struct ether_hdr *)rte_pktmbuf_adj(mbuf, hsize);
+}
+
+static inline uint8_t handle_gre_decap(struct task_gre_decap *task, struct rte_mbuf *mbuf)
+{
+	struct ipv4_hdr *pip = (struct ipv4_hdr *)(rte_pktmbuf_mtod(mbuf, struct ether_hdr *) + 1);
+
+	if (pip->next_proto_id != IPPROTO_GRE) {
+		plog_warn("Invalid packet proto_id = 0x%x expect 0x%x\n",
+			pip->next_proto_id, IPPROTO_GRE);
+		return OUT_DISCARD;
+	}
+
+	struct cpe_gre_data data;
+	struct cpe_gre_key key;
+	struct gre_hdr *pgre = (struct gre_hdr *)(pip + 1);
+	data.gre_id = pgre->gre_id;
+	data.cpe_ip = pip->src_addr;
+
+	struct ether_hdr *peth = gre_decap(pgre, mbuf);
+	PROX_PANIC(peth != 0, "Failed to gre_decap");
+
+	pip = (struct ipv4_hdr *)(peth + 1);
+
+/* emulate client MAC for test purposes */
+#if 1
+	if (pgre->type == ETYPE_IPv4) {
+		struct ether_hdr eth = {
+			.d_addr = {.addr_bytes =
+				   {0x0A, 0x02, 0x0A, 0x0A, 0x00, 0x01}},
+			.s_addr = {.addr_bytes =
+				   {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
+			.ether_type = ETYPE_IPv4
+		};
+		uint32_t hip = rte_bswap32(pip->src_addr);
+		eth.s_addr.addr_bytes[2] = (hip >> 24) & 0xFF;
+		eth.s_addr.addr_bytes[3] = (hip >> 16) & 0xFF;
+		eth.s_addr.addr_bytes[4] = (hip >> 8) & 0xFF;
+		eth.s_addr.addr_bytes[5] = (hip) & 0xFF;
+		rte_memcpy(peth, &eth, sizeof(struct ether_hdr));
+	}
+	ether_addr_copy(&peth->s_addr, &key.clt_mac);
+#endif
+
+	data.tsc = rte_rdtsc() + task->cpe_timeout;
+
+	int32_t hash_index = rte_hash_add_key(task->cpe_gre_hash, &key);
+	if (unlikely(hash_index < 0)) {
+		plog_warn("Failed to add key, gre %x\n", data.gre_id);
+	}
+	else if (unlikely(hash_index >= MAX_GRE)) {
+		plog_warn("Failed to add: Invalid hash_index = 0x%x\n",
+			hash_index);
+		return OUT_DISCARD;
+	}
+	rte_memcpy(&task->cpe_gre_data[hash_index], &data, sizeof(data));
+	if (task->runtime_flags & TASK_TX_CRC) {
+		prox_ip_cksum(mbuf, pip, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+	}
+
+	return 0;
+}
+
+void handle_gre_encap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_gre_decap *task = (struct task_gre_decap *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t done = 0;
+
+	while (n_pkts) {
+		uint16_t chopped = RTE_MIN(n_pkts, 16);
+		prefetch_pkts(mbufs, chopped);
+		handle_gre_encap16(task, mbufs, chopped, out + done);
+		mbufs += chopped;
+		n_pkts -= chopped;
+		done += chopped;
+	}
+
+	task->base.tx_pkt(&task->base, mbufs - done, done, out);
+}
+
+#define DO_ENC_ETH_OVER_GRE 1
+#define DO_ENC_IP_OVER_GRE 0
+
+static inline void handle_gre_encap16(struct task_gre_decap *task, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	for (uint8_t i = 0; i < n_pkts; ++i) {
+		struct ether_hdr *peth = rte_pktmbuf_mtod(mbufs[i], struct ether_hdr *);
+		ether_addr_copy(&peth->d_addr, &task->key[i].clt_mac);
+	}
+
+	int32_t hash_index[16];
+	rte_hash_lookup_bulk(task->cpe_gre_hash, task->key_ptr, n_pkts, hash_index);
+	for (uint8_t i = 0; i < n_pkts; ++i ) {
+		if (unlikely(hash_index[i] < 0)) {
+			plog_warn("Invalid hash_index (<0) = 0x%x\n", hash_index[i]);
+			out[i] = OUT_DISCARD;
+		}
+		else if (unlikely(hash_index[i] >= MAX_GRE)) {
+			plog_warn("Invalid hash_index = 0x%x\n", hash_index[i]);
+			out[i] = OUT_DISCARD;
+		}
+		rte_prefetch0(&task->cpe_gre_data[hash_index[i]]);
+	}
+
+	for (uint8_t i = 0; i < n_pkts; ++i ) {
+		if (likely(out[i] != OUT_DISCARD)) {
+			out[i] = handle_gre_encap(task, mbufs[i], &task->cpe_gre_data[hash_index[i]]);
+		}
+	}
+}
+
+#ifdef DO_ENC_ETH_OVER_GRE
+#define PKT_PREPEND_LEN (sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr))
+#elif DO_ENC_IP_OVER_GRE
+#define PKT_PREPEND_LEN (sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr))
+#else
+
+static inline uint8_t handle_gre_encap(struct task_gre_decap *task, struct rte_mbuf *mbuf, struct cpe_gre_data *table)
+{
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	struct ipv4_hdr *pip = (struct ipv4_hdr *)(peth + 1);
+	uint16_t ip_len = rte_be_to_cpu_16(pip->total_length);
+
+	struct cpe_gre_key key;
+	ether_addr_copy(&peth->d_addr, &key.clt_mac);
+
+#ifdef GRE_TP
+	/* policing enabled */
+	if (task->cycles_per_byte) {
+		const uint16_t pkt_size = rte_pktmbuf_pkt_len(mbuf) + ETHER_CRC_LEN;
+		uint64_t tsc_now = rte_rdtsc();
+		if (table->tp_tbsize < pkt_size) {
+			uint64_t cycles_diff = tsc_now - table->tp_tsc;
+			double dB = ((double)cycles_diff) / task->cycles_per_byte;
+			if (dB > (double)task->tb_size) {
+				dB = task->tb_size;
+			}
+			if ((table->tp_tbsize + dB) >= pkt_size) {
+				table->tp_tbsize += dB;
+				table->tp_tsc = tsc_now;
+			}
+			else {
+				TASK_STATS_ADD_DROP_DISCARD(&task->base.aux->stats, 1);
+				return OUT_DISCARD;
+			}
+		}
+		table->tp_tbsize -= pkt_size;
+	}
+#endif /* GRE_TP */
+
+	/* reuse ethernet header from payload, retain payload (ip) in
+	   case of DO_ENC_IP_OVER_GRE */
+	peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, PKT_PREPEND_LEN);
+	PREFETCH0(peth);
+	ip_len += PKT_PREPEND_LEN;
+
+	pip = (struct ipv4_hdr *)(peth + 1);
+	struct gre_hdr *pgre = (struct gre_hdr *)(pip + 1);
+
+	struct ether_hdr eth = {
+		.d_addr = {.addr_bytes = {0x0A, 0x0A, 0x0A, 0xC8, 0x00, 0x02}},
+		.s_addr = {.addr_bytes = {0x0A, 0x0A, 0x0A, 0xC8, 0x00, 0x01}},
+		.ether_type = ETYPE_IPv4
+	};
+	rte_memcpy(peth, &eth, sizeof(struct ether_hdr));
+
+	rte_memcpy(pgre, &gre_hdr_proto, sizeof(struct gre_hdr));
+#if DO_ENC_ETH_OVER_GRE
+	pgre->type = ETYPE_EoGRE;
+#elif DO_ENC_IP_OVER_GRE
+	pgre->type = ETYPE_IPv4;
+#endif
+	pgre->gre_id = table->gre_id;
+
+	rte_memcpy(pip, &tunnel_ip_proto, sizeof(struct ipv4_hdr));
+	pip->src_addr = 0x02010a0a;	//emulate port ip
+	pip->dst_addr = table->cpe_ip;
+	pip->total_length = rte_cpu_to_be_16(ip_len);
+
+	if (task->runtime_flags & TASK_TX_CRC) {
+		prox_ip_cksum(mbuf, pip, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+	}
+
+	return 0;
+}
+
+void update_arp_entries_gre(void *data)
+{
+	uint64_t cur_tsc = rte_rdtsc();
+	struct task_gre_decap *task = (struct task_gre_decap *)data;
+
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
+	// rte_hash_iterate might take a long time if no entries found => we should not use it here
+	// struct rte_hash is now internal.....
+	// => Not implemented
+#else
+	uint32_t *sig_bucket = (hash_sig_t *)&(task->cpe_gre_hash->sig_tbl[task->bucket_index * task->cpe_gre_hash->sig_tbl_bucket_size]);
+	uint32_t table_index = task->bucket_index * task->cpe_gre_hash->bucket_entries;
+
+	uint8_t *entry_bucket =
+	    (uint8_t *) & task->cpe_gre_hash->key_tbl[task->bucket_index * task->cpe_gre_hash->bucket_entries * task->cpe_gre_hash->key_tbl_key_size];
+
+	for (uint32_t pos = 0; pos < task->cpe_gre_hash->bucket_entries; ++pos, ++table_index) {
+		struct cpe_gre_entry *key = (struct cpe_gre_entry *)&entry_bucket[pos * task->cpe_gre_hash->key_tbl_key_size];
+		if (task->cpe_gre_data[table_index].tsc < cur_tsc) {
+			sig_bucket[pos] = 0;
+			task->cpe_gre_data[table_index].tsc = UINT64_MAX;
+		}
+	}
+	++task->bucket_index;
+	task->bucket_index &= task->cpe_gre_hash->bucket_bitmask;
+#endif
+}
diff --git a/VNFs/DPPD-PROX/handle_impair.c b/VNFs/DPPD-PROX/handle_impair.c
new file mode 100644
index 00000000..3f2ee0eb
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_impair.c
@@ -0,0 +1,421 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <rte_cycles.h>
+#include <rte_version.h>
+
+#include "prox_malloc.h"
+#include "lconf.h"
+#include "log.h"
+#include "random.h"
+#include "handle_impair.h"
+#include "prefetch.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#endif
+
+#define DELAY_ACCURACY	11		// accuracy of 2048 cycles ~= 1 micro-second
+#define DELAY_MAX_MASK	0x1FFFFF	// Maximum 2M * 2K cycles ~1 second
+
+struct queue_elem {
+	struct rte_mbuf *mbuf;
+	uint64_t        tsc;
+};
+
+struct queue {
+	struct queue_elem *queue_elem;
+	unsigned queue_head;
+	unsigned queue_tail;
+};
+
+struct task_impair {
+	struct task_base base;
+	struct queue_elem *queue;
+	uint32_t random_delay_us;
+	uint32_t delay_us;
+	uint64_t delay_time;
+	uint64_t delay_time_mask;
+	unsigned queue_head;
+	unsigned queue_tail;
+	unsigned queue_mask;
+	int tresh;
+	unsigned int seed;
+	struct random state;
+	uint64_t last_idx;
+	struct queue *buffer;
+	uint32_t socket_id;
+	int need_update;
+};
+
+static int handle_bulk_impair(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+static int handle_bulk_impair_random(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+static int handle_bulk_random_drop(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+
+void task_impair_set_proba(struct task_base *tbase, float proba)
+{
+	struct task_impair *task = (struct task_impair *)tbase;
+	task->tresh = ((uint64_t) RAND_MAX) * (uint32_t)(proba * 10000) / 1000000;
+}
+
+void task_impair_set_delay_us(struct task_base *tbase, uint32_t delay_us, uint32_t random_delay_us)
+{
+	struct task_impair *task = (struct task_impair *)tbase;
+	task->need_update = 1;
+	task->random_delay_us = random_delay_us;
+	task->delay_us = delay_us;
+}
+
+static void task_impair_update(struct task_base *tbase)
+{
+	struct task_impair *task = (struct task_impair *)tbase;
+	uint32_t queue_len = 0;
+	size_t mem_size;
+	if (!task->need_update)
+		return;
+	task->need_update = 0;
+	uint64_t now = rte_rdtsc();
+	uint8_t out[MAX_PKT_BURST] = {0};
+	uint64_t now_idx = (now >> DELAY_ACCURACY) & DELAY_MAX_MASK;
+
+	if (task->random_delay_us) {
+		tbase->handle_bulk = handle_bulk_impair_random;
+		task->delay_time = usec_to_tsc(task->random_delay_us);
+		task->delay_time_mask = rte_align32pow2(task->delay_time) - 1;
+		queue_len = rte_align32pow2((1250L * task->random_delay_us) / 84 / (DELAY_MAX_MASK + 1));
+	} else if (task->delay_us == 0) {
+		tbase->handle_bulk = handle_bulk_random_drop;
+		task->delay_time = 0;
+	} else {
+		tbase->handle_bulk = handle_bulk_impair;
+		task->delay_time = usec_to_tsc(task->delay_us);
+		queue_len = rte_align32pow2(1250 * task->delay_us / 84);
+	}
+	if (task->queue) {
+		struct rte_mbuf *new_mbufs[MAX_PKT_BURST];
+		while (task->queue_tail != task->queue_head) {
+			now = rte_rdtsc();
+			uint16_t idx = 0;
+			while (idx < MAX_PKT_BURST && task->queue_tail != task->queue_head) {
+				if (task->queue[task->queue_tail].tsc <= now) {
+					out[idx] = rand_r(&task->seed) <= task->tresh? 0 : OUT_DISCARD;
+					new_mbufs[idx++] = task->queue[task->queue_tail].mbuf;
+					task->queue_tail = (task->queue_tail + 1) & task->queue_mask;
+				}
+				else {
+					break;
+				}
+			}
+			if (idx)
+				task->base.tx_pkt(&task->base, new_mbufs, idx, out);
+		}
+		prox_free(task->queue);
+		task->queue = NULL;
+	}
+	if (task->buffer) {
+		struct rte_mbuf *new_mbufs[MAX_PKT_BURST];
+		while (task->last_idx != ((now_idx - 1) & DELAY_MAX_MASK)) {
+			now = rte_rdtsc();
+			uint16_t pkt_idx = 0;
+			while ((pkt_idx < MAX_PKT_BURST) && (task->last_idx != ((now_idx - 1) & DELAY_MAX_MASK))) {
+				struct queue *queue = &task->buffer[task->last_idx];
+				while ((pkt_idx < MAX_PKT_BURST) && (queue->queue_tail != queue->queue_head)) {
+					out[pkt_idx] = rand_r(&task->seed) <= task->tresh? 0 : OUT_DISCARD;
+					new_mbufs[pkt_idx++] = queue->queue_elem[queue->queue_tail].mbuf;
+					queue->queue_tail = (queue->queue_tail + 1) & task->queue_mask;
+				}
+				task->last_idx = (task->last_idx + 1) & DELAY_MAX_MASK;
+			}
+
+			if (pkt_idx)
+				task->base.tx_pkt(&task->base, new_mbufs, pkt_idx, out);
+		}
+		for (int i = 0; i < DELAY_MAX_MASK + 1; i++) {
+			if (task->buffer[i].queue_elem)
+				prox_free(task->buffer[i].queue_elem);
+		}
+		prox_free(task->buffer);
+		task->buffer = NULL;
+	}
+
+	if (queue_len < MAX_PKT_BURST)
+		queue_len= MAX_PKT_BURST;
+	task->queue_mask = queue_len - 1;
+	if (task->queue_mask < MAX_PKT_BURST - 1)
+		task->queue_mask = MAX_PKT_BURST - 1;
+	mem_size = (task->queue_mask + 1) * sizeof(task->queue[0]);
+
+	if (task->delay_us) {
+		task->queue_head = 0;
+		task->queue_tail = 0;
+		task->queue = prox_zmalloc(mem_size, task->socket_id);
+		if (task->queue == NULL) {
+			plog_err("Not enough memory to allocate queue\n");
+			task->queue_mask = 0;
+		}
+	} else if (task->random_delay_us) {
+		size_t size = (DELAY_MAX_MASK + 1) * sizeof(struct queue);
+		plog_info("Allocating %zd bytes\n", size);
+		task->buffer = prox_zmalloc(size, task->socket_id);
+		PROX_PANIC(task->buffer == NULL, "Not enough memory to allocate buffer\n");
+		plog_info("Allocating %d x %zd bytes\n", DELAY_MAX_MASK + 1, mem_size);
+
+		for (int i = 0; i < DELAY_MAX_MASK + 1; i++) {
+			task->buffer[i].queue_elem = prox_zmalloc(mem_size, task->socket_id);
+			PROX_PANIC(task->buffer[i].queue_elem == NULL, "Not enough memory to allocate buffer elems\n");
+		}
+	}
+	random_init_seed(&task->state);
+}
+
+static int handle_bulk_random_drop(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_impair *task = (struct task_impair *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	for (uint16_t i = 0; i < n_pkts; ++i) {
+		out[i] = rand_r(&task->seed) <= task->tresh? 0 : OUT_DISCARD;
+	}
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+	task_impair_update(tbase);
+}
+
+static int handle_bulk_impair(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_impair *task = (struct task_impair *)tbase;
+	uint64_t now = rte_rdtsc();
+	uint8_t out[MAX_PKT_BURST] = {0};
+	uint16_t enqueue_failed;
+	uint16_t i;
+	int ret = 0;
+
+	int nb_empty_slots = (task->queue_tail - task->queue_head + task->queue_mask) & task->queue_mask;
+	if (likely(nb_empty_slots >= n_pkts)) {
+		/* We know n_pkts fits, no need to check for every packet */
+		for (i = 0; i < n_pkts; ++i) {
+			task->queue[task->queue_head].tsc = now + task->delay_time;
+			task->queue[task->queue_head].mbuf = mbufs[i];
+			task->queue_head = (task->queue_head + 1) & task->queue_mask;
+		}
+	} else {
+		for (i = 0; i < n_pkts; ++i) {
+			if (((task->queue_head + 1) & task->queue_mask) != task->queue_tail) {
+				task->queue[task->queue_head].tsc = now + task->delay_time;
+				task->queue[task->queue_head].mbuf = mbufs[i];
+				task->queue_head = (task->queue_head + 1) & task->queue_mask;
+			}
+			else {
+				/* Rest does not fit, need to drop those packets. */
+				enqueue_failed = i;
+				for (;i < n_pkts; ++i) {
+					out[i] = OUT_DISCARD;
+				}
+				ret+= task->base.tx_pkt(&task->base, mbufs + enqueue_failed,
+					  	n_pkts - enqueue_failed, out + enqueue_failed);
+				break;
+			}
+		}
+	}
+
+	struct rte_mbuf *new_mbufs[MAX_PKT_BURST];
+	uint16_t idx = 0;
+
+	if (task->tresh != RAND_MAX) {
+		while (idx < MAX_PKT_BURST && task->queue_tail != task->queue_head) {
+			if (task->queue[task->queue_tail].tsc <= now) {
+				out[idx] = rand_r(&task->seed) <= task->tresh? 0 : OUT_DISCARD;
+				new_mbufs[idx] = task->queue[task->queue_tail].mbuf;
+				PREFETCH0(new_mbufs[idx]);
+				PREFETCH0(&new_mbufs[idx]->cacheline1);
+				idx++;
+				task->queue_tail = (task->queue_tail + 1) & task->queue_mask;
+			}
+			else {
+				break;
+			}
+		}
+	} else {
+		while (idx < MAX_PKT_BURST && task->queue_tail != task->queue_head) {
+			if (task->queue[task->queue_tail].tsc <= now) {
+				out[idx] = 0;
+				new_mbufs[idx] = task->queue[task->queue_tail].mbuf;
+				PREFETCH0(new_mbufs[idx]);
+				PREFETCH0(&new_mbufs[idx]->cacheline1);
+				idx++;
+				task->queue_tail = (task->queue_tail + 1) & task->queue_mask;
+			}
+			else {
+				break;
+			}
+		}
+	}
+
+	if (idx)
+		ret+= task->base.tx_pkt(&task->base, new_mbufs, idx, out);
+	task_impair_update(tbase);
+	return ret;
+}
+
+/*
+ * We want to avoid using division and mod for performance reasons.
+ * We also want to support up to one second delay, and express it in tsc
+ * So the delay in tsc needs up to 32 bits (supposing procesor freq is less than 4GHz).
+ * If the max_delay is smaller, we make sure we use less bits.
+ * Note that we lose the MSB of the xorshift - 64 bits could hold
+ * two or three delays in TSC - but would probably make implementation more complex
+ * and not huge gain expected. Maybe room for optimization.
+ * Using this implementation, we might have to run random more than once for a delay
+ * but in average this should occur less than 50% of the time.
+*/
+
+static inline uint64_t random_delay(struct random *state, uint64_t max_delay, uint64_t max_delay_mask)
+{
+	uint64_t val;
+	while(1) {
+		val = random_next(state);
+		if ((val & max_delay_mask) < max_delay)
+			return (val & max_delay_mask);
+	}
+}
+
+static int handle_bulk_impair_random(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_impair *task = (struct task_impair *)tbase;
+	uint64_t now = rte_rdtsc();
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t enqueue_failed;
+	uint16_t i;
+	int ret = 0;
+	uint64_t packet_time, idx;
+	uint64_t now_idx = (now >> DELAY_ACCURACY) & DELAY_MAX_MASK;
+
+	for (i = 0; i < n_pkts; ++i) {
+		packet_time = now + random_delay(&task->state, task->delay_time, task->delay_time_mask);
+		idx = (packet_time >> DELAY_ACCURACY) & DELAY_MAX_MASK;
+		while (idx != ((now_idx - 1) & DELAY_MAX_MASK)) {
+			struct queue *queue = &task->buffer[idx];
+			if (((queue->queue_head + 1) & task->queue_mask) != queue->queue_tail) {
+				queue->queue_elem[queue->queue_head].mbuf = mbufs[i];
+				queue->queue_head = (queue->queue_head + 1) & task->queue_mask;
+				break;
+			} else {
+				idx = (idx + 1) & DELAY_MAX_MASK;
+			}
+		}
+		if (idx == ((now_idx - 1) & DELAY_MAX_MASK)) {
+			/* Rest does not fit, need to drop packet. Note that further packets might fit as might want to be sent earlier */
+			out[0] = OUT_DISCARD;
+			ret+= task->base.tx_pkt(&task->base, mbufs + i, 1, out);
+			plog_warn("Unexpectdly dropping packets\n");
+		}
+	}
+
+	struct rte_mbuf *new_mbufs[MAX_PKT_BURST];
+	uint16_t pkt_idx = 0;
+
+	while ((pkt_idx < MAX_PKT_BURST) && (task->last_idx != ((now_idx - 1) & DELAY_MAX_MASK))) {
+		struct queue *queue = &task->buffer[task->last_idx];
+		while ((pkt_idx < MAX_PKT_BURST) && (queue->queue_tail != queue->queue_head)) {
+			out[pkt_idx] = rand_r(&task->seed) <= task->tresh? 0 : OUT_DISCARD;
+			new_mbufs[pkt_idx] = queue->queue_elem[queue->queue_tail].mbuf;
+			PREFETCH0(new_mbufs[pkt_idx]);
+			PREFETCH0(&new_mbufs[pkt_idx]->cacheline1);
+			pkt_idx++;
+			queue->queue_tail = (queue->queue_tail + 1) & task->queue_mask;
+		}
+		task->last_idx = (task->last_idx + 1) & DELAY_MAX_MASK;
+	}
+
+	if (pkt_idx)
+		ret+= task->base.tx_pkt(&task->base, new_mbufs, pkt_idx, out);
+	task_impair_update(tbase);
+	return ret;
+}
+
+static void init_task(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_impair *task = (struct task_impair *)tbase;
+	uint32_t queue_len = 0;
+	size_t mem_size;
+	unsigned socket_id;
+	uint64_t delay_us = 0;
+
+	task->seed = rte_rdtsc();
+	if (targ->probability == 0)
+		targ->probability = 1000000;
+
+	task->tresh = ((uint64_t) RAND_MAX) * targ->probability / 1000000;
+
+	if ((targ->delay_us == 0) && (targ->random_delay_us == 0)) {
+		tbase->handle_bulk = handle_bulk_random_drop;
+		task->delay_time = 0;
+	} else if (targ->random_delay_us) {
+		tbase->handle_bulk = handle_bulk_impair_random;
+		task->delay_time = usec_to_tsc(targ->random_delay_us);
+		task->delay_time_mask = rte_align32pow2(task->delay_time) - 1;
+		delay_us = targ->random_delay_us;
+		queue_len = rte_align32pow2((1250L * delay_us) / 84 / (DELAY_MAX_MASK + 1));
+	} else {
+		task->delay_time = usec_to_tsc(targ->delay_us);
+		delay_us = targ->delay_us;
+		queue_len = rte_align32pow2(1250 * delay_us / 84);
+	}
+	/* Assume Line-rate is maximum transmit speed.
+   	   TODO: take link speed if tx is port.
+	*/
+	if (queue_len < MAX_PKT_BURST)
+		queue_len= MAX_PKT_BURST;
+	task->queue_mask = queue_len - 1;
+	if (task->queue_mask < MAX_PKT_BURST - 1)
+		task->queue_mask = MAX_PKT_BURST - 1;
+
+	mem_size = (task->queue_mask + 1) * sizeof(task->queue[0]);
+	socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	task->socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	if (targ->delay_us) {
+		task->queue = prox_zmalloc(mem_size, socket_id);
+		PROX_PANIC(task->queue == NULL, "Not enough memory to allocate queue\n");
+		task->queue_head = 0;
+		task->queue_tail = 0;
+	} else if (targ->random_delay_us) {
+		size_t size = (DELAY_MAX_MASK + 1) * sizeof(struct queue);
+		plog_info("Allocating %zd bytes\n", size);
+		task->buffer = prox_zmalloc(size, socket_id);
+		PROX_PANIC(task->buffer == NULL, "Not enough memory to allocate buffer\n");
+		plog_info("Allocating %d x %zd bytes\n", DELAY_MAX_MASK + 1, mem_size);
+
+		for (int i = 0; i < DELAY_MAX_MASK + 1; i++) {
+			task->buffer[i].queue_elem = prox_zmalloc(mem_size, socket_id);
+			PROX_PANIC(task->buffer[i].queue_elem == NULL, "Not enough memory to allocate buffer elems\n");
+		}
+	}
+	random_init_seed(&task->state);
+}
+
+static struct task_init tinit = {
+	.mode_str = "impair",
+	.init = init_task,
+	.handle = handle_bulk_impair,
+	.flag_features = TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS | TASK_FEATURE_ZERO_RX,
+	.size = sizeof(struct task_impair)
+};
+
+__attribute__((constructor)) static void ctor(void)
+{
+	reg_task(&tinit);
+}
diff --git a/VNFs/DPPD-PROX/handle_impair.h b/VNFs/DPPD-PROX/handle_impair.h
new file mode 100644
index 00000000..162213ed
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_impair.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_IMPAIR_H_
+#define _HANDLE_IMPAIR_H_
+
+void task_impair_set_delay_us(struct task_base *tbase, uint32_t delay_us, uint32_t random_delay_us);
+void task_impair_set_proba(struct task_base *tbase, float proba);
+
+#endif /* _HANDLE_IMPAIR_H_ */
diff --git a/VNFs/DPPD-PROX/handle_ipv6_tunnel.c b/VNFs/DPPD-PROX/handle_ipv6_tunnel.c
new file mode 100644
index 00000000..a92f9cdc
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_ipv6_tunnel.c
@@ -0,0 +1,466 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ip.h>
+#include <rte_udp.h>
+#include <rte_tcp.h>
+#include <rte_table_hash.h>
+#include <rte_ether.h>
+#include <rte_version.h>
+#include <rte_byteorder.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+
+#include "tx_pkt.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "prox_port_cfg.h"
+#include "prefetch.h"
+#include "lconf.h"
+#include "hash_utils.h"
+#include "etypes.h"
+#include "prox_cksum.h"
+#include "defines.h"
+#include "log.h"
+#include "quit.h"
+#include "prox_cfg.h"
+#include "parse_utils.h"
+#include "cfgfile.h"
+#include "prox_shared.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define IPPROTO_IPIP IPPROTO_IPV4
+#endif
+
+struct ipv6_tun_dest {
+        struct ipv6_addr  dst_addr;
+	struct ether_addr dst_mac;
+};
+
+typedef enum ipv6_tun_dir_t {
+        TUNNEL_DIR_ENCAP = 0,
+        TUNNEL_DIR_DECAP = 1,
+} ipv6_tun_dir_t;
+
+struct task_ipv6_tun_base {
+	struct task_base        base;
+	struct ether_addr       src_mac;
+	uint8_t                 core_nb;
+	uint64_t                keys[64];
+	struct rte_mbuf*        fake_packets[64];
+	uint16_t                lookup_port_mask;  // Mask used before looking up the port
+	void*                   lookup_table;      // Fast lookup table for bindings
+	uint32_t		runtime_flags;
+	int                     offload_crc;
+};
+
+struct task_ipv6_decap {
+	struct task_ipv6_tun_base   base;
+        struct ether_addr           dst_mac;
+};
+
+struct task_ipv6_encap {
+	struct task_ipv6_tun_base   base;
+	uint32_t                    ipaddr;
+	struct ipv6_addr            local_endpoint_addr;
+	uint8_t                     tunnel_hop_limit;
+};
+
+#define IPv6_VERSION 6
+#ifndef IPPROTO_IPV4
+#define IPPROTO_IPV4	4
+#endif
+
+#define MAKE_KEY_FROM_FIELDS(ipv4_addr, port, port_mask) ( ((uint64_t)ipv4_addr << 16) | (port & port_mask) )
+
+static int handle_ipv6_decap_bulk(struct task_base* tbase, struct rte_mbuf** rx_mbuf, const uint16_t n_pkts);
+static int handle_ipv6_encap_bulk(struct task_base* tbase, struct rte_mbuf** rx_mbuf, const uint16_t n_pkts);
+
+static void init_lookup_table(struct task_ipv6_tun_base* ptask, struct task_args *targ)
+{
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	/* The lookup table is a per-core data structure to reduce the
+	   memory footprint and improve cache utilization. Since
+	   operations on the hash table are not safe, the data
+	   structure can't be used on a per socket or on a system wide
+	   basis. */
+	ptask->lookup_table = prox_sh_find_core(targ->lconf->id, "ipv6_binding_table");
+	if (NULL == ptask->lookup_table) {
+		struct ipv6_tun_binding_table *table;
+		PROX_PANIC(!strcmp(targ->tun_bindings, ""), "No tun bindings specified\n");
+		int ret = lua_to_ip6_tun_binding(prox_lua(), GLOBAL, targ->tun_bindings, socket_id, &table);
+		PROX_PANIC(ret, "Failed to read tun_bindings config:\n %s\n", get_lua_to_errors());
+
+		struct rte_table_hash_key8_ext_params table_hash_params = {
+			.n_entries = (table->num_binding_entries * 4),
+			.n_entries_ext = (table->num_binding_entries * 2) >> 1,
+			.f_hash = hash_crc32,
+			.seed = 0,
+			.signature_offset = HASH_METADATA_OFFSET(8),  // Ignored for dosig tables
+			.key_offset = HASH_METADATA_OFFSET(0),
+		};
+                plogx_info("IPv6 Tunnel allocating lookup table on socket %d\n", socket_id);
+		ptask->lookup_table = rte_table_hash_key8_ext_dosig_ops.
+				f_create(&table_hash_params, socket_id, sizeof(struct ipv6_tun_dest));
+		PROX_PANIC(ptask->lookup_table == NULL, "Error creating IPv6 Tunnel lookup table");
+
+		for (unsigned idx = 0; idx < table->num_binding_entries; idx++) {
+			int key_found = 0;
+			void* entry_in_hash = NULL;
+			struct ipv6_tun_dest data;
+			struct ipv6_tun_binding_entry* entry = &table->entry[idx];
+                        uint64_t key = MAKE_KEY_FROM_FIELDS(rte_cpu_to_be_32(entry->public_ipv4), entry->public_port, ptask->lookup_port_mask);
+			rte_memcpy(&data.dst_addr, &entry->endpoint_addr, sizeof(struct ipv6_addr));
+			rte_memcpy(&data.dst_mac, &entry->next_hop_mac, sizeof(struct ether_addr));
+
+			int ret = rte_table_hash_key8_ext_dosig_ops.f_add(ptask->lookup_table, &key, &data, &key_found, &entry_in_hash);
+			PROX_PANIC(ret, "Error adding entry (%d) to binding lookup table", idx);
+			PROX_PANIC(key_found, "key_found!!! for idx=%d\n", idx);
+
+#ifdef DBG_IPV6_TUN_BINDING
+			plog_info("Bind: %x:0x%x (port_mask 0x%x) key=0x%"PRIx64"\n", entry->public_ipv4, entry->public_port, ptask->lookup_port_mask, key);
+			plog_info("  -> "IPv6_BYTES_FMT" ("MAC_BYTES_FMT")\n", IPv6_BYTES(entry->endpoint_addr.bytes), MAC_BYTES(entry->next_hop_mac.addr_bytes));
+			plog_info("  -> "IPv6_BYTES_FMT" ("MAC_BYTES_FMT")\n", IPv6_BYTES(data.dst_addr.bytes), MAC_BYTES(data.dst_mac.addr_bytes));
+			plog_info("  -> entry_in_hash=%p\n", entry_in_hash);
+#endif
+		}
+                plogx_info("IPv6 Tunnel created %d lookup table entries\n", table->num_binding_entries);
+
+		prox_sh_add_core(targ->lconf->id, "ipv6_binding_table", ptask->lookup_table);
+	}
+}
+
+static void init_task_ipv6_tun_base(struct task_ipv6_tun_base* tun_base, struct task_args* targ)
+{
+	memcpy(&tun_base->src_mac, find_reachable_port(targ), sizeof(tun_base->src_mac));
+
+	tun_base->lookup_port_mask = targ->lookup_port_mask;  // Mask used before looking up the port
+
+	init_lookup_table(tun_base, targ);
+
+	for (uint32_t i = 0; i < 64; ++i) {
+		tun_base->fake_packets[i] = (struct rte_mbuf*)((uint8_t*)&tun_base->keys[i] - sizeof (struct rte_mbuf));
+	}
+
+	plogx_info("IPv6 Tunnel MAC="MAC_BYTES_FMT" port_mask=0x%x\n",
+		  MAC_BYTES(tun_base->src_mac.addr_bytes), tun_base->lookup_port_mask);
+
+	struct prox_port_cfg *port = find_reachable_port(targ);
+	if (port) {
+		tun_base->offload_crc = port->capabilities.tx_offload_cksum;
+	}
+}
+
+static void init_task_ipv6_decap(struct task_base* tbase, struct task_args* targ)
+{
+	struct task_ipv6_decap* tun_task = (struct task_ipv6_decap*)tbase;
+	struct task_ipv6_tun_base* tun_base = (struct task_ipv6_tun_base*)tun_task;
+
+	init_task_ipv6_tun_base(tun_base, targ);
+	tun_base->runtime_flags = targ->runtime_flags;
+
+        memcpy(&tun_task->dst_mac, &targ->edaddr, sizeof(tun_task->dst_mac));
+}
+
+static void init_task_ipv6_encap(struct task_base* tbase, struct task_args* targ)
+{
+	struct task_ipv6_encap* tun_task = (struct task_ipv6_encap*)tbase;
+	struct task_ipv6_tun_base *tun_base = (struct task_ipv6_tun_base*)tun_task;
+
+	init_task_ipv6_tun_base(tun_base, targ);
+
+	rte_memcpy(&tun_task->local_endpoint_addr, &targ->local_ipv6, sizeof(tun_task->local_endpoint_addr));
+	tun_task->tunnel_hop_limit = targ->tunnel_hop_limit;
+	tun_base->runtime_flags = targ->runtime_flags;
+}
+
+static struct task_init task_init_ipv6_decap = {
+	.mode_str = "ipv6_decap",
+	.init = init_task_ipv6_decap,
+	.handle = handle_ipv6_decap_bulk,
+	.size = sizeof(struct task_ipv6_decap)
+};
+
+static struct task_init task_init_ipv6_encap = {
+	.mode_str = "ipv6_encap",
+	.init = init_task_ipv6_encap,
+	.handle = handle_ipv6_encap_bulk,
+	.size = sizeof(struct task_ipv6_encap)
+};
+
+__attribute__((constructor)) static void reg_task_ipv6_decap(void)
+{
+	reg_task(&task_init_ipv6_decap);
+}
+
+__attribute__((constructor)) static void reg_task_ipv6_encap(void)
+{
+	reg_task(&task_init_ipv6_encap);
+}
+
+static inline uint8_t handle_ipv6_decap(struct task_ipv6_decap* ptask, struct rte_mbuf* rx_mbuf, struct ipv6_tun_dest* tun_dest);
+static inline uint8_t handle_ipv6_encap(struct task_ipv6_encap* ptask, struct rte_mbuf* rx_mbuf, struct ipv6_tun_dest* tun_dest);
+
+static inline int extract_key_fields( __attribute__((unused)) struct task_ipv6_tun_base* ptask, struct ipv4_hdr* pip4, ipv6_tun_dir_t dir, uint32_t* pAddr, uint16_t* pPort)
+{
+        *pAddr = (dir == TUNNEL_DIR_DECAP) ? pip4->src_addr : pip4->dst_addr;
+
+        if (pip4->next_proto_id == IPPROTO_UDP) {
+                struct udp_hdr* pudp = (struct udp_hdr *)(pip4 + 1);
+                *pPort = rte_be_to_cpu_16((dir == TUNNEL_DIR_DECAP) ? pudp->src_port : pudp->dst_port);
+        }
+        else if (pip4->next_proto_id == IPPROTO_TCP) {
+                struct tcp_hdr* ptcp = (struct tcp_hdr *)(pip4 + 1);
+                *pPort = rte_be_to_cpu_16((dir == TUNNEL_DIR_DECAP) ? ptcp->src_port : ptcp->dst_port);
+        }
+        else {
+                plog_warn("IPv6 Tunnel: IPv4 packet of unexpected type proto_id=0x%x\n", pip4->next_proto_id);
+                *pPort = 0xffff;
+                return -1;
+        }
+
+        return 0;
+}
+
+static inline void extract_key(struct task_ipv6_tun_base* ptask, struct ipv4_hdr* pip4, ipv6_tun_dir_t dir, uint64_t* pkey)
+{
+        uint32_t lookup_addr;
+        uint16_t lookup_port;
+
+        if (unlikely( extract_key_fields(ptask, pip4, dir, &lookup_addr, &lookup_port))) {
+                plog_warn("IPv6 Tunnel: Unable to extract fields from packet\n");
+                *pkey = 0xffffffffL;
+                return;
+        }
+
+        *pkey = MAKE_KEY_FROM_FIELDS(lookup_addr, lookup_port, ptask->lookup_port_mask);
+}
+
+static inline struct ipv4_hdr* get_ipv4_decap(struct rte_mbuf *mbuf)
+{
+        struct ether_hdr* peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+        struct ipv6_hdr* pip6 = (struct ipv6_hdr *)(peth + 1);
+        struct ipv4_hdr* pip4 = (struct ipv4_hdr*) (pip6 + 1);  // TODO - Skip Option headers
+
+        return pip4;
+}
+
+static inline struct ipv4_hdr* get_ipv4_encap(struct rte_mbuf *mbuf)
+{
+        struct ether_hdr* peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+        struct ipv4_hdr* pip4 = (struct ipv4_hdr *)(peth + 1);
+
+        return pip4;
+}
+
+static inline void extract_key_decap(struct task_ipv6_tun_base* ptask, struct rte_mbuf *mbuf, uint64_t* pkey)
+{
+        extract_key(ptask, get_ipv4_decap(mbuf), TUNNEL_DIR_DECAP, pkey);
+}
+
+static inline void extract_key_decap_bulk(struct task_ipv6_tun_base* ptask, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+        for (uint16_t j = 0; j < n_pkts; ++j) {
+                extract_key_decap(ptask, mbufs[j], &ptask->keys[j]);
+        }
+}
+
+static inline void extract_key_encap(struct task_ipv6_tun_base* ptask, struct rte_mbuf *mbuf, uint64_t* pkey)
+{
+        extract_key(ptask, get_ipv4_encap(mbuf), TUNNEL_DIR_ENCAP, pkey);
+}
+
+static inline void extract_key_encap_bulk(struct task_ipv6_tun_base* ptask, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+        for (uint16_t j = 0; j < n_pkts; ++j) {
+                extract_key_encap(ptask, mbufs[j], &ptask->keys[j]);
+        }
+}
+
+__attribute__((cold)) static void handle_error(struct task_ipv6_tun_base* ptask, struct rte_mbuf* mbuf, ipv6_tun_dir_t dir)
+{
+        uint32_t lookup_addr;
+        uint16_t lookup_port;
+        uint64_t key;
+
+        struct ipv4_hdr* pip4 = (dir == TUNNEL_DIR_DECAP) ? get_ipv4_decap(mbuf) : get_ipv4_encap(mbuf);
+        extract_key_fields(ptask, pip4, dir, &lookup_addr, &lookup_port);
+        extract_key(ptask, pip4, dir, &key);
+
+        plog_warn("IPv6 Tunnel (%s) lookup failed for "IPv4_BYTES_FMT":%d [key=0x%"PRIx64"]\n",
+                        (dir == TUNNEL_DIR_DECAP) ? "decap" : "encap",
+                        IPv4_BYTES(((unsigned char*)&lookup_addr)), lookup_port, key);
+}
+
+static int handle_ipv6_decap_bulk(struct task_base* tbase, struct rte_mbuf** mbufs, const uint16_t n_pkts)
+{
+        struct task_ipv6_decap* task = (struct task_ipv6_decap *)tbase;
+        uint64_t pkts_mask = RTE_LEN2MASK(n_pkts, uint64_t);
+        struct ipv6_tun_dest* entries[64];
+	uint8_t out[MAX_PKT_BURST];
+        uint64_t lookup_hit_mask;
+        uint16_t n_kept = 0;
+
+        prefetch_pkts(mbufs, n_pkts);
+
+        // Lookup to verify packets are valid for their respective tunnels (their sending lwB4)
+        extract_key_decap_bulk(&task->base, mbufs, n_pkts);
+        rte_table_hash_key8_ext_dosig_ops.f_lookup(task->base.lookup_table, task->base.fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
+
+        if (likely(lookup_hit_mask == pkts_mask)) {
+                for (uint16_t j = 0; j < n_pkts; ++j) {
+                        out[j] = handle_ipv6_decap(task, mbufs[j], entries[j]);
+                }
+        }
+        else {
+                for (uint16_t j = 0; j < n_pkts; ++j) {
+                        if (unlikely(!((lookup_hit_mask >> j) & 0x1))) {
+                                handle_error(&task->base, mbufs[j], TUNNEL_DIR_DECAP);
+				out[j] = OUT_DISCARD;
+                                continue;
+                        }
+                        out[j] = handle_ipv6_decap(task, mbufs[j], entries[j]);
+                }
+        }
+
+	return task->base.base.tx_pkt(tbase, mbufs, n_pkts, out);
+}
+
+static int handle_ipv6_encap_bulk(struct task_base* tbase, struct rte_mbuf** mbufs, const uint16_t n_pkts)
+{
+	struct task_ipv6_encap* task = (struct task_ipv6_encap *)tbase;
+        uint64_t pkts_mask = RTE_LEN2MASK(n_pkts, uint64_t);
+        struct ipv6_tun_dest* entries[64];
+        uint64_t lookup_hit_mask;
+	uint8_t out[MAX_PKT_BURST];
+        uint16_t n_kept = 0;
+
+	prefetch_first(mbufs, n_pkts);
+
+        extract_key_encap_bulk(&task->base, mbufs, n_pkts);
+        rte_table_hash_key8_ext_dosig_ops.f_lookup(task->base.lookup_table, task->base.fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
+
+        if (likely(lookup_hit_mask == pkts_mask)) {
+                for (uint16_t j = 0; j < n_pkts; ++j) {
+                        out[j] = handle_ipv6_encap(task, mbufs[j], entries[j]);
+                }
+        }
+        else {
+                for (uint16_t j = 0; j < n_pkts; ++j) {
+                        if (unlikely(!((lookup_hit_mask >> j) & 0x1))) {
+                                handle_error(&task->base, mbufs[j], TUNNEL_DIR_ENCAP);
+				out[j] = OUT_DISCARD;
+                                continue;
+                        }
+                        out[j] = handle_ipv6_encap(task, mbufs[j], entries[j]);
+                }
+        }
+
+	return task->base.base.tx_pkt(tbase, mbufs, n_pkts, out);
+}
+
+static inline uint8_t handle_ipv6_decap(struct task_ipv6_decap* ptask, struct rte_mbuf* rx_mbuf, __attribute__((unused)) struct ipv6_tun_dest* tun_dest)
+{
+	struct ether_hdr* peth = rte_pktmbuf_mtod(rx_mbuf, struct ether_hdr *);
+
+	if (unlikely(peth->ether_type != ETYPE_IPv6)) {
+		plog_warn("Received non IPv6 packet on ipv6 tunnel port\n");
+		// Drop packet
+		return OUT_DISCARD;
+	}
+
+	struct ipv6_hdr* pip6 = (struct ipv6_hdr *)(peth + 1);
+	int ipv6_hdr_len = sizeof(struct ipv6_hdr);
+
+	// TODO - Skip over any IPv6 Extension Header:
+	//      If pip6->next_header is in (0, 43, 44, 50, 51, 60, 135), skip ahead pip->hdr_ext_len
+	//      bytes and repeat. Increase ipv6_hdr_len with as much, each time.
+
+	if (unlikely(pip6->proto != IPPROTO_IPIP)) {
+		plog_warn("Received non IPv4 content within IPv6 tunnel packet\n");
+		// Drop packet
+		return OUT_DISCARD;
+	}
+
+        // Discard IPv6 encapsulation
+        rte_pktmbuf_adj(rx_mbuf, ipv6_hdr_len);
+        peth = rte_pktmbuf_mtod(rx_mbuf, struct ether_hdr *);
+
+        // Restore Ethernet header
+        ether_addr_copy(&ptask->base.src_mac, &peth->s_addr);
+        ether_addr_copy(&ptask->dst_mac, &peth->d_addr);
+        peth->ether_type = ETYPE_IPv4;
+
+	return 0;
+}
+
+static inline uint8_t handle_ipv6_encap(struct task_ipv6_encap* ptask, struct rte_mbuf* rx_mbuf, __attribute__((unused)) struct ipv6_tun_dest* tun_dest)
+{
+        //plog_info("Found tunnel endpoint:"IPv6_BYTES_FMT" ("MAC_BYTES_FMT")\n", IPv6_BYTES(tun_dest->dst_addr), MAC_BYTES(tun_dest->dst_mac.addr_bytes));
+
+	struct ether_hdr* peth = (struct ether_hdr *)(rte_pktmbuf_mtod(rx_mbuf, struct ether_hdr *));
+	struct ipv4_hdr* pip4 = (struct ipv4_hdr *)(peth + 1);
+	uint16_t ipv4_length = rte_be_to_cpu_16(pip4->total_length);
+	struct task_ipv6_tun_base* tun_base = (struct task_ipv6_tun_base*)ptask;
+
+	if (unlikely((pip4->version_ihl >> 4) != 4)) {
+		plog_warn("Received non IPv4 packet at ipv6 tunnel input\n");
+		// Drop packet
+		return OUT_DISCARD;
+	}
+
+	if (pip4->time_to_live) {
+		pip4->time_to_live--;
+	}
+	else {
+		plog_info("TTL = 0 => Dropping\n");
+		return OUT_DISCARD;
+	}
+	pip4->hdr_checksum = 0;
+
+	// Remove padding if any (we don't want to encapsulate garbage at end of IPv4 packet)
+	int padding = rte_pktmbuf_pkt_len(rx_mbuf) - (ipv4_length + sizeof(struct ether_hdr));
+	if (unlikely(padding > 0)) {
+	        rte_pktmbuf_trim(rx_mbuf, padding);
+	}
+
+	// Encapsulate
+	const int extra_space = sizeof(struct ipv6_hdr);
+	peth = (struct ether_hdr *)rte_pktmbuf_prepend(rx_mbuf, extra_space);
+
+	// Ethernet Header
+	ether_addr_copy(&ptask->base.src_mac, &peth->s_addr);
+	ether_addr_copy(&tun_dest->dst_mac, &peth->d_addr);
+	peth->ether_type = ETYPE_IPv6;
+
+	// Set up IPv6 Header
+	struct ipv6_hdr* pip6 = (struct ipv6_hdr *)(peth + 1);
+	pip6->vtc_flow = rte_cpu_to_be_32(IPv6_VERSION << 28);
+	pip6->proto = IPPROTO_IPIP;
+	pip6->payload_len = rte_cpu_to_be_16(ipv4_length);
+	pip6->hop_limits = ptask->tunnel_hop_limit;
+	rte_memcpy(pip6->dst_addr, &tun_dest->dst_addr, sizeof(pip6->dst_addr));
+	rte_memcpy(pip6->src_addr, &ptask->local_endpoint_addr, sizeof(pip6->src_addr));
+
+	if (tun_base->runtime_flags & TASK_TX_CRC) {
+	// We modified the TTL in the IPv4 header, hence have to recompute the IPv4 checksum
+#define TUNNEL_L2_LEN (sizeof(struct ether_hdr) + sizeof(struct ipv6_hdr))
+		prox_ip_cksum(rx_mbuf, pip4, TUNNEL_L2_LEN, sizeof(struct ipv4_hdr), ptask->base.offload_crc);
+	}
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/handle_irq.c b/VNFs/DPPD-PROX/handle_irq.c
new file mode 100644
index 00000000..4abf84a1
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_irq.c
@@ -0,0 +1,169 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+
+#include "lconf.h"
+#include "task_base.h"
+#include "task_init.h"
+#include "handle_irq.h"
+#include "log.h"
+#include "unistd.h"
+#include "input.h"
+
+#define MAX_INDEX	65535 * 16
+
+struct irq_info {
+	uint64_t tsc;
+	uint64_t lat;
+};
+
+struct irq_bucket {
+	uint64_t index;
+	struct irq_info info[MAX_INDEX];
+};
+
+struct task_irq {
+	struct task_base base;
+	uint64_t start_tsc;
+	uint64_t tsc;
+	uint64_t max_irq;
+	uint8_t  lcore_id;
+	volatile uint16_t stats_use_lt; /* which lt to use, */
+	volatile uint16_t task_use_lt; /* 0 or 1 depending on which of the 2 result records are used */
+	struct irq_bucket buffer[2];
+};
+
+#define MAX_INTERRUPT_LENGTH	500000	/* Maximum length of an interrupt is (1 / MAX_INTERRUPT_LENGTH) seconds */
+
+/*
+ *	This module is not handling any packets.
+ *	It loops on rdtsc() and checks whether it has been interrupted
+ *		 for more than (1 / MAX_INTERRUPT_LENGTH) sec.
+ *	This is a debugging only task, useful to check if the system h
+ *		as been properly configured.
+*/
+
+void task_irq_show_stats(struct task_irq *task_irq, struct input *input)
+{
+	struct irq_bucket *bucket = &task_irq->buffer[!task_irq->task_use_lt];
+	if (input->reply) {
+		char buf[8192] = {0};
+		if (bucket->index == 0) {
+			sprintf(buf, "\n");
+			input->reply(input, buf, strlen(buf));
+			buf[0] = 0;
+		}
+		for (uint64_t i = 0; i < bucket->index; i++) {
+			sprintf(buf + strlen(buf), "%d; %"PRIu64"""; %ld; %ld; %ld; %ld ;",
+				task_irq->lcore_id,
+				i,
+				bucket->info[i].lat,
+				bucket->info[i].lat * 1000000 / rte_get_tsc_hz(),
+				bucket->info[i].tsc - task_irq->start_tsc,
+				(bucket->info[i].tsc - task_irq->start_tsc) * 1000 / rte_get_tsc_hz());
+			sprintf(buf+strlen(buf), "\n");
+			input->reply(input, buf, strlen(buf));
+			buf[0] = 0;
+		}
+	} else {
+		for (uint64_t i = 0; i < bucket->index; i++)
+			if (bucket->info[i].lat)
+				plog_info("[%d]; Interrupt %"PRIu64": %ld cycles (%ld micro-sec) at %ld cycles (%ld msec)\n",
+					  task_irq->lcore_id,
+					  i,
+					  bucket->info[i].lat,
+					  bucket->info[i].lat * 1000000 / rte_get_tsc_hz(),
+					  bucket->info[i].tsc - task_irq->start_tsc,
+					  (bucket->info[i].tsc - task_irq->start_tsc) * 1000 / rte_get_tsc_hz());
+	}
+	task_irq->stats_use_lt = !task_irq->task_use_lt;
+	bucket->index = 0;
+}
+
+static void irq_stop(struct task_base *tbase)
+{
+	struct task_irq *task = (struct task_irq *)tbase;
+	uint32_t i;
+	uint32_t lcore_id = rte_lcore_id();
+	int bucket_id;
+
+	plog_info("Stopping core %u\n", lcore_id);
+	plog_info("Core ID; Interrupt (nanosec); Time (msec)\n");
+	for (int j = 0; j < 2; j++) {
+		// Start dumping the oldest bucket first
+		if (task->buffer[0].info[0].tsc < task->buffer[1].info[0].tsc)
+			bucket_id = j;
+		else
+			bucket_id = !j;
+		struct irq_bucket *bucket = &task->buffer[bucket_id];
+		for (i=0; i< bucket->index;i++) {
+			if (bucket->info[i].lat != 0) {
+				plog_info("%d; %ld; %ld\n",
+					  lcore_id,
+					  bucket->info[i].lat * 1000000000 / rte_get_tsc_hz(),
+					  (bucket->info[i].tsc - task->start_tsc) * 1000 / rte_get_tsc_hz());
+			}
+		}
+	}
+	plog_info("Core %u stopped\n", lcore_id);
+}
+
+static inline int handle_irq_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_irq *task = (struct task_irq *)tbase;
+	uint64_t tsc1;
+	uint64_t index;
+
+	if (task->stats_use_lt != task->task_use_lt)
+		task->task_use_lt = task->stats_use_lt;
+	struct irq_bucket *bucket = &task->buffer[task->task_use_lt];
+
+	tsc1 = rte_rdtsc();
+	if ((task->tsc != 0) && ((tsc1 - task->tsc) > task->max_irq) && (bucket->index < MAX_INDEX)) {
+		bucket->info[bucket->index].tsc = tsc1;
+		bucket->info[bucket->index++].lat = tsc1 - task->tsc;
+	}
+	task->tsc = tsc1;
+	return 0;
+}
+
+static void init_task_irq(struct task_base *tbase,
+			  __attribute__((unused)) struct task_args *targ)
+{
+	struct task_irq *task = (struct task_irq *)tbase;
+	// max_irq expressed in cycles
+	task->max_irq = rte_get_tsc_hz() / MAX_INTERRUPT_LENGTH;
+	task->start_tsc = rte_rdtsc();
+	task->lcore_id = targ->lconf->id;
+	plog_info("\tusing irq mode with max irq set to %ld cycles\n", task->max_irq);
+}
+
+static struct task_init task_init_irq = {
+	.mode_str = "irq",
+	.init = init_task_irq,
+	.handle = handle_irq_bulk,
+	.stop = irq_stop,
+	.flag_features = TASK_FEATURE_NO_RX,
+	.size = sizeof(struct task_irq)
+};
+
+static struct task_init task_init_none;
+
+__attribute__((constructor)) static void reg_task_irq(void)
+{
+	reg_task(&task_init_irq);
+}
diff --git a/VNFs/DPPD-PROX/handle_irq.h b/VNFs/DPPD-PROX/handle_irq.h
new file mode 100644
index 00000000..784bf0d6
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_irq.h
@@ -0,0 +1,25 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_IRQ_H_
+#define _HANDLE_IRQ_H_
+
+struct task_irq;
+struct input;
+
+void task_irq_show_stats(struct task_irq *task_irq, struct input *input);
+
+#endif /* _HANDLE_IRQ_H_ */
diff --git a/VNFs/DPPD-PROX/handle_l2fwd.c b/VNFs/DPPD-PROX/handle_l2fwd.c
new file mode 100644
index 00000000..79a5f02e
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_l2fwd.c
@@ -0,0 +1,117 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mbuf.h>
+
+#include "task_init.h"
+#include "task_base.h"
+#include "lconf.h"
+#include "log.h"
+#include "prox_port_cfg.h"
+
+struct task_l2fwd {
+	struct task_base base;
+	uint8_t src_dst_mac[12];
+	uint32_t runtime_flags;
+};
+
+static int handle_l2fwd_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_l2fwd *task = (struct task_l2fwd *)tbase;
+	struct ether_hdr *hdr;
+	struct ether_addr mac;
+
+	if ((task->runtime_flags & (TASK_ARG_DST_MAC_SET|TASK_ARG_SRC_MAC_SET)) == (TASK_ARG_DST_MAC_SET|TASK_ARG_SRC_MAC_SET)) {
+		/* Source and Destination mac hardcoded */
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *);
+               		rte_memcpy(hdr, task->src_dst_mac, sizeof(task->src_dst_mac));
+		}
+	} else {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *);
+			if ((task->runtime_flags & (TASK_ARG_DO_NOT_SET_SRC_MAC|TASK_ARG_SRC_MAC_SET)) == 0) {
+				/* dst mac will be used as src mac */
+				ether_addr_copy(&hdr->d_addr, &mac);
+			}
+
+			if (task->runtime_flags & TASK_ARG_DST_MAC_SET)
+				ether_addr_copy((struct ether_addr *)&task->src_dst_mac[0], &hdr->d_addr);
+			else if ((task->runtime_flags & TASK_ARG_DO_NOT_SET_DST_MAC) == 0)
+				ether_addr_copy(&hdr->s_addr, &hdr->d_addr);
+
+			if (task->runtime_flags & TASK_ARG_SRC_MAC_SET) {
+				ether_addr_copy((struct ether_addr *)&task->src_dst_mac[6], &hdr->s_addr);
+			} else if ((task->runtime_flags & TASK_ARG_DO_NOT_SET_SRC_MAC) == 0) {
+				ether_addr_copy(&mac, &hdr->s_addr);
+			}
+		}
+	}
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, NULL);
+}
+
+static void init_task_l2fwd(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_l2fwd *task = (struct task_l2fwd *)tbase;
+	struct ether_addr *src_addr, *dst_addr;
+
+	/*
+	 * Destination MAC can come from
+	 *    - pre-configured mac in case 'dst mac=xx:xx:xx:xx:xx:xx' in config file
+	 *    - src mac from the packet in case 'dst mac=packet' in config file
+	 *    - not written in case 'dst mac=no' in config file
+	 *    - (default - no 'dst mac') src mac from the packet
+	 * Source MAC can come from
+	 *    - pre-configured mac in case 'src mac=xx:xx:xx:xx:xx:xx' in config file
+	 *    - dst mac from the packet in case 'src mac=packet' in config file
+	 *    - not written in case 'src mac=no' in config file
+	 *    - (default - no 'src mac') if (tx_port) port mac
+	 *    - (default - no 'src mac') if (no tx_port) dst mac from the packet
+	 */
+
+	if (targ->flags & TASK_ARG_DST_MAC_SET) {
+		dst_addr = &targ->edaddr;
+		memcpy(&task->src_dst_mac[0], dst_addr, sizeof(*src_addr));
+	}
+
+	if (targ->flags & TASK_ARG_SRC_MAC_SET) {
+		src_addr =  &targ->esaddr;
+		memcpy(&task->src_dst_mac[6], src_addr, sizeof(*dst_addr));
+		plog_info("\t\tCore %d: src mac set from config file\n", targ->lconf->id);
+	} else if ((targ->flags & TASK_ARG_DO_NOT_SET_SRC_MAC) == 0) {
+		if (targ->nb_txports) {
+			src_addr = &prox_port_cfg[task->base.tx_params_hw.tx_port_queue[0].port].eth_addr;
+			targ->flags |= TASK_ARG_SRC_MAC_SET;
+			plog_info("\t\tCore %d: src mac set from port\n", targ->lconf->id);
+			memcpy(&task->src_dst_mac[6], src_addr, sizeof(*dst_addr));
+		}
+	}
+	task->runtime_flags = targ->flags;
+}
+
+static struct task_init task_init_l2fwd = {
+	.mode_str = "l2fwd",
+	.init = init_task_l2fwd,
+	.handle = handle_l2fwd_bulk,
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS|TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS|TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS,
+	.size = sizeof(struct task_l2fwd),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+__attribute__((constructor)) static void reg_task_l2fwd(void)
+{
+	reg_task(&task_init_l2fwd);
+}
diff --git a/VNFs/DPPD-PROX/handle_lat.c b/VNFs/DPPD-PROX/handle_lat.c
new file mode 100644
index 00000000..0b7ad561
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_lat.c
@@ -0,0 +1,650 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+//#define LAT_DEBUG
+
+#include <rte_cycles.h>
+#include <stdio.h>
+#include <math.h>
+
+#include "handle_gen.h"
+#include "prox_malloc.h"
+#include "mbuf_utils.h"
+#include "handle_lat.h"
+#include "log.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "stats.h"
+#include "lconf.h"
+#include "quit.h"
+#include "eld.h"
+#include "prox_shared.h"
+
+#define DEFAULT_BUCKET_SIZE	10
+
+struct lat_info {
+	uint32_t rx_packet_index;
+	uint32_t tx_packet_index;
+	uint32_t tx_err;
+	uint32_t rx_err;
+	uint64_t rx_time;
+	uint64_t tx_time;
+	uint16_t port_queue_id;
+#ifdef LAT_DEBUG
+	uint16_t id_in_bulk;
+	uint16_t bulk_size;
+	uint64_t begin;
+	uint64_t after;
+	uint64_t before;
+#endif
+};
+
+struct delayed_latency_entry {
+	uint32_t rx_packet_idx;
+	uint64_t pkt_rx_time;
+	uint64_t pkt_tx_time;
+	uint64_t rx_time_err;
+};
+
+struct delayed_latency {
+	struct delayed_latency_entry entries[64];
+};
+
+static struct delayed_latency_entry *delayed_latency_get(struct delayed_latency *delayed_latency, uint32_t rx_packet_idx)
+{
+	if (delayed_latency->entries[rx_packet_idx % 64].rx_packet_idx == rx_packet_idx)
+		return &delayed_latency->entries[rx_packet_idx % 64];
+	else
+		return NULL;
+}
+
+static struct delayed_latency_entry *delayed_latency_create(struct delayed_latency *delayed_latency, uint32_t rx_packet_idx)
+{
+	delayed_latency->entries[rx_packet_idx % 64].rx_packet_idx = rx_packet_idx;
+	return &delayed_latency->entries[rx_packet_idx % 64];
+}
+
+struct rx_pkt_meta_data {
+	uint8_t  *hdr;
+	uint32_t pkt_tx_time;
+	uint32_t bytes_after_in_bulk;
+};
+
+struct task_lat {
+	struct task_base base;
+	uint64_t limit;
+	uint64_t rx_packet_index;
+	uint64_t last_pkts_tsc;
+	struct delayed_latency delayed_latency;
+	struct lat_info *latency_buffer;
+	uint32_t latency_buffer_idx;
+	uint32_t latency_buffer_size;
+	uint64_t begin;
+	uint16_t lat_pos;
+	uint16_t unique_id_pos;
+	uint16_t accur_pos;
+	uint16_t sig_pos;
+	uint32_t sig;
+	volatile uint16_t use_lt; /* which lt to use, */
+	volatile uint16_t using_lt; /* 0 or 1 depending on which of the 2 measurements are used */
+	struct lat_test lt[2];
+	struct lat_test *lat_test;
+	uint32_t generator_count;
+	struct early_loss_detect *eld;
+	struct rx_pkt_meta_data *rx_pkt_meta;
+	FILE *fp_rx;
+	FILE *fp_tx;
+};
+
+static uint32_t abs_diff(uint32_t a, uint32_t b)
+{
+       return a < b? UINT32_MAX - (b - a - 1) : a - b;
+}
+
+struct lat_test *task_lat_get_latency_meassurement(struct task_lat *task)
+{
+	if (task->use_lt == task->using_lt)
+		return &task->lt[!task->using_lt];
+	return NULL;
+}
+
+void task_lat_use_other_latency_meassurement(struct task_lat *task)
+{
+	task->use_lt = !task->using_lt;
+}
+
+static void task_lat_update_lat_test(struct task_lat *task)
+{
+	if (task->use_lt != task->using_lt) {
+		task->using_lt = task->use_lt;
+		task->lat_test = &task->lt[task->using_lt];
+		task->lat_test->accuracy_limit_tsc = task->limit;
+	}
+}
+
+static int compare_tx_time(const void *val1, const void *val2)
+{
+	const struct lat_info *ptr1 = val1;
+	const struct lat_info *ptr2 = val2;
+
+	return ptr1->tx_time - ptr2->tx_time;
+}
+
+static int compare_queue_id(const void *val1, const void *val2)
+{
+	return compare_tx_time(val1, val2);
+}
+
+static void fix_latency_buffer_tx_time(struct lat_info *lat, uint32_t count)
+{
+	uint32_t id, time, old_id = 0, old_time = 0, n_overflow = 0;
+
+	for (uint32_t i = 0; i < count; i++) {
+		id = lat->port_queue_id;
+		time = lat->tx_time;
+		if (id == old_id) {
+			// Same queue id as previous entry; time should always increase
+			if (time < old_time) {
+				n_overflow++;
+			}
+			lat->tx_time += UINT32_MAX * n_overflow;
+			old_time = time;
+		} else {
+			// Different queue_id, time starts again at 0
+			old_id = id;
+			old_time = 0;
+			n_overflow = 0;
+		}
+	}
+}
+
+static void task_lat_count_remaining_lost_packets(struct task_lat *task)
+{
+	struct lat_test *lat_test = task->lat_test;
+
+	for (uint32_t j = 0; j < task->generator_count; j++) {
+		struct early_loss_detect *eld = &task->eld[j];
+
+		lat_test->lost_packets += early_loss_detect_count_remaining_loss(eld);
+	}
+}
+
+static void task_lat_reset_eld(struct task_lat *task)
+{
+	for (uint32_t j = 0; j < task->generator_count; j++) {
+		early_loss_detect_reset(&task->eld[j]);
+	}
+}
+
+static uint64_t lat_latency_buffer_get_min_tsc(struct task_lat *task)
+{
+	uint64_t min_tsc = UINT64_MAX;
+
+	for (uint32_t i = 0; i < task->latency_buffer_idx; i++) {
+		if (min_tsc > task->latency_buffer[i].tx_time)
+			min_tsc = task->latency_buffer[i].tx_time;
+	}
+
+	return min_tsc << LATENCY_ACCURACY;
+}
+
+static uint64_t lat_info_get_lat_tsc(struct lat_info *lat_info)
+{
+	uint64_t lat = abs_diff(lat_info->rx_time, lat_info->tx_time);
+
+	return lat << LATENCY_ACCURACY;
+}
+
+static uint64_t lat_info_get_tx_err_tsc(const struct lat_info *lat_info)
+{
+	return ((uint64_t)lat_info->tx_err) << LATENCY_ACCURACY;
+}
+
+static uint64_t lat_info_get_rx_err_tsc(const struct lat_info *lat_info)
+{
+	return ((uint64_t)lat_info->rx_err) << LATENCY_ACCURACY;
+}
+
+static uint64_t lat_info_get_rx_tsc(const struct lat_info *lat_info)
+{
+	return ((uint64_t)lat_info) << LATENCY_ACCURACY;
+}
+
+static uint64_t lat_info_get_tx_tsc(const struct lat_info *lat_info)
+{
+	return ((uint64_t)lat_info) << LATENCY_ACCURACY;
+}
+
+static void lat_write_latency_to_file(struct task_lat *task)
+{
+	uint64_t min_tsc;
+	uint32_t n_loss;
+
+	min_tsc = lat_latency_buffer_get_min_tsc(task);
+
+	// Dumping all packet statistics
+	fprintf(task->fp_rx, "Latency stats for %u packets, ordered by rx time\n", task->latency_buffer_idx);
+	fprintf(task->fp_rx, "rx index; queue; tx index; lat (nsec);tx time;\n");
+	for (uint32_t i = 0; i < task->latency_buffer_idx ; i++) {
+		struct lat_info *lat_info = &task->latency_buffer[i];
+		uint64_t lat_tsc = lat_info_get_lat_tsc(lat_info);
+		uint64_t rx_tsc = lat_info_get_rx_tsc(lat_info);
+		uint64_t tx_tsc = lat_info_get_tx_tsc(lat_info);
+
+		fprintf(task->fp_rx, "%u%d;%d;%ld;%lu;%lu\n",
+			lat_info->rx_packet_index,
+			lat_info->port_queue_id,
+			lat_info->tx_packet_index,
+			tsc_to_nsec(lat_tsc),
+			tsc_to_nsec(rx_tsc - min_tsc),
+			tsc_to_nsec(tx_tsc - min_tsc));
+	}
+
+	// To detect dropped packets, we need to sort them based on TX
+	plogx_info("Sorting packets based on queue_id\n");
+	qsort (task->latency_buffer, task->latency_buffer_idx, sizeof(struct lat_info), compare_queue_id);
+	plogx_info("Adapting tx_time\n");
+	fix_latency_buffer_tx_time(task->latency_buffer, task->latency_buffer_idx);
+	plogx_info("Sorting packets based on tx_time\n");
+	qsort (task->latency_buffer, task->latency_buffer_idx, sizeof(struct lat_info), compare_tx_time);
+	plogx_info("Sorted packets based on tx_time\n");
+
+	// A packet is marked as dropped if 2 packets received from the same queue are not consecutive
+	fprintf(task->fp_tx, "Latency stats for %u packets, sorted by tx time\n", task->latency_buffer_idx);
+	fprintf(task->fp_tx, "queue;tx index; rx index; lat (nsec);tx time; rx time; tx_err;rx_err\n");
+
+	uint32_t prev_tx_packet_index = -1;
+	for (uint32_t i = 0; i < task->latency_buffer_idx; i++) {
+		struct lat_info *lat_info = &task->latency_buffer[i];
+		uint64_t lat_tsc = lat_info_get_lat_tsc(lat_info);
+		uint64_t tx_err_tsc = lat_info_get_tx_err_tsc(lat_info);
+		uint64_t rx_err_tsc = lat_info_get_rx_err_tsc(lat_info);
+		uint64_t rx_tsc = lat_info_get_rx_tsc(lat_info);
+		uint64_t tx_tsc = lat_info_get_tx_tsc(lat_info);
+
+		/* Packet n + 64 delivers the TX error for packet n,
+		   hence the last 64 packets do no have TX error. */
+		if (i + 64 >= task->latency_buffer_idx) {
+			tx_err_tsc = 0;
+		}
+		// Log dropped packet
+		n_loss = lat_info->tx_packet_index - prev_tx_packet_index - 1;
+		if (n_loss)
+			fprintf(task->fp_tx, "===> %d;%d;0;0;0;0; lost %d packets <===\n",
+				lat_info->port_queue_id,
+				lat_info->tx_packet_index - n_loss, n_loss);
+		// Log next packet
+		fprintf(task->fp_tx, "%d;%d;%u;%lu;%lu;%lu;%lu;%lu\n",
+			lat_info->port_queue_id,
+			lat_info->tx_packet_index,
+			lat_info->rx_packet_index,
+			tsc_to_nsec(lat_tsc),
+			tsc_to_nsec(tx_tsc - min_tsc),
+			tsc_to_nsec(rx_tsc - min_tsc),
+			tsc_to_nsec(tx_err_tsc),
+			tsc_to_nsec(rx_err_tsc));
+#ifdef LAT_DEBUG
+		fprintf(task->fp_tx, ";%d from %d;%lu;%lu;%lu",
+			lat_info->id_in_bulk,
+			lat_info->bulk_size,
+			tsc_to_nsec(lat_info->begin - min_tsc),
+			tsc_to_nsec(lat_info->before - min_tsc),
+			tsc_to_nsec(lat_info->after - min_tsc));
+#endif
+		fprintf(task->fp_tx, "\n");
+		prev_tx_packet_index = lat_info->tx_packet_index;
+	}
+	fflush(task->fp_rx);
+	fflush(task->fp_tx);
+	task->latency_buffer_idx = 0;
+}
+
+static void lat_stop(struct task_base *tbase)
+{
+	struct task_lat *task = (struct task_lat *)tbase;
+
+	if (task->unique_id_pos) {
+		task_lat_count_remaining_lost_packets(task);
+		task_lat_reset_eld(task);
+	}
+	if (task->latency_buffer)
+		lat_write_latency_to_file(task);
+}
+
+#ifdef LAT_DEBUG
+static void task_lat_store_lat_debug(struct task_lat *task, uint32_t rx_packet_index, uint32_t id_in_bulk, uint32_t bulk_size)
+{
+	struct lat_info *lat_info = &task->latency_buffer[rx_packet_index];
+
+	lat_info->bulk_size = bulk_size;
+	lat_info->id_in_bulk = id_in_bulk;
+	lat_info->begin = task->begin;
+	lat_info->before = task->base.aux->tsc_rx.before;
+	lat_info->after = task->base.aux->tsc_rx.after;
+}
+#endif
+
+static void task_lat_store_lat_buf(struct task_lat *task, uint64_t rx_packet_index, struct unique_id *unique_id, uint64_t rx_time, uint64_t tx_time, uint64_t rx_err, uint64_t tx_err)
+{
+	struct lat_info *lat_info;
+	uint8_t generator_id = 0;
+	uint32_t packet_index = 0;
+
+	if (unique_id)
+		unique_id_get(unique_id, &generator_id, &packet_index);
+
+	/* If unique_id_pos is specified then latency is stored per
+	   packet being sent. Lost packets are detected runtime, and
+	   latency stored for those packets will be 0 */
+	lat_info = &task->latency_buffer[task->latency_buffer_idx++];
+	lat_info->rx_packet_index = task->latency_buffer_idx - 1;
+	lat_info->tx_packet_index = packet_index;
+	lat_info->port_queue_id = generator_id;
+	lat_info->rx_time = rx_time;
+	lat_info->tx_time = tx_time;
+	lat_info->rx_err = rx_err;
+	lat_info->tx_err = tx_err;
+}
+
+static uint32_t task_lat_early_loss_detect(struct task_lat *task, struct unique_id *unique_id)
+{
+	struct early_loss_detect *eld;
+	uint8_t generator_id;
+	uint32_t packet_index;
+
+	unique_id_get(unique_id, &generator_id, &packet_index);
+
+	if (generator_id >= task->generator_count)
+		return 0;
+
+	eld = &task->eld[generator_id];
+
+	return early_loss_detect_add(eld, packet_index);
+}
+
+static uint64_t tsc_extrapolate_backward(uint64_t tsc_from, uint64_t bytes, uint64_t tsc_minimum)
+{
+	uint64_t tsc = tsc_from - rte_get_tsc_hz()*bytes/1250000000;
+	if (likely(tsc > tsc_minimum))
+		return tsc;
+	else
+		return tsc_minimum;
+}
+
+static void lat_test_histogram_add(struct lat_test *lat_test, uint64_t lat_tsc)
+{
+	uint64_t bucket_id = (lat_tsc >> lat_test->bucket_size);
+	size_t bucket_count = sizeof(lat_test->buckets)/sizeof(lat_test->buckets[0]);
+
+	bucket_id = bucket_id < bucket_count? bucket_id : bucket_count;
+	lat_test->buckets[bucket_id]++;
+}
+
+static void lat_test_add_lost(struct lat_test *lat_test, uint64_t lost_packets)
+{
+	lat_test->lost_packets += lost_packets;
+}
+
+static void lat_test_add_latency(struct lat_test *lat_test, uint64_t lat_tsc, uint64_t error)
+{
+	lat_test->tot_all_pkts++;
+
+	if (error > lat_test->accuracy_limit_tsc)
+		return;
+	lat_test->tot_pkts++;
+
+	lat_test->tot_lat += lat_tsc;
+	lat_test->tot_lat_error += error;
+
+	/* (a +- b)^2 = a^2 +- (2ab + b^2) */
+	lat_test->var_lat += lat_tsc * lat_tsc;
+	lat_test->var_lat_error += 2 * lat_tsc * error;
+	lat_test->var_lat_error += error * error;
+
+	if (lat_tsc > lat_test->max_lat) {
+		lat_test->max_lat = lat_tsc;
+		lat_test->max_lat_error = error;
+	}
+	if (lat_tsc < lat_test->min_lat) {
+		lat_test->min_lat = lat_tsc;
+		lat_test->min_lat_error = error;
+	}
+
+#ifdef LATENCY_HISTOGRAM
+	lat_test_histogram_add(lat_test, lat_tsc);
+#endif
+}
+
+static int task_lat_can_store_latency(struct task_lat *task)
+{
+	return task->latency_buffer_idx < task->latency_buffer_size;
+}
+
+static void task_lat_store_lat(struct task_lat *task, uint64_t rx_packet_index, uint64_t rx_time, uint64_t tx_time, uint64_t rx_error, uint64_t tx_error, struct unique_id *unique_id)
+{
+	if (tx_time == 0)
+		return;
+	uint32_t lat_tsc = abs_diff(rx_time, tx_time) << LATENCY_ACCURACY;
+
+	lat_test_add_latency(task->lat_test, lat_tsc, rx_error + tx_error);
+
+	if (task_lat_can_store_latency(task)) {
+		task_lat_store_lat_buf(task, rx_packet_index, unique_id, rx_time, tx_time, rx_error, tx_error);
+	}
+}
+
+static int handle_lat_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_lat *task = (struct task_lat *)tbase;
+	uint64_t rx_time_err;
+
+	uint32_t pkt_rx_time, pkt_tx_time;
+
+	if (n_pkts == 0) {
+		task->begin = tbase->aux->tsc_rx.before;
+		return 0;
+	}
+
+	task_lat_update_lat_test(task);
+
+	const uint64_t rx_tsc = tbase->aux->tsc_rx.after;
+	uint32_t tx_time_err = 0;
+
+	/* Go once through all received packets and read them.  If
+	   packet has just been modified by another core, the cost of
+	   latency will be partialy amortized though the bulk size */
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		struct rte_mbuf *mbuf = mbufs[j];
+		task->rx_pkt_meta[j].hdr = rte_pktmbuf_mtod(mbuf, uint8_t *);
+	}
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+	}
+
+	if (task->sig) {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			if (*(uint32_t *)(task->rx_pkt_meta[j].hdr + task->sig_pos) == task->sig)
+				task->rx_pkt_meta[j].pkt_tx_time = *(uint32_t *)(task->rx_pkt_meta[j].hdr + task->lat_pos);
+			else
+				task->rx_pkt_meta[j].pkt_tx_time = 0;
+		}
+	} else {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			task->rx_pkt_meta[j].pkt_tx_time = *(uint32_t *)(task->rx_pkt_meta[j].hdr + task->lat_pos);
+		}
+	}
+
+	uint32_t bytes_total_in_bulk = 0;
+	// Find RX time of first packet, for RX accuracy
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		uint16_t flipped = n_pkts - 1 - j;
+
+		task->rx_pkt_meta[flipped].bytes_after_in_bulk = bytes_total_in_bulk;
+		bytes_total_in_bulk += mbuf_wire_size(mbufs[flipped]);
+	}
+
+	pkt_rx_time = tsc_extrapolate_backward(rx_tsc, task->rx_pkt_meta[0].bytes_after_in_bulk, task->last_pkts_tsc) >> LATENCY_ACCURACY;
+	if ((uint32_t)((task->begin >> LATENCY_ACCURACY)) > pkt_rx_time) {
+		// Extrapolation went up to BEFORE begin => packets were stuck in the NIC but we were not seeing them
+		rx_time_err = pkt_rx_time - (uint32_t)(task->last_pkts_tsc >> LATENCY_ACCURACY);
+	} else {
+		rx_time_err = pkt_rx_time - (uint32_t)(task->begin >> LATENCY_ACCURACY);
+	}
+
+	struct unique_id *unique_id = NULL;
+	struct delayed_latency_entry *delayed_latency_entry;
+
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		struct rx_pkt_meta_data *rx_pkt_meta = &task->rx_pkt_meta[j];
+		uint8_t *hdr = rx_pkt_meta->hdr;
+
+		pkt_rx_time = tsc_extrapolate_backward(rx_tsc, rx_pkt_meta->bytes_after_in_bulk, task->last_pkts_tsc) >> LATENCY_ACCURACY;
+		pkt_tx_time = rx_pkt_meta->pkt_tx_time;
+
+		if (task->unique_id_pos) {
+			unique_id = (struct unique_id *)(hdr + task->unique_id_pos);
+
+			uint32_t n_loss = task_lat_early_loss_detect(task, unique_id);
+			lat_test_add_lost(task->lat_test, n_loss);
+		}
+
+		/* If accuracy is enabled, latency is reported with a
+		   delay of 64 packets since the generator puts the
+		   accuracy for packet N into packet N + 64. The delay
+		   ensures that all reported latencies have both rx
+		   and tx error. */
+		if (task->accur_pos) {
+			tx_time_err = *(uint32_t *)(hdr + task->accur_pos);
+
+			delayed_latency_entry = delayed_latency_get(&task->delayed_latency, task->rx_packet_index - 64);
+
+			if (delayed_latency_entry) {
+				task_lat_store_lat(task,
+						   task->rx_packet_index,
+						   delayed_latency_entry->pkt_rx_time,
+						   delayed_latency_entry->pkt_tx_time,
+						   delayed_latency_entry->rx_time_err,
+						   tx_time_err,
+						   unique_id);
+			}
+
+			delayed_latency_entry = delayed_latency_create(&task->delayed_latency, task->rx_packet_index);
+			delayed_latency_entry->pkt_rx_time = pkt_rx_time;
+			delayed_latency_entry->pkt_tx_time = pkt_tx_time;
+			delayed_latency_entry->rx_time_err = rx_time_err;
+		} else {
+			task_lat_store_lat(task,
+					   task->rx_packet_index,
+					   pkt_rx_time,
+					   pkt_tx_time,
+					   0,
+					   0,
+					   unique_id);
+		}
+		task->rx_packet_index++;
+	}
+	int ret;
+	ret = task->base.tx_pkt(&task->base, mbufs, n_pkts, NULL);
+	task->begin = tbase->aux->tsc_rx.before;
+	task->last_pkts_tsc = tbase->aux->tsc_rx.after;
+	return ret;
+}
+
+static void init_task_lat_latency_buffer(struct task_lat *task, uint32_t core_id)
+{
+	const int socket_id = rte_lcore_to_socket_id(core_id);
+	char name[256];
+	size_t latency_buffer_mem_size = 0;
+
+	if (task->latency_buffer_size > UINT32_MAX - MAX_RING_BURST)
+		task->latency_buffer_size = UINT32_MAX - MAX_RING_BURST;
+
+	latency_buffer_mem_size = sizeof(struct lat_info) * task->latency_buffer_size;
+
+	task->latency_buffer = prox_zmalloc(latency_buffer_mem_size, socket_id);
+	PROX_PANIC(task->latency_buffer == NULL, "Failed to allocate %ld kbytes for %s\n", latency_buffer_mem_size / 1024, name);
+
+	sprintf(name, "latency.rx_%d.txt", core_id);
+	task->fp_rx = fopen(name, "w+");
+	PROX_PANIC(task->fp_rx == NULL, "Failed to open %s\n", name);
+
+	sprintf(name, "latency.tx_%d.txt", core_id);
+	task->fp_tx = fopen(name, "w+");
+	PROX_PANIC(task->fp_tx == NULL, "Failed to open %s\n", name);
+}
+
+static void task_lat_init_eld(struct task_lat *task, uint8_t socket_id)
+{
+	uint8_t *generator_count = prox_sh_find_system("generator_count");
+	size_t eld_mem_size;
+
+	if (generator_count == NULL)
+		task->generator_count = 0;
+	else
+		task->generator_count = *generator_count;
+
+	eld_mem_size = sizeof(task->eld[0]) * task->generator_count;
+	task->eld = prox_zmalloc(eld_mem_size, socket_id);
+}
+
+void task_lat_set_accuracy_limit(struct task_lat *task, uint32_t accuracy_limit_nsec)
+{
+	task->limit = nsec_to_tsc(accuracy_limit_nsec);
+}
+
+static void init_task_lat(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_lat *task = (struct task_lat *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->lat_pos = targ->lat_pos;
+	task->accur_pos = targ->accur_pos;
+	task->unique_id_pos = targ->packet_id_pos;
+	task->latency_buffer_size = targ->latency_buffer_size;
+
+	if (task->latency_buffer_size) {
+		init_task_lat_latency_buffer(task, targ->lconf->id);
+	}
+
+	if (targ->bucket_size < LATENCY_ACCURACY) {
+		targ->bucket_size = DEFAULT_BUCKET_SIZE;
+	}
+
+	task->lt[0].bucket_size = targ->bucket_size - LATENCY_ACCURACY;
+	task->lt[1].bucket_size = targ->bucket_size - LATENCY_ACCURACY;
+        if (task->unique_id_pos) {
+		task_lat_init_eld(task, socket_id);
+		task_lat_reset_eld(task);
+        }
+	task->lat_test = &task->lt[task->using_lt];
+
+	task_lat_set_accuracy_limit(task, targ->accuracy_limit_nsec);
+	task->rx_pkt_meta = prox_zmalloc(MAX_RX_PKT_ALL * sizeof(*task->rx_pkt_meta), socket_id);
+	PROX_PANIC(task->rx_pkt_meta == NULL, "unable to allocate memory to store RX packet meta data");
+}
+
+static struct task_init task_init_lat = {
+	.mode_str = "lat",
+	.init = init_task_lat,
+	.handle = handle_lat_bulk,
+	.stop = lat_stop,
+	.flag_features = TASK_FEATURE_TSC_RX | TASK_FEATURE_RX_ALL | TASK_FEATURE_ZERO_RX | TASK_FEATURE_NEVER_DISCARDS,
+	.size = sizeof(struct task_lat)
+};
+
+__attribute__((constructor)) static void reg_task_lat(void)
+{
+	reg_task(&task_init_lat);
+}
diff --git a/VNFs/DPPD-PROX/handle_lat.h b/VNFs/DPPD-PROX/handle_lat.h
new file mode 100644
index 00000000..a832a641
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_lat.h
@@ -0,0 +1,189 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_LAT_H_
+#define _HANDLE_LAT_H_
+
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+
+#include "task_base.h"
+#include "clock.h"
+
+#define MAX_PACKETS_FOR_LATENCY 64
+#define LATENCY_ACCURACY	1
+
+struct lat_test {
+	uint64_t tot_all_pkts;
+	uint64_t tot_pkts;
+	uint64_t max_lat;
+	uint64_t min_lat;
+	uint64_t tot_lat;
+	unsigned __int128 var_lat; /* variance */
+	uint64_t accuracy_limit_tsc;
+
+	uint64_t max_lat_error;
+	uint64_t min_lat_error;
+	uint64_t tot_lat_error;
+	unsigned __int128 var_lat_error;
+
+	uint64_t buckets[128];
+	uint64_t bucket_size;
+	uint64_t lost_packets;
+};
+
+static struct time_unit lat_test_get_accuracy_limit(struct lat_test *lat_test)
+{
+	return tsc_to_time_unit(lat_test->accuracy_limit_tsc);
+}
+
+static struct time_unit_err lat_test_get_avg(struct lat_test *lat_test)
+{
+	uint64_t tsc;
+	uint64_t tsc_error;
+
+	tsc = lat_test->tot_lat/lat_test->tot_pkts;
+	tsc_error = lat_test->tot_lat_error/lat_test->tot_pkts;
+
+	struct time_unit_err ret = {
+		.time = tsc_to_time_unit(tsc),
+		.error = tsc_to_time_unit(tsc_error),
+	};
+
+	return ret;
+}
+
+static struct time_unit_err lat_test_get_min(struct lat_test *lat_test)
+{
+	struct time_unit_err ret = {
+		.time = tsc_to_time_unit(lat_test->min_lat),
+		.error = tsc_to_time_unit(lat_test->min_lat_error),
+	};
+
+	return ret;
+}
+
+static struct time_unit_err lat_test_get_max(struct lat_test *lat_test)
+{
+	struct time_unit_err ret = {
+		.time = tsc_to_time_unit(lat_test->max_lat),
+		.error = tsc_to_time_unit(lat_test->max_lat_error),
+	};
+
+	return ret;
+}
+
+static struct time_unit_err lat_test_get_stddev(struct lat_test *lat_test)
+{
+	unsigned __int128 avg_tsc = lat_test->tot_lat/lat_test->tot_pkts;
+	unsigned __int128 avg_tsc_squared = avg_tsc * avg_tsc;
+	unsigned __int128 avg_squares_tsc = lat_test->var_lat/lat_test->tot_pkts;
+
+	/* The assumption is that variance fits into 64 bits, meaning
+	   that standard deviation fits into 32 bits. In other words,
+	   the assumption is that the standard deviation is not more
+	   than approximately 1 second. */
+	uint64_t var_tsc = avg_squares_tsc - avg_tsc_squared;
+	uint64_t stddev_tsc = sqrt(var_tsc);
+
+	unsigned __int128 avg_tsc_error = lat_test->tot_lat_error / lat_test->tot_pkts;
+	unsigned __int128 avg_tsc_squared_error = 2 * avg_tsc * avg_tsc_error + avg_tsc_error * avg_tsc_error;
+	unsigned __int128 avg_squares_tsc_error = lat_test->var_lat_error / lat_test->tot_pkts;
+
+	uint64_t var_tsc_error = avg_squares_tsc_error + avg_tsc_squared_error;
+
+	/* sqrt(a+-b) = sqrt(a) +- (-sqrt(a) + sqrt(a + b)) */
+
+	uint64_t stddev_tsc_error = - stddev_tsc + sqrt(var_tsc + var_tsc_error);
+
+	struct time_unit_err ret = {
+		.time = tsc_to_time_unit(stddev_tsc),
+		.error = tsc_to_time_unit(stddev_tsc_error),
+	};
+
+	return ret;
+}
+
+static void _lat_test_histogram_combine(struct lat_test *dst, struct lat_test *src)
+{
+	for (size_t i = 0; i < sizeof(dst->buckets)/sizeof(dst->buckets[0]); ++i)
+		dst->buckets[i] += src->buckets[i];
+}
+
+static void lat_test_combine(struct lat_test *dst, struct lat_test *src)
+{
+	dst->tot_all_pkts += src->tot_all_pkts;
+
+	dst->tot_pkts += src->tot_pkts;
+
+	dst->tot_lat += src->tot_lat;
+	dst->tot_lat_error += src->tot_lat_error;
+
+	/* (a +- b)^2 = a^2 +- (2ab + b^2) */
+	dst->var_lat += src->var_lat;
+	dst->var_lat_error += src->var_lat_error;
+
+	if (src->max_lat > dst->max_lat) {
+		dst->max_lat = src->max_lat;
+		dst->max_lat_error = src->max_lat_error;
+	}
+	if (src->min_lat < dst->min_lat) {
+		dst->min_lat = src->min_lat;
+		dst->min_lat_error = src->min_lat_error;
+	}
+
+	if (src->accuracy_limit_tsc > dst->accuracy_limit_tsc)
+		dst->accuracy_limit_tsc = src->accuracy_limit_tsc;
+	dst->lost_packets += src->lost_packets;
+
+#ifdef LATENCY_HISTOGRAM
+	_lat_test_histogram_combine(dst, src);
+#endif
+}
+
+static void lat_test_reset(struct lat_test *lat_test)
+{
+	lat_test->tot_all_pkts = 0;
+	lat_test->tot_pkts = 0;
+	lat_test->max_lat = 0;
+	lat_test->min_lat = -1;
+	lat_test->tot_lat = 0;
+	lat_test->var_lat = 0;
+	lat_test->max_lat_error = 0;
+	lat_test->min_lat_error = 0;
+	lat_test->tot_lat_error = 0;
+	lat_test->var_lat_error = 0;
+	lat_test->accuracy_limit_tsc = 0;
+
+	lat_test->lost_packets = 0;
+
+	memset(lat_test->buckets, 0, sizeof(lat_test->buckets));
+}
+
+static void lat_test_copy(struct lat_test *dst, struct lat_test *src)
+{
+	if (src->tot_all_pkts)
+		memcpy(dst, src, sizeof(struct lat_test));
+}
+
+struct task_lat;
+
+struct lat_test *task_lat_get_latency_meassurement(struct task_lat *task);
+void task_lat_use_other_latency_meassurement(struct task_lat *task);
+void task_lat_set_accuracy_limit(struct task_lat *task, uint32_t accuracy_limit_nsec);
+
+#endif /* _HANDLE_LAT_H_ */
diff --git a/VNFs/DPPD-PROX/handle_lb_5tuple.c b/VNFs/DPPD-PROX/handle_lb_5tuple.c
new file mode 100644
index 00000000..ae973f1c
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_lb_5tuple.c
@@ -0,0 +1,143 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_hash.h>
+#include <rte_ether.h>
+#include <rte_memcpy.h>
+#include <rte_mbuf.h>
+#include <rte_ip.h>
+#include <rte_tcp.h>
+#include <rte_udp.h>
+#include <rte_version.h>
+#include <rte_byteorder.h>
+
+#include "handle_lb_5tuple.h"
+#include "prox_malloc.h"
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+#include "etypes.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "lconf.h"
+#include "log.h"
+#include "prefetch.h"
+#include "prox_globals.h"
+#include "defines.h"
+#include "quit.h"
+
+#define BYTE_VALUE_MAX 256
+#define ALL_32_BITS 0xffffffff
+#define BIT_8_TO_15 0x0000ff00
+
+#define HASH_MAX_SIZE 4*8*1024*1024
+
+struct task_lb_5tuple {
+	struct task_base base;
+	uint32_t runtime_flags;
+	struct rte_hash *lookup_hash;
+	uint8_t out_if[HASH_MAX_SIZE] __rte_cache_aligned;
+};
+
+static __m128i mask0;
+static inline uint8_t get_ipv4_dst_port(struct task_lb_5tuple *task, void *ipv4_hdr, uint8_t portid, struct rte_hash * ipv4_l3fwd_lookup_struct)
+{
+	int ret = 0;
+	union ipv4_5tuple_host key;
+
+	ipv4_hdr = (uint8_t *)ipv4_hdr + offsetof(struct ipv4_hdr, time_to_live);
+	__m128i data = _mm_loadu_si128((__m128i*)(ipv4_hdr));
+	/* Get 5 tuple: dst port, src port, dst IP address, src IP address and protocol */
+	key.xmm = _mm_and_si128(data, mask0);
+
+	/* Get 5 tuple: dst port, src port, dst IP address, src IP address and protocol */
+	/*
+ 	rte_mov16(&key.pad0, ipv4_hdr);
+	key.pad0 = 0;
+	key.pad1 = 0;
+	*/
+	/* Find destination port */
+	ret = rte_hash_lookup(ipv4_l3fwd_lookup_struct, (const void *)&key);
+	return (uint8_t)((ret < 0)? portid : task->out_if[ret]);
+}
+
+static inline uint8_t handle_lb_5tuple(struct task_lb_5tuple *task, struct rte_mbuf *mbuf)
+{
+	struct ether_hdr *eth_hdr;
+	struct ipv4_hdr *ipv4_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+
+	switch (eth_hdr->ether_type) {
+	case ETYPE_IPv4:
+		/* Handle IPv4 headers.*/
+		ipv4_hdr = (struct ipv4_hdr *) (eth_hdr + 1);
+		return get_ipv4_dst_port(task, ipv4_hdr, OUT_DISCARD, task->lookup_hash);
+	default:
+		return OUT_DISCARD;
+	}
+}
+
+static int handle_lb_5tuple_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_lb_5tuple *task = (struct task_lb_5tuple *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_lb_5tuple(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_lb_5tuple(task, mbufs[j]);
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static void init_task_lb_5tuple(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_lb_5tuple *task = (struct task_lb_5tuple *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	mask0 = _mm_set_epi32(ALL_32_BITS, ALL_32_BITS, ALL_32_BITS, BIT_8_TO_15);
+
+	uint8_t *out_table = task->out_if;
+	int ret = lua_to_tuples(prox_lua(), GLOBAL, "tuples", socket_id, &task->lookup_hash, &out_table);
+	PROX_PANIC(ret, "Failed to read tuples from config\n");
+
+	task->runtime_flags = targ->flags;
+}
+
+static struct task_init task_init_lb_5tuple = {
+	.mode_str = "lb5tuple",
+	.init = init_task_lb_5tuple,
+	.handle = handle_lb_5tuple_bulk,
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS | TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS,
+	.size = sizeof(struct task_lb_5tuple),
+};
+
+__attribute__((constructor)) static void reg_task_lb_5tuple(void)
+{
+	reg_task(&task_init_lb_5tuple);
+}
diff --git a/VNFs/DPPD-PROX/handle_lb_5tuple.h b/VNFs/DPPD-PROX/handle_lb_5tuple.h
new file mode 100644
index 00000000..bb830fa7
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_lb_5tuple.h
@@ -0,0 +1,33 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_LB_TUP_H_
+#define _HANDLE_LB_TUP_H_
+
+union ipv4_5tuple_host {
+	struct {
+		uint8_t  pad0;
+		uint8_t  proto;
+		uint16_t pad1;
+		uint32_t ip_src;
+		uint32_t ip_dst;
+		uint16_t port_src;
+		uint16_t port_dst;
+	};
+	__m128i xmm;
+};
+
+#endif /* _HANDLE_LB_TUP_H_ */
diff --git a/VNFs/DPPD-PROX/handle_lb_net.c b/VNFs/DPPD-PROX/handle_lb_net.c
new file mode 100644
index 00000000..878b8158
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_lb_net.c
@@ -0,0 +1,577 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+
+#include <rte_mbuf.h>
+#include <rte_ip.h>
+#include <rte_table_hash.h>
+#include <rte_byteorder.h>
+#include <rte_version.h>
+
+#include "prox_malloc.h"
+#include "handle_lb_net.h"
+#include "task_base.h"
+#include "defines.h"
+#include "tx_pkt.h"
+#include "log.h"
+#include "stats.h"
+#include "mpls.h"
+#include "etypes.h"
+#include "gre.h"
+#include "prefetch.h"
+#include "qinq.h"
+#include "hash_utils.h"
+#include "quit.h"
+#include "flow_iter.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#endif
+
+struct task_lb_net {
+	struct task_base      base;
+	uint16_t              qinq_tag;
+	uint8_t               bit_mask;
+	uint8_t               nb_worker_threads;
+	uint8_t               worker_byte_offset_ipv4;
+	uint8_t               worker_byte_offset_ipv6;
+	uint8_t               runtime_flags;
+};
+
+struct task_lb_net_lut {
+	struct task_base      base;
+	uint8_t               nb_worker_threads;
+	uint8_t               runtime_flags;
+	struct rte_table_hash *worker_hash_table;
+	uint8_t               *worker_lut;
+	uint32_t              keys[64];
+	struct rte_mbuf       *fake_packets[64];
+};
+
+static inline uint8_t handle_lb_net(struct task_lb_net *task, struct rte_mbuf *mbuf);
+static inline int extract_gre_key(struct task_lb_net_lut *task, uint32_t *key, struct rte_mbuf *mbuf);
+
+static struct rte_table_hash *setup_gre_to_wt_lookup(struct task_args *targ, uint8_t n_workers, int socket_id)
+{
+	uint32_t gre_id, rss;
+	void* entry_in_hash;
+	int r, key_found = 0;
+	struct rte_table_hash *ret;
+	uint32_t count = 0;
+
+	for (int i = 0; i < n_workers; ++i) {
+		struct core_task ct = targ->core_task_set[0].core_task[i];
+		struct task_args *t = core_targ_get(ct.core, ct.task);
+
+		struct flow_iter *it = &t->task_init->flow_iter;
+
+		PROX_PANIC(t->task_init->flow_iter.beg == NULL,
+			   "Load distributor can't find flows owned by destination worker %d\n", i);
+
+		for (it->beg(it, t); !it->is_end(it, t); it->next(it, t)) {
+			count++;
+		}
+	}
+
+	struct rte_table_hash_ext_params table_hash_params = {
+		.key_size = 4,
+		.n_keys = count,
+		.n_buckets = count,
+		.n_buckets_ext = count >> 1,
+		.f_hash = hash_crc32,
+		.seed = 0,
+		.signature_offset = HASH_METADATA_OFFSET(0),
+		.key_offset = HASH_METADATA_OFFSET(0),
+	};
+
+	ret = rte_table_hash_ext_dosig_ops.f_create(&table_hash_params, socket_id, sizeof(uint8_t));
+
+	for (int i = 0; i < n_workers; ++i) {
+		struct core_task ct = targ->core_task_set[0].core_task[i];
+		struct task_args *t = core_targ_get(ct.core, ct.task);
+
+		PROX_PANIC(t->task_init->flow_iter.beg == NULL,
+			   "Load distributor can't find flows owned by destination worker %d\n", i);
+
+		struct flow_iter *it = &t->task_init->flow_iter;
+
+		for (it->beg(it, t); !it->is_end(it, t); it->next(it, t)) {
+			uint32_t gre_id = it->get_gre_id(it, t);
+			uint8_t dst = i;
+
+			r = rte_table_hash_ext_dosig_ops.f_add(ret, &gre_id, &dst, &key_found, &entry_in_hash);
+			if (r) {
+				plog_err("Failed to add gre_id = %x, dest worker = %u\n", gre_id, i);
+			}
+			else {
+				plog_dbg("Core %u added: gre_id %x, dest woker = %u\n", targ->lconf->id, gre_id, i);
+			}
+		}
+	}
+	return ret;
+}
+
+static uint8_t *setup_wt_indexed_table(struct task_args *targ, uint8_t n_workers, int socket_id)
+{
+	uint32_t gre_id, rss;
+	uint32_t max_gre_id = 0;
+	uint8_t queue;
+	uint8_t *ret = NULL;
+	void* entry_in_hash;
+	int key_found = 0;
+
+	for (int i = 0; i < n_workers; ++i) {
+		struct core_task ct = targ->core_task_set[0].core_task[i];
+		struct task_args *t = core_targ_get(ct.core, ct.task);
+
+		struct flow_iter *it = &t->task_init->flow_iter;
+
+		PROX_PANIC(t->task_init->flow_iter.beg == NULL,
+			   "Load distributor can't find flows owned by destination worker %d\n", i);
+
+		for (it->beg(it, t); !it->is_end(it, t); it->next(it, t)) {
+			uint32_t gre_id = it->get_gre_id(it, t);
+			if (gre_id > max_gre_id)
+				max_gre_id = gre_id;
+		}
+	}
+
+	PROX_PANIC(max_gre_id == 0, "Failed to get maximum GRE ID from workers");
+
+	ret = prox_zmalloc(1 + max_gre_id, socket_id);
+	PROX_PANIC(ret == NULL, "Failed to allocate worker_lut\n");
+
+	for (int i = 0; i < n_workers; ++i) {
+		struct core_task ct = targ->core_task_set[0].core_task[i];
+		struct task_args *t = core_targ_get(ct.core, ct.task);
+
+		PROX_PANIC(t->task_init->flow_iter.beg == NULL,
+			   "Load distributor can't find flows owned by destination worker %d\n", i);
+
+		struct flow_iter *it = &t->task_init->flow_iter;
+
+		for (it->beg(it, t); !it->is_end(it, t); it->next(it, t)) {
+			uint32_t gre_id = it->get_gre_id(it, t);
+			uint8_t dst = i;
+
+			ret[gre_id] = dst;
+		}
+	}
+	return ret;
+}
+
+static void init_task_lb_net(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_lb_net *task = (struct task_lb_net *)tbase;
+
+	task->qinq_tag = targ->qinq_tag;
+	task->runtime_flags = targ->runtime_flags;
+	task->worker_byte_offset_ipv6 = 23;
+	task->worker_byte_offset_ipv4 = 15;
+	task->nb_worker_threads       = targ->nb_worker_threads;
+	/* The optimal configuration is when the number of worker threads
+	   is a power of 2. In that case, a bit_mask can be used. Setting
+	   the bitmask to 0xff disables the "optimal" usage of bitmasks
+	   and the actual number of worker threads will be used instead. */
+	task->bit_mask = rte_is_power_of_2(targ->nb_worker_threads) ? targ->nb_worker_threads - 1 : 0xff;
+}
+
+static void init_task_lb_net_lut(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_lb_net_lut *task = (struct task_lb_net_lut *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->runtime_flags = targ->runtime_flags;
+	task->nb_worker_threads       = targ->nb_worker_threads;
+	for (uint32_t i = 0; i < 64; ++i) {
+		task->fake_packets[i] = (struct rte_mbuf*)((uint8_t*)&task->keys[i] - sizeof (struct rte_mbuf));
+	}
+
+	task->worker_hash_table = setup_gre_to_wt_lookup(targ, task->nb_worker_threads, socket_id);
+}
+
+static void init_task_lb_net_indexed_table(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_lb_net_lut *task = (struct task_lb_net_lut *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->runtime_flags = targ->runtime_flags;
+	task->nb_worker_threads       = targ->nb_worker_threads;
+
+	task->worker_lut = setup_wt_indexed_table(targ, task->nb_worker_threads, socket_id);
+}
+
+static int handle_lb_net_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_lb_net *task = (struct task_lb_net *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_lb_net(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_lb_net(task, mbufs[j]);
+	}
+#endif
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static int handle_lb_net_lut_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_lb_net_lut *task = (struct task_lb_net_lut *)tbase;
+	uint16_t not_dropped = 0;
+	uint8_t out[MAX_PKT_BURST];
+	// process packet, i.e. decide if the packet has to be dropped or not and where the packet has to go
+	uint16_t j;
+	prefetch_first(mbufs, n_pkts);
+
+	uint64_t pkts_mask = RTE_LEN2MASK(n_pkts, uint64_t);
+	uint8_t *wt[MAX_PKT_BURST];
+	uint64_t lookup_hit_mask = 0;
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		if (extract_gre_key(task, &task->keys[j], mbufs[j])) {
+			// Packet will be dropped after lookup
+			pkts_mask &= ~(1 << j);
+			out[j] = OUT_DISCARD;
+		}
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		if (extract_gre_key(task, &task->keys[j], mbufs[j])) {
+			pkts_mask &= ~(1 << j);
+			out[j] = OUT_DISCARD;
+			rte_prefetch0(RTE_MBUF_METADATA_UINT8_PTR(mbufs[j], 0));
+		}
+	}
+#endif
+	// keys have been extracted for all packets, now do the lookup
+	rte_table_hash_ext_dosig_ops.f_lookup(task->worker_hash_table, task->fake_packets, pkts_mask, &lookup_hit_mask, (void**)wt);
+	/* mbufs now contains the packets that have not been dropped */
+	if (likely(lookup_hit_mask == RTE_LEN2MASK(n_pkts, uint64_t))) {
+		for (j = 0; j < n_pkts; ++j) {
+			out[j] = *wt[j];
+		}
+	}
+	else {
+		for (j = 0; j < n_pkts; ++j) {
+			if (unlikely(!((lookup_hit_mask >> j) & 0x1))) {
+				plog_warn("Packet %d keys %x can not be sent to worker thread => dropped\n", j, task->keys[j]);
+				out[j] = OUT_DISCARD;
+			}
+			else {
+				out[j] = *wt[j];
+			}
+		}
+	}
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static int handle_lb_net_indexed_table_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_lb_net_lut *task = (struct task_lb_net_lut *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	// process packet, i.e. decide if the packet has to be dropped or not and where the packet has to go
+	uint16_t j;
+	uint32_t gre_id;
+	prefetch_first(mbufs, n_pkts);
+
+	uint64_t pkts_mask = RTE_LEN2MASK(n_pkts, uint64_t);
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		if (extract_gre_key(task, &gre_id, mbufs[j])) {
+			// Packet will be dropped after lookup
+			pkts_mask &= ~(1 << j);
+			out[j] = OUT_DISCARD;
+		} else {
+			out[j] = task->worker_lut[rte_bswap32(gre_id)];
+		}
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		if (extract_gre_key(task, &gre_id, mbufs[j])) {
+			pkts_mask &= ~(1 << j);
+			out[j] = OUT_DISCARD;
+		} else {
+			out[j] = task->worker_lut[rte_bswap32(gre_id)];
+		}
+	}
+#endif
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static inline uint8_t worker_from_mask(struct task_lb_net *task, uint32_t val)
+{
+	if (task->bit_mask != 0xff) {
+		return val & task->bit_mask;
+	}
+	else {
+		return val % task->nb_worker_threads;
+	}
+}
+
+static inline int extract_gre_key(struct task_lb_net_lut *task, uint32_t *key, struct rte_mbuf *mbuf)
+{
+	// For all packets, one by one, remove MPLS tag if any and fills in keys used by "fake" packets
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	// Check for MPLS TAG
+	struct ipv4_hdr *ip;
+	if (peth->ether_type == ETYPE_MPLSU) {
+		struct mpls_hdr *mpls = (struct mpls_hdr *)(peth + 1);
+		uint32_t mpls_len = 0;
+		while (!(mpls->bytes & 0x00010000)) {
+			mpls++;
+			mpls_len += sizeof(struct mpls_hdr);
+		}
+		mpls_len += sizeof(struct mpls_hdr);
+		ip = (struct ipv4_hdr *)(mpls + 1);
+		switch (ip->version_ihl >> 4) {
+		case 4:
+			// Remove MPLS Tag if requested
+			if (task->runtime_flags & TASK_MPLS_TAGGING) {
+				peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+				peth->ether_type = ETYPE_IPv4;
+			}
+			break;
+		case 6:
+			plog_warn("IPv6 not supported in this mode\n");
+			return 1;;
+		default:
+			plog_warn("Unexpected IP version %d\n", ip->version_ihl >> 4);
+			return 1;
+		}
+	}
+	else {
+		ip = (struct ipv4_hdr *)(peth + 1);
+	}
+	// Entry point for the packet => check for packet validity
+	// => do not use extract_key_core(mbufs[j], &task->keys[j]);
+	//
+	if (likely(ip->next_proto_id == IPPROTO_GRE)) {
+		struct gre_hdr *pgre = (struct gre_hdr *)(ip + 1);
+		if (likely(pgre->bits & GRE_KEY_PRESENT)) {
+			uint32_t gre_id;
+			if (pgre->bits & (GRE_CRC_PRESENT | GRE_ROUTING_PRESENT)) {
+				// gre_id = *((uint32_t *)((uint8_t *)pgre + 8));
+				*key = *(uint32_t *)((uint8_t *)pgre + 8);
+			}
+			else {
+				// gre_id = *((uint32_t *)((uint8_t *)pgre + 4));
+				*key = *(uint32_t *)((uint8_t *)pgre + 4);
+			}
+		}
+		else {
+			plog_warn("Key not present\n");
+			return 1;
+		}
+	}
+	else {
+		plog_warn("Invalid protocol: GRE xas expected, got 0x%x\n", ip->next_proto_id);
+		return 1;
+	}
+	return 0;
+}
+
+static inline uint8_t lb_ip4(struct task_lb_net *task, struct ipv4_hdr *ip)
+{
+	if (unlikely(ip->version_ihl >> 4 != 4)) {
+		plog_warn("Expected to receive IPv4 packet but IP version was %d\n",
+			ip->version_ihl >> 4);
+		return OUT_DISCARD;
+	}
+
+	if (ip->next_proto_id == IPPROTO_GRE) {
+		struct gre_hdr *pgre = (struct gre_hdr *)(ip + 1);
+
+		if (pgre->bits & GRE_KEY_PRESENT) {
+			uint32_t gre_id;
+			if (pgre->bits & (GRE_CRC_PRESENT | GRE_ROUTING_PRESENT)) {
+				gre_id = *((uint32_t *)((uint8_t *)pgre + 8));
+			}
+			else {
+				gre_id = *((uint32_t *)((uint8_t *)pgre + 4));
+			}
+
+			gre_id = rte_be_to_cpu_32(gre_id) & 0xFFFFFFF;
+			uint8_t worker = worker_from_mask(task, gre_id);
+			plogx_dbg("gre_id = %u worker = %u\n", gre_id, worker);
+			return worker + task->nb_worker_threads * IPV4;
+		}
+		else {
+			plog_warn("Key not present\n");
+			return OUT_DISCARD;
+		}
+	}
+	else if (ip->next_proto_id == IPPROTO_UDP) {
+		uint8_t worker = worker_from_mask(task, rte_bswap32(ip->dst_addr));
+		return worker + task->nb_worker_threads * IPV4;
+	}
+	return OUT_DISCARD;
+}
+
+static inline uint8_t lb_ip6(struct task_lb_net *task, struct ipv6_hdr *ip)
+{
+	if (unlikely((*(uint8_t*)ip) >> 4 != 6)) {
+		plog_warn("Expected to receive IPv6 packet but IP version was %d\n",
+			*(uint8_t*)ip >> 4);
+		return OUT_DISCARD;
+	}
+
+	uint8_t worker = worker_from_mask(task, *((uint8_t *)ip + task->worker_byte_offset_ipv6));
+	return worker + task->nb_worker_threads * IPV6;
+}
+
+static inline uint8_t lb_mpls(struct task_lb_net *task, struct ether_hdr *peth, struct rte_mbuf *mbuf)
+{
+	struct mpls_hdr *mpls = (struct mpls_hdr *)(peth + 1);
+	uint32_t mpls_len = 0;
+	while (!(mpls->bytes & 0x00010000)) {
+		mpls++;
+		mpls_len += sizeof(struct mpls_hdr);
+	}
+	mpls_len += sizeof(struct mpls_hdr);
+	struct ipv4_hdr *ip = (struct ipv4_hdr *)(mpls + 1);
+
+	switch (ip->version_ihl >> 4) {
+	case 4:
+		if (task->runtime_flags & TASK_MPLS_TAGGING) {
+			peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+			peth->ether_type = ETYPE_IPv4;
+		}
+		return lb_ip4(task, ip);
+	case 6:
+		if (task->runtime_flags & TASK_MPLS_TAGGING) {
+			peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+			peth->ether_type = ETYPE_IPv6;
+		}
+		return lb_ip6(task, (struct ipv6_hdr *)ip);
+	default:
+		plogd_warn(mbuf, "Failed Decoding MPLS Packet - neither IPv4 neither IPv6: version %u for packet : \n", ip->version_ihl);
+		return OUT_DISCARD;
+	}
+}
+
+static inline uint8_t lb_qinq(struct task_lb_net *task, struct qinq_hdr *qinq)
+{
+	if (qinq->cvlan.eth_proto != ETYPE_VLAN) {
+		plog_warn("Unexpected proto in QinQ = %#04x\n", qinq->cvlan.eth_proto);
+		return OUT_DISCARD;
+	}
+	uint32_t qinq_tags = rte_bswap16(qinq->cvlan.vlan_tci & 0xFF0F);
+	return worker_from_mask(task, qinq_tags);
+}
+
+static inline uint8_t handle_lb_net(struct task_lb_net *task, struct rte_mbuf *mbuf)
+{
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	const uint16_t len = rte_pktmbuf_pkt_len(mbuf);
+	if (len < 60) {
+		plogd_warn(mbuf, "Unexpected frame len = %d for packet : \n", len);
+		return OUT_DISCARD;
+	}
+
+	switch (peth->ether_type) {
+	case ETYPE_MPLSU:
+		return lb_mpls(task, peth, mbuf);
+	case ETYPE_8021ad:
+		return lb_qinq(task, (struct qinq_hdr *)peth);
+	case ETYPE_IPv4:
+		return lb_ip4(task, (struct ipv4_hdr *)(peth + 1));
+	case ETYPE_IPv6:
+		return lb_ip6(task, (struct ipv6_hdr *)(peth + 1));
+	case ETYPE_LLDP:
+		return OUT_DISCARD;
+	default:
+		if (peth->ether_type == task->qinq_tag)
+			return lb_qinq(task, (struct qinq_hdr *)peth);
+		plogd_warn(mbuf, "Unexpected frame Ether type = %#06x for packet : \n", peth->ether_type);
+		return OUT_DISCARD;
+	}
+
+	return 1;
+}
+
+static struct task_init task_init_lb_net = {
+	.mode_str = "lbnetwork",
+	.init = init_task_lb_net,
+	.handle = handle_lb_net_bulk,
+	.size = sizeof(struct task_lb_net),
+	.flag_features = TASK_FEATURE_GRE_ID
+};
+
+static struct task_init task_init_lb_net_lut_qinq_rss = {
+	.mode_str = "lbnetwork",
+	.sub_mode_str = "lut_qinq_rss",
+	.init = init_task_lb_net_lut,
+	.handle = handle_lb_net_lut_bulk,
+	.size = sizeof(struct task_lb_net_lut),
+	.flag_features = TASK_FEATURE_LUT_QINQ_RSS
+};
+
+static struct task_init task_init_lb_net_lut_qinq_hash = {
+	.mode_str = "lbnetwork",
+	.sub_mode_str = "lut_qinq_hash",
+	.init = init_task_lb_net_lut,
+	.handle = handle_lb_net_lut_bulk,
+	.size = sizeof(struct task_lb_net_lut),
+	.flag_features = TASK_FEATURE_LUT_QINQ_HASH
+};
+
+static struct task_init task_init_lb_net_indexed_table_rss = {
+	.mode_str = "lbnetwork",
+	.sub_mode_str = "indexed_table_rss",
+	.init = init_task_lb_net_indexed_table,
+	.handle = handle_lb_net_indexed_table_bulk,
+	.size = sizeof(struct task_lb_net_lut),
+	.flag_features = TASK_FEATURE_LUT_QINQ_RSS
+};
+
+static struct task_init task_init_lb_net_indexed_table_hash = {
+	.mode_str = "lbnetwork",
+	.sub_mode_str = "indexed_table_hash",
+	.init = init_task_lb_net_indexed_table,
+	.handle = handle_lb_net_indexed_table_bulk,
+	.size = sizeof(struct task_lb_net_lut),
+	.flag_features = TASK_FEATURE_LUT_QINQ_HASH
+};
+
+__attribute__((constructor)) static void reg_task_lb_net(void)
+{
+	reg_task(&task_init_lb_net);
+	reg_task(&task_init_lb_net_lut_qinq_rss);
+	reg_task(&task_init_lb_net_lut_qinq_hash);
+	reg_task(&task_init_lb_net_indexed_table_rss);
+	reg_task(&task_init_lb_net_indexed_table_hash);
+}
diff --git a/VNFs/DPPD-PROX/handle_lb_net.h b/VNFs/DPPD-PROX/handle_lb_net.h
new file mode 100644
index 00000000..4124fbd6
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_lb_net.h
@@ -0,0 +1,27 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_LB_NET_H_
+#define _HANDLE_LB_NET_H_
+
+#include "defaults.h"
+
+static inline int8_t rss_to_queue(int rss, int nb_queues)
+{
+        return (rss & ((1 << MAX_RSS_QUEUE_BITS) - 1)) % nb_queues;
+}
+
+#endif /* _HANDLE_LB_NET_H_ */
diff --git a/VNFs/DPPD-PROX/handle_lb_pos.c b/VNFs/DPPD-PROX/handle_lb_pos.c
new file mode 100644
index 00000000..4324e94d
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_lb_pos.c
@@ -0,0 +1,156 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mbuf.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+#include <rte_hash_crc.h>
+
+#include "log.h"
+#include "task_base.h"
+#include "defines.h"
+#include "tx_pkt.h"
+#include "task_init.h"
+#include "quit.h"
+#include "mpls.h"
+#include "etypes.h"
+#include "gre.h"
+#include "prefetch.h"
+
+struct task_lb_pos {
+	struct task_base base;
+	uint16_t         byte_offset;
+	uint8_t          n_workers;
+};
+
+static void init_task_lb_pos(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_lb_pos *task = (struct task_lb_pos *)tbase;
+
+	task->n_workers = targ->nb_worker_threads;
+	task->byte_offset = targ->byte_offset;
+}
+
+static int handle_lb_pos_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_lb_pos *task = (struct task_lb_pos *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t offset = task->byte_offset;
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		uint8_t* pkt = rte_pktmbuf_mtod(mbufs[j], uint8_t*);
+		out[j] = pkt[offset] % task->n_workers;
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		uint8_t* pkt = rte_pktmbuf_mtod(mbufs[j], uint8_t*);
+		out[j] = pkt[offset] % task->n_workers;
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+union ip_port {
+	struct {
+		uint32_t ip;
+		uint32_t port;
+	};
+	uint64_t ip_port;
+};
+
+struct pkt_ether_ipv4_udp {
+	struct ether_hdr ether;
+	struct ipv4_hdr  ipv4;
+	struct udp_hdr   udp;
+} __attribute__((unused));
+
+static uint8_t handle_lb_ip_port(struct task_lb_pos *task, struct rte_mbuf *mbuf)
+{
+	union ip_port ip_port;
+	uint8_t ret;
+
+	struct pkt_ether_ipv4_udp *pkt = rte_pktmbuf_mtod(mbuf, void *);
+
+	if (pkt->ether.ether_type != ETYPE_IPv4 ||
+	    (pkt->ipv4.next_proto_id != IPPROTO_TCP &&
+	     pkt->ipv4.next_proto_id != IPPROTO_UDP))
+		return OUT_DISCARD;
+
+	if (task->byte_offset == 0) {
+		ip_port.ip   = pkt->ipv4.src_addr;
+		ip_port.port = pkt->udp.src_port;
+	}
+	else {
+		ip_port.ip   = pkt->ipv4.dst_addr;
+		ip_port.port = pkt->udp.dst_port;
+	}
+
+	return rte_hash_crc(&ip_port.ip_port, sizeof(ip_port.ip_port), 0) % task->n_workers;
+}
+
+static int handle_lb_ip_port_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_lb_pos *task = (struct task_lb_pos *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+	uint64_t ip_port = 0;
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_lb_ip_port(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_lb_ip_port(task, mbufs[j]);
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static struct task_init task_init_lb_pos = {
+	.mode_str = "lbpos",
+	.init = init_task_lb_pos,
+	.handle = handle_lb_pos_bulk,
+	.size = sizeof(struct task_lb_pos)
+};
+
+static struct task_init task_init_lb_pos2 = {
+	.mode_str = "lbpos",
+	.sub_mode_str = "ip_port",
+	.init = init_task_lb_pos,
+	.handle = handle_lb_ip_port_bulk,
+	.size = sizeof(struct task_lb_pos)
+};
+
+__attribute__((constructor)) static void reg_task_lb_pos(void)
+{
+	reg_task(&task_init_lb_pos);
+	reg_task(&task_init_lb_pos2);
+}
diff --git a/VNFs/DPPD-PROX/handle_lb_qinq.c b/VNFs/DPPD-PROX/handle_lb_qinq.c
new file mode 100644
index 00000000..d58703c5
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_lb_qinq.c
@@ -0,0 +1,377 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+
+#include <rte_mbuf.h>
+#include <rte_ip.h>
+#include <rte_byteorder.h>
+#include <rte_version.h>
+
+#include "prox_malloc.h"
+#include "task_base.h"
+#include "tx_pkt.h"
+#include "rx_pkt.h"
+#include "etypes.h"
+#include "log.h"
+#include "quit.h"
+#include "qinq.h"
+#include "lconf.h"
+#include "prefetch.h"
+#include "defines.h"
+#include "prox_cfg.h"
+#include "hash_utils.h"
+#include "handle_lb_net.h"
+#include "toeplitz.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#endif
+
+/* Load balancing based on one byte, figures out what type of packet
+   is passed and depending on the type, pass the packet to the correct
+   worker thread. If an unsupported packet type is used, the packet is
+   simply dropped. This Load balancer can only handling QinQ packets
+   (i.e. packets comming from the vCPE). */
+int handle_lb_qinq_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+int handle_lb_qinq_bulk_set_port(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+
+struct task_lb_qinq {
+	struct task_base        base;
+	uint8_t                 *worker_table;
+	uint8_t                 bit_mask;
+	uint8_t                 protocols_mask;
+	uint8_t                 nb_worker_threads;
+	uint16_t                qinq_tag;
+};
+
+static void init_task_lb_qinq(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_lb_qinq *task = (struct task_lb_qinq *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->qinq_tag = targ->qinq_tag;
+	task->nb_worker_threads = targ->nb_worker_threads;
+	task->bit_mask = rte_is_power_of_2(targ->nb_worker_threads) ? targ->nb_worker_threads - 1 : 0xff;
+
+	/* The load distributor is sending to a set of cores. These
+	   cores are responsible for handling a set of flows
+	   identified by a qinq tag. The load distributor identifies
+	   the flows and forwards them to the appropriate worker. The
+	   mapping from flow to worker is stored within the
+	   work_table. Build the worker_table by asking each worker
+	   which flows are handled. */
+
+	task->worker_table = prox_zmalloc(0x1000000, socket_id);
+	for (int i = 0; i < targ->nb_worker_threads; ++i) {
+		struct core_task ct = targ->core_task_set[0].core_task[i];
+		struct task_args *t = core_targ_get(ct.core, ct.task);
+
+		PROX_PANIC(t->task_init->flow_iter.beg == NULL,
+			   "Load distributor can't find flows owned by destination worker %d\n", i);
+
+		struct flow_iter *it = &t->task_init->flow_iter;
+
+		int cnt = 0;
+		for (it->beg(it, t); !it->is_end(it, t); it->next(it, t)) {
+			uint16_t svlan = it->get_svlan(it, t);
+			uint16_t cvlan = it->get_cvlan(it, t);
+
+			task->worker_table[PKT_TO_LUTQINQ(svlan, cvlan)] = i;
+		}
+
+	}
+
+	/* Check which protocols we are allowed to send to worker tasks */
+	for (int i = 0; i < MAX_PROTOCOLS; ++i) {
+		int is_active = !!targ->core_task_set[i].n_elems;
+		task->protocols_mask |= is_active << i;
+	}
+	plog_info("\t\ttask_lb_qinq protocols_mask = 0x%x\n", task->protocols_mask);
+
+	if (targ->task_init->flag_features & TASK_FEATURE_LUT_QINQ_RSS)
+		tbase->flags |=  BASE_FLAG_LUT_QINQ_RSS;
+	if (targ->task_init->flag_features & TASK_FEATURE_LUT_QINQ_HASH)
+		tbase->flags |=  BASE_FLAG_LUT_QINQ_HASH;
+	plog_info("\t\ttask_lb_qinq flags = 0x%x\n", tbase->flags);
+}
+
+static struct task_init task_init_lb_qinq = {
+	.mode_str = "lbqinq",
+	.init = init_task_lb_qinq,
+	.handle = handle_lb_qinq_bulk,
+	.size = sizeof(struct task_lb_qinq)
+};
+
+/*
+	Add correct port id to mbufs coming from a DPDK ring port in the loadbalancer.
+	For the split-bng using DPDK rings between the vSwitch and the VMs
+	we need to know the port from which a packet was received.
+	The ring PMD in dpdk does not update the port field in the mbuf
+	and thus we have no control over the port numbers that are being used.
+	This submode allows the loadbalancer to set the port number on which it
+	received the mbuf.
+*/
+static struct task_init task_init_lb_qinq_set_port = {
+	.mode_str = "lbqinq",
+	.sub_mode_str = "lut_qinq_set_port",
+	.init = init_task_lb_qinq,
+	.handle = handle_lb_qinq_bulk_set_port,
+	.size = sizeof(struct task_lb_qinq)
+};
+
+/*
+	Load Balance on Hash of combination of cvlan and svlan
+*/
+static struct task_init task_init_lb_qinq_hash_friend = {
+	.mode_str = "lbqinq",
+	.sub_mode_str ="lut_qinq_hash_friend",
+	.init = init_task_lb_qinq,
+	.handle = handle_lb_qinq_bulk,
+	.flag_features = TASK_FEATURE_LUT_QINQ_HASH,
+	.size = sizeof(struct task_lb_qinq)
+};
+
+/*
+	Load Balance on rss of combination of cvlan and svlan.
+	This could be used to compare with HW implementations.
+*/
+static struct task_init task_init_lb_qinq_rss_friend = {
+	.mode_str = "lbqinq",
+	.sub_mode_str ="lut_qinq_rss_friend",
+	.init = init_task_lb_qinq,
+	.handle = handle_lb_qinq_bulk,
+	.flag_features = TASK_FEATURE_LUT_QINQ_RSS,
+	.size = sizeof(struct task_lb_qinq)
+};
+
+__attribute__((constructor)) static void reg_task_lb_qinq(void)
+{
+	reg_task(&task_init_lb_qinq);
+	reg_task(&task_init_lb_qinq_hash_friend);
+	reg_task(&task_init_lb_qinq_rss_friend);
+	reg_task(&task_init_lb_qinq_set_port);
+}
+
+static inline uint8_t handle_lb_qinq(struct task_lb_qinq *task, struct rte_mbuf *mbuf);
+
+int handle_lb_qinq_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_lb_qinq *task = (struct task_lb_qinq *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_lb_qinq(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_lb_qinq(task, mbufs[j]);
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+int handle_lb_qinq_bulk_set_port(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_lb_qinq *task = (struct task_lb_qinq *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+	uint32_t port_id = mbufs[0]->pkt.in_port;
+#else
+	uint32_t port_id = mbufs[0]->port;
+#endif
+
+	if (tbase->rx_pkt == rx_pkt_hw) {
+		port_id = tbase->rx_params_hw.last_read_portid + tbase->rx_params_hw.nb_rxports;
+		port_id = ( port_id - 1 ) % tbase->rx_params_hw.nb_rxports;
+		port_id = tbase->rx_params_hw.rx_pq[port_id].port;
+	} else if (tbase->rx_pkt == rx_pkt_hw1) {
+		port_id = tbase->rx_params_hw1.rx_pq.port;
+	}
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+		mbufs[j]->pkt.in_port = port_id;
+#else
+		mbufs[j]->port = port_id;
+#endif
+		out[j] = handle_lb_qinq(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+		mbufs[j]->pkt.in_port = port_id;
+#else
+		mbufs[j]->port = port_id;
+#endif
+		out[j] = handle_lb_qinq(task, mbufs[j]);
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+struct qinq_packet {
+	struct qinq_hdr qinq_hdr;
+	union {
+		struct ipv4_hdr ipv4_hdr;
+		struct ipv6_hdr ipv6_hdr;
+	};
+} __attribute__((packed));
+
+struct qinq_packet_data {
+	struct ether_addr  d_addr;
+	struct ether_addr  s_addr;
+	uint64_t qinq;
+} __attribute__((packed));
+
+struct ether_packet {
+	struct ether_hdr ether_hdr;
+	union {
+		struct ipv4_hdr ipv4_hdr;
+		struct ipv6_hdr ipv6_hdr;
+	};
+} __attribute__((packed));
+
+struct cpe_packet {
+	union {
+		struct qinq_packet  qp;
+		struct ether_packet ep;
+		struct qinq_packet_data qd;
+	};
+};
+
+static inline uint8_t get_worker(struct task_lb_qinq *task, struct cpe_packet *packet)
+{
+	uint8_t worker = 0;
+	if (((struct task_base *)task)->flags & BASE_FLAG_LUT_QINQ_HASH) {
+		// Load Balance on Hash of combination of cvlan and svlan
+		uint64_t qinq_net = packet->qd.qinq;
+		qinq_net = qinq_net & 0xFF0F0000FF0F0000;	// Mask Proto and QoS bits
+		if (task->bit_mask != 0xff) {
+			worker = hash_crc32(&qinq_net,8,0) & task->bit_mask;
+		}
+		else {
+			worker = hash_crc32(&qinq_net,8,0) % task->nb_worker_threads;
+		}
+		plogx_dbg("Sending packet svlan=%x, cvlan=%x, pseudo_qinq=%lx to worker %d\n", rte_bswap16(0xFF0F & packet->qp.qinq_hdr.svlan.vlan_tci), rte_bswap16(0xFF0F & packet->qp.qinq_hdr.cvlan.vlan_tci), qinq_net, worker);
+	} else if (((struct task_base *)task)->flags & BASE_FLAG_LUT_QINQ_RSS){
+		// Load Balance on rss of combination of cvlan and svlan
+		uint32_t qinq = (packet->qp.qinq_hdr.cvlan.vlan_tci & 0xFF0F) << 16;
+		uint32_t rss = toeplitz_hash((uint8_t *)&qinq, 4);
+		if (task->bit_mask != 0xff) {
+			worker = rss & task->bit_mask;
+		} else {
+			worker = (0x1ff & rss) % task->nb_worker_threads;
+		}
+		plogx_dbg("Sending packet svlan=%x, cvlan=%x, rss_input=%x, rss=%x to worker %d\n", rte_bswap16(0xFF0F & packet->qp.qinq_hdr.svlan.vlan_tci), rte_bswap16(0xFF0F & packet->qp.qinq_hdr.cvlan.vlan_tci), qinq, rss, worker);
+	} else {
+		uint16_t svlan = packet->qp.qinq_hdr.svlan.vlan_tci;
+		uint16_t cvlan = packet->qp.qinq_hdr.cvlan.vlan_tci;
+		prefetch_nta(&task->worker_table[PKT_TO_LUTQINQ(svlan, cvlan)]);
+		worker = task->worker_table[PKT_TO_LUTQINQ(svlan, cvlan)];
+
+		const size_t pos = offsetof(struct cpe_packet, qp.qinq_hdr.cvlan.vlan_tci);
+		plogx_dbg("qinq = %u, worker = %u, pos = %lu\n", rte_be_to_cpu_16(cvlan), worker, pos);
+	}
+	return worker;
+}
+
+static inline uint8_t handle_lb_qinq(struct task_lb_qinq *task, struct rte_mbuf *mbuf)
+{
+	struct cpe_packet *packet = rte_pktmbuf_mtod(mbuf, struct cpe_packet*);
+	if (packet->ep.ether_hdr.ether_type == ETYPE_IPv4) {
+		if (unlikely((packet->ep.ipv4_hdr.version_ihl >> 4) != 4)) {
+			plogx_err("Invalid Version %u for ETYPE_IPv4\n", packet->ep.ipv4_hdr.version_ihl);
+			return OUT_DISCARD;
+		}
+		/* use 24 bits from the IP, clients are from the 10.0.0.0/8 network */
+		const uint32_t tmp = rte_bswap32(packet->ep.ipv4_hdr.src_addr) & 0x00FFFFFF;
+		const uint32_t svlan = rte_bswap16(tmp >> 12);
+		const uint32_t cvlan = rte_bswap16(tmp & 0x0FFF);
+		prefetch_nta(&task->worker_table[PKT_TO_LUTQINQ(svlan, cvlan)]);
+		uint8_t worker = task->worker_table[PKT_TO_LUTQINQ(svlan, cvlan)];
+		return worker + IPV4 * task->nb_worker_threads;
+	}
+	else if (unlikely(packet->qp.qinq_hdr.svlan.eth_proto != task->qinq_tag)) {
+		/* might receive LLDP from the L2 switch... */
+		if (packet->qp.qinq_hdr.svlan.eth_proto != ETYPE_LLDP) {
+			plogdx_err(mbuf, "Invalid packet for LB in QinQ mode\n");
+		}
+		return OUT_DISCARD;
+	}
+
+	uint8_t worker = 0;
+	uint8_t proto = 0xFF;
+	switch (packet->qp.qinq_hdr.ether_type) {
+	case ETYPE_IPv4: {
+		if (unlikely((packet->qp.ipv4_hdr.version_ihl >> 4) != 4)) {
+			plogx_err("Invalid Version %u for ETYPE_IPv4\n", packet->qp.ipv4_hdr.version_ihl);
+			return OUT_DISCARD;
+		}
+		worker = get_worker(task, packet);
+		proto = IPV4;
+		break;
+	}
+	case ETYPE_IPv6: {
+		if (unlikely((packet->qp.ipv4_hdr.version_ihl >> 4) != 6)) {
+			plogx_err("Invalid Version %u for ETYPE_IPv6\n", packet->qp.ipv4_hdr.version_ihl);
+			return OUT_DISCARD;
+		}
+		/* Use IP Destination when IPV6 QinQ */
+		if (task->bit_mask != 0xff) {
+			worker = ((uint8_t *)packet)[61] & task->bit_mask;
+		}
+		else {
+			worker = ((uint8_t *)packet)[61] % task->nb_worker_threads;
+		}
+		proto = IPV6;
+		break;
+	}
+	case ETYPE_ARP: {
+		// We can only send to ARP ring if it exists
+		if (0 != (task->protocols_mask & (1 << ARP))) {
+			proto = ARP;
+		} else {
+			proto = IPV4;
+		}
+		worker = get_worker(task, packet);
+		break;
+	}
+	default:
+		plogx_warn("Error in ETYPE_8021ad: ether_type = %#06x\n", packet->qp.qinq_hdr.ether_type);
+		return OUT_DISCARD;
+	}
+
+	return worker + proto * task->nb_worker_threads;
+}
diff --git a/VNFs/DPPD-PROX/handle_mirror.c b/VNFs/DPPD-PROX/handle_mirror.c
new file mode 100644
index 00000000..0d764b4d
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_mirror.c
@@ -0,0 +1,161 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <rte_mbuf.h>
+
+#include "mbuf_utils.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "lconf.h"
+#include "log.h"
+#include "prox_port_cfg.h"
+#include "quit.h"
+
+/* Task that sends packets to multiple outputs. Note that in case of n
+   outputs, the output packet rate is n times the input packet
+   rate. Also, since the packet is duplicated by increasing the
+   refcnt, a change to a packet in subsequent tasks connected through
+   one of the outputs of this task will also change the packets as
+   seen by tasks connected behind through other outputs. The correct
+   way to resolve this is to create deep copies of the packet. */
+struct task_mirror {
+	struct task_base base;
+	uint32_t         n_dests;
+};
+
+struct task_mirror_copy {
+	struct task_base   base;
+	struct rte_mempool *mempool;
+	uint32_t           n_dests;
+};
+
+static int handle_mirror_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	int ret = 0;
+	struct task_mirror *task = (struct task_mirror *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	struct rte_mbuf *mbufs2[MAX_PKT_BURST];
+
+	/* Since after calling tx_pkt the mbufs parameter of a handle
+	   function becomes invalid and handle_mirror calls tx_pkt
+	   multiple times, the pointers are copied first. This copy is
+	   used in each call to tx_pkt below. */
+	rte_memcpy(mbufs2, mbufs, sizeof(mbufs[0]) * n_pkts);
+
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		rte_pktmbuf_refcnt_update(mbufs2[j], task->n_dests - 1);
+	}
+	for (uint16_t j = 0; j < task->n_dests; ++j) {
+		memset(out, j, n_pkts);
+
+		ret+= task->base.tx_pkt(&task->base, mbufs2, n_pkts, out);
+	}
+	return ret;
+}
+
+static int handle_mirror_bulk_copy(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_mirror_copy *task = (struct task_mirror_copy *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	int ret = 0;
+
+	/* Send copies of the packet to all but the first
+	   destination */
+	struct rte_mbuf *new_pkts[MAX_PKT_BURST];
+
+	for (uint16_t j = 1; j < task->n_dests; ++j) {
+		if (rte_mempool_get_bulk(task->mempool, (void **)new_pkts, n_pkts) < 0) {
+			continue;
+		}
+		/* Finally, forward the incoming packets. */
+		for (uint16_t i = 0; i < n_pkts; ++i) {
+			void *dst, *src;
+			uint16_t pkt_len;
+
+			out[i] = j;
+			init_mbuf_seg(new_pkts[i]);
+
+			pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+			rte_pktmbuf_pkt_len(new_pkts[i]) = pkt_len;
+			rte_pktmbuf_data_len(new_pkts[i]) = pkt_len;
+
+			dst = rte_pktmbuf_mtod(new_pkts[i], void *);
+			src = rte_pktmbuf_mtod(mbufs[i], void *);
+
+			rte_memcpy(dst, src, pkt_len);
+		}
+		ret+= task->base.tx_pkt(&task->base, new_pkts, n_pkts, out);
+	}
+
+	/* Finally, forward the incoming packets to the first destination. */
+	memset(out, 0, n_pkts);
+	ret+= task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+	return ret;
+}
+
+static void init_task_mirror(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_mirror *task = (struct task_mirror *)tbase;
+
+	task->n_dests = targ->nb_txports? targ->nb_txports : targ->nb_txrings;
+}
+
+static void init_task_mirror_copy(struct task_base *tbase, struct task_args *targ)
+{
+	static char name[] = "mirror_pool";
+	struct task_mirror_copy *task = (struct task_mirror_copy *)tbase;
+	const int sock_id = rte_lcore_to_socket_id(targ->lconf->id);
+	task->n_dests = targ->nb_txports? targ->nb_txports : targ->nb_txrings;
+
+	name[0]++;
+	task->mempool = rte_mempool_create(name,
+					   targ->nb_mbuf - 1, MBUF_SIZE,
+					   targ->nb_cache_mbuf,
+					   sizeof(struct rte_pktmbuf_pool_private),
+					   rte_pktmbuf_pool_init, NULL,
+					   rte_pktmbuf_init, 0,
+					   sock_id, 0);
+	PROX_PANIC(task->mempool == NULL,
+		   "Failed to allocate memory pool on socket %u with %u elements\n",
+		   sock_id, targ->nb_mbuf - 1);
+	task->n_dests = targ->nb_txports? targ->nb_txports : targ->nb_txrings;
+}
+
+static struct task_init task_init_mirror = {
+	.mode_str = "mirror",
+	.init = init_task_mirror,
+	.handle = handle_mirror_bulk,
+	.flag_features = TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS | TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS | TASK_FEATURE_TXQ_FLAGS_REFCOUNT,
+	.size = sizeof(struct task_mirror),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+static struct task_init task_init_mirror2 = {
+	.mode_str = "mirror",
+	.sub_mode_str = "copy",
+	.init = init_task_mirror_copy,
+	.handle = handle_mirror_bulk_copy,
+	.flag_features = TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS | TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS,
+	.size = sizeof(struct task_mirror),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+__attribute__((constructor)) static void reg_task_mirror(void)
+{
+	reg_task(&task_init_mirror);
+	reg_task(&task_init_mirror2);
+}
diff --git a/VNFs/DPPD-PROX/handle_mplstag.c b/VNFs/DPPD-PROX/handle_mplstag.c
new file mode 100644
index 00000000..ce5996eb
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_mplstag.c
@@ -0,0 +1,157 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "defines.h"
+#include "hash_entry_types.h"
+#include "mpls.h"
+#include "prefetch.h"
+#include "task_base.h"
+#include "tx_pkt.h"
+#include "task_init.h"
+#include "prox_port_cfg.h"
+#include "prox_cksum.h"
+#include "thread_generic.h"
+#include "prefetch.h"
+#include "prox_assert.h"
+#include "etypes.h"
+#include "log.h"
+#include "mbuf_utils.h"
+
+struct task_unmpls {
+	struct task_base base;
+	uint8_t n_tags;
+};
+
+static void init_task_unmpls(__attribute__((unused)) struct task_base *tbase,
+			     __attribute__((unused)) struct task_args *targ)
+{
+}
+
+static inline uint8_t handle_unmpls(__attribute__((unused)) struct task_unmpls *task, struct rte_mbuf *mbuf)
+{
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+        struct mpls_hdr *mpls = (struct mpls_hdr *)(peth + 1);
+        uint32_t mpls_len = sizeof(struct mpls_hdr);
+        while (!(mpls->bytes & 0x00010000)) {
+                mpls++;
+                mpls_len += sizeof(struct mpls_hdr);
+        }
+		uint32_t tot_eth_addr_len = 2*sizeof(struct ether_addr);
+		rte_memcpy(((uint8_t *)peth) + mpls_len, peth, tot_eth_addr_len);
+        struct ipv4_hdr *ip = (struct ipv4_hdr *)(mpls + 1);
+        switch (ip->version_ihl >> 4) {
+        case 4:
+                peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+                peth->ether_type = ETYPE_IPv4;
+                return 0;
+        case 6:
+                peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+                peth->ether_type = ETYPE_IPv6;
+                return 0;
+        default:
+                plog_warn("Failed Decoding MPLS Packet - neither IPv4 nor IPv6: version %u\n", ip->version_ihl);
+                return OUT_DISCARD;
+        }
+}
+
+static int handle_unmpls_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+        struct task_unmpls *task = (struct task_unmpls *)tbase;
+        uint8_t out[MAX_PKT_BURST];
+        uint16_t j;
+        prefetch_first(mbufs, n_pkts);
+        for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+                PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+                PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+                out[j] = handle_unmpls(task, mbufs[j]);
+        }
+#ifdef PROX_PREFETCH_OFFSET
+        PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+        for (; j < n_pkts; ++j) {
+                out[j] = handle_unmpls(task, mbufs[j]);
+        }
+#endif
+        return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static struct task_init task_init_unmpls = {
+	.mode_str = "unmpls",
+	.init = init_task_unmpls,
+	.handle = handle_unmpls_bulk,
+	.thread_x = thread_generic,
+	.size = sizeof(struct task_unmpls)
+};
+
+struct task_tagmpls {
+	struct task_base base;
+	uint8_t n_tags;
+};
+
+static void init_task_tagmpls(__attribute__((unused)) struct task_base *tbase,
+			      __attribute__((unused)) struct task_args *targ)
+{
+}
+
+static inline uint8_t handle_tagmpls(__attribute__((unused)) struct task_tagmpls *task, struct rte_mbuf *mbuf)
+{
+        struct ether_hdr *peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, 4);
+        PROX_ASSERT(peth);
+        rte_prefetch0(peth);
+	uint32_t mpls = 0;
+
+	uint32_t tot_eth_addr_len = 2*sizeof(struct ether_addr);
+	rte_memcpy(peth, ((uint8_t *)peth) + sizeof(struct mpls_hdr), tot_eth_addr_len);
+        *((uint32_t *)(peth + 1)) = mpls | 0x00010000; // Set BoS to 1
+        peth->ether_type = ETYPE_MPLSU;
+        return 0;
+}
+
+static int handle_tagmpls_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+        struct task_tagmpls *task = (struct task_tagmpls *)tbase;
+        uint8_t out[MAX_PKT_BURST];
+        uint16_t j;
+        prefetch_first(mbufs, n_pkts);
+        for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+                PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+                PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+                out[j] = handle_tagmpls(task, mbufs[j]);
+        }
+#ifdef PROX_PREFETCH_OFFSET
+        PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+        for (; j < n_pkts; ++j) {
+                out[j] = handle_tagmpls(task, mbufs[j]);
+        }
+#endif
+        return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static struct task_init task_init_tagmpls = {
+	.mode_str = "tagmpls",
+	.init = init_task_tagmpls,
+	.handle = handle_tagmpls_bulk,
+	.size = sizeof(struct task_tagmpls)
+};
+
+__attribute__((constructor)) static void reg_task_mplstag(void)
+{
+	reg_task(&task_init_unmpls);
+	reg_task(&task_init_tagmpls);
+}
diff --git a/VNFs/DPPD-PROX/handle_nat.c b/VNFs/DPPD-PROX/handle_nat.c
new file mode 100644
index 00000000..23d7ad87
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_nat.c
@@ -0,0 +1,196 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mbuf.h>
+#include <rte_hash.h>
+#include <rte_hash_crc.h>
+#include <rte_ether.h>
+#include <rte_ip.h>
+#include <rte_version.h>
+#include <rte_byteorder.h>
+
+#include "prox_lua_types.h"
+#include "prox_lua.h"
+#include "prox_malloc.h"
+#include "prox_cksum.h"
+#include "prefetch.h"
+#include "etypes.h"
+#include "log.h"
+#include "quit.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "lconf.h"
+#include "log.h"
+#include "prox_port_cfg.h"
+
+struct task_nat {
+	struct task_base base;
+	struct rte_hash  *hash;
+	uint32_t         *entries;
+	int              use_src;
+	int              offload_crc;
+};
+
+struct pkt_eth_ipv4 {
+	struct ether_hdr ether_hdr;
+	struct ipv4_hdr  ipv4_hdr;
+} __attribute__((packed));
+
+static int handle_nat(struct task_nat *task, struct rte_mbuf *mbuf)
+{
+	uint32_t *ip_addr;
+	struct pkt_eth_ipv4 *pkt = rte_pktmbuf_mtod(mbuf, struct pkt_eth_ipv4 *);
+	int ret;
+
+	/* Currently, only support eth/ipv4 packets */
+	if (pkt->ether_hdr.ether_type != ETYPE_IPv4)
+		return OUT_DISCARD;
+	if (task->use_src)
+		ip_addr = &(pkt->ipv4_hdr.src_addr);
+	else
+		ip_addr = &(pkt->ipv4_hdr.dst_addr);
+
+	ret = rte_hash_lookup(task->hash, ip_addr);
+
+	/* Drop all packets for which no translation has been
+	   configured. */
+	if (ret < 0)
+		return OUT_DISCARD;
+
+        *ip_addr = task->entries[ret];
+	prox_ip_udp_cksum(mbuf, &pkt->ipv4_hdr, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+	return 0;
+}
+
+static int handle_nat_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+        struct task_nat *task = (struct task_nat *)tbase;
+        uint8_t out[MAX_PKT_BURST];
+        uint16_t j;
+        prefetch_first(mbufs, n_pkts);
+        for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+                PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+                PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+                out[j] = handle_nat(task, mbufs[j]);
+        }
+#ifdef PROX_PREFETCH_OFFSET
+        PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+        for (; j < n_pkts; ++j) {
+                out[j] = handle_nat(task, mbufs[j]);
+        }
+#endif
+        return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static int lua_to_hash_nat(struct lua_State *L, enum lua_place from, const char *name,
+			   uint8_t socket, struct rte_hash **hash, uint32_t **entries)
+{
+	struct rte_hash *ret_hash;
+	uint32_t *ret_entries;
+	uint32_t n_entries;
+	uint32_t ip_from, ip_to;
+	int ret, pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	lua_len(L, -1);
+	n_entries = lua_tointeger(L, -1);
+	lua_pop(L, 1);
+
+	PROX_PANIC(n_entries == 0, "No entries for NAT\n");
+
+	static char hash_name[30] = "000_hash_nat_table";
+
+	const struct rte_hash_parameters hash_params = {
+		.name = hash_name,
+		.entries = n_entries * 4,
+		.key_len = sizeof(ip_from),
+		.hash_func = rte_hash_crc,
+		.hash_func_init_val = 0,
+	};
+
+	ret_hash = rte_hash_create(&hash_params);
+	PROX_PANIC(ret_hash == NULL, "Failed to set up hash table for NAT\n");
+	name++;
+	ret_entries = prox_zmalloc(n_entries * sizeof(ip_to), socket);
+	PROX_PANIC(ret_entries == NULL, "Failed to allocate memory for NAT %u entries\n", n_entries);
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_ip(L, TABLE, "from", &ip_from) ||
+		    lua_to_ip(L, TABLE, "to", &ip_to))
+			return -1;
+
+		ip_from = rte_bswap32(ip_from);
+		ip_to = rte_bswap32(ip_to);
+
+		ret = rte_hash_lookup(ret_hash, (const void *)&ip_from);
+		PROX_PANIC(ret >= 0, "Key %x already exists in NAT hash table\n", ip_from);
+
+		ret = rte_hash_add_key(ret_hash, (const void *)&ip_from);
+
+		PROX_PANIC(ret < 0, "Failed to add Key %x to NAT hash table\n", ip_from);
+		ret_entries[ret] = ip_to;
+		lua_pop(L, 1);
+	}
+
+	lua_pop(L, pop);
+
+	*hash = ret_hash;
+	*entries = ret_entries;
+	return 0;
+}
+
+static void init_task_nat(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_nat *task = (struct task_nat *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	int ret;
+
+	/* Use destination IP by default. */
+	task->use_src = targ->use_src;
+
+	PROX_PANIC(!strcmp(targ->nat_table, ""), "No nat table specified\n");
+	ret = lua_to_hash_nat(prox_lua(), GLOBAL, targ->nat_table, socket_id, &task->hash, &task->entries);
+	PROX_PANIC(ret != 0, "Failed to load NAT table from lua:\n%s\n", get_lua_to_errors());
+	struct prox_port_cfg *port = find_reachable_port(targ);
+	if (port) {
+		task->offload_crc = port->capabilities.tx_offload_cksum;
+	}
+
+}
+
+/* Basic static nat. */
+static struct task_init task_init_nat = {
+	.mode_str = "nat",
+	.init = init_task_nat,
+	.handle = handle_nat_bulk,
+#ifdef SOFT_CRC
+	.flag_features = TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS|TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS,
+#else
+	.flag_features = TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS,
+#endif
+	.size = sizeof(struct task_nat),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+__attribute__((constructor)) static void reg_task_nat(void)
+{
+	reg_task(&task_init_nat);
+}
diff --git a/VNFs/DPPD-PROX/handle_nop.c b/VNFs/DPPD-PROX/handle_nop.c
new file mode 100644
index 00000000..b3eef54c
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_nop.c
@@ -0,0 +1,53 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "handle_nop.h"
+#include "thread_nop.h"
+
+static struct task_init task_init_nop_thrpt_opt = {
+	.mode_str = "nop",
+	.init = NULL,
+	.handle = handle_nop_bulk,
+	.thread_x = thread_nop,
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS|TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS|TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS|TASK_FEATURE_THROUGHPUT_OPT|TASK_FEATURE_MULTI_RX,
+	.size = sizeof(struct task_nop),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+static struct task_init task_init_nop_lat_opt = {
+	.mode_str = "nop",
+	.sub_mode_str = "latency optimized",
+	.init = NULL,
+	.handle = handle_nop_bulk,
+	.thread_x = thread_nop,
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS|TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS|TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS|TASK_FEATURE_MULTI_RX,
+	.size = sizeof(struct task_nop),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+static struct task_init task_init_none;
+
+__attribute__((constructor)) static void reg_task_nop(void)
+{
+	reg_task(&task_init_nop_thrpt_opt);
+	reg_task(&task_init_nop_lat_opt);
+
+	/* For backwards compatibility, add none */
+	task_init_none = task_init_nop_thrpt_opt;
+	strcpy(task_init_none.mode_str, "none");
+
+	reg_task(&task_init_none);
+}
diff --git a/VNFs/DPPD-PROX/handle_nop.h b/VNFs/DPPD-PROX/handle_nop.h
new file mode 100644
index 00000000..0f84eaa3
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_nop.h
@@ -0,0 +1,33 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_NOP_H_
+#define _HANDLE_NOP_H_
+
+#include "task_base.h"
+#include "task_init.h"
+
+struct task_nop {
+	struct task_base base;
+};
+
+static inline int handle_nop_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_nop *task = (struct task_nop *)tbase;
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, NULL);
+}
+
+#endif /* _HANDLE_NOP_H_ */
diff --git a/VNFs/DPPD-PROX/handle_nsh.c b/VNFs/DPPD-PROX/handle_nsh.c
new file mode 100644
index 00000000..65a80c3d
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_nsh.c
@@ -0,0 +1,225 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ethdev.h>
+#include <rte_ether.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#include "vxlangpe_nsh.h"
+#include "task_base.h"
+#include "tx_pkt.h"
+#include "task_init.h"
+#include "thread_generic.h"
+#include "prefetch.h"
+#include "log.h"
+
+#define VXLAN_GPE_HDR_SZ sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + sizeof(struct vxlan_gpe_hdr) + sizeof(struct nsh_hdr)
+#define ETHER_NSH_TYPE 0x4F89 /* 0x894F in little endian */
+#define VXLAN_GPE_NSH_TYPE 0xB612 /* 4790 in little endian */
+#define VXLAN_GPE_NP 0x4
+
+uint16_t decap_nsh_packets(struct rte_mbuf **mbufs, uint16_t n_pkts);
+uint16_t encap_nsh_packets(struct rte_mbuf **mbufs, uint16_t n_pkts);
+
+struct task_decap_nsh {
+	struct task_base base;
+};
+
+struct task_encap_nsh {
+	struct task_base base;
+};
+
+static void init_task_decap_nsh(__attribute__((unused)) struct task_base *tbase,
+			     __attribute__((unused)) struct task_args *targ)
+{
+	return;
+}
+
+static inline uint8_t handle_decap_nsh(__attribute__((unused)) struct task_decap_nsh *task, struct rte_mbuf *mbuf)
+{
+	struct ether_hdr *eth_hdr = NULL;
+	struct udp_hdr *udp_hdr = NULL;
+	struct vxlan_gpe_hdr *vxlan_gpe_hdr = NULL;
+	uint16_t hdr_len;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	if (eth_hdr->ether_type == ETHER_NSH_TYPE) {
+		/* "decapsulate" Ethernet + NSH header by moving packet pointer */
+		hdr_len = sizeof(struct ether_hdr) + sizeof(struct nsh_hdr);
+
+		mbuf->data_len = (uint16_t)(mbuf->data_len - hdr_len);
+		mbuf->data_off += hdr_len;
+		mbuf->pkt_len = (uint32_t)(mbuf->pkt_len - hdr_len);
+		/* save length of header in reserved 16bits of rte_mbuf */
+		mbuf->udata64 = hdr_len;
+	}
+	else {
+		if (mbuf->data_len < VXLAN_GPE_HDR_SZ) {
+			mbuf->udata64 = 0;
+			return 0;
+		}
+
+		/* check the UDP destination port */
+		udp_hdr = (struct udp_hdr *)(((unsigned char *)eth_hdr) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr));
+		if (udp_hdr->dst_port != VXLAN_GPE_NSH_TYPE) {
+			mbuf->udata64 = 0;
+			return 0;
+		}
+
+		/* check the Next Protocol field in VxLAN-GPE header */
+		vxlan_gpe_hdr = (struct vxlan_gpe_hdr *)(((unsigned char *)eth_hdr) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr));
+		if (vxlan_gpe_hdr->next_proto != VXLAN_GPE_NP) {
+			mbuf->udata64 = 0;
+			return 0;
+		}
+
+		/* "decapsulate" VxLAN-GPE + NSH header by moving packet pointer */
+		hdr_len = VXLAN_GPE_HDR_SZ;
+
+		mbuf->data_len = (uint16_t)(mbuf->data_len - hdr_len);
+		mbuf->data_off += hdr_len;
+		mbuf->pkt_len  = (uint32_t)(mbuf->pkt_len - hdr_len);
+		/* save length of header in reserved 16bits of rte_mbuf */
+		mbuf->udata64 = hdr_len;
+	}
+
+	return 0;
+}
+
+static int handle_decap_nsh_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_decap_nsh *task = (struct task_decap_nsh *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_decap_nsh(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_decap_nsh(task, mbufs[j]);
+	}
+#endif
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static void init_task_encap_nsh(__attribute__((unused)) struct task_base *tbase,
+			      __attribute__((unused)) struct task_args *targ)
+{
+	return;
+}
+
+static inline uint8_t handle_encap_nsh(__attribute__((unused)) struct task_encap_nsh *task, struct rte_mbuf *mbuf)
+{
+	struct ether_hdr *eth_hdr = NULL;
+	struct nsh_hdr *nsh_hdr = NULL;
+	struct udp_hdr *udp_hdr = NULL;
+	struct vxlan_gpe_hdr *vxlan_gpe_hdr = NULL;
+	uint16_t hdr_len;
+
+	if (mbuf == NULL)
+		return 0;
+	if (mbuf->udata64 == 0)
+		return 0;
+
+	/* use header length saved in reserved 16bits of rte_mbuf to
+	   "encapsulate" transport + NSH header by moving packet pointer */
+	mbuf->data_len = (uint16_t)(mbuf->data_len + mbuf->udata64);
+	mbuf->data_off -= mbuf->udata64;
+	mbuf->pkt_len  = (uint32_t)(mbuf->pkt_len + mbuf->udata64);
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	if (eth_hdr->ether_type == ETHER_NSH_TYPE) {
+		nsh_hdr = (struct nsh_hdr *) (((unsigned char *)eth_hdr) + sizeof(struct ether_hdr));
+
+		/* decrement Service Index in NSH header */
+		if (nsh_hdr->sf_index > 0)
+			nsh_hdr->sf_index -= 1;
+	}
+	else {
+		/* "encapsulate" VxLAN-GPE + NSH header by moving packet pointer */
+		if (mbuf->data_len < VXLAN_GPE_HDR_SZ)
+			return 0;
+
+		/* check the UDP destination port */
+		udp_hdr = (struct udp_hdr *)(((unsigned char *)eth_hdr) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr));
+		if (udp_hdr->dst_port != VXLAN_GPE_NSH_TYPE)
+			return 0;
+
+		/* check the Next Protocol field in VxLAN-GPE header */
+		vxlan_gpe_hdr = (struct vxlan_gpe_hdr *)(((unsigned char *)eth_hdr) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr));
+		if (vxlan_gpe_hdr->next_proto != VXLAN_GPE_NP)
+			return 0;
+
+		/* decrement Service Index in NSH header */
+		nsh_hdr = (struct nsh_hdr *)(((unsigned char *)vxlan_gpe_hdr) + sizeof(struct vxlan_gpe_hdr));
+		if (nsh_hdr->sf_index > 0)
+			nsh_hdr->sf_index -= 1;
+	}
+
+	return 0;
+}
+
+static int handle_encap_nsh_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_encap_nsh *task = (struct task_encap_nsh *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_encap_nsh(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_encap_nsh(task, mbufs[j]);
+	}
+#endif
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static struct task_init task_init_decap_nsh = {
+	.mode_str = "decapnsh",
+	.init = init_task_decap_nsh,
+	.handle = handle_decap_nsh_bulk,
+	.thread_x = thread_generic,
+	.size = sizeof(struct task_decap_nsh)
+};
+
+static struct task_init task_init_encap_nsh = {
+	.mode_str = "encapnsh",
+	.init = init_task_encap_nsh,
+	.handle = handle_encap_nsh_bulk,
+	.size = sizeof(struct task_encap_nsh)
+};
+
+__attribute__((constructor)) static void reg_task_nshtag(void)
+{
+	reg_task(&task_init_decap_nsh);
+	reg_task(&task_init_encap_nsh);
+}
diff --git a/VNFs/DPPD-PROX/handle_pf_acl.c b/VNFs/DPPD-PROX/handle_pf_acl.c
new file mode 100644
index 00000000..16ac0330
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_pf_acl.c
@@ -0,0 +1,104 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_table_stub.h>	//FIXME: ACL
+
+#include "log.h"
+#include "quit.h"
+#include "thread_pipeline.h"
+
+struct task_pf_acl {
+	struct task_pipe pipe;
+	//TODO
+};
+
+static void init_task_pf_acl(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_pipe *tpipe = (struct task_pipe *)tbase;
+//	struct task_pf_acl *task = (struct task_pf_acl *)tpipe;
+	int err;
+
+	/* create pipeline, input ports and output ports */
+	init_pipe_create_in_out(tpipe, targ);
+
+	/* create ACL pipeline table */
+	//TODO
+
+//FIXME: this is not ACL (
+	/* create pipeline tables */
+	for (uint8_t i = 0; i < tpipe->n_ports_in; ++i) {
+		struct rte_pipeline_table_params table_params = {
+			.ops = &rte_table_stub_ops,
+			.arg_create = NULL,
+			.f_action_hit = NULL,
+			.f_action_miss = NULL,
+			.arg_ah = NULL,
+			.action_data_size = 0,
+		};
+		err = rte_pipeline_table_create(tpipe->p, &table_params,
+				&tpipe->table_id[i]);
+		PROX_PANIC(err != 0, "Failed to create table %u "
+				"for %s pipeline on core %u task %u: "
+				"err = %d\n",
+				i, targ->task_init->mode_str,
+				targ->lconf->id, targ->task,
+				err);
+	}
+	tpipe->n_tables = tpipe->n_ports_in;
+	PROX_PANIC(tpipe->n_tables < 1, "No table created "
+			"for %s pipeline on core %u task %u\n",
+			targ->task_init->mode_str, targ->lconf->id, targ->task);
+
+	/* add default entry to tables */
+	for (uint8_t i = 0; i < tpipe->n_tables; ++i) {
+		struct rte_pipeline_table_entry default_entry = {
+			.action = RTE_PIPELINE_ACTION_PORT,
+			{.port_id = tpipe->port_out_id[i % tpipe->n_ports_out]},
+		};
+		struct rte_pipeline_table_entry *default_entry_ptr;
+		err = rte_pipeline_table_default_entry_add(tpipe->p, tpipe->table_id[i],
+				&default_entry, &default_entry_ptr);
+		PROX_PANIC(err != 0, "Failed to add default entry to table %u "
+				"for %s pipeline on core %u task %u: "
+				"err = %d\n",
+				i, targ->task_init->mode_str,
+				targ->lconf->id, targ->task,
+				err);
+	}
+//FIXME: this is not ACL )
+
+	/* connect pipeline input ports to ACL pipeline table */
+	init_pipe_connect_one(tpipe, targ, tpipe->table_id[0]);
+
+	/* enable pipeline input ports */
+	init_pipe_enable(tpipe, targ);
+
+	/* check pipeline consistency */
+	init_pipe_check(tpipe, targ);
+}
+
+static struct task_init task_init_pf_acl = {
+	.mode_str = "pf_acl",
+	.init = init_task_pf_acl,
+	.handle = handle_pipe,
+	.thread_x = thread_pipeline,
+	.size = sizeof(struct task_pf_acl),
+};
+
+__attribute__((constructor)) static void reg_task_pf_acl(void)
+{
+	reg_task(&task_init_pf_acl);
+}
diff --git a/VNFs/DPPD-PROX/handle_police.c b/VNFs/DPPD-PROX/handle_police.c
new file mode 100644
index 00000000..125e8c0a
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_police.c
@@ -0,0 +1,270 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <rte_mbuf.h>
+#include <rte_cycles.h>
+#include <rte_version.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+#include "prox_malloc.h"
+#include "task_base.h"
+#include "task_init.h"
+#include "lconf.h"
+#include "prefetch.h"
+#include "quit.h"
+#include "log.h"
+#include "defines.h"
+#include "qinq.h"
+#include "prox_cfg.h"
+#include "prox_shared.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#endif
+
+struct task_police {
+	struct task_base base;
+	union {
+		struct rte_meter_srtcm *sr_flows;
+		struct rte_meter_trtcm *tr_flows;
+	};
+
+	uint16_t           *user_table;
+	enum police_action police_act[3][3];
+	uint16_t overhead;
+	uint8_t runtime_flags;
+};
+
+typedef uint8_t (*hp) (struct task_police *task, struct rte_mbuf *mbuf, uint64_t tsc, uint32_t user);
+
+static uint8_t handle_police(struct task_police *task, struct rte_mbuf *mbuf, uint64_t tsc, uint32_t user)
+{
+	enum rte_meter_color in_color = e_RTE_METER_GREEN;
+	enum rte_meter_color out_color;
+	uint32_t pkt_len = rte_pktmbuf_pkt_len(mbuf) + task->overhead;
+	out_color = rte_meter_srtcm_color_aware_check(&task->sr_flows[user], tsc, pkt_len, in_color);
+
+	return task->police_act[in_color][out_color] == ACT_DROP? OUT_DISCARD : 0;
+}
+
+static uint8_t handle_police_tr(struct task_police *task, struct rte_mbuf *mbuf, uint64_t tsc, uint32_t user)
+{
+	enum rte_meter_color in_color = e_RTE_METER_GREEN;
+	enum rte_meter_color out_color;
+	uint32_t pkt_len = rte_pktmbuf_pkt_len(mbuf) + task->overhead;
+	out_color = rte_meter_trtcm_color_aware_check(&task->tr_flows[user], tsc, pkt_len, in_color);
+
+	if (task->runtime_flags  & TASK_MARK) {
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+		uint32_t subport, pipe, traffic_class, queue;
+		enum rte_meter_color color;
+
+		rte_sched_port_pkt_read_tree_path(mbuf, &subport, &pipe, &traffic_class, &queue);
+		color = task->police_act[in_color][out_color];
+
+		rte_sched_port_pkt_write(mbuf, subport, pipe, traffic_class, queue, color);
+#else
+		struct rte_sched_port_hierarchy *sched =
+			(struct rte_sched_port_hierarchy *) &mbuf->pkt.hash.sched;
+		sched->color = task->police_act[in_color][out_color];
+#endif
+	}
+
+	return task->police_act[in_color][out_color] == ACT_DROP? OUT_DISCARD : 0;
+}
+
+static inline int get_user(struct task_police *task, struct rte_mbuf *mbuf)
+{
+	if (task->runtime_flags & TASK_CLASSIFY) {
+		struct qinq_hdr *pqinq = rte_pktmbuf_mtod(mbuf, struct qinq_hdr *);
+		return PKT_TO_LUTQINQ(pqinq->svlan.vlan_tci, pqinq->cvlan.vlan_tci);
+	}
+
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+	uint32_t dummy;
+	uint32_t pipe;
+
+	rte_sched_port_pkt_read_tree_path(mbuf, &dummy, &pipe, &dummy, &dummy);
+	return pipe;
+#else
+	struct rte_sched_port_hierarchy *sched =
+		(struct rte_sched_port_hierarchy *) &mbuf->pkt.hash.sched;
+	return sched->pipe;
+#endif
+}
+
+#define PHASE1_DELAY PREFETCH_OFFSET
+#define PHASE2_DELAY PREFETCH_OFFSET
+#define PHASE3_DELAY PREFETCH_OFFSET
+#define PHASE4_DELAY PREFETCH_OFFSET
+
+static inline int handle_pb(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, hp handle_police_func)
+{
+	struct task_police *task = (struct task_police *)tbase;
+	uint16_t j;
+	uint64_t cur_tsc = rte_rdtsc();
+	uint32_t user[64];
+	uint8_t  out[MAX_PKT_BURST];
+	uint32_t cur_user;
+	for (j = 0; j < PHASE1_DELAY && j < n_pkts; ++j) {
+		PREFETCH0(mbufs[j]);
+	}
+
+	for (j = 0; j < PHASE2_DELAY && j + PHASE1_DELAY < n_pkts; ++j) {
+		PREFETCH0(mbufs[j + PHASE1_DELAY]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j], void*));
+	}
+
+	for (j = 0; j < PHASE3_DELAY && j + PHASE2_DELAY + PHASE1_DELAY < n_pkts; ++j) {
+		PREFETCH0(mbufs[j + PHASE2_DELAY + PHASE1_DELAY]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PHASE2_DELAY], void*));
+                cur_user = get_user(task, mbufs[j]);
+		user[j] = cur_user;
+		PREFETCH0(&task->user_table[cur_user]);
+	}
+
+	/* At this point, the whole pipeline is running */
+	for (j = 0; j + PHASE3_DELAY + PHASE2_DELAY + PHASE1_DELAY < n_pkts; ++j) {
+		PREFETCH0(mbufs[j + PHASE3_DELAY + PHASE2_DELAY + PHASE1_DELAY]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PHASE3_DELAY + PHASE2_DELAY], void*));
+		cur_user = get_user(task, mbufs[j + PHASE3_DELAY]);
+		user[j + PHASE3_DELAY] = cur_user;
+		PREFETCH0(&task->user_table[cur_user]);
+
+		out[j] = handle_police_func(task, mbufs[j], cur_tsc, task->user_table[user[j]]);
+	}
+
+	/* Last part of pipeline */
+	for (; j + PHASE3_DELAY + PHASE2_DELAY < n_pkts; ++j) {
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PHASE3_DELAY + PHASE2_DELAY], void*));
+		PREFETCH0(&task->user_table[j + PHASE3_DELAY]);
+		cur_user = get_user(task, mbufs[j + PHASE3_DELAY]);
+		user[j + PHASE3_DELAY] = cur_user;
+		PREFETCH0(&task->user_table[cur_user]);
+
+		out[j] = handle_police_func(task, mbufs[j], cur_tsc, task->user_table[user[j]]);
+	}
+
+	for (; j + PHASE3_DELAY < n_pkts; ++j) {
+		cur_user = get_user(task, mbufs[j + PHASE3_DELAY]);
+		user[j + PHASE3_DELAY] = cur_user;
+		PREFETCH0(&task->user_table[cur_user]);
+
+		out[j] = handle_police_func(task, mbufs[j], cur_tsc, task->user_table[user[j]]);
+	}
+
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_police_func(task, mbufs[j], cur_tsc, task->user_table[user[j]]);
+	}
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static int handle_police_bulk(struct task_base *tbase, struct rte_mbuf **mbuf, uint16_t n_pkts)
+{
+        return handle_pb(tbase, mbuf, n_pkts, handle_police);
+}
+
+static int handle_police_tr_bulk(struct task_base *tbase, struct rte_mbuf **mbuf, uint16_t n_pkts)
+{
+        return handle_pb(tbase, mbuf, n_pkts, handle_police_tr);
+}
+
+static void init_task_police(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_police *task = (struct task_police *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->overhead = targ->overhead;
+	task->runtime_flags = targ->runtime_flags;
+
+	task->user_table = prox_sh_find_socket(socket_id, "user_table");
+	if (!task->user_table) {
+		PROX_PANIC(!strcmp(targ->user_table, ""), "No user table defined\n");
+		int ret = lua_to_user_table(prox_lua(), GLOBAL, targ->user_table, socket_id, &task->user_table);
+		PROX_PANIC(ret, "Failed to create user table from config:\n%s\n", get_lua_to_errors());
+		prox_sh_add_socket(socket_id, "user_table", task->user_table);
+	}
+
+	if (strcmp(targ->task_init->sub_mode_str, "trtcm")) {
+		task->sr_flows = prox_zmalloc(targ->n_flows * sizeof(*task->sr_flows), socket_id);
+		PROX_PANIC(task->sr_flows == NULL, "Failed to allocate flow contexts\n");
+		PROX_PANIC(!targ->cir, "Commited information rate is set to 0\n");
+		PROX_PANIC(!targ->cbs, "Commited information bucket size is set to 0\n");
+		PROX_PANIC(!targ->ebs, "Execess information bucket size is set to 0\n");
+
+		struct rte_meter_srtcm_params params = {
+			.cir = targ->cir,
+			.cbs = targ->cbs,
+			.ebs = targ->ebs,
+		};
+
+		for (uint32_t i = 0; i < targ->n_flows; ++i) {
+			rte_meter_srtcm_config(&task->sr_flows[i], &params);
+		}
+	}
+	else {
+		task->tr_flows = prox_zmalloc(targ->n_flows * sizeof(*task->tr_flows), socket_id);
+		PROX_PANIC(task->tr_flows == NULL, "Failed to allocate flow contexts\n");
+		PROX_PANIC(!targ->pir, "Peak information rate is set to 0\n");
+		PROX_PANIC(!targ->cir, "Commited information rate is set to 0\n");
+		PROX_PANIC(!targ->pbs, "Peak information bucket size is set to 0\n");
+		PROX_PANIC(!targ->cbs, "Commited information bucket size is set to 0\n");
+
+		struct rte_meter_trtcm_params params = {
+			.pir = targ->pir,
+			.pbs = targ->pbs,
+			.cir = targ->cir,
+			.cbs = targ->cbs,
+		};
+
+		for (uint32_t i = 0; i < targ->n_flows; ++i) {
+			rte_meter_trtcm_config(&task->tr_flows[i], &params);
+		}
+	}
+
+	for (uint32_t i = 0; i < 3; ++i) {
+		for (uint32_t j = 0; j < 3; ++j) {
+			task->police_act[i][j] = targ->police_act[i][j];
+		}
+	}
+}
+
+static struct task_init task_init_police = {
+	.mode_str = "police",
+	.init = init_task_police,
+	.handle = handle_police_bulk,
+	.flag_features = TASK_FEATURE_CLASSIFY,
+	.size = sizeof(struct task_police)
+};
+
+static struct task_init task_init_police2 = {
+	.mode_str = "police",
+	.sub_mode_str = "trtcm",
+	.init = init_task_police,
+	.handle = handle_police_tr_bulk,
+	.flag_features = TASK_FEATURE_CLASSIFY,
+	.size = sizeof(struct task_police)
+};
+
+__attribute__((constructor)) static void reg_task_police(void)
+{
+	reg_task(&task_init_police);
+	reg_task(&task_init_police2);
+}
diff --git a/VNFs/DPPD-PROX/handle_qinq_decap4.c b/VNFs/DPPD-PROX/handle_qinq_decap4.c
new file mode 100644
index 00000000..f5c80227
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_qinq_decap4.c
@@ -0,0 +1,659 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_byteorder.h>
+#include <rte_cycles.h>
+#include <rte_table_hash.h>
+#include <rte_lpm.h>
+#include <rte_version.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+#include "handle_qinq_decap4.h"
+#include "handle_qinq_encap4.h"
+#include "stats.h"
+#include "tx_pkt.h"
+#include "defines.h"
+#include "handle_routing.h"
+#include "prox_assert.h"
+#include "task_init.h"
+#include "quit.h"
+#include "pkt_prototypes.h"
+#include "task_base.h"
+#include "task_init.h"
+#include "bng_pkts.h"
+#include "prox_cksum.h"
+#include "expire_cpe.h"
+#include "prox_port_cfg.h"
+#include "prefetch.h"
+#include "prox_cfg.h"
+#include "lconf.h"
+#include "prox_cfg.h"
+#include "prox_shared.h"
+
+struct task_qinq_decap4 {
+	struct task_base        base;
+	struct rte_table_hash   *cpe_table;
+	struct rte_table_hash   *qinq_gre_table;
+	struct qinq_gre_data    *qinq_gre_data;
+	struct next_hop         *next_hops;
+	struct rte_lpm          *ipv4_lpm;
+	uint32_t                local_ipv4;
+	uint16_t                qinq_tag;
+	uint8_t                 runtime_flags;
+	int                     offload_crc;
+	uint64_t                keys[64];
+	uint64_t                src_mac[PROX_MAX_PORTS];
+	struct rte_mbuf*        fake_packets[64];
+	struct expire_cpe       expire_cpe;
+	uint64_t                cpe_timeout;
+	uint8_t                 mapping[PROX_MAX_PORTS];
+};
+
+static uint8_t handle_qinq_decap4(struct task_qinq_decap4 *task, struct rte_mbuf *mbuf, struct qinq_gre_data* entry);
+/* Convert IPv4 packets to GRE and optionally store QinQ Tags */
+static void arp_update(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+static void arp_msg(struct task_base *tbase, void **data, uint16_t n_msgs);
+
+static void init_task_qinq_decap4(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_qinq_decap4 *task = (struct task_qinq_decap4 *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	struct lpm4 *lpm;
+
+	task->cpe_table = targ->cpe_table;
+	task->cpe_timeout = msec_to_tsc(targ->cpe_table_timeout_ms);
+
+	PROX_PANIC(!strcmp(targ->route_table, ""), "route table not specified\n");
+	lpm = prox_sh_find_socket(socket_id, targ->route_table);
+	if (!lpm) {
+		int ret = lua_to_lpm4(prox_lua(), GLOBAL, targ->route_table, socket_id, &lpm);
+		PROX_PANIC(ret, "Failed to load IPv4 LPM:\n%s\n", get_lua_to_errors());
+		prox_sh_add_socket(socket_id, targ->route_table, lpm);
+	}
+	task->ipv4_lpm = lpm->rte_lpm;
+	task->next_hops = lpm->next_hops;
+
+	task->qinq_tag = targ->qinq_tag;
+	task->local_ipv4 = targ->local_ipv4;
+	task->runtime_flags = targ->runtime_flags;
+	if (strcmp(targ->task_init->sub_mode_str, "pe"))
+		PROX_PANIC(targ->qinq_gre_table == NULL, "can't set up qinq gre\n");
+
+	task->qinq_gre_table = targ->qinq_gre_table;
+
+	if (targ->cpe_table_timeout_ms) {
+		targ->lconf->period_func = check_expire_cpe;
+		task->expire_cpe.cpe_table = task->cpe_table;
+		targ->lconf->period_data = &task->expire_cpe;
+		targ->lconf->period_timeout = msec_to_tsc(500) / NUM_VCPES;
+	}
+
+	for (uint32_t i = 0; i < 64; ++i) {
+		task->fake_packets[i] = (struct rte_mbuf*)((uint8_t*)&task->keys[i] - sizeof (struct rte_mbuf));
+	}
+	if (task->runtime_flags & TASK_ROUTING) {
+		if (targ->nb_txrings) {
+			struct task_args *dtarg;
+			struct core_task ct;
+
+			for (uint32_t i = 0; i < targ->nb_txrings; ++i) {
+				ct = targ->core_task_set[0].core_task[i];
+				dtarg = core_targ_get(ct.core, ct.task);
+				dtarg = find_reachable_task_sending_to_port(dtarg);
+
+				PROX_PANIC(dtarg == NULL, "Error finding destination port through other tasks for outgoing ring %u\n", i);
+				task->src_mac[i] = *(uint64_t*)&prox_port_cfg[dtarg->tx_port_queue[0].port].eth_addr;
+			}
+		}
+		else {
+			for (uint32_t i = 0; i < targ->nb_txports; ++i) {
+				task->src_mac[i] = *(uint64_t*)&prox_port_cfg[targ->tx_port_queue[i].port].eth_addr;
+			}
+		}
+	}
+
+	if (targ->runtime_flags & TASK_CTRL_HANDLE_ARP) {
+		targ->lconf->ctrl_func_p[targ->task] = arp_update;
+	}
+
+	/* Copy the mapping from a sibling task which is configured
+	   with mode encap4. The mapping is constant, so it is faster
+	   to apply it when entries are added (least common case)
+	   instead of re-applying it for every packet (most common
+	   case). */
+
+	for (uint8_t task_id = 0; task_id < targ->lconf->n_tasks_all; ++task_id) {
+		enum task_mode smode = targ->lconf->targs[task_id].mode;
+		if (QINQ_ENCAP4 == smode) {
+			for (uint8_t i = 0; i < PROX_MAX_PORTS; ++i) {
+				task->mapping[i] = targ->lconf->targs[task_id].mapping[i];
+			}
+		}
+	}
+
+	struct prox_port_cfg *port = find_reachable_port(targ);
+	if (port) {
+		task->offload_crc = port->capabilities.tx_offload_cksum;
+	}
+
+	// By default, calling this function 1K times per second => 64K ARP per second max
+	// If 4 interfaces sending to here, = ~0.1% of workload.
+	// If receiving more ARP, they will be dropped, or will dramatically slow down LB if in "no drop" mode.
+	targ->lconf->ctrl_timeout = freq_to_tsc(targ->ctrl_freq);
+	targ->lconf->ctrl_func_m[targ->task] = arp_msg;
+}
+
+static void early_init_table(struct task_args *targ)
+{
+	if (!targ->qinq_gre_table && !targ->cpe_table) {
+		init_qinq_gre_table(targ, get_qinq_gre_map(targ));
+		init_cpe4_table(targ);
+	}
+}
+
+static inline void extract_key_bulk(struct rte_mbuf **mbufs, uint16_t n_pkts, struct task_qinq_decap4 *task)
+{
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		extract_key_cpe(mbufs[j], &task->keys[j]);
+	}
+}
+
+__attribute__((cold)) static void handle_error(struct rte_mbuf *mbuf)
+{
+        struct cpe_pkt *packet = rte_pktmbuf_mtod(mbuf, struct cpe_pkt *);
+#ifdef USE_QINQ
+        uint64_t key = (*(uint64_t*)(((uint8_t *)packet) + 12)) & 0xFF0FFFFFFF0FFFFF;
+	uint32_t svlan = packet->qinq_hdr.svlan.vlan_tci;
+	uint32_t cvlan = packet->qinq_hdr.cvlan.vlan_tci;
+
+	svlan = rte_be_to_cpu_16(svlan & 0xFF0F);
+	cvlan = rte_be_to_cpu_16(cvlan & 0xFF0F);
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
+	plogx_err("Can't convert key %016lx qinq %d|%d (%x|%x) to gre_id, rss=%x flags=%lx, status_err_len=%lx, L2Tag=%d type=%d\n",
+		  key, svlan, cvlan, svlan, cvlan, mbuf->hash.rss, mbuf->ol_flags, mbuf->udata64, mbuf->vlan_tci_outer, mbuf->packet_type);
+#else
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+	plogx_err("Can't convert key %016lx qinq %d|%d (%x|%x) to gre_id, rss=%x flags=%lx, status_err_len=%lx, L2Tag=%d type=%d\n",
+		  key, svlan, cvlan, svlan, cvlan, mbuf->hash.rss, mbuf->ol_flags, mbuf->udata64, mbuf->reserved, mbuf->packet_type);
+#else
+	plogx_err("Can't convert key %016lx qinq %d|%d (%x|%x) to gre_id, flags=%x, L2Tag=%d\n",
+		  key, svlan, cvlan, svlan, cvlan, mbuf->ol_flags, mbuf->reserved);
+#endif
+#endif
+#else
+	plogx_err("Can't convert ip %x to gre_id\n", rte_bswap32(packet->ipv4_hdr.src_addr));
+#endif
+}
+
+static int add_cpe_entry(struct rte_table_hash *hash, struct cpe_key *key, struct cpe_data *data)
+{
+	void* entry_in_hash;
+	int ret, key_found = 0;
+
+	ret = rte_table_hash_key8_ext_dosig_ops.
+		f_add(hash, key, data, &key_found, &entry_in_hash);
+	if (unlikely(ret)) {
+		plogx_err("Failed to add key: ip %x, gre %x\n", key->ip, key->gre_id);
+		return 1;
+	}
+	return 0;
+}
+
+static void extract_key_data_arp(struct rte_mbuf* mbuf, struct cpe_key* key, struct cpe_data* data, const struct qinq_gre_data* entry, uint64_t cpe_timeout, uint8_t* mapping)
+{
+	const struct cpe_packet_arp *packet = rte_pktmbuf_mtod(mbuf, const struct cpe_packet_arp *);
+	uint32_t svlan = packet->qinq_hdr.svlan.vlan_tci & 0xFF0F;
+	uint32_t cvlan = packet->qinq_hdr.cvlan.vlan_tci & 0xFF0F;
+	uint8_t port_id;
+	key->ip = packet->arp.data.spa;
+	key->gre_id = entry->gre_id;
+
+	data->mac_port_8bytes = *((const uint64_t *)(&packet->qinq_hdr.s_addr));
+	data->qinq_svlan = svlan;
+	data->qinq_cvlan = cvlan;
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+	port_id = mbuf->port;
+
+#else
+	port_id = mbuf->pkt.in_port;
+#endif
+	uint8_t mapped = mapping[port_id];
+	data->mac_port.out_idx = mapping[port_id];
+
+	if (unlikely(mapped == 255)) {
+		/* This error only occurs if the system is configured incorrectly */
+		plog_warn("Failed adding packet: unknown mapping for port %d", port_id);
+		data->mac_port.out_idx = 0;
+	}
+
+	data->user = entry->user;
+	data->tsc = rte_rdtsc() + cpe_timeout;
+}
+
+void arp_msg_to_str(char *str, struct arp_msg *msg)
+{
+	sprintf(str, "%u %u %u %u %u.%u.%u.%u %x:%x:%x:%x:%x:%x %u\n",
+		msg->data.mac_port.out_idx, msg->key.gre_id, msg->data.qinq_svlan, msg->data.qinq_cvlan,
+		msg->key.ip_bytes[0], msg->key.ip_bytes[1], msg->key.ip_bytes[2], msg->key.ip_bytes[3],
+		msg->data.mac_port_b[0], msg->data.mac_port_b[1], msg->data.mac_port_b[2],
+		msg->data.mac_port_b[3], msg->data.mac_port_b[4], msg->data.mac_port_b[5], msg->data.user);
+}
+
+int str_to_arp_msg(struct arp_msg *msg, const char *str)
+{
+	uint32_t ip[4],	interface, gre_id, svlan, cvlan, mac[6], user;
+
+	int ret = sscanf(str, "%u %u %u %u %u.%u.%u.%u %x:%x:%x:%x:%x:%x %u",
+			 &interface, &gre_id, &svlan, &cvlan,
+			 ip, ip + 1, ip + 2, ip + 3,
+			 mac, mac + 1, mac + 2, mac + 3, mac + 4, mac + 5, &user);
+
+	for (uint8_t i = 0; i < 4; ++i)
+		msg->key.ip_bytes[i] = ip[i];
+	msg->key.gre_id = gre_id;
+
+	for (uint8_t i = 0; i < 4; ++i)
+		msg->data.mac_port_b[i] = mac[i];
+	msg->data.qinq_svlan = svlan;
+	msg->data.qinq_cvlan = cvlan;
+	msg->data.user = user;
+	msg->data.mac_port.out_idx = interface;
+
+	return ret != 15;
+}
+
+void arp_update_from_msg(struct rte_table_hash * cpe_table, struct arp_msg **msgs, uint16_t n_msgs, uint64_t cpe_timeout)
+{
+	int ret, key_found = 0;
+	void* entry_in_hash;
+
+	for (uint16_t i = 0; i < n_msgs; ++i) {
+		msgs[i]->data.tsc = rte_rdtsc() + cpe_timeout;
+		ret = rte_table_hash_key8_ext_dosig_ops.
+			f_add(cpe_table, &msgs[i]->key, &msgs[i]->data, &key_found, &entry_in_hash);
+		if (unlikely(ret)) {
+			plogx_err("Failed to add key %x, gre %x\n", msgs[i]->key.ip, msgs[i]->key.gre_id);
+		}
+	}
+}
+
+static void arp_msg(struct task_base *tbase, void **data, uint16_t n_msgs)
+{
+	struct task_qinq_decap4 *task = (struct task_qinq_decap4 *)tbase;
+	struct arp_msg **msgs = (struct arp_msg **)data;
+
+	arp_update_from_msg(task->cpe_table, msgs, n_msgs, task->cpe_timeout);
+}
+
+static void arp_update(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_qinq_decap4 *task = (struct task_qinq_decap4 *)tbase;
+
+	prefetch_pkts(mbufs, n_pkts);
+	extract_key_bulk(mbufs, n_pkts, task);
+
+	uint64_t pkts_mask = RTE_LEN2MASK(n_pkts, uint64_t);
+	uint64_t lookup_hit_mask = 0;
+	struct qinq_gre_data* entries[64];
+	rte_table_hash_key8_ext_dosig_ops.f_lookup(task->qinq_gre_table, task->fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
+
+	TASK_STATS_ADD_RX(&task->base.aux->stats, n_pkts);
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		if (unlikely(!((lookup_hit_mask >> j) & 0x1))) {
+			handle_error(mbufs[j]);
+			rte_pktmbuf_free(mbufs[j]);
+			continue;
+		}
+
+		struct cpe_key key;
+		struct cpe_data data;
+
+		extract_key_data_arp(mbufs[j], &key, &data, entries[j], task->cpe_timeout, task->mapping);
+
+		void* entry_in_hash;
+		int ret, key_found = 0;
+
+		ret = rte_table_hash_key8_ext_dosig_ops.
+			f_add(task->cpe_table, &key, &data, &key_found, &entry_in_hash);
+
+		if (unlikely(ret)) {
+			plogx_err("Failed to add key %x, gre %x\n", key.ip, key.gre_id);
+			TASK_STATS_ADD_DROP_DISCARD(&task->base.aux->stats, 1);
+		}
+
+		/* should do ARP reply */
+		TASK_STATS_ADD_DROP_HANDLED(&task->base.aux->stats, 1);
+		rte_pktmbuf_free(mbufs[j]);
+	}
+}
+
+static int handle_qinq_decap4_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_qinq_decap4 *task = (struct task_qinq_decap4 *)tbase;
+	uint64_t pkts_mask = RTE_LEN2MASK(n_pkts, uint64_t);
+	struct qinq_gre_data* entries[64];
+	uint8_t out[MAX_PKT_BURST];
+	uint64_t lookup_hit_mask;
+	prefetch_pkts(mbufs, n_pkts);
+
+	// Prefetch headroom, as we will prepend mbuf and write to this cache line
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		PREFETCH0((rte_pktmbuf_mtod(mbufs[j], char*)-1));
+	}
+
+	extract_key_bulk(mbufs, n_pkts, task);
+	rte_table_hash_key8_ext_dosig_ops.f_lookup(task->qinq_gre_table, task->fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
+
+	if (likely(lookup_hit_mask == pkts_mask)) {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			out[j] = handle_qinq_decap4(task, mbufs[j], entries[j]);
+		}
+	}
+	else {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			if (unlikely(!((lookup_hit_mask >> j) & 0x1))) {
+				// This might fail as the packet has not the expected QinQ or it's not an IPv4 packet
+	                        handle_error(mbufs[j]);
+				out[j] = OUT_DISCARD;
+				continue;
+			}
+			out[j] = handle_qinq_decap4(task, mbufs[j], entries[j]);
+		}
+	}
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+/* add gre header */
+static inline void gre_encap(struct task_qinq_decap4 *task, uint32_t src_ipv4, struct rte_mbuf *mbuf, uint32_t gre_id)
+{
+#ifdef USE_QINQ
+	struct ipv4_hdr *pip = (struct ipv4_hdr *)(1 + rte_pktmbuf_mtod(mbuf, struct qinq_hdr *));
+#else
+	struct ipv4_hdr *pip = (struct ipv4_hdr *)(1 + rte_pktmbuf_mtod(mbuf, struct ether_hdr *));
+#endif
+	uint16_t ip_len = rte_be_to_cpu_16(pip->total_length);
+	uint16_t padlen = rte_pktmbuf_pkt_len(mbuf) - 20 - ip_len - sizeof(struct qinq_hdr);
+
+	if (padlen) {
+		rte_pktmbuf_trim(mbuf, padlen);
+	}
+
+	PROX_PANIC(rte_pktmbuf_data_len(mbuf) - padlen + 20 > ETHER_MAX_LEN,
+	           "Would need to fragment packet new size = %u - not implemented\n",
+	           rte_pktmbuf_data_len(mbuf) - padlen + 20);
+
+#ifdef USE_QINQ
+	/* prepend only 20 bytes instead of 28, 8 bytes are present from the QinQ */
+	struct ether_hdr *peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, 20);
+#else
+	struct ether_hdr *peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, 28);
+#endif
+
+	PROX_ASSERT(peth);
+	PREFETCH0(peth);
+	if (task->runtime_flags & TASK_TX_CRC) {
+		/* calculate IP CRC here to avoid problems with -O3 flag with gcc */
+#ifdef MPLS_ROUTING
+		prox_ip_cksum(mbuf, pip, sizeof(struct ether_hdr) + sizeof(struct mpls_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+#else
+		prox_ip_cksum(mbuf, pip, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+#endif
+	}
+
+	/* new IP header */
+	struct ipv4_hdr *p_tunnel_ip = (struct ipv4_hdr *)(peth + 1);
+	rte_memcpy(p_tunnel_ip, &tunnel_ip_proto, sizeof(struct ipv4_hdr));
+	ip_len += sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr);
+	p_tunnel_ip->total_length = rte_cpu_to_be_16(ip_len);
+	p_tunnel_ip->src_addr = src_ipv4;
+
+	/* Add GRE Header values */
+	struct gre_hdr *pgre = (struct gre_hdr *)(p_tunnel_ip + 1);
+
+	rte_memcpy(pgre, &gre_hdr_proto, sizeof(struct gre_hdr));
+	pgre->gre_id = gre_id;
+	peth->ether_type = ETYPE_IPv4;
+}
+
+static inline uint16_t calc_padlen(const struct rte_mbuf *mbuf, const uint16_t ip_len)
+{
+	return rte_pktmbuf_pkt_len(mbuf) - DOWNSTREAM_DELTA - ip_len - offsetof(struct cpe_pkt, ipv4_hdr);
+}
+
+static inline uint8_t gre_encap_route(uint32_t src_ipv4, struct rte_mbuf *mbuf, uint32_t gre_id, struct task_qinq_decap4 *task)
+{
+	PROX_PANIC(rte_pktmbuf_data_len(mbuf) + DOWNSTREAM_DELTA  > ETHER_MAX_LEN,
+	           "Would need to fragment packet new size = %u - not implemented\n",
+	           rte_pktmbuf_data_len(mbuf) + DOWNSTREAM_DELTA);
+
+	struct core_net_pkt_m *packet = (struct core_net_pkt_m *)rte_pktmbuf_prepend(mbuf, DOWNSTREAM_DELTA);
+	PROX_ASSERT(packet);
+	PREFETCH0(packet);
+
+	struct ipv4_hdr *pip = &((struct cpe_pkt_delta *)packet)->pkt.ipv4_hdr;
+	uint16_t ip_len = rte_be_to_cpu_16(pip->total_length);
+
+	/* returns 0 on success, returns -ENOENT of failure (or -EINVAL if first or last parameter is NULL) */
+#if RTE_VERSION >= RTE_VERSION_NUM(16,4,0,1)
+	uint32_t next_hop_index;
+#else
+	uint8_t next_hop_index;
+#endif
+	if (unlikely(rte_lpm_lookup(task->ipv4_lpm, rte_bswap32(pip->dst_addr), &next_hop_index) != 0)) {
+		plog_warn("lpm_lookup failed for ip %x: rc = %d\n", rte_bswap32(pip->dst_addr), -ENOENT);
+		return ROUTE_ERR;
+	}
+	PREFETCH0(&task->next_hops[next_hop_index]);
+
+	/* calculate outer IP CRC here to avoid problems with -O3 flag with gcc */
+	const uint16_t padlen = calc_padlen(mbuf, ip_len);
+	if (padlen) {
+		rte_pktmbuf_trim(mbuf, padlen);
+	}
+	const uint8_t port_id = task->next_hops[next_hop_index].mac_port.out_idx;
+
+	*((uint64_t *)(&packet->ether_hdr.d_addr)) = task->next_hops[next_hop_index].mac_port_8bytes;
+	*((uint64_t *)(&packet->ether_hdr.s_addr)) = task->src_mac[task->next_hops[next_hop_index].mac_port.out_idx];
+
+#ifdef MPLS_ROUTING
+	packet->mpls_bytes = task->next_hops[next_hop_index].mpls | 0x00010000; // Set BoS to 1
+	packet->ether_hdr.ether_type = ETYPE_MPLSU;
+#else
+	packet->ether_hdr.ether_type = ETYPE_IPv4;
+#endif
+
+	/* New IP header */
+	rte_memcpy(&packet->tunnel_ip_hdr, &tunnel_ip_proto, sizeof(struct ipv4_hdr));
+	ip_len += sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr);
+	packet->tunnel_ip_hdr.total_length = rte_cpu_to_be_16(ip_len);
+	packet->tunnel_ip_hdr.src_addr = src_ipv4;
+	packet->tunnel_ip_hdr.dst_addr = task->next_hops[next_hop_index].ip_dst;
+	if (task->runtime_flags & TASK_TX_CRC) {
+#ifdef MPLS_ROUTING
+		prox_ip_cksum(mbuf, (void *)&(packet->tunnel_ip_hdr), sizeof(struct ether_hdr) + sizeof(struct mpls_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+#else
+		prox_ip_cksum(mbuf, (void *)&(packet->tunnel_ip_hdr), sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+#endif
+	}
+
+	/* Add GRE Header values */
+	rte_memcpy(&packet->gre_hdr, &gre_hdr_proto, sizeof(struct gre_hdr));
+	packet->gre_hdr.gre_id = rte_be_to_cpu_32(gre_id);
+
+	return port_id;
+}
+
+static void extract_key_data(struct rte_mbuf* mbuf, struct cpe_key* key, struct cpe_data* data, const struct qinq_gre_data* entry, uint64_t cpe_timeout, uint8_t *mapping)
+{
+	struct cpe_pkt *packet = rte_pktmbuf_mtod(mbuf, struct cpe_pkt *);
+	uint8_t port_id;
+
+#ifndef USE_QINQ
+        const uint32_t tmp = rte_bswap32(packet->ipv4_hdr.src_addr) & 0x00FFFFFF;
+	const uint32_t svlan = rte_bswap16(tmp >> 12);
+	const uint32_t cvlan = rte_bswap16(tmp & 0x0FFF);
+#endif
+
+#ifdef USE_QINQ
+	key->ip = packet->ipv4_hdr.src_addr;
+#else
+	key->ip = 0;
+#endif
+	key->gre_id = entry->gre_id;
+
+#ifdef USE_QINQ
+	data->mac_port_8bytes = *((const uint64_t *)(&packet->qinq_hdr.s_addr));
+	data->qinq_svlan      = packet->qinq_hdr.svlan.vlan_tci & 0xFF0F;
+	data->qinq_cvlan      = packet->qinq_hdr.cvlan.vlan_tci & 0xFF0F;
+#else
+	data->mac_port_8bytes = *((const uint64_t *)(&packet->ether_hdr.s_addr));
+	data->qinq_svlan      = svlan;
+	data->qinq_cvlan      = cvlan;
+#endif
+
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+	port_id = mbuf->port;
+
+#else
+	port_id = mbuf->pkt.in_port;
+#endif
+	uint8_t mapped = mapping[port_id];
+	data->mac_port.out_idx = mapped;
+
+	if (unlikely(mapped == 255)) {
+		/* This error only occurs if the system is configured incorrectly */
+		plog_warn("Failed adding packet: unknown mapping for port %d", port_id);
+		data->mac_port.out_idx = 0;
+	}
+	else {
+		data->mac_port.out_idx = mapped;
+	}
+
+	data->user             = entry->user;
+	data->tsc              = rte_rdtsc() + cpe_timeout;
+}
+
+static uint8_t handle_qinq_decap4(struct task_qinq_decap4 *task, struct rte_mbuf *mbuf, struct qinq_gre_data* entry)
+{
+	if (!(task->runtime_flags & (TASK_CTRL_HANDLE_ARP|TASK_FP_HANDLE_ARP))) {
+		// We learn CPE MAC addresses on every packets
+		struct cpe_key key;
+		struct cpe_data data;
+		extract_key_data(mbuf, &key, &data, entry, task->cpe_timeout, task->mapping);
+		//plogx_err("Adding key ip=%x/gre_id=%x data (svlan|cvlan)=%x|%x, rss=%x, gre_id=%x\n", key.ip, key.gre_id, data.qinq_svlan,data.qinq_cvlan, mbuf->hash.rss, entry->gre_id);
+
+		if (add_cpe_entry(task->cpe_table, &key, &data)) {
+			plog_warn("Failed to add ARP entry\n");
+			return OUT_DISCARD;
+		}
+	}
+	if (task->runtime_flags & TASK_FP_HANDLE_ARP) {
+		// We learn CPE MAC addresses on ARP packets in Fast Path
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+		if (mbuf->packet_type == 0xB) {
+			struct cpe_key key;
+			struct cpe_data data;
+			extract_key_data_arp(mbuf, &key, &data, entry, task->cpe_timeout, task->mapping);
+
+			if (add_cpe_entry(task->cpe_table, &key, &data)) {
+				plog_warn("Failed to add ARP entry\n");
+				return OUT_DISCARD;
+			}
+			return OUT_HANDLED;
+		} else
+#endif
+		{
+#ifdef USE_QINQ
+			struct cpe_pkt *packet = rte_pktmbuf_mtod(mbuf, struct cpe_pkt*);
+			if (packet->qinq_hdr.svlan.eth_proto == task->qinq_tag &&
+			    packet->qinq_hdr.ether_type == ETYPE_ARP) {
+				struct cpe_key key;
+				struct cpe_data data;
+				extract_key_data_arp(mbuf, &key, &data, entry, task->cpe_timeout, task->mapping);
+
+				if (add_cpe_entry(task->cpe_table, &key, &data)) {
+					plog_warn("Failed to add ARP entry\n");
+					return OUT_DISCARD;
+				}
+				return OUT_HANDLED;
+			}
+#endif
+		}
+	}
+	if (task->runtime_flags & TASK_ROUTING) {
+		uint8_t tx_portid;
+		tx_portid = gre_encap_route(task->local_ipv4, mbuf, entry->gre_id, task);
+
+		return tx_portid == ROUTE_ERR? OUT_DISCARD : tx_portid;
+	}
+	else {
+		gre_encap(task, task->local_ipv4, mbuf, entry->gre_id);
+		return 0;
+	}
+}
+
+static void flow_iter_next(struct flow_iter *iter, struct task_args *targ)
+{
+	do {
+		iter->idx++;
+	} while (iter->idx < (int)get_qinq_gre_map(targ)->count &&
+		 get_qinq_gre_map(targ)->entries[iter->idx].gre_id % targ->nb_slave_threads != targ->worker_thread_id);
+}
+
+static void flow_iter_beg(struct flow_iter *iter, struct task_args *targ)
+{
+	iter->idx = -1;
+	flow_iter_next(iter, targ);
+}
+
+static int flow_iter_is_end(struct flow_iter *iter, struct task_args *targ)
+{
+	return iter->idx == (int)get_qinq_gre_map(targ)->count;
+}
+
+static uint16_t flow_iter_get_svlan(struct flow_iter *iter, struct task_args *targ)
+{
+	return get_qinq_gre_map(targ)->entries[iter->idx].svlan;
+}
+
+static uint16_t flow_iter_get_cvlan(struct flow_iter *iter, struct task_args *targ)
+{
+	return get_qinq_gre_map(targ)->entries[iter->idx].cvlan;
+}
+
+static struct task_init task_init_qinq_decapv4_table = {
+	.mode = QINQ_DECAP4,
+	.mode_str = "qinqdecapv4",
+	.early_init = early_init_table,
+	.init = init_task_qinq_decap4,
+	.handle = handle_qinq_decap4_bulk,
+	.flag_features = TASK_FEATURE_ROUTING,
+	.flow_iter = {
+		.beg       = flow_iter_beg,
+		.is_end    = flow_iter_is_end,
+		.next      = flow_iter_next,
+		.get_svlan = flow_iter_get_svlan,
+		.get_cvlan = flow_iter_get_cvlan,
+	},
+	.size = sizeof(struct task_qinq_decap4)
+};
+
+__attribute__((constructor)) static void reg_task_qinq_decap4(void)
+{
+	reg_task(&task_init_qinq_decapv4_table);
+}
diff --git a/VNFs/DPPD-PROX/handle_qinq_decap4.h b/VNFs/DPPD-PROX/handle_qinq_decap4.h
new file mode 100644
index 00000000..ae2475d2
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_qinq_decap4.h
@@ -0,0 +1,34 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_QINQ_DECAP4_H_
+#define _HANDLE_QINQ_DECAP4_H_
+
+#include "hash_entry_types.h"
+
+struct rte_table_hash;
+
+struct arp_msg {
+	struct cpe_key key;
+	struct cpe_data data;
+};
+
+void arp_msg_to_str(char *str, struct arp_msg *msg);
+int str_to_arp_msg(struct arp_msg *msg, const char *str);
+
+void arp_update_from_msg(struct rte_table_hash * cpe_table, struct arp_msg **msgs, uint16_t n_msgs, uint64_t cpe_timeout);
+
+#endif /* _HANDLE_QINQ_DECAP4_H_ */
diff --git a/VNFs/DPPD-PROX/handle_qinq_decap6.c b/VNFs/DPPD-PROX/handle_qinq_decap6.c
new file mode 100644
index 00000000..d876c733
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_qinq_decap6.c
@@ -0,0 +1,197 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+#include <rte_table_hash.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+
+#include "handle_qinq_encap6.h"
+#include "log.h"
+#include "lconf.h"
+#include "task_init.h"
+#include "task_base.h"
+#include "tx_pkt.h"
+#include "defines.h"
+#include "pkt_prototypes.h"
+#include "prox_assert.h"
+#include "hash_utils.h"
+#include "task_base.h"
+#include "prefetch.h"
+#include "hash_entry_types.h"
+#include "prox_cfg.h"
+#include "log.h"
+#include "quit.h"
+#include "prox_shared.h"
+
+/* Packets must all be IPv6, always store QinQ tags for lookup (not configurable) */
+struct task_qinq_decap6 {
+	struct task_base                base;
+	struct rte_table_hash           *cpe_table;
+	uint16_t                        *user_table;
+	uint32_t                        bucket_index;
+	struct ether_addr 		edaddr;
+	struct rte_lpm6                 *rte_lpm6;
+	void*                           period_data; /* used if using dual stack*/
+	void (*period_func)(void* data);
+	uint64_t                        cpe_timeout;
+};
+
+void update_arp_entries6(void* data);
+
+static void init_task_qinq_decap6(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_qinq_decap6 *task = (struct task_qinq_decap6 *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->edaddr = targ->edaddr;
+	task->cpe_table = targ->cpe_table;
+	task->cpe_timeout = msec_to_tsc(targ->cpe_table_timeout_ms);
+
+	if (targ->cpe_table_timeout_ms) {
+		if (targ->lconf->period_func) {
+			task->period_func = targ->lconf->period_func;
+			task->period_data = targ->lconf->period_data;
+		}
+		targ->lconf->period_func = update_arp_entries6;
+		targ->lconf->period_data = tbase;
+		targ->lconf->period_timeout = msec_to_tsc(500) / NUM_VCPES;
+	}
+
+	task->user_table = prox_sh_find_socket(socket_id, "user_table");
+	if (!task->user_table) {
+		PROX_PANIC(!strcmp(targ->user_table, ""), "No user table defined\n");
+		int ret = lua_to_user_table(prox_lua(), GLOBAL, targ->user_table, socket_id, &task->user_table);
+		PROX_PANIC(ret, "Failed to create user table from config:\n%s\n", get_lua_to_errors());
+		prox_sh_add_socket(socket_id, "user_table", task->user_table);
+	}
+
+	struct lpm6 *lpm = prox_sh_find_socket(socket_id, "lpm6");
+	if (!lpm) {
+		struct lpm6 *lpm6;
+		int ret;
+
+		ret = lua_to_lpm6(prox_lua(), GLOBAL, "lpm6", socket_id, &lpm6);
+		PROX_PANIC(ret, "Failed to read lpm6 from config:\n%s\n", get_lua_to_errors());
+		prox_sh_add_socket(socket_id, "lpm6", lpm6);
+	}
+	task->rte_lpm6 = lpm->rte_lpm6;
+}
+
+static void early_init(struct task_args *targ)
+{
+	if (!targ->cpe_table) {
+		init_cpe6_table(targ);
+	}
+}
+
+static inline uint8_t handle_qinq_decap6(struct task_qinq_decap6 *task, struct rte_mbuf *mbuf)
+{
+	struct qinq_hdr *pqinq = rte_pktmbuf_mtod(mbuf, struct qinq_hdr *);
+	struct ipv6_hdr *pip6 = (struct ipv6_hdr *)(pqinq + 1);
+
+	uint16_t svlan = pqinq->svlan.vlan_tci & 0xFF0F;
+	uint16_t cvlan = pqinq->cvlan.vlan_tci & 0xFF0F;
+
+	struct cpe_data entry;
+	entry.mac_port_8bytes = *((uint64_t *)(((uint8_t *)pqinq) + 5)) << 16;
+	entry.qinq_svlan = svlan;
+	entry.qinq_cvlan = cvlan;
+	entry.user = task->user_table[PKT_TO_LUTQINQ(svlan, cvlan)];
+	entry.tsc = rte_rdtsc() + task->cpe_timeout;
+
+	int key_found = 0;
+	void* entry_in_hash = NULL;
+	int ret = rte_table_hash_ext_dosig_ops.
+		f_add(task->cpe_table, pip6->src_addr, &entry, &key_found, &entry_in_hash);
+
+	if (unlikely(ret)) {
+		plogx_err("Failed to add key " IPv6_BYTES_FMT "\n", IPv6_BYTES(pip6->src_addr));
+		return OUT_DISCARD;
+	}
+
+	pqinq = (struct qinq_hdr *)rte_pktmbuf_adj(mbuf, 2 * sizeof(struct vlan_hdr));
+	PROX_ASSERT(pqinq);
+	pqinq->ether_type = ETYPE_IPv6;
+	// Dest MAC addresses
+	ether_addr_copy(&task->edaddr, &pqinq->d_addr);
+	return 0;
+}
+
+static int handle_qinq_decap6_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_qinq_decap6 *task = (struct task_qinq_decap6 *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_qinq_decap6(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_qinq_decap6(task, mbufs[j]);
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+void update_arp_entries6(void* data)
+{
+	uint64_t cur_tsc = rte_rdtsc();
+	struct task_qinq_decap6 *task = (struct task_qinq_decap6 *)data;
+
+	struct cpe_data *entries[4] = {0};
+	void *key[4] = {0};
+	uint64_t n_buckets = get_bucket(task->cpe_table, task->bucket_index, key, (void**)entries);
+
+	for (uint8_t i = 0; i < 4 && entries[i]; ++i) {
+		if (entries[i]->tsc < cur_tsc) {
+			int key_found = 0;
+			void* entry = 0;
+			rte_table_hash_ext_dosig_ops.f_delete(task->cpe_table, key[i], &key_found, entry);
+		}
+	}
+
+	task->bucket_index++;
+	task->bucket_index &= (n_buckets - 1);
+
+	if (task->period_func) {
+		task->period_func(task->period_data);
+	}
+}
+
+static struct task_init task_init_qinq_decap6 = {
+	.mode = QINQ_DECAP6,
+	.mode_str = "qinqdecapv6",
+	.early_init = early_init,
+	.init = init_task_qinq_decap6,
+	.handle = handle_qinq_decap6_bulk,
+	.size = sizeof(struct task_qinq_decap6)
+};
+
+__attribute__((constructor)) static void reg_task_qinq_decap6(void)
+{
+	reg_task(&task_init_qinq_decap6);
+}
diff --git a/VNFs/DPPD-PROX/handle_qinq_encap4.c b/VNFs/DPPD-PROX/handle_qinq_encap4.c
new file mode 100644
index 00000000..24181959
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_qinq_encap4.c
@@ -0,0 +1,662 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_table_hash.h>
+#include <rte_cycles.h>
+
+#include "mbuf_utils.h"
+#include "prox_malloc.h"
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+#include "handle_qinq_encap4.h"
+#include "handle_qinq_decap4.h"
+#include "prox_args.h"
+#include "defines.h"
+#include "tx_pkt.h"
+#include "prefetch.h"
+#include "pkt_prototypes.h"
+#include "hash_entry_types.h"
+#include "task_init.h"
+#include "bng_pkts.h"
+#include "prox_cksum.h"
+#include "hash_utils.h"
+#include "quit.h"
+#include "prox_port_cfg.h"
+#include "handle_lb_net.h"
+#include "prox_cfg.h"
+#include "cfgfile.h"
+#include "toeplitz.h"
+#include "prox_shared.h"
+
+static struct cpe_table_data *read_cpe_table_config(const char *name, uint8_t socket)
+{
+	struct lua_State *L = prox_lua();
+	struct cpe_table_data *ret = NULL;
+
+	lua_getglobal(L, name);
+	PROX_PANIC(lua_isnil(L, -1), "Coudn't find cpe_table data\n");
+
+	return ret;
+}
+
+struct qinq_gre_map *get_qinq_gre_map(struct task_args *targ)
+{
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	struct qinq_gre_map *ret = prox_sh_find_socket(socket_id, "qinq_gre_map");
+
+	if (!ret) {
+		PROX_PANIC(!strcmp(targ->user_table, ""), "No user table defined\n");
+		int rv = lua_to_qinq_gre_map(prox_lua(), GLOBAL, targ->user_table, socket_id, &ret);
+		PROX_PANIC(rv, "Error reading mapping between qinq and gre from qinq_gre_map: \n%s\n",
+			   get_lua_to_errors());
+		prox_sh_add_socket(socket_id, "qinq_gre_map", ret);
+	}
+	return ret;
+}
+
+/* Encapsulate IPv4 packets in QinQ. QinQ tags are derived from gre_id. */
+int handle_qinq_encap4_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+static void arp_msg(struct task_base *tbase, void **data, uint16_t n_msgs);
+
+static void fill_table(struct task_args *targ, struct rte_table_hash *table)
+{
+	struct cpe_table_data *cpe_table_data;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	int ret = lua_to_cpe_table_data(prox_lua(), GLOBAL, targ->cpe_table_name, socket_id, &cpe_table_data);
+	const uint8_t n_slaves = targ->nb_slave_threads;
+	const uint8_t worker_id = targ->worker_thread_id;
+
+	for (uint32_t i = 0; i < cpe_table_data->n_entries; ++i) {
+		if (rte_bswap32(cpe_table_data->entries[i].ip) % n_slaves != worker_id) {
+			continue;
+		}
+		struct cpe_table_entry *entry = &cpe_table_data->entries[i];
+
+		uint32_t port_idx = prox_cfg.cpe_table_ports[entry->port_idx];
+		PROX_PANIC(targ->mapping[port_idx] == 255, "Error reading cpe table: Mapping for port %d is missing", port_idx);
+
+		struct cpe_key key = {
+			.ip = entry->ip,
+			.gre_id = entry->gre_id,
+		};
+
+		struct cpe_data data = {
+			.qinq_svlan = entry->svlan,
+			.qinq_cvlan = entry->cvlan,
+			.user = entry->user,
+			.mac_port = {
+				.mac = entry->eth_addr,
+				.out_idx = targ->mapping[port_idx],
+			},
+			.tsc = UINT64_MAX,
+		};
+
+		int key_found;
+		void* entry_in_hash;
+		rte_table_hash_key8_ext_dosig_ops.f_add(table, &key, &data, &key_found, &entry_in_hash);
+	}
+}
+
+static void init_task_qinq_encap4(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_qinq_encap4 *task = (struct task_qinq_encap4 *)(tbase);
+	int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+
+	task->qinq_tag = targ->qinq_tag;
+	task->cpe_table = targ->cpe_table;
+	task->cpe_timeout = msec_to_tsc(targ->cpe_table_timeout_ms);
+
+	if (!strcmp(targ->task_init->sub_mode_str, "pe")) {
+		PROX_PANIC(!strcmp(targ->cpe_table_name, ""), "CPE table not configured\n");
+		fill_table(targ, task->cpe_table);
+	}
+
+#ifdef ENABLE_EXTRA_USER_STATISTICS
+	task->n_users = targ->n_users;
+	task->stats_per_user = prox_zmalloc(targ->n_users * sizeof(uint32_t), socket_id);
+#endif
+	if (targ->runtime_flags & TASK_CLASSIFY) {
+		PROX_PANIC(!strcmp(targ->dscp, ""), "DSCP table not specified\n");
+		task->dscp = prox_sh_find_socket(socket_id, targ->dscp);
+		if (!task->dscp) {
+			int ret = lua_to_dscp(prox_lua(), GLOBAL, targ->dscp, socket_id, &task->dscp);
+			PROX_PANIC(ret, "Failed to create dscp table from config:\n%s\n",
+				   get_lua_to_errors());
+			prox_sh_add_socket(socket_id, targ->dscp, task->dscp);
+		}
+	}
+
+	task->runtime_flags = targ->runtime_flags;
+
+	for (uint32_t i = 0; i < 64; ++i) {
+		task->fake_packets[i] = (struct rte_mbuf*)((uint8_t*)&task->keys[i] - sizeof (struct rte_mbuf));
+	}
+
+	targ->lconf->ctrl_timeout = freq_to_tsc(targ->ctrl_freq);
+	targ->lconf->ctrl_func_m[targ->task] = arp_msg;
+
+	struct prox_port_cfg *port = find_reachable_port(targ);
+	if (port) {
+		task->offload_crc = port->capabilities.tx_offload_cksum;
+	}
+
+	/* TODO: check if it is not necessary to limit reverse mapping
+	   for the elements that have been changing in mapping? */
+
+	for (uint32_t i =0 ; i < sizeof(targ->mapping)/sizeof(targ->mapping[0]); ++i) {
+		task->src_mac[targ->mapping[i]] = *(uint64_t*)&prox_port_cfg[i].eth_addr;
+	}
+
+	/* task->src_mac[entry->port_idx] = *(uint64_t*)&prox_port_cfg[entry->port_idx].eth_addr; */
+}
+
+static void arp_msg(struct task_base *tbase, void **data, uint16_t n_msgs)
+{
+	struct task_qinq_encap4 *task = (struct task_qinq_encap4 *)tbase;
+	struct arp_msg **msgs = (struct arp_msg **)data;
+
+	arp_update_from_msg(task->cpe_table, msgs, n_msgs, task->cpe_timeout);
+}
+
+static inline void add_key(struct task_args *targ, struct qinq_gre_map *qinq_gre_map, struct rte_table_hash* qinq_gre_table, uint32_t i, uint32_t *count)
+{
+	struct qinq_gre_data entry = {
+		.gre_id = qinq_gre_map->entries[i].gre_id,
+		.user = qinq_gre_map->entries[i].user,
+	};
+
+#ifdef USE_QINQ
+	struct vlans qinq2 = {
+		.svlan = {.eth_proto = targ->qinq_tag, .vlan_tci = qinq_gre_map->entries[i].svlan},
+		.cvlan = {.eth_proto = ETYPE_VLAN,     .vlan_tci = qinq_gre_map->entries[i].cvlan}
+	};
+
+	int key_found = 0;
+	void* entry_in_hash = NULL;
+	rte_table_hash_key8_ext_dosig_ops.f_add(qinq_gre_table, &qinq2, &entry, &key_found, &entry_in_hash);
+
+	plog_dbg("Core %u adding user %u (tag %x svlan %x cvlan %x), rss=%x\n",
+		 targ->lconf->id, qinq_gre_map->entries[i].user, qinq2.svlan.eth_proto,
+		 rte_bswap16(qinq_gre_map->entries[i].svlan),
+		 rte_bswap16(qinq_gre_map->entries[i].cvlan),
+		 qinq_gre_map->entries[i].rss);
+#else
+	/* lower 3 bytes of IPv4 address contain svlan/cvlan. */
+	uint64_t ip = ((uint32_t)rte_bswap16(qinq_gre_map->entries[i].svlan) << 12) |
+		rte_bswap16(qinq_gre_map->entries[i].cvlan);
+	int key_found = 0;
+	void* entry_in_hash = NULL;
+	rte_table_hash_key8_ext_dosig_ops.f_add(qinq_gre_table, &ip, &entry, &key_found, &entry_in_hash);
+
+	plog_dbg("Core %u hash table add: key = %016"PRIx64"\n",
+		 targ->lconf->id, ip);
+#endif
+	(*count)++;
+}
+
+void init_qinq_gre_table(struct task_args *targ, struct qinq_gre_map *qinq_gre_map)
+{
+	struct rte_table_hash* qinq_gre_table;
+	uint8_t table_part = targ->nb_slave_threads;
+	if (!rte_is_power_of_2(table_part)) {
+		table_part = rte_align32pow2(table_part) >> 1;
+	}
+
+	if (table_part == 0)
+		table_part = 1;
+
+	uint32_t n_entries = MAX_GRE / table_part;
+
+	struct rte_table_hash_key8_ext_params table_hash_params = {
+		.n_entries = n_entries,
+		.n_entries_ext = n_entries >> 1,
+		.f_hash = hash_crc32,
+		.seed = 0,
+		.signature_offset = HASH_METADATA_OFFSET(8),
+		.key_offset = HASH_METADATA_OFFSET(0),
+	};
+
+	qinq_gre_table = rte_table_hash_key8_ext_dosig_ops.
+		f_create(&table_hash_params, rte_lcore_to_socket_id(targ->lconf->id), sizeof(struct qinq_gre_data));
+
+	// LB configuration known from Network Load Balancer
+	// Find LB network Load balancer, i.e. ENCAP friend.
+	for (uint8_t task_id = 0; task_id < targ->lconf->n_tasks_all; ++task_id) {
+		enum task_mode smode = targ->lconf->targs[task_id].mode;
+		if (QINQ_ENCAP4 == smode) {
+			targ->lb_friend_core =  targ->lconf->targs[task_id].lb_friend_core;
+			targ->lb_friend_task =  targ->lconf->targs[task_id].lb_friend_task;
+		}
+	}
+	// Packet coming from Load balancer. LB could balance on gre_id LSB, qinq hash or qinq RSS
+	uint32_t flag_features = 0;
+	if (targ->lb_friend_core != 0xFF) {
+		struct task_args *lb_targ = &lcore_cfg[targ->lb_friend_core].targs[targ->lb_friend_task];
+		flag_features = lb_targ->task_init->flag_features;
+		plog_info("\t\tWT %d Updated features to %x from friend %d\n", targ->lconf->id, flag_features, targ->lb_friend_core);
+	} else {
+		plog_info("\t\tWT %d has no friend\n", targ->lconf->id);
+	}
+	if (targ->nb_slave_threads == 0)  {
+		// No slave threads, i.e. using RSS
+		plog_info("feature was %x is now %x\n", flag_features, TASK_FEATURE_LUT_QINQ_RSS);
+		flag_features = TASK_FEATURE_LUT_QINQ_RSS;
+	}
+	if ((flag_features & (TASK_FEATURE_GRE_ID|TASK_FEATURE_LUT_QINQ_RSS|TASK_FEATURE_LUT_QINQ_HASH)) == 0) {
+		plog_info("\t\tCould not find flag feature from Load balancer => supposing TASK_FEATURE_GRE_ID\n");
+		flag_features = TASK_FEATURE_GRE_ID;
+	}
+
+	/* Only store QinQ <-> GRE mapping for packets that are handled by this worker thread */
+	uint32_t count = 0;
+	if (flag_features & TASK_FEATURE_LUT_QINQ_RSS) {
+		// If there is a load balancer, number of worker thread is indicated by targ->nb_slave_threads and n_rxq = 0
+		// If there is no load balancers, number of worker thread is indicated by n_rxq and nb_slave_threads = 0
+		uint8_t nb_worker_threads, worker_thread_id;
+		if (targ->nb_slave_threads) {
+			nb_worker_threads = targ->nb_slave_threads;
+			worker_thread_id = targ->worker_thread_id;
+		} else if (prox_port_cfg[targ->rx_port_queue[0].port].n_rxq) {
+			nb_worker_threads = prox_port_cfg[targ->rx_port_queue[0].port].n_rxq;
+			worker_thread_id = targ->rx_port_queue[0].queue;
+		} else {
+			PROX_PANIC(1, "Unexpected: unknown number of worker thread\n");
+		}
+		plog_info("\t\tUsing %d worker_threads id %d\n", nb_worker_threads, worker_thread_id);
+		for (uint32_t i = 0; i < qinq_gre_map->count; ++i) {
+			if (targ->nb_slave_threads == 0 || rss_to_queue(qinq_gre_map->entries[i].rss, nb_worker_threads) == worker_thread_id) {
+				add_key(targ, qinq_gre_map, qinq_gre_table, i, &count);
+				//plog_info("Queue %d adding key %16lx, svlan %x cvlan %x, rss=%x\n", targ->rx_queue, *(uint64_t *)q, qinq_to_gre_lookup[i].svlan,  qinq_to_gre_lookup[i].cvlan, qinq_to_gre_lookup[i].rss);
+			}
+		}
+		plog_info("\t\tAdded %d entries to worker thread %d\n", count,  worker_thread_id);
+	} else if (flag_features & TASK_FEATURE_LUT_QINQ_HASH) {
+		for (uint32_t i = 0; i < qinq_gre_map->count; ++i) {
+			uint64_t cvlan = rte_bswap16(qinq_gre_map->entries[i].cvlan & 0xFF0F);
+			uint64_t svlan = rte_bswap16((qinq_gre_map->entries[i].svlan & 0xFF0F));
+			uint64_t qinq = rte_bswap64((svlan << 32) | cvlan);
+			uint8_t queue = hash_crc32(&qinq, 8, 0) % targ->nb_slave_threads;
+			if (queue == targ->worker_thread_id) {
+				add_key(targ, qinq_gre_map, qinq_gre_table, i, &count);
+			}
+		}
+		plog_info("\t\tAdded %d entries to WT %d\n", count,  targ->worker_thread_id);
+	} else if (flag_features & TASK_FEATURE_GRE_ID) {
+		for (uint32_t i = 0; i < qinq_gre_map->count; ++i) {
+			if (qinq_gre_map->entries[i].gre_id % targ->nb_slave_threads == targ->worker_thread_id) {
+				add_key(targ, qinq_gre_map, qinq_gre_table, i, &count);
+			}
+		}
+	}
+
+	for (uint8_t task_id = 0; task_id < targ->lconf->n_tasks_all; ++task_id) {
+		enum task_mode smode = targ->lconf->targs[task_id].mode;
+		if (QINQ_DECAP4 == smode) {
+			targ->lconf->targs[task_id].qinq_gre_table = qinq_gre_table;
+		}
+
+	}
+}
+
+void init_cpe4_table(struct task_args *targ)
+{
+	char name[64];
+	sprintf(name, "core_%u_CPEv4Table", targ->lconf->id);
+
+	uint8_t table_part = targ->nb_slave_threads;
+	if (!rte_is_power_of_2(table_part)) {
+		table_part = rte_align32pow2(table_part) >> 1;
+	}
+
+	if (table_part == 0)
+		table_part = 1;
+
+	uint32_t n_entries = MAX_GRE / table_part;
+	struct rte_table_hash_key8_ext_params table_hash_params = {
+		.n_entries = n_entries,
+		.n_entries_ext = n_entries >> 1,
+		.f_hash = hash_crc32,
+		.seed = 0,
+		.signature_offset = HASH_METADATA_OFFSET(8),
+		.key_offset = HASH_METADATA_OFFSET(0),
+	};
+	size_t entry_size = sizeof(struct cpe_data);
+	if (!rte_is_power_of_2(entry_size)) {
+		entry_size = rte_align32pow2(entry_size);
+	}
+
+	struct rte_table_hash* phash = rte_table_hash_key8_ext_dosig_ops.
+		f_create(&table_hash_params, rte_lcore_to_socket_id(targ->lconf->id), entry_size);
+	PROX_PANIC(NULL == phash, "Unable to allocate memory for IPv4 hash table on core %u\n", targ->lconf->id);
+
+	/* for locality, copy the pointer to the port structure where it is needed at packet handling time */
+	for (uint8_t task_id = 0; task_id < targ->lconf->n_tasks_all; ++task_id) {
+		enum task_mode smode = targ->lconf->targs[task_id].mode;
+		if (QINQ_ENCAP4 == smode || QINQ_DECAP4 == smode) {
+			targ->lconf->targs[task_id].cpe_table = phash;
+		}
+	}
+}
+
+static void early_init_table(struct task_args* targ)
+{
+	if (!targ->cpe_table) {
+		init_cpe4_table(targ);
+	}
+}
+
+static inline void restore_cpe(struct cpe_pkt *packet, struct cpe_data *table, __attribute__((unused)) uint16_t qinq_tag, uint64_t *src_mac)
+{
+#ifdef USE_QINQ
+        struct qinq_hdr *pqinq = &packet->qinq_hdr;
+	rte_memcpy(pqinq, &qinq_proto, sizeof(struct qinq_hdr));
+	(*(uint64_t *)(&pqinq->d_addr)) = table->mac_port_8bytes;
+	/* set source as well now */
+	*((uint64_t *)(&pqinq->s_addr)) = *((uint64_t *)&src_mac[table->mac_port.out_idx]);
+	pqinq->svlan.vlan_tci = table->qinq_svlan;
+	pqinq->cvlan.vlan_tci = table->qinq_cvlan;
+	pqinq->svlan.eth_proto = qinq_tag;
+	pqinq->cvlan.eth_proto = ETYPE_VLAN;
+	pqinq->ether_type = ETYPE_IPv4;
+#else
+	(*(uint64_t *)(&packet->ether_hdr.d_addr)) = table->mac_port_8bytes;
+	/* set source as well now */
+	*((uint64_t *)(&packet->ether_hdr.s_addr)) = *((uint64_t *)&src_mac[table->mac_port.out_idx]);
+	packet->ether_hdr.ether_type = ETYPE_IPv4;
+
+	packet->ipv4_hdr.dst_addr = rte_bswap32(10 << 24 | rte_bswap16(table->qinq_svlan) << 12 | rte_bswap16(table->qinq_cvlan));
+#endif
+}
+
+static inline uint8_t handle_qinq_encap4(struct task_qinq_encap4 *task, struct cpe_pkt *cpe_pkt, struct rte_mbuf *mbuf, struct cpe_data *entry);
+
+/* Same functionality as handle_qinq_encap_v4_bulk but untag MPLS as well. */
+static int handle_qinq_encap4_untag_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_qinq_encap4 *task = (struct task_qinq_encap4 *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	prefetch_pkts(mbufs, n_pkts);
+
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		if (likely(mpls_untag(mbufs[j]))) {
+			struct cpe_pkt* cpe_pkt = (struct cpe_pkt*) rte_pktmbuf_adj(mbufs[j], UPSTREAM_DELTA);
+			out[j] = handle_qinq_encap4(task, cpe_pkt, mbufs[j], NULL);
+		}
+		else {
+			out[j] = OUT_DISCARD;
+		}
+	}
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static inline void extract_key_bulk(struct task_qinq_encap4 *task, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		extract_key_core(mbufs[j], &task->keys[j]);
+	}
+}
+
+__attribute__((cold)) static void handle_error(struct rte_mbuf *mbuf)
+{
+	struct core_net_pkt* core_pkt = rte_pktmbuf_mtod(mbuf, struct core_net_pkt *);
+	uint32_t dst_ip = core_pkt->ip_hdr.dst_addr;
+	uint32_t le_gre_id = rte_be_to_cpu_32(core_pkt->gre_hdr.gre_id);
+
+	plogx_dbg("Unknown IP %x/gre_id %x\n", dst_ip, le_gre_id);
+}
+
+static int handle_qinq_encap4_bulk_pe(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_qinq_encap4 *task = (struct task_qinq_encap4 *)tbase;
+	uint64_t pkts_mask = RTE_LEN2MASK(n_pkts, uint64_t);
+	struct cpe_data* entries[64];
+	uint8_t out[MAX_PKT_BURST];
+	uint64_t lookup_hit_mask;
+
+	prefetch_pkts(mbufs, n_pkts);
+
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		struct ipv4_hdr* ip = (struct ipv4_hdr *)(rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *) + 1);
+		task->keys[j] = (uint64_t)ip->dst_addr;
+	}
+	rte_table_hash_key8_ext_dosig_ops.f_lookup(task->cpe_table, task->fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
+
+	if (likely(lookup_hit_mask == pkts_mask)) {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			struct cpe_pkt* cpe_pkt = (struct cpe_pkt*) rte_pktmbuf_prepend(mbufs[j], sizeof(struct qinq_hdr) - sizeof(struct ether_hdr));
+			uint16_t padlen = mbuf_calc_padlen(mbufs[j], cpe_pkt, &cpe_pkt->ipv4_hdr);
+
+			if (padlen) {
+				rte_pktmbuf_trim(mbufs[j], padlen);
+			}
+			out[j] = handle_qinq_encap4(task, cpe_pkt, mbufs[j], entries[j]);
+		}
+	}
+	else {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			if (unlikely(!((lookup_hit_mask >> j) & 0x1))) {
+				handle_error(mbufs[j]);
+				out[j] = OUT_DISCARD;
+				continue;
+			}
+			struct cpe_pkt* cpe_pkt = (struct cpe_pkt*) rte_pktmbuf_prepend(mbufs[j], sizeof(struct qinq_hdr) - sizeof(struct ether_hdr));
+			uint16_t padlen = mbuf_calc_padlen(mbufs[j], cpe_pkt, &cpe_pkt->ipv4_hdr);
+
+			if (padlen) {
+				rte_pktmbuf_trim(mbufs[j], padlen);
+			}
+			out[j] = handle_qinq_encap4(task, cpe_pkt, mbufs[j], entries[j]);
+		}
+	}
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+int handle_qinq_encap4_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_qinq_encap4 *task = (struct task_qinq_encap4 *)tbase;
+	uint64_t pkts_mask = RTE_LEN2MASK(n_pkts, uint64_t);
+	struct cpe_data* entries[64];
+	uint8_t out[MAX_PKT_BURST];
+	uint64_t lookup_hit_mask;
+
+	prefetch_pkts(mbufs, n_pkts);
+
+	// From GRE ID and IP address, retrieve QinQ and MAC addresses
+	extract_key_bulk(task, mbufs, n_pkts);
+	rte_table_hash_key8_ext_dosig_ops.f_lookup(task->cpe_table, task->fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
+
+	if (likely(lookup_hit_mask == pkts_mask)) {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			struct cpe_pkt* cpe_pkt = (struct cpe_pkt*) rte_pktmbuf_adj(mbufs[j], UPSTREAM_DELTA);
+			// We are receiving GRE tunnelled packets (and removing UPSTRAM_DELTA bytes), whose length is > 64 bytes
+			// So there should be no padding, but in case the is one, remove it
+			uint16_t padlen = mbuf_calc_padlen(mbufs[j], cpe_pkt, &cpe_pkt->ipv4_hdr);
+
+			if (padlen) {
+				rte_pktmbuf_trim(mbufs[j], padlen);
+			}
+			out[j] = handle_qinq_encap4(task, cpe_pkt, mbufs[j], entries[j]);
+		}
+	}
+	else {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			if (unlikely(!((lookup_hit_mask >> j) & 0x1))) {
+				handle_error(mbufs[j]);
+				out[j] = OUT_DISCARD;
+				continue;
+			}
+			struct cpe_pkt* cpe_pkt = (struct cpe_pkt*) rte_pktmbuf_adj(mbufs[j], UPSTREAM_DELTA);
+			uint16_t padlen = mbuf_calc_padlen(mbufs[j], cpe_pkt, &cpe_pkt->ipv4_hdr);
+
+			if (padlen) {
+				rte_pktmbuf_trim(mbufs[j], padlen);
+			}
+			out[j] = handle_qinq_encap4(task, cpe_pkt, mbufs[j], entries[j]);
+		}
+	}
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static inline uint8_t handle_qinq_encap4(struct task_qinq_encap4 *task, struct cpe_pkt *cpe_pkt, struct rte_mbuf *mbuf, struct cpe_data *entry)
+{
+	PROX_ASSERT(cpe_pkt);
+
+	if (cpe_pkt->ipv4_hdr.time_to_live) {
+		cpe_pkt->ipv4_hdr.time_to_live--;
+	}
+	else {
+		plog_info("TTL = 0 => Dropping\n");
+		return OUT_DISCARD;
+	}
+	cpe_pkt->ipv4_hdr.hdr_checksum = 0;
+
+	restore_cpe(cpe_pkt, entry, task->qinq_tag, task->src_mac);
+
+	if (task->runtime_flags & TASK_CLASSIFY) {
+		uint8_t queue = task->dscp[cpe_pkt->ipv4_hdr.type_of_service >> 2] & 0x3;
+		uint8_t tc = task->dscp[cpe_pkt->ipv4_hdr.type_of_service >> 2] >> 2;
+
+		rte_sched_port_pkt_write(mbuf, 0, entry->user, tc, queue, 0);
+	}
+#ifdef ENABLE_EXTRA_USER_STATISTICS
+	task->stats_per_user[entry->user]++;
+#endif
+	if (task->runtime_flags & TASK_TX_CRC) {
+		prox_ip_cksum(mbuf, &cpe_pkt->ipv4_hdr, sizeof(struct qinq_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+	}
+	return entry->mac_port.out_idx;
+}
+
+static void flow_iter_next(struct flow_iter *iter, struct task_args *targ)
+{
+	do {
+		iter->idx++;
+		uint8_t flag_features = iter->data;
+
+		if (flag_features & TASK_FEATURE_LUT_QINQ_RSS) {
+			// If there is a load balancer, number of worker thread is indicated by targ->nb_slave_threads and n_rxq = 0
+			// If there is no load balancers, number of worker thread is indicated by n_rxq and nb_slave_threads = 0
+			uint8_t nb_worker_threads, worker_thread_id;
+			nb_worker_threads = 1;
+			worker_thread_id = 1;
+			if (targ->nb_slave_threads) {
+				nb_worker_threads = targ->nb_slave_threads;
+				worker_thread_id = targ->worker_thread_id;
+			} else if (prox_port_cfg[targ->rx_port_queue[0].port].n_rxq) {
+				nb_worker_threads = prox_port_cfg[targ->rx_port_queue[0].port].n_rxq;
+				worker_thread_id = targ->rx_port_queue[0].queue;
+			} else {
+				plog_err("Unexpected: unknown number of worker thread\n");
+			}
+
+			if (targ->nb_slave_threads == 0 || rss_to_queue(get_qinq_gre_map(targ)->entries[iter->idx].rss, nb_worker_threads) == worker_thread_id)
+				break;
+		} else if (flag_features & TASK_FEATURE_LUT_QINQ_HASH) {
+			uint64_t cvlan = rte_bswap16(get_qinq_gre_map(targ)->entries[iter->idx].cvlan & 0xFF0F);
+			uint64_t svlan = rte_bswap16(get_qinq_gre_map(targ)->entries[iter->idx].svlan & 0xFF0F);
+			uint64_t qinq = rte_bswap64((svlan << 32) | cvlan);
+			uint8_t queue = hash_crc32(&qinq, 8, 0) % targ->nb_slave_threads;
+			if (queue == targ->worker_thread_id)
+				break;
+		} else if (flag_features & TASK_FEATURE_GRE_ID) {
+			if (get_qinq_gre_map(targ)->entries[iter->idx].gre_id % targ->nb_slave_threads == targ->worker_thread_id)
+				break;
+		}
+	} while (iter->idx != (int)get_qinq_gre_map(targ)->count);
+}
+
+static void flow_iter_beg(struct flow_iter *iter, struct task_args *targ)
+{
+	uint32_t flag_features = 0;
+	if (targ->lb_friend_core != 0xFF) {
+		struct task_args *lb_targ = &lcore_cfg[targ->lb_friend_core].targs[targ->lb_friend_task];
+		flag_features = lb_targ->task_init->flag_features;
+		plog_info("\t\tWT %d Updated features to %x from friend %d\n", targ->lconf->id, flag_features, targ->lb_friend_core);
+	} else {
+		plog_info("\t\tWT %d has no friend\n", targ->lconf->id);
+	}
+	if (targ->nb_slave_threads == 0)  {
+		// No slave threads, i.e. using RSS
+		plog_info("feature was %x is now %x\n", flag_features, TASK_FEATURE_LUT_QINQ_RSS);
+		flag_features = TASK_FEATURE_LUT_QINQ_RSS;
+	}
+	if ((flag_features & (TASK_FEATURE_GRE_ID|TASK_FEATURE_LUT_QINQ_RSS|TASK_FEATURE_LUT_QINQ_HASH)) == 0) {
+		plog_info("\t\tCould not find flag feature from Load balancer => supposing TASK_FEATURE_GRE_ID\n");
+		flag_features = TASK_FEATURE_GRE_ID;
+	}
+
+	iter->idx = -1;
+	flow_iter_next(iter, targ);
+}
+
+static int flow_iter_is_end(struct flow_iter *iter, struct task_args *targ)
+{
+	return iter->idx == (int)get_qinq_gre_map(targ)->count;
+}
+
+static uint32_t flow_iter_get_gre_id(struct flow_iter *iter, struct task_args *targ)
+{
+	return get_qinq_gre_map(targ)->entries[iter->idx].gre_id;
+}
+
+static struct task_init task_init_qinq_encap4_table = {
+	.mode = QINQ_ENCAP4,
+	.mode_str = "qinqencapv4",
+	.early_init = early_init_table,
+	.init = init_task_qinq_encap4,
+	.handle = handle_qinq_encap4_bulk,
+	/* In this case user in qinq_lookup table is the QoS user
+	   (from user_table), i.e. usually from 0 to 32K Otherwise it
+	   would have been a user from (0 to n_interface x 32K) */
+	.flow_iter = {
+		.beg        = flow_iter_beg,
+		.is_end     = flow_iter_is_end,
+		.next       = flow_iter_next,
+		.get_gre_id = flow_iter_get_gre_id,
+	},
+	.flag_features = TASK_FEATURE_CLASSIFY,
+	.size = sizeof(struct task_qinq_encap4)
+};
+
+static struct task_init task_init_qinq_encap4_table_pe = {
+	.mode = QINQ_ENCAP4,
+	.mode_str = "qinqencapv4",
+	.sub_mode_str = "pe",
+	.early_init = early_init_table,
+	.init = init_task_qinq_encap4,
+	.handle = handle_qinq_encap4_bulk_pe,
+	.flag_features = TASK_FEATURE_CLASSIFY,
+	.size = sizeof(struct task_qinq_encap4)
+};
+
+static struct task_init task_init_qinq_encap4_untag = {
+	.mode = QINQ_ENCAP4,
+	.sub_mode_str = "unmpls",
+	.mode_str = "qinqencapv4",
+	.init = init_task_qinq_encap4,
+	.handle = handle_qinq_encap4_untag_bulk,
+	.flag_features = TASK_FEATURE_CLASSIFY,
+	.size = sizeof(struct task_qinq_encap4)
+};
+
+__attribute__((constructor)) static void reg_task_qinq_encap4(void)
+{
+	reg_task(&task_init_qinq_encap4_table);
+	reg_task(&task_init_qinq_encap4_table_pe);
+	reg_task(&task_init_qinq_encap4_untag);
+}
diff --git a/VNFs/DPPD-PROX/handle_qinq_encap4.h b/VNFs/DPPD-PROX/handle_qinq_encap4.h
new file mode 100644
index 00000000..639135e0
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_qinq_encap4.h
@@ -0,0 +1,103 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_QINQ_ENCAP4_H_
+#define _HANDLE_QINQ_ENCAP4_H_
+
+#include <rte_ip.h>
+#include <rte_ether.h>
+
+#include "log.h"
+#include "prox_assert.h"
+#include "etypes.h"
+#include "mpls.h"
+#include "task_init.h"
+
+struct task_qinq_encap4 {
+        struct task_base base;
+        struct rte_table_hash  *cpe_table;
+	uint16_t         qinq_tag;
+	uint64_t         src_mac[PROX_MAX_PORTS];
+	int              offload_crc;
+        uint8_t          runtime_flags;
+        uint8_t          *dscp;
+        uint64_t         keys[64];
+        struct rte_mbuf* fake_packets[64];
+        uint64_t         cpe_timeout;
+#ifdef ENABLE_EXTRA_USER_STATISTICS
+        uint32_t        *stats_per_user;
+	uint32_t 	n_users;
+#endif
+};
+
+struct qinq_gre_entry {
+	uint16_t svlan;
+	uint16_t cvlan;
+	uint32_t gre_id;
+	uint32_t user;
+	uint32_t rss; // RSS based on Toeplitz_hash(svlan and cvlan)
+};
+
+struct qinq_gre_map {
+	uint32_t              count;
+	struct qinq_gre_entry entries[0];
+};
+
+struct qinq_gre_map *get_qinq_gre_map(struct task_args *targ);
+
+struct task_args;
+struct prox_shared;
+
+void init_qinq_gre_table(struct task_args *targ, struct qinq_gre_map *qinq_gre_map);
+void init_qinq_gre_hash(struct task_args *targ, struct qinq_gre_map *qinq_gre_map);
+void init_cpe4_table(struct task_args *targ);
+void init_cpe4_hash(struct task_args *targ);
+
+static inline uint8_t mpls_untag(struct rte_mbuf *mbuf)
+{
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	const uint16_t eth_type = peth->ether_type;
+
+	if (eth_type == ETYPE_MPLSU) {
+		struct ether_hdr *pneweth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
+		const struct mpls_hdr *mpls = (const struct mpls_hdr *)(peth + 1);
+
+		if (mpls->bos == 0) {
+			// Double MPLS tag
+			pneweth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
+			PROX_ASSERT(pneweth);
+		}
+
+		const struct ipv4_hdr *pip = (const struct ipv4_hdr *)(pneweth + 1);
+		if ((pip->version_ihl >> 4) == 4) {
+			pneweth->ether_type = ETYPE_IPv4;
+			return 1;
+		}
+		else if ((pip->version_ihl >> 4) == 6) {
+			pneweth->ether_type = ETYPE_IPv6;
+			return 1;
+		}
+
+		plog_info("Error removing MPLS: unexpected IP version: %d\n", pip->version_ihl >> 4);
+		return 0;
+	}
+	if (eth_type != ETYPE_LLDP) {
+		plog_info("Error Removing MPLS: ether_type = %#06x\n", eth_type);
+	}
+	return 0;
+}
+
+#endif /* _HANDLE_QINQ_ENCAP4_H_ */
diff --git a/VNFs/DPPD-PROX/handle_qinq_encap6.c b/VNFs/DPPD-PROX/handle_qinq_encap6.c
new file mode 100644
index 00000000..e5b774da
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_qinq_encap6.c
@@ -0,0 +1,224 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_table_hash.h>
+
+#include "handle_qinq_encap6.h"
+#include "handle_qinq_encap4.h"
+#include "task_base.h"
+#include "qinq.h"
+#include "defines.h"
+#include "tx_pkt.h"
+#include "hash_entry_types.h"
+#include "prefetch.h"
+#include "log.h"
+#include "lconf.h"
+#include "mpls.h"
+#include "hash_utils.h"
+#include "quit.h"
+
+struct task_qinq_encap6 {
+	struct task_base                    base;
+	uint16_t                            qinq_tag;
+	uint8_t				    tx_portid;
+	uint8_t                             runtime_flags;
+	struct rte_table_hash               *cpe_table;
+};
+
+static void init_task_qinq_encap6(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_qinq_encap6 *task = (struct task_qinq_encap6 *)tbase;
+
+	task->qinq_tag = targ->qinq_tag;
+	task->cpe_table = targ->cpe_table;
+	task->runtime_flags = targ->runtime_flags;
+}
+
+/* Encapsulate IPv6 packet in QinQ where the QinQ is derived from the IPv6 address */
+static inline uint8_t handle_qinq_encap6(struct rte_mbuf *mbuf, struct task_qinq_encap6 *task)
+{
+	struct qinq_hdr *pqinq = (struct qinq_hdr *)rte_pktmbuf_prepend(mbuf, 2 * sizeof(struct vlan_hdr));
+
+	PROX_ASSERT(pqinq);
+	struct ipv6_hdr *pip6 = (struct ipv6_hdr *)(pqinq + 1);
+
+	if (pip6->hop_limits) {
+		pip6->hop_limits--;
+	}
+	else {
+		plog_info("TTL = 0 => Dropping\n");
+		return OUT_DISCARD;
+	}
+
+	// TODO: optimize to use bulk as intended with the rte_table_library
+	uint64_t pkts_mask = RTE_LEN2MASK(1, uint64_t);
+	uint64_t lookup_hit_mask;
+	struct cpe_data* entries[64]; // TODO: use bulk size
+	rte_table_hash_ext_dosig_ops.f_lookup(task->cpe_table, &mbuf, pkts_mask, &lookup_hit_mask, (void**)entries);
+
+	if (lookup_hit_mask == 0x1) {
+		/* will also overwrite part of the destination addr */
+		(*(uint64_t *)pqinq) = entries[0]->mac_port_8bytes;
+		pqinq->svlan.eth_proto = task->qinq_tag;
+		pqinq->cvlan.eth_proto = ETYPE_VLAN;
+		pqinq->svlan.vlan_tci = entries[0]->qinq_svlan;
+		pqinq->cvlan.vlan_tci = entries[0]->qinq_cvlan;
+		pqinq->ether_type = ETYPE_IPv6;
+
+		/* classification can only be done from this point */
+		if (task->runtime_flags & TASK_CLASSIFY) {
+			rte_sched_port_pkt_write(mbuf, 0, entries[0]->user, 0, 0, 0);
+		}
+		return 0;
+	}
+	else {
+		plogx_err("Unknown IP " IPv6_BYTES_FMT "\n", IPv6_BYTES(pip6->dst_addr));
+		return OUT_DISCARD;
+	}
+}
+
+void init_cpe6_table(struct task_args *targ)
+{
+	char name[64];
+	sprintf(name, "core_%u_CPEv6Table", targ->lconf->id);
+
+	uint8_t table_part = targ->nb_slave_threads;
+	if (!rte_is_power_of_2(table_part)) {
+		table_part = rte_align32pow2(table_part) >> 1;
+	}
+
+	uint32_t n_entries = MAX_GRE / table_part;
+	struct rte_table_hash_ext_params table_hash_params = {
+		.key_size = sizeof(struct ipv6_addr),
+		.n_keys = n_entries,
+		.n_buckets = n_entries >> 2,
+		.n_buckets_ext = n_entries >> 3,
+		.f_hash = hash_crc32,
+		.seed = 0,
+		.signature_offset = HASH_METADATA_OFFSET(0),
+		.key_offset = HASH_METADATA_OFFSET(0),
+	};
+
+	size_t entry_size = sizeof(struct cpe_data);
+	if (!rte_is_power_of_2(entry_size)) {
+		entry_size = rte_align32pow2(entry_size);
+	}
+
+	struct rte_table_hash* phash = rte_table_hash_ext_dosig_ops.
+		f_create(&table_hash_params, rte_lcore_to_socket_id(targ->lconf->id), entry_size);
+	PROX_PANIC(phash == NULL, "Unable to allocate memory for IPv6 hash table on core %u\n", targ->lconf->id);
+
+	for (uint8_t task_id = 0; task_id < targ->lconf->n_tasks_all; ++task_id) {
+		enum task_mode smode = targ->lconf->targs[task_id].mode;
+		if (smode == QINQ_DECAP6 || smode == QINQ_ENCAP6) {
+			targ->lconf->targs[task_id].cpe_table = phash;
+		}
+	}
+}
+
+static void early_init(struct task_args *targ)
+{
+	if (!targ->cpe_table) {
+		init_cpe6_table(targ);
+	}
+}
+
+static int handle_qinq_encap6_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_qinq_encap6 *task = (struct task_qinq_encap6 *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+        prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_qinq_encap6(mbufs[j], task);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_qinq_encap6(mbufs[j], task);
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static int handle_qinq_encap6_untag_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_qinq_encap6 *task = (struct task_qinq_encap6 *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		if (likely(mpls_untag(mbufs[j]))) {
+			out[j] = handle_qinq_encap6(mbufs[j], task);
+		}
+		else {
+			out[j] = OUT_DISCARD;
+		}
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		if (likely(mpls_untag(mbufs[j]))) {
+			out[j] = handle_qinq_encap6(mbufs[j], task);
+		}
+		else {
+			out[j] = OUT_DISCARD;
+		}
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static struct task_init task_init_qinq_encap6 = {
+	.mode = QINQ_ENCAP6,
+	.mode_str = "qinqencapv6",
+	.init = init_task_qinq_encap6,
+	.early_init = early_init,
+	.handle = handle_qinq_encap6_bulk,
+	.flag_features = TASK_FEATURE_CLASSIFY,
+	.size = sizeof(struct task_qinq_encap6)
+};
+
+static struct task_init task_init_qinq_encap6_untag = {
+	.mode = QINQ_ENCAP6,
+	.mode_str = "qinqencapv6",
+	.sub_mode_str = "unmpls",
+	.early_init = early_init,
+	.init = init_task_qinq_encap6,
+	.handle = handle_qinq_encap6_untag_bulk,
+	.flag_features = TASK_FEATURE_CLASSIFY,
+	.size = sizeof(struct task_qinq_encap6)
+};
+
+__attribute__((constructor)) static void reg_task_qinq_encap6(void)
+{
+	reg_task(&task_init_qinq_encap6);
+	reg_task(&task_init_qinq_encap6_untag);
+}
diff --git a/VNFs/DPPD-PROX/handle_qinq_encap6.h b/VNFs/DPPD-PROX/handle_qinq_encap6.h
new file mode 100644
index 00000000..1f72b53c
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_qinq_encap6.h
@@ -0,0 +1,24 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_QINQ_ENCAP6_H_
+#define _HANDLE_QINQ_ENCAP6_H_
+
+struct task_args;
+
+void init_cpe6_table(struct task_args *targ);
+
+#endif /* _HANDLE_QINQ_ENCAP6_H_ */
diff --git a/VNFs/DPPD-PROX/handle_qos.c b/VNFs/DPPD-PROX/handle_qos.c
new file mode 100644
index 00000000..eef64796
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_qos.c
@@ -0,0 +1,179 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ip.h>
+#include <rte_mbuf.h>
+#include <rte_sched.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+
+#include "etypes.h"
+#include "stats.h"
+#include "task_init.h"
+#include "lconf.h"
+#include "task_base.h"
+#include "defines.h"
+#include "prefetch.h"
+#include "handle_qos.h"
+#include "log.h"
+#include "quit.h"
+#include "qinq.h"
+#include "prox_cfg.h"
+#include "prox_shared.h"
+
+struct task_qos {
+	struct task_base base;
+	struct rte_sched_port *sched_port;
+	uint16_t *user_table;
+	uint8_t  *dscp;
+	uint32_t nb_buffered_pkts;
+	uint8_t runtime_flags;
+};
+
+uint32_t task_qos_n_pkts_buffered(struct task_base *tbase)
+{
+	struct task_qos *task = (struct task_qos *)tbase;
+
+	return task->nb_buffered_pkts;
+}
+
+static inline int handle_qos_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_qos *task = (struct task_qos *)tbase;
+	int ret = 0;
+
+	if (n_pkts) {
+		if (task->runtime_flags & TASK_CLASSIFY) {
+			uint16_t j;
+#ifdef PROX_PREFETCH_OFFSET
+			for (j = 0; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+				prefetch_nta(mbufs[j]);
+			}
+			for (j = 1; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+				prefetch_nta(rte_pktmbuf_mtod(mbufs[j - 1], void *));
+			}
+#endif
+			uint8_t queue = 0;
+			uint8_t tc = 0;
+			for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+				prefetch_nta(mbufs[j + PREFETCH_OFFSET]);
+				prefetch_nta(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+				const struct qinq_hdr *pqinq = rte_pktmbuf_mtod(mbufs[j], const struct qinq_hdr *);
+				uint32_t qinq = PKT_TO_LUTQINQ(pqinq->svlan.vlan_tci, pqinq->cvlan.vlan_tci);
+				if (pqinq->ether_type == ETYPE_IPv4) {
+					const struct ipv4_hdr *ipv4_hdr = (const struct ipv4_hdr *)(pqinq + 1);
+					queue = task->dscp[ipv4_hdr->type_of_service >> 2] & 0x3;
+					tc = task->dscp[ipv4_hdr->type_of_service >> 2] >> 2;
+				} else {
+					// Keep queue and tc = 0 for other packet types like ARP
+					queue = 0;
+					tc = 0;
+				}
+
+				rte_sched_port_pkt_write(mbufs[j], 0, task->user_table[qinq], tc, queue, 0);
+			}
+#ifdef PROX_PREFETCH_OFFSET
+			prefetch_nta(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+			for (; j < n_pkts; ++j) {
+				const struct qinq_hdr *pqinq = rte_pktmbuf_mtod(mbufs[j], const struct qinq_hdr *);
+				uint32_t qinq = PKT_TO_LUTQINQ(pqinq->svlan.vlan_tci, pqinq->cvlan.vlan_tci);
+				if (pqinq->ether_type == ETYPE_IPv4) {
+					const struct ipv4_hdr *ipv4_hdr = (const struct ipv4_hdr *)(pqinq + 1);
+					queue = task->dscp[ipv4_hdr->type_of_service >> 2] & 0x3;
+					tc = task->dscp[ipv4_hdr->type_of_service >> 2] >> 2;
+				} else {
+					// Keep queue and tc = 0 for other packet types like ARP
+					queue = 0;
+					tc = 0;
+				}
+
+				rte_sched_port_pkt_write(mbufs[j], 0, task->user_table[qinq], tc, queue, 0);
+			}
+#endif
+		}
+		int16_t ret = rte_sched_port_enqueue(task->sched_port, mbufs, n_pkts);
+		task->nb_buffered_pkts += ret;
+		TASK_STATS_ADD_IDLE(&task->base.aux->stats, n_pkts - ret);
+	}
+
+	if (task->nb_buffered_pkts) {
+		n_pkts = rte_sched_port_dequeue(task->sched_port, mbufs, 32);
+		if (likely(n_pkts)) {
+			task->nb_buffered_pkts -= n_pkts;
+			ret = task->base.tx_pkt(&task->base, mbufs, n_pkts, NULL);
+		}
+	}
+	return ret;
+}
+
+static void init_task_qos(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_qos *task = (struct task_qos *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	char name[64];
+
+	snprintf(name, sizeof(name), "qos_sched_port_%u_%u", targ->lconf->id, 0);
+
+	targ->qos_conf.port_params.name = name;
+	targ->qos_conf.port_params.socket = socket_id;
+	task->sched_port = rte_sched_port_config(&targ->qos_conf.port_params);
+
+	PROX_PANIC(task->sched_port == NULL, "failed to create sched_port");
+
+	plog_info("number of pipes: %d\n\n", targ->qos_conf.port_params.n_pipes_per_subport);
+	int err = rte_sched_subport_config(task->sched_port, 0, targ->qos_conf.subport_params);
+	PROX_PANIC(err != 0, "Failed setting up sched_port subport, error: %d", err);
+
+	/* only single subport and single pipe profile is supported */
+	for (uint32_t pipe = 0; pipe < targ->qos_conf.port_params.n_pipes_per_subport; ++pipe) {
+		err = rte_sched_pipe_config(task->sched_port, 0 , pipe, 0);
+		PROX_PANIC(err != 0, "failed setting up sched port pipe, error: %d", err);
+	}
+
+	task->runtime_flags = targ->runtime_flags;
+
+	task->user_table = prox_sh_find_socket(socket_id, "user_table");
+	if (!task->user_table) {
+		PROX_PANIC(!strcmp(targ->user_table, ""), "No user table defined\n");
+		int ret = lua_to_user_table(prox_lua(), GLOBAL, targ->user_table, socket_id, &task->user_table);
+		PROX_PANIC(ret, "Failed to create user table from config:\n%s\n", get_lua_to_errors());
+		prox_sh_add_socket(socket_id, "user_table", task->user_table);
+	}
+
+	if (task->runtime_flags & TASK_CLASSIFY) {
+		PROX_PANIC(!strcmp(targ->dscp, ""), "DSCP table not specified\n");
+		task->dscp = prox_sh_find_socket(socket_id, targ->dscp);
+		if (!task->dscp) {
+			int ret = lua_to_dscp(prox_lua(), GLOBAL, targ->dscp, socket_id, &task->dscp);
+			PROX_PANIC(ret, "Failed to create dscp table from config:\n%s\n", get_lua_to_errors());
+			prox_sh_add_socket(socket_id, targ->dscp, task->dscp);
+		}
+	}
+}
+
+static struct task_init task_init_qos = {
+	.mode_str = "qos",
+	.init = init_task_qos,
+	.handle = handle_qos_bulk,
+	.flag_features = TASK_FEATURE_CLASSIFY | TASK_FEATURE_NEVER_DISCARDS | TASK_FEATURE_MULTI_RX | TASK_FEATURE_ZERO_RX,
+	.size = sizeof(struct task_qos)
+};
+
+__attribute__((constructor)) static void reg_task_qos(void)
+{
+	reg_task(&task_init_qos);
+}
diff --git a/VNFs/DPPD-PROX/handle_qos.h b/VNFs/DPPD-PROX/handle_qos.h
new file mode 100644
index 00000000..0fabe9b8
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_qos.h
@@ -0,0 +1,26 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_QOS_H_
+#define _HANDLE_QOS_H_
+
+#include <inttypes.h>
+
+struct task_base;
+
+uint32_t task_qos_n_pkts_buffered(struct task_base *tbase);
+
+#endif /* _HANDLE_QOS_H_ */
diff --git a/VNFs/DPPD-PROX/handle_read.c b/VNFs/DPPD-PROX/handle_read.c
new file mode 100644
index 00000000..9a06a2b1
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_read.c
@@ -0,0 +1,78 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ip.h>
+
+#include "task_base.h"
+#include "task_init.h"
+#include "defines.h"
+#include "prefetch.h"
+#include "log.h"
+
+struct task_read {
+	struct task_base    base;
+};
+
+static int handle_read_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_read *task = (struct task_read *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+	uint64_t *first;
+
+#ifdef PROX_PREFETCH_OFFSET
+	for (j = 0; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		PREFETCH0(mbufs[j]);
+	}
+	for (j = 1; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j - 1], void *));
+	}
+#endif
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		first = rte_pktmbuf_mtod(mbufs[j], uint64_t *);
+		out[j] = *first != 0? 0: OUT_DISCARD;
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	prefetch_nta(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		first = rte_pktmbuf_mtod(mbufs[j], uint64_t *);
+		out[j] = *first != 0? 0: OUT_DISCARD;
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static void init_task_read(__attribute__((unused)) struct task_base *tbase,
+			   __attribute__((unused)) struct task_args *targ)
+{
+}
+
+static struct task_init task_init_read = {
+	.mode_str = "read",
+	.init = init_task_read,
+	.handle = handle_read_bulk,
+	.size = sizeof(struct task_read)
+};
+
+__attribute__((constructor)) static void reg_task_read(void)
+{
+	reg_task(&task_init_read);
+}
diff --git a/VNFs/DPPD-PROX/handle_routing.c b/VNFs/DPPD-PROX/handle_routing.c
new file mode 100644
index 00000000..9dd45ed8
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_routing.c
@@ -0,0 +1,321 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_lpm.h>
+#include <rte_cycles.h>
+#include <string.h>
+#include <rte_version.h>
+#include <rte_ip.h>
+#include <rte_byteorder.h>
+
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+
+#include "quit.h"
+#include "log.h"
+#include "handle_routing.h"
+#include "tx_pkt.h"
+#include "gre.h"
+#include "lconf.h"
+#include "prox_port_cfg.h"
+#include "etypes.h"
+#include "prefetch.h"
+#include "hash_entry_types.h"
+#include "mpls.h"
+#include "qinq.h"
+#include "prox_cfg.h"
+#include "ip6_addr.h"
+#include "prox_shared.h"
+#include "prox_cksum.h"
+#include "mbuf_utils.h"
+
+struct task_routing {
+	struct task_base                base;
+	uint8_t                         runtime_flags;
+	struct lcore_cfg                *lconf;
+	struct rte_lpm                  *ipv4_lpm;
+	struct next_hop                 *next_hops;
+	int                             offload_crc;
+	uint32_t			number_free_rules;
+	uint16_t                        qinq_tag;
+	uint32_t                        marking[4];
+	uint64_t                        src_mac[PROX_MAX_PORTS];
+};
+
+static void routing_update(struct task_base *tbase, void **data, uint16_t n_msgs)
+{
+	struct task_routing *task = (struct task_routing *)tbase;
+	struct route_msg *msg;
+
+	for (uint16_t i = 0; i < n_msgs; ++i) {
+		msg = (struct route_msg *)data[i];
+
+		if (task->number_free_rules == 0) {
+			plog_warn("Failed adding route: %u.%u.%u.%u/%u: lpm table full\n",
+				msg->ip_bytes[0], msg->ip_bytes[1], msg->ip_bytes[2],
+				msg->ip_bytes[3], msg->prefix);
+		} else {
+			if (rte_lpm_add(task->ipv4_lpm, rte_bswap32(msg->ip), msg->prefix, msg->nh)) {
+				plog_warn("Failed adding route: %u.%u.%u.%u/%u\n",
+					msg->ip_bytes[0], msg->ip_bytes[1], msg->ip_bytes[2],
+					msg->ip_bytes[3], msg->prefix);
+			} else {
+				task->number_free_rules--;
+			}
+		}
+	}
+}
+
+static void init_task_routing(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_routing *task = (struct task_routing *)tbase;
+	const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
+	struct lpm4 *lpm;
+
+	task->lconf = targ->lconf;
+	task->qinq_tag = targ->qinq_tag;
+	task->runtime_flags = targ->runtime_flags;
+
+	PROX_PANIC(!strcmp(targ->route_table, ""), "route table not specified\n");
+	if (targ->flags & TASK_ARG_LOCAL_LPM) {
+		int ret = lua_to_lpm4(prox_lua(), GLOBAL, targ->route_table, socket_id, &lpm);
+		PROX_PANIC(ret, "Failed to load IPv4 LPM:\n%s\n", get_lua_to_errors());
+		prox_sh_add_socket(socket_id, targ->route_table, lpm);
+
+		task->number_free_rules = lpm->n_free_rules;
+	}
+	else {
+		lpm = prox_sh_find_socket(socket_id, targ->route_table);
+		if (!lpm) {
+			int ret = lua_to_lpm4(prox_lua(), GLOBAL, targ->route_table, socket_id, &lpm);
+			PROX_PANIC(ret, "Failed to load IPv4 LPM:\n%s\n", get_lua_to_errors());
+			prox_sh_add_socket(socket_id, targ->route_table, lpm);
+		}
+	}
+	task->ipv4_lpm = lpm->rte_lpm;
+	task->next_hops = lpm->next_hops;
+	task->number_free_rules = lpm->n_free_rules;
+
+	for (uint32_t i = 0; i < MAX_HOP_INDEX; i++) {
+		int tx_port = task->next_hops[i].mac_port.out_idx;
+		if ((tx_port > targ->nb_txports - 1) && (tx_port > targ->nb_txrings - 1)) {
+			PROX_PANIC(1, "Routing Table contains port %d but only %d tx port/ %d ring:\n", tx_port, targ->nb_txports, targ->nb_txrings);
+		}
+	}
+
+        if (targ->nb_txrings) {
+		struct task_args *dtarg;
+		struct core_task ct;
+		for (uint32_t i = 0; i < targ->nb_txrings; ++i) {
+			ct = targ->core_task_set[0].core_task[i];
+			dtarg = core_targ_get(ct.core, ct.task);
+			dtarg = find_reachable_task_sending_to_port(dtarg);
+			if (task->runtime_flags & TASK_MPLS_TAGGING) {
+				task->src_mac[i] = (0x0000ffffffffffff & ((*(uint64_t*)&prox_port_cfg[dtarg->tx_port_queue[0].port].eth_addr))) | ((uint64_t)ETYPE_MPLSU << (64 - 16));
+			} else {
+				task->src_mac[i] = (0x0000ffffffffffff & ((*(uint64_t*)&prox_port_cfg[dtarg->tx_port_queue[0].port].eth_addr))) | ((uint64_t)ETYPE_IPv4 << (64 - 16));
+			}
+		}
+	} else {
+		for (uint32_t i = 0; i < targ->nb_txports; ++i) {
+			if (task->runtime_flags & TASK_MPLS_TAGGING) {
+				task->src_mac[i] = (0x0000ffffffffffff & ((*(uint64_t*)&prox_port_cfg[targ->tx_port_queue[i].port].eth_addr))) | ((uint64_t)ETYPE_MPLSU << (64 - 16));
+			} else {
+				task->src_mac[i] = (0x0000ffffffffffff & ((*(uint64_t*)&prox_port_cfg[targ->tx_port_queue[i].port].eth_addr))) | ((uint64_t)ETYPE_IPv4 << (64 - 16));
+                	}
+                }
+	}
+
+	for (uint32_t i = 0; i < 4; ++i) {
+		task->marking[i] = rte_bswap32(targ->marking[i] << 9);
+	}
+
+	struct prox_port_cfg *port = find_reachable_port(targ);
+	if (port) {
+		task->offload_crc = port->capabilities.tx_offload_cksum;
+	}
+
+	targ->lconf->ctrl_func_m[targ->task] = routing_update;
+	targ->lconf->ctrl_timeout = freq_to_tsc(20);
+}
+
+static inline uint8_t handle_routing(struct task_routing *task, struct rte_mbuf *mbuf);
+
+static int handle_routing_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_routing *task = (struct task_routing *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_routing(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_routing(task, mbufs[j]);
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static void set_l2(struct task_routing *task, struct rte_mbuf *mbuf, uint8_t nh_idx)
+{
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	*((uint64_t *)(&peth->d_addr)) = task->next_hops[nh_idx].mac_port_8bytes;
+	*((uint64_t *)(&peth->s_addr)) = task->src_mac[task->next_hops[nh_idx].mac_port.out_idx];
+}
+
+static void set_l2_mpls(struct task_routing *task, struct rte_mbuf *mbuf, uint8_t nh_idx, uint16_t l2_len)
+{
+	struct ether_hdr *peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, sizeof(struct mpls_hdr));
+	l2_len += sizeof(struct mpls_hdr);
+	prox_ip_cksum(mbuf, (struct ipv4_hdr *)((uint8_t *)peth + l2_len), l2_len, sizeof(struct ipv4_hdr), task->offload_crc);
+
+	*((uint64_t *)(&peth->d_addr)) = task->next_hops[nh_idx].mac_port_8bytes;
+	*((uint64_t *)(&peth->s_addr)) = task->src_mac[task->next_hops[nh_idx].mac_port.out_idx];
+	/* MPLSU ether_type written as high word of 64bit src_mac prepared by init_task_routing */
+	struct mpls_hdr *mpls = (struct mpls_hdr *)(peth + 1);
+
+	if (task->runtime_flags & TASK_MARK) {
+                  enum rte_meter_color color = rte_sched_port_pkt_read_color(mbuf);
+
+                *(uint32_t *)mpls = task->next_hops[nh_idx].mpls | task->marking[color] | 0x00010000; // Set BoS to 1
+	}
+	else {
+		*(uint32_t *)mpls = task->next_hops[nh_idx].mpls | 0x00010000; // Set BoS to 1
+	}
+}
+
+static uint8_t route_ipv4(struct task_routing *task, uint8_t *beg, uint32_t ip_offset, struct rte_mbuf *mbuf)
+{
+	struct ipv4_hdr *ip = (struct ipv4_hdr*)(beg + ip_offset);
+	struct ether_hdr *peth_out;
+	uint8_t tx_port;
+	uint32_t dst_ip;
+
+	if (unlikely(ip->version_ihl >> 4 != 4)) {
+                plog_warn("Offset: %d\n", ip_offset);
+		plog_warn("Expected to receive IPv4 packet but IP version was %d\n",
+			ip->version_ihl >> 4);
+		return OUT_DISCARD;
+	}
+
+	switch(ip->next_proto_id) {
+	case IPPROTO_GRE: {
+		struct gre_hdr *pgre = (struct gre_hdr *)(ip + 1);
+		dst_ip = ((struct ipv4_hdr *)(pgre + 1))->dst_addr;
+		break;
+	}
+	case IPPROTO_TCP:
+	case IPPROTO_UDP:
+		dst_ip = ip->dst_addr;
+		break;
+	default:
+		/* Routing for other protocols is not implemented */
+		return OUT_DISCARD;
+	}
+
+#if RTE_VERSION >= RTE_VERSION_NUM(16,4,0,1)
+	uint32_t next_hop_index;
+#else
+	uint8_t next_hop_index;
+#endif
+	if (unlikely(rte_lpm_lookup(task->ipv4_lpm, rte_bswap32(dst_ip), &next_hop_index) != 0)) {
+		uint8_t* dst_ipp = (uint8_t*)&dst_ip;
+		plog_warn("lpm_lookup failed for ip %d.%d.%d.%d: rc = %d\n",
+			dst_ipp[0], dst_ipp[1], dst_ipp[2], dst_ipp[3], -ENOENT);
+		return OUT_DISCARD;
+	}
+
+	tx_port = task->next_hops[next_hop_index].mac_port.out_idx;
+	if (task->runtime_flags & TASK_MPLS_TAGGING) {
+	        uint16_t padlen = rte_pktmbuf_pkt_len(mbuf) - rte_be_to_cpu_16(ip->total_length) - ip_offset;
+		if (padlen) {
+			rte_pktmbuf_trim(mbuf, padlen);
+                }
+
+                set_l2_mpls(task, mbuf, next_hop_index, ip_offset);
+        }
+	else {
+		set_l2(task, mbuf, next_hop_index);
+        }
+	return tx_port;
+}
+
+static inline uint8_t handle_routing(struct task_routing *task, struct rte_mbuf *mbuf)
+{
+	struct qinq_hdr *qinq;
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+
+	switch (peth->ether_type) {
+	case ETYPE_8021ad: {
+		struct qinq_hdr *qinq = (struct qinq_hdr *)peth;
+		if ((qinq->cvlan.eth_proto != ETYPE_VLAN)) {
+			plog_warn("Unexpected proto in QinQ = %#04x\n", qinq->cvlan.eth_proto);
+			return OUT_DISCARD;
+		}
+
+		return route_ipv4(task, (uint8_t*)qinq, sizeof(*qinq), mbuf);
+	}
+	case ETYPE_IPv4:
+		return route_ipv4(task, (uint8_t*)peth, sizeof(*peth), mbuf);
+	case ETYPE_MPLSU: {
+		/* skip MPLS headers if any for routing */
+		struct mpls_hdr *mpls = (struct mpls_hdr *)(peth + 1);
+		uint32_t count = sizeof(struct ether_hdr);
+		while (!(mpls->bytes & 0x00010000)) {
+			mpls++;
+			count += sizeof(struct mpls_hdr);
+		}
+		count += sizeof(struct mpls_hdr);
+
+		return route_ipv4(task, (uint8_t*)peth, count, mbuf);
+	}
+	default:
+		if (peth->ether_type == task->qinq_tag) {
+			struct qinq_hdr *qinq = (struct qinq_hdr *)peth;
+			if ((qinq->cvlan.eth_proto != ETYPE_VLAN)) {
+				plog_warn("Unexpected proto in QinQ = %#04x\n", qinq->cvlan.eth_proto);
+				return OUT_DISCARD;
+			}
+
+			return route_ipv4(task, (uint8_t*)qinq, sizeof(*qinq), mbuf);
+		}
+		plog_warn("Failed routing packet: ether_type %#06x is unknown\n", peth->ether_type);
+		return OUT_DISCARD;
+	}
+}
+
+static struct task_init task_init_routing = {
+	.mode_str = "routing",
+	.init = init_task_routing,
+	.handle = handle_routing_bulk,
+	.flag_features = TASK_FEATURE_ROUTING,
+	.size = sizeof(struct task_routing)
+};
+
+__attribute__((constructor)) static void reg_task_routing(void)
+{
+	reg_task(&task_init_routing);
+}
diff --git a/VNFs/DPPD-PROX/handle_routing.h b/VNFs/DPPD-PROX/handle_routing.h
new file mode 100644
index 00000000..e3dde93d
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_routing.h
@@ -0,0 +1,29 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_ROUTING_H_
+#define _HANDLE_ROUTING_H_
+
+struct route_msg {
+	union {
+		uint32_t ip;
+		uint8_t ip_bytes[4];
+	};
+	uint32_t prefix;
+	uint32_t nh;
+};
+
+#endif /* _HANDLE_ROUTING_H_ */
diff --git a/VNFs/DPPD-PROX/handle_swap.c b/VNFs/DPPD-PROX/handle_swap.c
new file mode 100644
index 00000000..8e5a94ce
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_swap.c
@@ -0,0 +1,291 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mbuf.h>
+#include <rte_udp.h>
+
+#include "task_init.h"
+#include "task_base.h"
+#include "lconf.h"
+#include "log.h"
+#include "arp.h"
+#include "handle_swap.h"
+#include "prox_port_cfg.h"
+#include "mpls.h"
+#include "qinq.h"
+#include "gre.h"
+#include "prefetch.h"
+
+struct task_swap {
+	struct task_base base;
+	uint8_t src_dst_mac[12];
+	uint32_t runtime_flags;
+	uint32_t tmp_ip;
+	uint32_t ip;
+};
+
+static void task_update_config(struct task_swap *task)
+{
+	if (unlikely(task->ip != task->tmp_ip))
+		task->ip = task->tmp_ip;
+}
+
+static void write_src_and_dst_mac(struct task_swap *task, struct rte_mbuf *mbuf)
+{
+	struct ether_hdr *hdr;
+	struct ether_addr mac;
+
+	if (unlikely((task->runtime_flags & (TASK_ARG_DST_MAC_SET|TASK_ARG_SRC_MAC_SET)) == (TASK_ARG_DST_MAC_SET|TASK_ARG_SRC_MAC_SET))) {
+		/* Source and Destination mac hardcoded */
+		hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+              	rte_memcpy(hdr, task->src_dst_mac, sizeof(task->src_dst_mac));
+	} else {
+		hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+		if (likely((task->runtime_flags & TASK_ARG_SRC_MAC_SET) == 0)) {
+			/* dst mac will be used as src mac */
+			ether_addr_copy(&hdr->d_addr, &mac);
+		}
+
+		if (unlikely(task->runtime_flags & TASK_ARG_DST_MAC_SET))
+			ether_addr_copy((struct ether_addr *)&task->src_dst_mac[0], &hdr->d_addr);
+		else
+			ether_addr_copy(&hdr->s_addr, &hdr->d_addr);
+
+		if (unlikely(task->runtime_flags & TASK_ARG_SRC_MAC_SET)) {
+			ether_addr_copy((struct ether_addr *)&task->src_dst_mac[6], &hdr->s_addr);
+		} else {
+			ether_addr_copy(&mac, &hdr->s_addr);
+		}
+	}
+}
+static inline int handle_arp_request(struct task_swap *task, struct ether_hdr_arp *hdr_arp, struct ether_addr *s_addr, uint32_t ip)
+{
+	if ((hdr_arp->arp.data.tpa == ip) || (ip == 0)) {
+		prepare_arp_reply(hdr_arp, s_addr);
+		memcpy(hdr_arp->ether_hdr.d_addr.addr_bytes, hdr_arp->ether_hdr.s_addr.addr_bytes, 6);
+		memcpy(hdr_arp->ether_hdr.s_addr.addr_bytes, s_addr, 6);
+		return 0;
+	} else if (task->runtime_flags & TASK_MULTIPLE_MAC) {
+		struct ether_addr tmp_s_addr;
+		create_mac(hdr_arp, &tmp_s_addr);
+		prepare_arp_reply(hdr_arp, &tmp_s_addr);
+		memcpy(hdr_arp->ether_hdr.d_addr.addr_bytes, hdr_arp->ether_hdr.s_addr.addr_bytes, 6);
+		memcpy(hdr_arp->ether_hdr.s_addr.addr_bytes, &tmp_s_addr, 6);
+		return 0;
+	} else {
+		plogx_dbg("Received ARP on unexpected IP %x, expecting %x\n", rte_be_to_cpu_32(hdr_arp->arp.data.tpa), rte_be_to_cpu_32(ip));
+		return OUT_DISCARD;
+	}
+}
+
+/*
+ * swap mode does not send arp requests, so does not expect arp replies
+ * Need to understand later whether we must send arp requests
+ */
+static inline int handle_arp_replies(struct task_swap *task, struct ether_hdr_arp *hdr_arp)
+{
+	return OUT_DISCARD;
+}
+
+static int handle_swap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_swap *task = (struct task_swap *)tbase;
+	struct ether_hdr *hdr;
+	struct ether_addr mac;
+	struct ipv4_hdr *ip_hdr;
+	struct udp_hdr *udp_hdr;
+	uint32_t ip;
+	uint16_t port;
+	uint8_t out[64] = {0};
+	struct mpls_hdr *mpls;
+	uint32_t mpls_len = 0;
+	struct qinq_hdr *qinq;
+	struct vlan_hdr *vlan;
+	struct ether_hdr_arp *hdr_arp;
+	uint16_t j;
+
+	for (j = 0; j < n_pkts; ++j) {
+		PREFETCH0(mbufs[j]);
+	}
+	for (j = 0; j < n_pkts; ++j) {
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j], void *));
+	}
+
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *);
+		switch (hdr->ether_type) {
+		case ETYPE_ARP:
+			hdr_arp = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr_arp *);
+			if (arp_is_gratuitous(hdr_arp)) {
+				plog_info("Received gratuitous packet \n");
+				out[j] = OUT_DISCARD;
+			} else if (hdr_arp->arp.oper == ARP_REQUEST) {
+				out[j] = handle_arp_request(task, hdr_arp, (struct ether_addr *)&task->src_dst_mac[6], task->ip);
+			} else if (hdr_arp->arp.oper == ARP_REPLY) {
+				out[j] = handle_arp_replies(task, hdr_arp);
+			} else {
+				plog_info("Received unexpected ARP operation %d\n", hdr_arp->arp.oper);
+				out[j] = OUT_DISCARD;
+			}
+			continue;
+		case ETYPE_MPLSU:
+			mpls = (struct mpls_hdr *)(hdr + 1);
+			while (!(mpls->bytes & 0x00010000)) {
+				mpls++;
+				mpls_len += sizeof(struct mpls_hdr);
+			}
+			mpls_len += sizeof(struct mpls_hdr);
+			ip_hdr = (struct ipv4_hdr *)(mpls + 1);
+			break;
+		case ETYPE_8021ad:
+			qinq = (struct qinq_hdr *)hdr;
+			if (qinq->cvlan.eth_proto != ETYPE_VLAN) {
+				plog_warn("Unexpected proto in QinQ = %#04x\n", qinq->cvlan.eth_proto);
+				out[j] = OUT_DISCARD;
+				continue;
+			}
+			ip_hdr = (struct ipv4_hdr *)(qinq + 1);
+			break;
+		case ETYPE_VLAN:
+			vlan = (struct vlan_hdr *)(hdr + 1);
+			if (vlan->eth_proto == ETYPE_IPv4) {
+				ip_hdr = (struct ipv4_hdr *)(vlan + 1);
+			} else if (vlan->eth_proto == ETYPE_VLAN) {
+				vlan = (struct vlan_hdr *)(vlan + 1);
+				if (vlan->eth_proto == ETYPE_IPv4) {
+					ip_hdr = (struct ipv4_hdr *)(vlan + 1);
+				}
+				else if (vlan->eth_proto == ETYPE_IPv6) {
+					plog_warn("Unsupported IPv6\n");
+					out[j] = OUT_DISCARD;
+					continue;
+				}
+				else {
+					plog_warn("Unsupported packet type\n");
+					out[j] = OUT_DISCARD;
+					continue;
+				}
+			} else {
+				plog_warn("Unsupported packet type\n");
+				out[j] = OUT_DISCARD;
+				continue;
+			}
+			break;
+		case ETYPE_IPv4:
+			ip_hdr = (struct ipv4_hdr *)(hdr + 1);
+			break;
+		case ETYPE_IPv6:
+			plog_warn("Unsupported IPv6\n");
+			out[j] = OUT_DISCARD;
+			continue;
+		case ETYPE_LLDP:
+			out[j] = OUT_DISCARD;
+			continue;
+		default:
+			plog_warn("Unsupported ether_type 0x%x\n", hdr->ether_type);
+			out[j] = OUT_DISCARD;
+			continue;
+		}
+		udp_hdr = (struct udp_hdr *)(ip_hdr + 1);
+		ip = ip_hdr->dst_addr;
+		ip_hdr->dst_addr = ip_hdr->src_addr;
+		ip_hdr->src_addr = ip;
+		if (ip_hdr->next_proto_id == IPPROTO_GRE) {
+			struct gre_hdr *pgre = (struct gre_hdr *)(ip_hdr + 1);
+			struct ipv4_hdr *inner_ip_hdr = ((struct ipv4_hdr *)(pgre + 1));
+			ip = inner_ip_hdr->dst_addr;
+			inner_ip_hdr->dst_addr = inner_ip_hdr->src_addr;
+			inner_ip_hdr->src_addr = ip;
+			udp_hdr = (struct udp_hdr *)(inner_ip_hdr + 1);
+			port = udp_hdr->dst_port;
+			udp_hdr->dst_port = udp_hdr->src_port;
+			udp_hdr->src_port = port;
+		} else {
+			port = udp_hdr->dst_port;
+			udp_hdr->dst_port = udp_hdr->src_port;
+			udp_hdr->src_port = port;
+		}
+		write_src_and_dst_mac(task, mbufs[j]);
+	}
+	task_update_config(task);
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static void init_task_swap(struct task_base *tbase, struct task_args *targ)
+{
+	struct task_swap *task = (struct task_swap *)tbase;
+	struct ether_addr *src_addr, *dst_addr;
+
+	/*
+	 * Destination MAC can come from
+	 *    - pre-configured mac in case 'dst mac=xx:xx:xx:xx:xx:xx' in config file
+	 *    - src mac from the packet in case 'dst mac=packet' in config file
+	 *    - not written in case 'dst mac=no' in config file
+	 *    - (default - no 'dst mac') src mac from the packet
+	 * Source MAC can come from
+	 *    - pre-configured mac in case 'src mac=xx:xx:xx:xx:xx:xx' in config file
+	 *    - dst mac from the packet in case 'src mac=packet' in config file
+	 *    - not written in case 'src mac=no' in config file
+	 *    - (default - no 'src mac') if (tx_port) port mac
+	 *    - (default - no 'src mac') if (no tx_port) dst mac from the packet
+	 */
+
+	if (targ->flags & TASK_ARG_DST_MAC_SET) {
+		dst_addr = &targ->edaddr;
+		memcpy(&task->src_dst_mac[0], dst_addr, sizeof(*src_addr));
+	}
+
+	if (targ->flags & TASK_ARG_SRC_MAC_SET) {
+		src_addr =  &targ->esaddr;
+		memcpy(&task->src_dst_mac[6], src_addr, sizeof(*dst_addr));
+		plog_info("\t\tCore %d: src mac set from config file\n", targ->lconf->id);
+	} else if (targ->nb_txports) {
+		src_addr = &prox_port_cfg[task->base.tx_params_hw.tx_port_queue[0].port].eth_addr;
+		memcpy(&task->src_dst_mac[6], src_addr, sizeof(*dst_addr));
+		if (targ->flags & TASK_ARG_HW_SRC_MAC){
+			targ->flags |= TASK_ARG_SRC_MAC_SET;
+			plog_info("\t\tCore %d: src mac set from port\n", targ->lconf->id);
+		}
+	}
+	task->runtime_flags = targ->flags;
+	task->ip = rte_cpu_to_be_32(targ->local_ipv4);
+	task->tmp_ip = task->ip;
+}
+
+static struct task_init task_init_swap = {
+	.mode_str = "swap",
+	.init = init_task_swap,
+	.handle = handle_swap_bulk,
+	.flag_features = TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS|TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS,
+	.size = sizeof(struct task_swap),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+static struct task_init task_init_swap_arp = {
+	.mode_str = "swap",
+	.sub_mode_str = "l3",
+	.init = init_task_swap,
+	.handle = handle_swap_bulk,
+	.flag_features = TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS|TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS,
+	.size = sizeof(struct task_swap),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+__attribute__((constructor)) static void reg_task_swap(void)
+{
+	reg_task(&task_init_swap);
+	reg_task(&task_init_swap_arp);
+}
diff --git a/VNFs/DPPD-PROX/handle_swap.h b/VNFs/DPPD-PROX/handle_swap.h
new file mode 100644
index 00000000..ef2fee04
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_swap.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HANDLE_SWAP_H_
+#define _HANDLE_SWAP_H_
+
+struct task_base;
+void task_swap_set_local_ip(struct task_base *tbase, uint32_t ip);
+
+#endif /* _HANDLE_SWAP_H_ */
diff --git a/VNFs/DPPD-PROX/handle_tsc.c b/VNFs/DPPD-PROX/handle_tsc.c
new file mode 100644
index 00000000..e686aaa2
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_tsc.c
@@ -0,0 +1,51 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mbuf.h>
+#include <rte_cycles.h>
+
+#include "task_base.h"
+#include "task_init.h"
+#include "thread_generic.h"
+
+struct task_tsc {
+	struct task_base base;
+};
+
+static int handle_bulk_tsc(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_tsc *task = (struct task_tsc *)tbase;
+	const uint64_t rx_tsc = rte_rdtsc();
+
+	for (uint16_t j = 0; j < n_pkts; ++j)
+		mbufs[j]->udata64 = rx_tsc;
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, NULL);
+}
+
+static struct task_init task_init = {
+	.mode_str = "tsc",
+	.init = NULL,
+	.handle = handle_bulk_tsc,
+	.flag_features = TASK_FEATURE_NEVER_DISCARDS|TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS|TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS|TASK_FEATURE_THROUGHPUT_OPT,
+	.size = sizeof(struct task_tsc),
+	.mbuf_size = 2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM,
+};
+
+__attribute__((constructor)) static void reg_task_nop(void)
+{
+	reg_task(&task_init);
+}
diff --git a/VNFs/DPPD-PROX/handle_untag.c b/VNFs/DPPD-PROX/handle_untag.c
new file mode 100644
index 00000000..2fc8fe64
--- /dev/null
+++ b/VNFs/DPPD-PROX/handle_untag.c
@@ -0,0 +1,144 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ip.h>
+
+#include "log.h"
+#include "tx_pkt.h"
+#include "task_base.h"
+#include "task_init.h"
+#include "mpls.h"
+#include "defines.h"
+#include "prefetch.h"
+#include "qinq.h"
+#include "prox_assert.h"
+#include "etypes.h"
+
+struct task_untag {
+	struct task_base base;
+	uint16_t         etype;
+};
+
+static void init_task_untag(struct task_base *tbase, __attribute__((unused)) struct task_args *targ)
+{
+	struct task_untag *task = (struct task_untag *)tbase;
+	task->etype = targ->etype;
+}
+
+static inline uint8_t handle_untag(struct task_untag *task, struct rte_mbuf *mbuf);
+
+static int handle_untag_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	struct task_untag *task = (struct task_untag *)tbase;
+	uint8_t out[MAX_PKT_BURST];
+	uint16_t j;
+
+	prefetch_first(mbufs, n_pkts);
+
+	for (j = 0; j + PREFETCH_OFFSET < n_pkts; ++j) {
+#ifdef PROX_PREFETCH_OFFSET
+		PREFETCH0(mbufs[j + PREFETCH_OFFSET]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j + PREFETCH_OFFSET - 1], void *));
+#endif
+		out[j] = handle_untag(task, mbufs[j]);
+	}
+#ifdef PROX_PREFETCH_OFFSET
+	PREFETCH0(rte_pktmbuf_mtod(mbufs[n_pkts - 1], void *));
+	for (; j < n_pkts; ++j) {
+		out[j] = handle_untag(task, mbufs[j]);
+	}
+#endif
+
+	return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
+}
+
+static inline uint8_t untag_mpls(struct rte_mbuf *mbuf, struct ether_hdr *peth)
+{
+	struct ether_hdr *pneweth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
+	const struct mpls_hdr *mpls = (const struct mpls_hdr *)(peth + 1);
+	const struct ipv4_hdr *pip = (const struct ipv4_hdr *)(mpls + 1);
+	PROX_ASSERT(pneweth);
+
+	if (mpls->bos == 0) {
+		// Double MPLS tag
+		pneweth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
+		PROX_ASSERT(pneweth);
+	}
+
+	if ((pip->version_ihl >> 4) == 4) {
+		pneweth->ether_type = ETYPE_IPv4;
+		return 0;
+	}
+	else if ((pip->version_ihl >> 4) == 6) {
+		pneweth->ether_type = ETYPE_IPv6;
+		return 0;
+	}
+
+	plog_warn("Failed Decoding MPLS Packet - neither IPv4 neither IPv6: version %u\n", pip->version_ihl);
+	return OUT_DISCARD;
+}
+
+static uint8_t untag_qinq(struct rte_mbuf *mbuf, struct qinq_hdr *qinq)
+{
+	if ((qinq->cvlan.eth_proto != ETYPE_VLAN)) {
+		plog_warn("Unexpected proto in QinQ = %#04x\n", qinq->cvlan.eth_proto);
+		return OUT_DISCARD;
+	}
+
+	rte_pktmbuf_adj(mbuf, sizeof(struct qinq_hdr) - sizeof(struct ether_hdr));
+	return 0;
+}
+
+static inline uint8_t handle_untag(struct task_untag *task, struct rte_mbuf *mbuf)
+{
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	const uint16_t etype = peth->ether_type;
+
+	if (etype != task->etype) {
+		plog_warn("Failed Removing %04x tag: ether_type = %#06x\n", task->etype, peth->ether_type);
+		return OUT_DISCARD;
+	}
+
+	switch (etype) {
+	case ETYPE_MPLSU:
+		/* MPLS Decapsulation */
+		return untag_mpls(mbuf, peth);
+	case ETYPE_LLDP:
+		return OUT_DISCARD;
+	case ETYPE_IPv6:
+		return 0;
+	case ETYPE_IPv4:
+		return 0;
+	case ETYPE_8021ad:
+	case ETYPE_VLAN:
+		return untag_qinq(mbuf, (struct qinq_hdr *)peth);
+	default:
+		plog_warn("Failed untagging header: ether_type = %#06x is not supported\n", peth->ether_type);
+		return OUT_DISCARD;
+	}
+}
+
+static struct task_init task_init_untag = {
+	.mode_str = "untag",
+	.init = init_task_untag,
+	.handle = handle_untag_bulk,
+	.size = sizeof(struct task_untag)
+};
+
+__attribute__((constructor)) static void reg_task_untag(void)
+{
+	reg_task(&task_init_untag);
+}
diff --git a/VNFs/DPPD-PROX/hash_entry_types.h b/VNFs/DPPD-PROX/hash_entry_types.h
new file mode 100644
index 00000000..e2cbcb3c
--- /dev/null
+++ b/VNFs/DPPD-PROX/hash_entry_types.h
@@ -0,0 +1,71 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HASH_ENTRY_TYPES_H_
+#define _HASH_ENTRY_TYPES_H_
+
+#include <rte_ether.h>
+
+struct ether_addr_port {
+	struct ether_addr 	mac;
+	uint8_t                 pad;
+	uint8_t	                out_idx;
+};
+
+struct next_hop {
+	uint32_t                ip_dst;
+	uint32_t                mpls;
+	union {
+		uint64_t               mac_port_8bytes;
+		struct ether_addr_port mac_port;
+	};
+};
+
+struct next_hop6 {
+	uint8_t                ip_dst[16];
+	uint32_t               mpls;
+	union {
+		uint64_t               mac_port_8bytes;
+		struct ether_addr_port mac_port;
+	};
+};
+
+struct cpe_data {
+	uint16_t qinq_svlan;
+	uint16_t qinq_cvlan;
+	uint32_t user;
+	union {
+		uint64_t               mac_port_8bytes;
+		struct ether_addr_port mac_port;
+		uint8_t                mac_port_b[8];
+	};
+	uint64_t tsc;
+};
+
+struct cpe_key {
+	union {
+		uint32_t ip;
+		uint8_t ip_bytes[4];
+	};
+	uint32_t gre_id;
+} __attribute__((__packed__));
+
+struct qinq_gre_data {
+	uint32_t gre_id;
+	uint32_t user;
+} __attribute__((__packed__));
+
+#endif /* _HASH_ENTRY_TYPES_H_ */
diff --git a/VNFs/DPPD-PROX/hash_set.c b/VNFs/DPPD-PROX/hash_set.c
new file mode 100644
index 00000000..5ea93e96
--- /dev/null
+++ b/VNFs/DPPD-PROX/hash_set.c
@@ -0,0 +1,105 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_hash_crc.h>
+#include <string.h>
+
+#include "prox_malloc.h"
+#include "prox_assert.h"
+#include "hash_set.h"
+
+#define HASH_SET_ALLOC_CHUNCK 1024
+#define HASH_SET_ALLOC_CHUNCK_MEM (sizeof(struct hash_set_entry) * 1024)
+
+struct hash_set_entry {
+	uint32_t              crc;
+	void                  *data;
+	size_t                len;
+	struct hash_set_entry *next;
+};
+
+struct hash_set {
+	uint32_t              n_buckets;
+	int                   socket_id;
+	struct hash_set_entry *alloc;
+	size_t                alloc_count;
+	struct hash_set_entry *mem[0];
+};
+
+static struct hash_set_entry *hash_set_alloc_entry(struct hash_set *hs)
+{
+	struct hash_set_entry *ret;
+
+	if (hs->alloc_count == 0) {
+		size_t mem_size = HASH_SET_ALLOC_CHUNCK *
+			sizeof(struct hash_set_entry);
+
+		hs->alloc = prox_zmalloc(mem_size, hs->socket_id);
+		hs->alloc_count = HASH_SET_ALLOC_CHUNCK;
+	}
+
+	ret = hs->alloc;
+	hs->alloc++;
+	hs->alloc_count--;
+	return ret;
+}
+
+struct hash_set *hash_set_create(uint32_t n_buckets, int socket_id)
+{
+	struct hash_set *ret;
+	size_t mem_size = sizeof(*ret) + sizeof(ret->mem[0]) * n_buckets;
+
+	ret = prox_zmalloc(mem_size, socket_id);
+	ret->n_buckets = n_buckets;
+	ret->socket_id = socket_id;
+
+	return ret;
+}
+
+void *hash_set_find(struct hash_set *hs, void *data, size_t len)
+{
+	uint32_t crc = rte_hash_crc(data, len, 0);
+
+	struct hash_set_entry *entry = hs->mem[crc % hs->n_buckets];
+
+	while (entry) {
+		if (entry->crc == crc && entry->len == len &&
+		    memcmp(entry->data, data, len) == 0)
+			return entry->data;
+		entry = entry->next;
+	}
+	return NULL;
+}
+
+void hash_set_add(struct hash_set *hs, void *data, size_t len)
+{
+	uint32_t crc = rte_hash_crc(data, len, 0);
+	struct hash_set_entry *new = hash_set_alloc_entry(hs);
+
+	new->data = data;
+	new->len = len;
+	new->crc = crc;
+
+	if (hs->mem[crc % hs->n_buckets]) {
+		struct hash_set_entry *entry = hs->mem[crc % hs->n_buckets];
+		while (entry->next)
+			entry = entry->next;
+		entry->next = new;
+	}
+	else {
+		hs->mem[crc % hs->n_buckets] = new;
+	}
+}
diff --git a/VNFs/DPPD-PROX/hash_set.h b/VNFs/DPPD-PROX/hash_set.h
new file mode 100644
index 00000000..72345215
--- /dev/null
+++ b/VNFs/DPPD-PROX/hash_set.h
@@ -0,0 +1,26 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HASH_SET_H_
+#define _HASH_SET_H_
+
+struct hash_set;
+
+struct hash_set *hash_set_create(uint32_t n_buckets, int socket_id);
+void *hash_set_find(struct hash_set *hs, void *data, size_t len);
+void hash_set_add(struct hash_set *hs, void *data, size_t len);
+
+#endif /* _HASH_SET_H_ */
diff --git a/VNFs/DPPD-PROX/hash_utils.c b/VNFs/DPPD-PROX/hash_utils.c
new file mode 100644
index 00000000..4ebab94e
--- /dev/null
+++ b/VNFs/DPPD-PROX/hash_utils.c
@@ -0,0 +1,184 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <rte_hash_crc.h>
+#include <rte_table_hash.h>
+#include <rte_version.h>
+
+#include "hash_utils.h"
+
+/* These opaque structure definitions were copied from DPDK lib/librte_table/rte_table_hash_key8.c */
+
+struct rte_bucket_4_8 {
+	/* Cache line 0 */
+	uint64_t signature;
+	uint64_t lru_list;
+	struct rte_bucket_4_8 *next;
+	uint64_t next_valid;
+
+	uint64_t key[4];
+
+	/* Cache line 1 */
+	uint8_t data[0];
+};
+
+struct rte_table_hash_key8 {
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
+	struct rte_table_stats stats;
+#endif
+	/* Input parameters */
+	uint32_t n_buckets;
+	uint32_t n_entries_per_bucket;
+	uint32_t key_size;
+	uint32_t entry_size;
+	uint32_t bucket_size;
+	uint32_t signature_offset;
+	uint32_t key_offset;
+#if RTE_VERSION >= RTE_VERSION_NUM(2,2,0,0)
+	uint64_t key_mask;
+#endif
+	rte_table_hash_op_hash f_hash;
+	uint64_t seed;
+
+	/* Extendible buckets */
+	uint32_t n_buckets_ext;
+	uint32_t stack_pos;
+	uint32_t *stack;
+
+	/* Lookup table */
+	uint8_t memory[0] __rte_cache_aligned;
+};
+
+/* These opaque structure definitions were copied from DPDK lib/librte_table/rte_table_hash_ext.c */
+
+struct bucket {
+	union {
+		uintptr_t next;
+		uint64_t lru_list;
+	};
+	uint16_t sig[4];
+	uint32_t key_pos[4];
+};
+
+#define BUCKET_NEXT(bucket)						\
+	((void *) ((bucket)->next & (~1LU)))
+
+struct grinder {
+	struct bucket *bkt;
+	uint64_t sig;
+	uint64_t match;
+	uint32_t key_index;
+};
+
+struct rte_table_hash_ext {
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
+	struct rte_table_stats stats;
+#endif
+	/* Input parameters */
+	uint32_t key_size;
+	uint32_t entry_size;
+	uint32_t n_keys;
+	uint32_t n_buckets;
+	uint32_t n_buckets_ext;
+	rte_table_hash_op_hash f_hash;
+	uint64_t seed;
+	uint32_t signature_offset;
+	uint32_t key_offset;
+
+	/* Internal */
+	uint64_t bucket_mask;
+	uint32_t key_size_shl;
+	uint32_t data_size_shl;
+	uint32_t key_stack_tos;
+	uint32_t bkt_ext_stack_tos;
+
+	/* Grinder */
+	struct grinder grinders[64];
+
+	/* Tables */
+	struct bucket *buckets;
+	struct bucket *buckets_ext;
+	uint8_t *key_mem;
+	uint8_t *data_mem;
+	uint32_t *key_stack;
+	uint32_t *bkt_ext_stack;
+
+	/* Table memory */
+	uint8_t memory[0] __rte_cache_aligned;
+};
+
+uint64_t get_bucket(void* table, uint32_t bucket_idx, void** key, void** entries)
+{
+	struct rte_table_hash_ext *t = (struct rte_table_hash_ext *) table;
+	struct bucket *bkt0, *bkt, *bkt_prev;
+	uint64_t sig;
+	uint32_t bkt_index, i;
+	uint8_t n = 0;
+	bkt_index = bucket_idx & t->bucket_mask;
+	bkt0 = &t->buckets[bkt_index];
+	sig = (bucket_idx >> 16) | 1LLU;
+
+	/* Key is present in the bucket */
+	for (bkt = bkt0; bkt != NULL; bkt = BUCKET_NEXT(bkt)) {
+		for (i = 0; i < 4; i++) {
+			uint64_t bkt_sig = (uint64_t) bkt->sig[i];
+			uint32_t bkt_key_index = bkt->key_pos[i];
+			uint8_t *bkt_key =
+				&t->key_mem[bkt_key_index << t->key_size_shl];
+
+			if (sig == bkt_sig) {
+				key[n] = bkt_key;
+				entries[n++] = &t->data_mem[bkt_key_index << t->data_size_shl];
+				/* Assume no more than 4 entries in total (including extended state) */
+				if (n == 4)
+					return t->n_buckets;
+			}
+		}
+	}
+	return t->n_buckets;
+}
+
+uint64_t get_bucket_key8(void* table, uint32_t bucket_idx, void** key, void** entries)
+{
+	struct rte_bucket_4_8 *bucket, *bucket0;
+	struct rte_table_hash_key8* f = table;
+	uint8_t n = 0;
+
+	bucket0 = (struct rte_bucket_4_8 *) &f->memory[bucket_idx * f->bucket_size];
+	for (bucket = bucket0; bucket != NULL; bucket = bucket->next) {
+		uint64_t mask;
+
+		for (uint8_t i = 0, mask = 1LLU; i < 4; i++, mask <<= 1) {
+			uint64_t bucket_signature = bucket->signature;
+
+			if (bucket_signature & mask) {
+				key[n] = &bucket->key[i];
+				entries[n++] = &bucket->data[i *f->entry_size];
+				/* Assume no more than 4 entries
+				   in total (including extended state) */
+				if (n == 4)
+					return f->n_buckets;
+			}
+		}
+	}
+	return f->n_buckets;
+}
+
+uint64_t hash_crc32(void* key, uint32_t key_size, uint64_t seed)
+{
+	return rte_hash_crc(key, key_size, seed);
+}
diff --git a/VNFs/DPPD-PROX/hash_utils.h b/VNFs/DPPD-PROX/hash_utils.h
new file mode 100644
index 00000000..a2536ffb
--- /dev/null
+++ b/VNFs/DPPD-PROX/hash_utils.h
@@ -0,0 +1,42 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HASH_UTILS_H_
+#define _HASH_UTILS_H_
+
+#include <rte_common.h>
+#include <rte_version.h>
+
+struct rte_table_hash;
+
+/* Take DPDK 2.2.0 ABI change into account: offset 0 now means first byte of mbuf struct
+ * see http://www.dpdk.org/browse/dpdk/commit/?id=ba92d511ddacf863fafaaa14c0577f30ee57d092
+ */
+#if RTE_VERSION >= RTE_VERSION_NUM(2,2,0,0)
+#define HASH_METADATA_OFFSET(offset)	(sizeof(struct rte_mbuf) + (offset))
+#else
+#define HASH_METADATA_OFFSET(offset)	(offset)
+#endif
+
+/* Wrap crc32 hash function to match that required for rte_table */
+uint64_t hash_crc32(void* key, uint32_t key_size, uint64_t seed);
+
+void print_hash_table_size(const struct rte_table_hash *h);
+void print_hash_table(const struct rte_table_hash *h);
+
+uint64_t get_bucket_key8(void* table, uint32_t bucket_idx, void** key, void** entries);
+uint64_t get_bucket(void* table, uint32_t bucket_idx, void** key, void** entries);
+#endif /* _HASH_UTILS_H_ */
diff --git a/VNFs/DPPD-PROX/heap.c b/VNFs/DPPD-PROX/heap.c
new file mode 100644
index 00000000..69b0736e
--- /dev/null
+++ b/VNFs/DPPD-PROX/heap.c
@@ -0,0 +1,515 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <rte_version.h>
+#include <rte_prefetch.h>
+#include <rte_memory.h>
+
+#include "prox_malloc.h"
+#include "prox_assert.h"
+#include "heap.h"
+#include "log.h"
+
+#include <string.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+struct heap_elem {
+	uint64_t priority;
+	struct heap_ref *ref;
+	struct heap_elem *prev;
+	struct heap_elem *next;
+	struct heap_elem *child;
+};
+
+struct strl {
+	char *str;
+	size_t len;
+};
+
+int heap_top_is_lower(struct heap *h, uint64_t prio)
+{
+	return !heap_is_empty(h) && h->top->priority < prio;
+}
+
+static int heap_elem_check(struct heap_elem *e, int is_top)
+{
+	if (!e)
+		return 1;
+	if (e != e->prev &&
+	    e != e->next &&
+	    e != e->child)
+		return 1;
+	else
+		return 0;
+
+	if (is_top && e->prev != NULL)
+		return 0;
+	if (!is_top && e->prev == NULL)
+		return 0;
+
+	if (e->next) {
+		if (e->next->prev != e)
+			return 0;
+
+		if (heap_elem_check(e->next, 0))
+			return 1;
+		else
+			return 0;
+	}
+
+	if (e->child) {
+		if (e->child->prev != e)
+			return 0;
+
+		if (heap_elem_check(e->child, 0))
+			return 1;
+		else
+			return 0;
+	}
+
+	return 1;
+}
+
+static int heap_elem_in_heap_elem(struct heap_elem *in, struct heap_elem *find)
+{
+	if (in == find)
+		return 1;
+
+	if (in->next) {
+		if (heap_elem_in_heap_elem(in->next, find))
+			return 1;
+	}
+	if (in->child) {
+		if (heap_elem_in_heap_elem(in->child, find))
+			return 1;
+	}
+
+	return 0;
+}
+
+static int heap_elem_in_heap(struct heap *h, struct heap_elem *e)
+{
+	if (h->top == NULL)
+		return 0;
+
+	return heap_elem_in_heap_elem(h->top, e);
+}
+
+static int heap_elem_is_avail(struct heap *h, struct heap_elem *e)
+{
+	for (uint32_t i = 0; i < h->n_avail; ++i) {
+		if (h->avail[i] == e)
+			return 1;
+	}
+	return 0;
+}
+
+static uint32_t heap_elem_calc_size(struct heap_elem *e)
+{
+	int ret = 0;
+
+	if (e)
+		ret++;
+	else
+		return ret;
+
+	if (e->next)
+		ret += heap_elem_calc_size(e->next);
+	if (e->child)
+		ret += heap_elem_calc_size(e->child);
+	return ret;
+}
+
+static uint32_t heap_calc_size(struct heap *h)
+{
+	return heap_elem_calc_size(h->top);
+}
+
+static void cat_indent(struct strl *s, int indent)
+{
+	size_t r;
+
+	if (s->len < 50)
+		return ;
+
+	for (int i = 0; i < indent; ++i) {
+		r = snprintf(s->str, s->len, " ");
+		s->str += r;
+		s->len -= r;
+	}
+}
+
+static void cat_priority(struct strl *s, uint64_t priority)
+{
+	size_t r;
+
+	if (s->len < 50)
+		return ;
+
+	r = snprintf(s->str, s->len, "%"PRIu64"\n", priority);
+	s->str += r;
+	s->len -= r;
+}
+
+static void heap_print2(struct heap_elem *e, int indent, struct strl *s)
+{
+	size_t r;
+
+	cat_indent(s, indent);
+	cat_priority(s, e->priority);
+
+	struct heap_elem *child = e->child;
+
+	while (child) {
+		heap_print2(child, indent + 1, s);
+		child = child->next;
+	}
+}
+
+static void heap_print3(struct heap_elem *e, char *result, size_t buf_len)
+{
+	struct strl s;
+
+	s.str = result;
+	s.len = buf_len;
+
+	heap_print2(e, 0, &s);
+}
+
+void heap_print(struct heap *h, char *result, size_t buf_len)
+{
+	if (h->n_elems == 0) {
+		*result = 0;
+		return ;
+	}
+
+	heap_print3(h->top, result, buf_len);
+}
+
+struct heap *heap_create(uint32_t max_elems, int socket_id)
+{
+	struct heap *ret;
+	size_t mem_size = 0;
+	size_t elem_mem = 0;
+	struct heap_elem *e;
+
+	/* max_elems + 1 since index start at 1. Store total number of
+	   elements in the first entry (which is unused otherwise). */
+	mem_size += sizeof(struct heap);
+	mem_size += sizeof(((struct heap *)0)->top) * max_elems;
+	mem_size = RTE_CACHE_LINE_ROUNDUP(mem_size);
+	elem_mem = mem_size;
+	mem_size += sizeof(*((struct heap *)0)->top) * max_elems;
+	ret = prox_zmalloc(mem_size, socket_id);
+	if (!ret)
+		return NULL;
+
+	e = (struct heap_elem *)(((uint8_t *)ret) + elem_mem);
+	PROX_ASSERT((void *)&e[max_elems] <= (void *)ret + mem_size);
+
+	for (uint32_t i = 0; i < max_elems; ++i) {
+		PROX_ASSERT(e->priority == 0);
+		PROX_ASSERT(e->ref == 0);
+		PROX_ASSERT(e->prev == 0);
+		PROX_ASSERT(e->next == 0);
+		PROX_ASSERT(e->child == 0);
+
+		ret->avail[ret->n_avail++] = e++;
+	}
+
+	PROX_ASSERT(ret->n_elems + ret->n_avail == max_elems);
+	return ret;
+}
+
+static struct heap_elem *heap_get(struct heap *h)
+{
+	PROX_ASSERT(h->n_avail);
+
+	return h->avail[--h->n_avail];
+}
+
+static void heap_put(struct heap *h, struct heap_elem *e)
+{
+	h->avail[h->n_avail++] = e;
+}
+
+void heap_add(struct heap *h, struct heap_ref *ref, uint64_t priority)
+{
+	PROX_ASSERT(h);
+	PROX_ASSERT(ref);
+	PROX_ASSERT(ref->elem == NULL);
+	PROX_ASSERT(heap_elem_check(h->top, 1));
+	PROX_ASSERT(h->n_elems == heap_calc_size(h));
+
+	if (h->n_elems == 0) {
+		h->n_elems++;
+		h->top = heap_get(h);
+
+		h->top->priority = priority;
+		h->top->ref = ref;
+		ref->elem = h->top;
+		h->top->prev = NULL;
+		h->top->next = NULL;
+		h->top->child = NULL;
+
+		PROX_ASSERT(heap_elem_check(h->top, 1));
+		PROX_ASSERT(h->n_elems == heap_calc_size(h));
+		return ;
+	}
+
+	h->n_elems++;
+	/* New element becomes new top */
+	if (h->top->priority > priority) {
+		struct heap_elem *n = heap_get(h);
+
+		n->priority = priority;
+		n->ref = ref;
+		ref->elem = n;
+		n->prev = NULL;
+		n->next = NULL;
+		n->child = h->top;
+
+		h->top->prev = n;
+		h->top = n;
+	}
+	/* New element is added as first sibling */
+	else {
+		struct heap_elem *n = heap_get(h);
+		n->priority = priority;
+		n->ref = ref;
+		ref->elem = n;
+		n->prev = h->top;
+		n->next = h->top->child;
+		if (h->top->child)
+			h->top->child->prev = n;
+		n->child = NULL;
+		h->top->child = n;
+	}
+
+	PROX_ASSERT(heap_elem_check(h->top, 1));
+	PROX_ASSERT(h->n_elems == heap_calc_size(h));
+}
+
+static void heap_merge_tops_left(struct heap_elem *left, struct heap_elem *right)
+{
+	PROX_ASSERT(left->priority <= right->priority);
+	PROX_ASSERT(left != right);
+
+	/* right moves down and becomes first child of left. */
+	left->next = right->next;
+	if (right->next)
+		right->next->prev = left;
+
+	right->next = left->child;
+	if (left->child)
+		left->child->prev = right;
+
+	/* right->prev is now referring to parent since right is the
+	   new first child. */
+	left->child = right;
+}
+
+static void heap_merge_tops_right(struct heap_elem *left, struct heap_elem *right)
+{
+	PROX_ASSERT(left->priority >= right->priority);
+	PROX_ASSERT(left != right);
+
+	/* Left goes down one layer */
+	right->prev = left->prev;
+	if (left->prev)
+		left->prev->next = right;
+
+	left->next = right->child;
+	if (right->child)
+		right->child->prev = left;
+
+	left->prev = right;
+	right->child = left;
+}
+
+static struct heap_elem *heap_merge_children(struct heap_elem *e)
+{
+	struct heap_elem *next = e->next;
+	struct heap_elem *tmp;
+	struct heap_elem *prev;
+	struct heap_elem *first;
+
+	PROX_ASSERT(e);
+	int cnt = 0;
+	/* TODO: is this really needed? */
+	if (!next)
+		return e;
+
+	if (e->priority < next->priority)
+		first = e;
+	else
+		first = next;
+
+	/* Forward pass */
+	do {
+		cnt++;
+		tmp = next->next;
+		rte_prefetch0(tmp);
+		if (e->priority < next->priority) {
+			heap_merge_tops_left(e, next);
+			prev = e;
+			PROX_ASSERT(e->child == next);
+		}
+		else {
+			heap_merge_tops_right(e, next);
+			PROX_ASSERT(next->child == e);
+			prev = next;
+		}
+
+		if (tmp) {
+			tmp->prev = prev;
+			e = tmp;
+			/* Next could be empty, (uneven # children) */
+			if (!tmp->next)
+				break;
+			next = tmp->next;
+		}
+		else {
+			/* Even number of nodes, after breaking set e
+			   to the last merged pair top */
+			if (e->priority >= next->priority)
+				e = next;
+			break;
+		}
+	} while (1);
+	/* Backward pass, merge everything with the right until the
+	   first child */
+	while (first != e) {
+		prev = e->prev;
+
+		if (e->priority < prev->priority) {
+			heap_merge_tops_right(prev, e);
+			if (prev == first) {
+				first = e;
+				break;
+			}
+		}
+		else {
+			heap_merge_tops_left(prev, e);
+			e = prev;
+		}
+	}
+	return first;
+}
+
+static int heap_elem_first_sibling(const struct heap_elem *e)
+{
+	return e->prev->child == e;
+}
+
+void heap_del(struct heap *h, struct heap_ref *d)
+{
+	struct heap_elem *del = d->elem;
+
+	PROX_ASSERT(del);
+	PROX_ASSERT(heap_elem_in_heap(h, del));
+	PROX_ASSERT(!heap_elem_is_avail(h, del));
+	PROX_ASSERT(h->n_elems == heap_calc_size(h));
+	PROX_ASSERT(heap_elem_check(h->top, 1));
+	PROX_ASSERT(h->top->next == NULL);
+	PROX_ASSERT(h->top->prev == NULL);
+
+	d->elem = NULL;
+	/* Del is at the top */
+	if (del->prev == NULL) {
+		PROX_ASSERT(del == h->top);
+		if (del->child) {
+			del->child->prev = NULL;
+			h->top = heap_merge_children(del->child);
+			PROX_ASSERT(h->top);
+		}
+		else {
+			h->top = NULL;
+		}
+
+		h->n_elems--;
+		heap_put(h, del);
+		PROX_ASSERT(heap_elem_check(h->top, 1));
+		PROX_ASSERT(h->n_elems == 0 || h->top != NULL);
+		PROX_ASSERT(h->n_elems == heap_calc_size(h));
+		return ;
+	}
+	PROX_ASSERT(del != h->top);
+
+	/* Del is somewhere in a lower layer. If it the first child,
+	   need to fix the parent differently. */
+	if (heap_elem_first_sibling(del)) {
+		del->prev->child = del->next;
+		if (del->next)
+			del->next->prev = del->prev;
+	}
+	else {
+		del->prev->next = del->next;
+		if (del->next)
+			del->next->prev = del->prev;
+	}
+
+	struct heap_elem *top2 = del->child;
+
+	/* If the node to be deleted has children, there is more work:
+	   merge the children into a single heap and merge with
+	   top. If there are no children, then the disconnection above
+	   is enough. */
+	if (top2) {
+		top2->prev = NULL;
+		top2 = heap_merge_children(top2);
+
+		/* Merge top2 with h->top */
+		if (h->top->priority < top2->priority) {
+			top2->next = h->top->child;
+			top2->prev = h->top;
+			if (h->top->child)
+				h->top->child->prev = top2;
+
+			h->top->child = top2;
+		}
+		else {
+			h->top->next = top2->child;
+			h->top->prev = top2;
+			if (top2->child)
+				top2->child->prev = h->top;
+
+			top2->child = h->top;
+			h->top = top2;
+		}
+
+	}
+	h->n_elems--;
+	heap_put(h, del);
+
+	PROX_ASSERT(heap_elem_check(h->top, 1));
+	PROX_ASSERT(h->n_elems == heap_calc_size(h));
+}
+
+struct heap_ref *heap_pop(struct heap *h)
+{
+	if (h->n_elems == 0)
+		return NULL;
+
+	struct heap_ref *ret = h->top->ref;
+
+	heap_del(h, h->top->ref);
+	return ret;
+}
diff --git a/VNFs/DPPD-PROX/heap.h b/VNFs/DPPD-PROX/heap.h
new file mode 100644
index 00000000..08e5f1a5
--- /dev/null
+++ b/VNFs/DPPD-PROX/heap.h
@@ -0,0 +1,53 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _HEAP_H_
+#define _HEAP_H_
+
+#include <inttypes.h>
+#include <stdlib.h>
+
+struct heap_ref {
+	struct heap_elem *elem;   /* timer management */
+};
+
+struct heap {
+	uint64_t n_elems;
+	struct heap_elem *top;
+	uint64_t n_avail;
+	struct heap_elem *avail[0];
+};
+
+static uint64_t heap_n_elems(const struct heap *h)
+{
+	return h->n_elems;
+}
+
+static int heap_is_empty(const struct heap *h)
+{
+	return !h->n_elems;
+}
+
+int heap_top_is_lower(struct heap *h, uint64_t prio);
+
+void heap_print(struct heap *h, char *result, size_t buf_len);
+
+struct heap *heap_create(uint32_t max_elems, int socket_id);
+void heap_add(struct heap *h, struct heap_ref *ref, uint64_t priority);
+void heap_del(struct heap *h, struct heap_ref *del);
+struct heap_ref *heap_pop(struct heap *h);
+
+#endif /* _HEAP_H_ */
diff --git a/VNFs/DPPD-PROX/helper-scripts/demo-scripts/prox.py b/VNFs/DPPD-PROX/helper-scripts/demo-scripts/prox.py
new file mode 100644
index 00000000..f9250d21
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/demo-scripts/prox.py
@@ -0,0 +1,53 @@
+#!/bin/env python2.7
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import socket
+
+class prox:
+    def __init__(self, ip):
+        self._ip = ip;
+        self._dat = ""
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            sock.connect((self._ip, 8474))
+        except:
+            raise Exception("Failed to connect to PROX on " + self._ip + ":8474")
+        self._sock = sock;
+
+    def send(self, msg):
+        self._sock.sendall(msg + "\n");
+        return self
+    def recv(self):
+        ret_str = "";
+        done = 0;
+        while done == 0:
+            if (len(self._dat) == 0):
+                self._dat = self._sock.recv(256);
+
+            while(len(self._dat)):
+                if (self._dat[0] == '\n'):
+                    done = 1
+                    self._dat = self._dat[1:]
+                    break;
+                else:
+                    ret_str += self._dat[0];
+                    self._dat = self._dat[1:]
+        return ret_str;
+
+    def wait_cmd_finished(self):
+        self.send("stats hz").recv();
diff --git a/VNFs/DPPD-PROX/helper-scripts/demo-scripts/tx_rate.py b/VNFs/DPPD-PROX/helper-scripts/demo-scripts/tx_rate.py
new file mode 100644
index 00000000..112b583a
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/demo-scripts/tx_rate.py
@@ -0,0 +1,74 @@
+#!/bin/env python2.7
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from prox import *
+from decimal import *
+from time import *
+
+class data_point:
+    value = 0;
+    tsc = 0;
+    def __init__(self, value, tsc):
+        self.value = value;
+        self.tsc = tsc;
+
+def measure_tx(prox_instance, port_id):
+    port_tx_pkt = "port(" + str(port_id) + ").tx.packets"
+    port_tsc = "port(" + str(port_id) + ").tsc";
+    cmd = "stats " + port_tx_pkt + "," + port_tsc;
+    reply = prox_instance.send(cmd).recv().split(",");
+
+    return data_point(int(reply[0]), int(reply[1]));
+
+def get_rate(first, second, hz):
+    tsc_diff = second.tsc - first.tsc;
+    value_diff = second.value - first.value;
+
+    return int(Decimal(value_diff * hz) / tsc_diff)
+
+# make sure that prox has been started with the -t parameter
+prox_instance = prox("127.0.0.1")
+print "Connected to prox"
+
+hz = int(prox_instance.send("stats hz").recv());
+
+print "System is running at " + str(hz) + " Hz"
+
+print "Showing TX pps on port 0"
+
+update_interval = 0.1
+
+print "Requesting new data every " + str(update_interval) + "s"
+
+measure = measure_tx(prox_instance, 0);
+while (True):
+    sleep(update_interval)
+    measure2 = measure_tx(prox_instance, 0);
+
+    # since PROX takes measurements at a configured rate (through
+    # update interval command or throw -r command line parameter), it
+    # might be possible that two consecutive measurements report the
+    # same. To get updates at a frequency higher than 1 Hz,
+    # reconfigure prox as mentioned above.
+
+    if (measure.tsc == measure2.tsc):
+        continue;
+
+    print get_rate(measure, measure2, hz);
+
+    measure = measure2;
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/README b/VNFs/DPPD-PROX/helper-scripts/dpi/README
new file mode 100644
index 00000000..f1100757
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/README
@@ -0,0 +1,41 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+The scripts in this directory characterize flow a DPI-enabled VNF. The
+characeterization is split up into two steps. The first step (dpi1.py)
+searches for the traffic profile parameter boundaries. The second step
+(dpi2.py) takes as input the output of the first step and searches for
+the maximum sustainable throughput of a DPI-enabled VNF.
+
+To run the first script, use:
+
+   python2.7 ./dpi1.py -t TEST_SYSTEM_DESCRIPTIONS -o OUTPUT1
+
+TEST_SYSTEM_DESCRIPTIONS is a comma-separated list of systems where
+the syntax of defining each system is shown below:
+
+   user@ip:proxDir:cfgDir
+
+To run the second script, use:
+
+   python2.7 ./dpi2.py -t TEST_SYSTEM_DESCRIPTIONS \
+   	     -s SYSTEM_UNDER_TEST_DESCRIPTIONS \
+	     -o OUTPUT2 -d \
+	     -i OUTPUT1
+
+Finally, the results can be processed using the following command:
+
+   python2.7 ./maketable.py -i OUTPUT1 -j OUTPUT2 -o FINAL_TABLE
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/config.py b/VNFs/DPPD-PROX/helper-scripts/dpi/config.py
new file mode 100644
index 00000000..ee3f04c6
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/config.py
@@ -0,0 +1,178 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import getopt
+import sys
+from systemconfig import *
+
+class Config:
+    _debug = False;
+    _test_systems = [];
+    _output_file_name = None;
+    _input_file_name = None
+    _input_file_name2 = None
+    _max_port_rate = 0.85
+    _sut = None
+    _accuracy = 2;
+    _threshold = 0.95
+    _once = None
+    _skipTime = 10
+    _testLength = 120
+    _dpiCoreList = range(1, 5)
+    _checkConditions = False;
+    _interCheckDuration = float(1)
+
+    def getInputFileName(self):
+        return self._input_file_name
+
+    def getInputFileName2(self):
+        return self._input_file_name2
+
+    def toString(self):
+        ret = ""
+        ret += "Test systems: \n"
+        for ts in self._test_systems:
+            ret += ts.toString();
+
+        if (self._sut is not None):
+            ret += "SUT: \n"
+            ret += self._sut.toString();
+
+        ret += "Output file name: " + str(self._output_file_name) + "\n"
+        ret += "Max port rate: " + str(self._max_port_rate) + "\n"
+        ret += "Accuracy: " + str(self._accuracy) + " digits after point"
+        return ret
+
+    def getErrorTestOne(self):
+        if (len(self._test_systems) == 0):
+            return "Missing test systems";
+        if (self._output_file_name is None):
+            return "No output file or input file defined";
+        return None
+
+    def getErrorTestTwo(self):
+        if (self._input_file_name is None):
+            return "Input file is missing"
+        if (self._input_file_name == self._output_file_name):
+            return "Input file and output file are the same"
+        return self.getErrorTestOne();
+
+    def getErrorMakeTable(self):
+        if (self._input_file_name is None):
+            return "Missing input file"
+        if (self._input_file_name2 is None):
+            return "Missing file with performance resuilts"
+        if (self._output_file_name is None):
+            return "No output file or input file defined";
+        if (self._input_file_name2 == self._input_file_name):
+            return "Input file used multiple times"
+        if (self._input_file_name == self._output_file_name):
+            return "output file is the same as the input file"
+        if (self._input_file_name2 == self._output_file_name):
+            return "output file is the same as the input file 2"
+
+        return None
+
+    def usageAndExit(self, argv0):
+        print "Usage: " + str(argv0)
+        print "-t    Add a test system, syntax: " + SystemConfig.expectedSyntax()
+        print "-s    Add SUT, syntax: " + SystemConfig.expectedSyntax()
+        print "-o    Ouput file name"
+        print "-a    Accuracy, number of digits after point"
+        print "-i    Input file"
+        print "-j    File with performance results"
+        print "-m    Maximum per port rate, by default 0.85 (85%)"
+        print "-d    Enable debugging"
+        print "-w    Fraction of connections to reach, by default is 0.95 (95%)"
+        print "-h    Show help"
+        print "-q    Run a single test iteration, syntax of argument "
+        print "-b    Skip time, by default 10 sec"
+        print "-l    Test length, by default 120 sec"
+        print "-n    Maximum number of DPI cores to test"
+        print "-k    Period between checking conditions, 1 second by default"
+        print "-c    Check conditions during 10 second period after convergence"
+        print "      is msr,conn,ss (i.e. -q 4000,100000,38.91)"
+        exit(-1);
+
+    def parse(self, programName, args):
+        try:
+            opts, args = getopt.getopt(args, "t:s:o:a:i:q:m:dhw:j:b:l:n:k:c")
+        except getopt.GetoptError as err:
+            print str(err)
+            return;
+        for option, arg in opts:
+            if(option == "-t"):
+                for ts in arg.split(","):
+                    syntaxErr = SystemConfig.checkSyntax(ts)
+                    if (syntaxErr != ""):
+                        print syntaxErr
+                        exit(-1);
+                    self._test_systems.append(SystemConfig(ts));
+            elif(option == "-s"):
+                syntaxErr = SystemConfig.checkSyntax(ts)
+                if (syntaxErr != ""):
+                    print syntaxErr
+                    exit(-1);
+                self._sut = SystemConfig(arg);
+            elif(option == "-w"):
+                self._threshold = float(arg)
+            elif(option == "-o"):
+                self._output_file_name = arg;
+            elif(option == '-a'):
+                self._accuracy = int(arg);
+            elif(option == "-i"):
+                self._input_file_name = arg;
+            elif(option == "-j"):
+                self._input_file_name2 = arg;
+            elif(option == "-q"):
+                self._once = arg.split(",")
+            elif(option == "-c"):
+                self._checkConditions = True;
+            elif(option == "-m"):
+                self._max_port_rate = float(arg);
+            elif(option == "-k"):
+                self._interCheckDuration = float(arg);
+            elif(option == "-d"):
+                self._debug = True
+            elif(option == '-h'):
+                self.usageAndExit(programName)
+            elif(option == '-b'):
+                self._skipTime = int(arg)
+            elif(option == '-l'):
+                self._testLength = int(arg)
+            elif(option == '-n'):
+                self._dpiCoreList = self.strToList(arg)
+            else:
+                self.usageAndExit(programName);
+
+    def strToList(self, arg):
+        elements = [];
+        tokens = arg.split(",");
+
+        for a in tokens:
+            if (a.count('-') == 0):
+                elements.append(int(a))
+            elif (a.count('-') == 1):
+                beg = int(a.split('-')[0]);
+                end = int(a.split('-')[1]);
+                if (beg > end):
+                    raise Exception("Invalid list input format")
+                elements += range(beg, end + 1);
+            else:
+                raise Exception("Invalid list input format")
+        return elements;
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/csvreader.py b/VNFs/DPPD-PROX/helper-scripts/dpi/csvreader.py
new file mode 100644
index 00000000..b0b650dc
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/csvreader.py
@@ -0,0 +1,78 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from decimal import *
+
+class CsvReaderError:
+    def __init__(self, msg):
+        self._msg = msg;
+
+    def __str__(self):
+        return self._msg;
+
+class CsvReader:
+    def __init__(self, fieldTypes = None):
+        self._file_name = None;
+        self._fieldTypes = fieldTypes;
+
+    def open(self, file_name):
+        self._file = open(file_name, 'r');
+        self._file_name = file_name;
+
+    def read(self):
+        line = "#"
+        while (len(line) != 0 and line[0] == "#"):
+            line = self._file.readline();
+
+        if (len(line) != 0):
+            return self._lineToEntry(line)
+        else:
+            return None;
+
+    def _lineToEntry(self, line):
+        split = line.strip().split(',');
+        if (self._fieldTypes is None):
+            return split;
+        have = len(split)
+        expected = len(self._fieldTypes)
+        if (have != expected):
+            raise CsvReaderError("Invalid number of fields %d != %d" % (have, expected))
+
+        entry = {};
+        for i in range(len(self._fieldTypes)):
+            curFieldType = self._fieldTypes[i][1]
+            curFieldName = self._fieldTypes[i][0];
+            if (curFieldType == "int"):
+                entry[curFieldName] = int(split[i])
+            elif (curFieldType == "Decimal"):
+                entry[curFieldName] = Decimal(split[i])
+            else:
+                raise CsvReaderError("Invalid field type %s" % curFieldType);
+        return entry;
+
+    def readAll(self):
+        ret = []
+        line = self.read();
+        while (line != None):
+            ret.append(line);
+            line = self.read();
+        return ret;
+
+    def close(self):
+        self._file.close();
+        self._file = None;
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/csvwriter.py b/VNFs/DPPD-PROX/helper-scripts/dpi/csvwriter.py
new file mode 100644
index 00000000..a5f055e8
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/csvwriter.py
@@ -0,0 +1,35 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+class CsvWriter:
+    def __init__(self):
+        self._file_name = None;
+
+    def open(self, file_name):
+        self._file = open(file_name, 'w');
+        self._file_name = file_name;
+
+    def write(self, elements):
+        elements_str = map(lambda x: str(x), elements);
+        line = ",".join(elements_str);
+        self._file.write(line + "\n");
+        self._file.flush();
+
+    def close(self):
+        self._file.close();
+        self._file = None;
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/dpi1.py b/VNFs/DPPD-PROX/helper-scripts/dpi/dpi1.py
new file mode 100644
index 00000000..ec3e4a03
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/dpi1.py
@@ -0,0 +1,243 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from testerset import *
+from time import sleep
+from time import time
+from decimal import *
+import copy
+from os import system
+import socket
+from itertools import chain
+from math import *
+from csvwriter import *
+from config import *
+from progress import *
+from proxmaxssprobe import *
+
+def runTest(minSetupRate, testParam):
+    print "Running test with following parameters:"
+    print testParam.toString();
+
+    testers = testerSet(config._test_systems, config._max_port_rate, testParam);
+
+    thresh = testParam.getConnections();
+    p = Progress(thresh, ["connections", "setup rate", "reTX"], False);
+    loop_count = 0;
+    converged = False;
+
+    testers.startForkJoin();
+    testers.wait_links_up();
+    testers.start_cores();
+
+    print "Running until convergence (%s connections)" % str(thresh)
+    while (not converged):
+        sleep(config._interCheckDuration)
+        testers.update_stats();
+        tot = testers.get_total_connections();
+        tot_retx = testers.get_total_retx();
+        rates = testers.get_rates();
+        curSetupRate = testers.get_setup_rate();
+        ierrors = testers.getIerrors();
+
+        converged = tot >= thresh;
+        if (not converged):
+            if (loop_count > 0 and curSetupRate < minSetupRate):
+                reason = str(curSetupRate) + " < " + str(minSetupRate);
+                print "Current setup rate is lower than min setup rate: " +  reason
+                testers.killProx();
+                return False, [];
+            if (not testers.conditionsGood()):
+                print "conditions are bad: " + testers.getReason();
+                testers.killProx();
+                return False, [];
+
+        if (config._debug):
+            p.setProgress(tot, [tot, curSetupRate, tot_retx]);
+            print p.toString();
+        loop_count += 1;
+    print "converged"
+
+    skipTime = config._skipTime
+    print "Connection threshold reached, waiting for " + str(skipTime) + "s, conditions checked = " + str(config._checkConditions)
+    while (skipTime > 0):
+        skipTime -= config._interCheckDuration
+        sleep(config._interCheckDuration)
+        testers.update_stats();
+        if (config._checkConditions and not testers.conditionsGood()):
+            print "conditions are bad: " + testers.getReason();
+            testers.killProx();
+            return False, [];
+
+    testers.tx_rate_meassurement();
+
+    testLength = config._testLength
+    print "Waiting final " + str(testLength) + "s"
+    while (testLength > 0):
+        testLength -= config._interCheckDuration
+        sleep(config._interCheckDuration)
+        testers.update_stats();
+        if (not testers.conditionsGood()):
+            print "conditions are bad: " + testers.getReason();
+            testers.killProx();
+            return False, [];
+
+    rates = testers.tx_rate_meassurement();
+
+    testers.killProx();
+    return True, rates;
+
+def find_ss(tot_conn, maxSetupRate, ss_max):
+    iterationCount = 0;
+    valid_ss = []
+    speed_ss = [];
+
+    # The setup rate must be in [0.2% of total connections, maxSetupRate]
+    # Also, it must not be hihger than 50% of the total connections
+    min_setup_rate = tot_conn / 500;
+
+    if (min_setup_rate > maxSetupRate):
+        print "min setup rate > max setup rate: " + str(min_setup_rate) + " > " + str(maxSetupRate);
+        return valid_ss, speed_ss;
+    if (maxSetupRate > tot_conn / 2):
+        print "maximum setup rate (" + str(maxSetupRate) + ") is more than 50% of " + str(tot_conn)
+        return valid_ss, speed_ss;
+
+    accuracy = 10**config._accuracy
+    ss_lo = 1
+    ss_hi = int(round(ss_max * accuracy,0))
+
+    iterationOverride = [ss_hi, ss_lo];
+    # Binary search for highest speed scaling
+    while (ss_lo <= ss_hi):
+        if (iterationCount < len(iterationOverride)):
+            ss = iterationOverride[iterationCount]
+        else:
+            ss = (ss_lo + ss_hi)/2;
+
+        testParam = TestParameters(maxSetupRate, tot_conn, float(ss)/accuracy);
+
+        success, rates = runTest(min_setup_rate, testParam);
+        print "success = " + str(success) + ", rates = " + str(rates)
+        if (success == True):
+            valid_ss.append(float(ss)/accuracy);
+            speed_ss.append(sum(rates)/len(rates))
+            ss_lo = ss + 1
+        else:
+            ss_hi = ss - 1;
+        iterationCount += 1
+    return valid_ss, speed_ss;
+
+def get_highest_ss_and_speed(valid_ss, speed_ss):
+    highest_ss = None;
+    highest_speed = None;
+
+    for i in range(len(valid_ss)):
+        if(highest_ss == None or highest_ss < valid_ss[i]):
+            highest_ss = valid_ss[i];
+            highest_speed = speed_ss[i];
+    return highest_ss, highest_speed;
+
+def get_max_ss():
+    ts = config._test_systems[0];
+    test_system = ProxMaxSSProbe(ts);
+    max_ss = test_system.getMaxSS();
+
+    return floor((max_ss * (10**config._accuracy)))/(10**config._accuracy)
+
+config = Config();
+config.parse(sys.argv[0], sys.argv[1:])
+
+err = config.getErrorTestOne();
+if (err is not None):
+    print "Invalid configuration: " + err;
+    exit(-1);
+else:
+    print config.toString()
+
+if (config._once is not None):
+    maxSetupRate = int(config._once[0])
+    minSetupRate = maxSetupRate/500
+    connections = int(config._once[1])
+    speedScaling = float(config._once[2])
+
+    testParam = TestParameters(maxSetupRate, connections, speedScaling)
+    success, rates = runTest(minSetupRate, testParam)
+    print "success = " + str(success) + ", port rates = " + str(rates)
+    exit(0);
+
+msr_list = []
+msr_list += range(4000, 20000, 2000)
+msr_list += range(20000, 100000, 20000)
+msr_list += range(100000, 300000, 50000)
+msr_list += range(300000, 800001, 100000);
+
+conn_list = [1*10**5, 2*10**5, 4*10**5, 8*10**5, 1*10**6, 2*10**6]
+
+summary_file = CsvWriter()
+summary_file.open(config._output_file_name)
+
+tot_it = 0;
+for tot_conn in conn_list:
+    for msr in msr_list:
+        if (msr >= tot_conn/2):
+            break;
+        tot_it += 1
+
+cnt = -1;
+print "Search will include " + str(tot_it) + " parameter combinations"
+print "Will search for highest link utilization"
+
+# If the lowest msr was a for n connections, then the lowest msr
+# for n + 1 connections can't be lower than a.
+low_sr = msr_list[0];
+
+max_ss = get_max_ss()
+
+high_ss = Decimal(max_ss)
+
+globalProgress = Progress(tot_it)
+globalProgress.setProgress(0);
+for tot_conn in conn_list:
+    had_success = False;
+    all_ss = []
+    for msr in msr_list:
+        globalProgress.incrProgress();
+
+        if (msr < low_sr):
+            print "skipping " + str(msr) + " since it is lower than " + str(low_sr)
+            continue;
+
+        print globalProgress.toString();
+
+        valid_ss, speed_ss = find_ss(tot_conn, msr, high_ss)
+        print "valid ss = " + str(valid_ss)
+        print "valid speeds = " + str(speed_ss)
+
+        if (len(valid_ss) > 0):
+            highest_ss, highest_speed = get_highest_ss_and_speed(valid_ss, speed_ss);
+            summary_file.write([msr, tot_conn, highest_ss, highest_speed]);
+
+            if (not had_success):
+                low_sr = msr;
+
+            had_success = True;
+        all_ss = all_ss + valid_ss;
+
+    if (len(all_ss) > 0):
+        high_ss = max(all_ss);
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/dpi2.py b/VNFs/DPPD-PROX/helper-scripts/dpi/dpi2.py
new file mode 100644
index 00000000..65473f61
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/dpi2.py
@@ -0,0 +1,229 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from testerset import *
+from proxdpisut import *
+from statsconsfile import *
+from time import sleep
+from time import time
+from decimal import *
+import copy
+from os import system
+import socket
+from itertools import chain
+from math import *
+from csvwriter import *
+from csvreader import *
+from config import *
+from progress import *
+from resultprocessor import *
+
+def runTest(coreCount, testParam):
+    print "Running test with following parameters:"
+    print testParam.toString();
+
+
+    testers = testerSet(config._test_systems, config._max_port_rate, testParam);
+
+    ret = TestResult(testers.getCount());
+    thresh = testParam.getConnections() * config._threshold;
+    converged = False;
+
+    sut = ProxDpiSut(config._sut, coreCount);
+
+    testers.startFork();
+    sut.startFork();
+    testers.startJoin();
+    sut.startJoin();
+    testers.wait_links_up();
+    sut.startAllCores();
+    sut.waitCmdFinished();
+    testers.start_cores();
+
+    ret.addTimeTS(testers.getTsc());
+    ret.addTimeSUT(sut.getTsc());
+
+    print "Running until convergence (%s connections)" % str(thresh)
+    p = Progress(thresh, ["connections", "setup rate", "reTX"], False);
+    while (not converged):
+        sleep(config._interCheckDuration)
+        testers.update_stats();
+
+        tot = testers.get_total_connections();
+        tot_retx = testers.get_total_retx();
+        rates = testers.get_rates();
+        cur_setup_rate = testers.get_setup_rate();
+        ierrors = testers.getIerrors();
+        converged = tot >= thresh;
+
+        if (not converged and not testers.conditionsGood()):
+            print "conditions are bad: " + testers.getReason();
+            sut.forceQuit();
+            sut.killProx();
+            testers.killProx();
+            return None;
+
+        if (sut.getIerrors() != 0):
+            testers.killProx();
+            print "Sending quit"
+            try:
+                sut.forceQuit();
+            except:
+                print "Sending quit failed"
+            sut.killProx();
+            return None;
+
+        if (config._debug):
+            p.setProgress(tot, [tot, cur_setup_rate, tot_retx]);
+            print p.toString();
+
+    skipTime = config._skipTime
+    print "Connection threshold reached, waiting for " + str(skipTime) + "s, conditions checked = " + str(config._checkConditions)
+    while (skipTime > 0):
+        skipTime -= config._interCheckDuration
+        sleep(config._interCheckDuration)
+        testers.update_stats();
+        if (config._checkConditions and not testers.conditionsGood()):
+            print "conditions are bad: " + testers.getReason();
+            sut.forceQuit();
+            sut.killProx();
+            testers.killProx();
+            return False, [];
+
+    ret.addTimeTS(testers.getTsc());
+    ret.addTimeSUT(sut.getTsc());
+
+    testers.tx_rate_meassurement();
+
+    testLength = config._testLength
+    print "Waiting final " + str(testLength) + "s"
+    while (testLength > 0):
+        testLength -= config._interCheckDuration
+        testers.update_stats();
+        if (not testers.conditionsGood()):
+            print "conditions are bad: " + testers.getReason();
+            sut.forceQuit();
+            sut.killProx();
+            testers.killProx();
+            return None;
+
+        if (sut.getIerrors() != 0):
+            testers.killProx();
+            print "Sending quit"
+            try:
+                sut.forceQuit();
+            except:
+                print "Sending quit failed"
+            sut.killProx();
+            return None;
+
+        sleep(config._interCheckDuration)
+
+    rates = testers.tx_rate_meassurement();
+    ret.addTimeTS(testers.getTsc());
+    ret.addTimeSUT(sut.getTsc());
+
+    print "Quiting Prox on SUT"
+    # make sure stats are flushed
+    sut.quitProx();
+    print "Quiting Prox on test system(s)"
+    testers.quitProx()
+
+    ret.rates = rates
+
+    sutStatsDump = "stats_dump_sut"
+    tsStatsDumpBaseName = "stats_dump_ts"
+
+    sut.scpStatsDump(sutStatsDump);
+    tsStatsDump = testers.scpStatsDump(tsStatsDumpBaseName);
+
+    ret.setTSStatsDump(tsStatsDump);
+    ret.setSUTStatsDump(sutStatsDump);
+    return ret
+
+def meassurePerf(coreCount, maxSetupRate, total_connections, ss_hi):
+    iterationCount = 0;
+    accuracy = 10**config._accuracy
+    ss_lo = 1
+    ss_hi = int(round(ss_hi * accuracy, 0))
+    success = True;
+
+    downrate = float(0)
+    highest_ss = 0
+    iterationOverride = [ss_hi, ss_lo];
+    while (ss_lo <= ss_hi):
+        if (iterationCount < len(iterationOverride)):
+            ss = iterationOverride[iterationCount]
+        else:
+            ss = (ss_lo + ss_hi)/2;
+
+        testParam = TestParameters(maxSetupRate, total_connections, float(ss)/accuracy);
+
+        result = runTest(coreCount, testParam);
+
+        if (result is None):
+            success = False
+        else:
+            rp = ResultProcessor(result)
+            rp.process();
+            success = rp.percentHandled() > 0.99999
+
+        print "test result = " + str(success)
+        if (success):
+            ss_lo = ss + 1;
+            highest_ss = max(highest_ss, ss);
+            print result.rates
+            downrate = sum(result.rates)/len(result.rates)
+        else:
+            ss_hi = ss - 1;
+        iterationCount += 1
+
+    return downrate, float(highest_ss)/accuracy
+
+config = Config();
+config.parse(sys.argv[0], sys.argv[1:])
+
+err = config.getErrorTestTwo();
+if (err is not None):
+    print "Invalid configuration: " + err;
+    exit(-1);
+else:
+    print config.toString()
+
+infileFields = []
+infileFields += [("msr", "int")]
+infileFields += [("conn", "int")]
+infileFields += [("ss", "Decimal")]
+infileFields += [("bw", "Decimal")]
+
+infile = CsvReader(infileFields);
+infile.open(config.getInputFileName())
+inputs = infile.readAll()
+infile.close();
+
+summary = CsvWriter();
+summary.open(config._output_file_name);
+
+print "Will test up SUT config with " + str(config._dpiCoreList) + " DPI cores"
+
+for a in inputs:
+    for coreCount in config._dpiCoreList:
+        downrate, ss = meassurePerf(coreCount, a["msr"], a["conn"], a["ss"]);
+        summary.write([coreCount, a["msr"], a["conn"], ss, downrate]);
+
+summary.close()
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/maketable.py b/VNFs/DPPD-PROX/helper-scripts/dpi/maketable.py
new file mode 100644
index 00000000..f8b7bdc0
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/maketable.py
@@ -0,0 +1,140 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import sys
+from config import *
+from csvreader import *
+from sets import Set
+from csvwriter import *
+
+class ResultEntry:
+    def __init__(self):
+        self.boundary = None;
+        self.cores = {}
+
+    def setBoundary(self, val):
+        self.boundary = val;
+
+    def addCoreResult(self, core, val):
+        self.cores[core] = val
+
+    def getCoreResult(self, core):
+        if (core in self.cores):
+            return self.cores[core];
+        return None;
+
+    def getBoundary(self):
+        return self.boundary;
+
+    def getCores(self):
+        return self.cores
+
+    def getMsr(self):
+        return self.msr;
+
+class DictEntry:
+    def __init__(self, key):
+        self.dictionary = {}
+        self.entries = []
+        self.key = key;
+
+config = Config();
+config.parse(sys.argv[0], sys.argv[1:])
+
+err = config.getErrorMakeTable();
+
+if (err is not None):
+    print err
+    exit(-1);
+
+if (config._debug):
+    print "Performance data: " + config.getInputFileName2()
+    print "Boundaries: " + config.getInputFileName()
+
+allData = {}
+
+infileFields = []
+infileFields += [("msr", "int")]
+infileFields += [("conn", "int")]
+infileFields += [("ss", "Decimal")]
+infileFields += [("bw", "Decimal")]
+
+boundariesFile = CsvReader(infileFields)
+boundariesFile.open(config.getInputFileName());
+boundaries = boundariesFile.readAll();
+
+cores = Set()
+
+orderedResults = []
+finalResults = {}
+
+for a in boundaries:
+    key = a["conn"]
+    if (key not in finalResults):
+        newDict = DictEntry(key)
+        finalResults[key] = newDict
+        orderedResults.append(newDict)
+
+for a in boundaries:
+    table = finalResults[a["conn"]]
+    key = a["msr"]
+    value = ResultEntry()
+    value.msr = a["msr"]
+    value.conn = a["conn"]
+    value.boundary = a["bw"]
+    table.dictionary[key] = value
+    table.entries.append(value)
+
+infileFields2 = []
+infileFields2 += [("cores", "int")]
+infileFields2 += [("msr", "int")]
+infileFields2 += [("conn", "int")]
+infileFields2 += [("ss", "Decimal")]
+infileFields2 += [("down", "Decimal")]
+
+resultsFile = CsvReader(infileFields2)
+resultsFile.open(config.getInputFileName2())
+
+for a in resultsFile.readAll():
+    table = finalResults[a["conn"]]
+    key = a["msr"]
+    table.dictionary[key].addCoreResult(a["cores"], a["down"])
+    cores.add(a["cores"]);
+
+
+outputFile = CsvWriter()
+
+outputFile.open(config._output_file_name)
+
+title = ["setup rate", "maximum"]
+for e in sorted(cores):
+    title += [str(e)]
+
+for a in orderedResults:
+    outputFile.write(["connections = " + str(a.key)])
+    outputFile.write(title)
+
+    for e in a.entries:
+        line = [str(e.getMsr())]
+        line += [str(e.getBoundary())]
+        for c in sorted(cores):
+            if (e.getCoreResult(c) is not None):
+                line += [str(e.getCoreResult(c))]
+            else:
+                line += [""]
+        outputFile.write(line)
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/progress.py b/VNFs/DPPD-PROX/helper-scripts/dpi/progress.py
new file mode 100644
index 00000000..5e44c678
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/progress.py
@@ -0,0 +1,67 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from decimal import *
+from time import time
+
+class Progress:
+    def __init__(self, limit, fieldNames = [], overallETA = True):
+        self._fieldNames = fieldNames;
+        self._limit = limit;
+        self._progress = 0;
+        self._prevProgress = 0;
+        self._prevTime = 0;
+        self._progressSetCount = 0;
+        self._time = 0;
+        self._overallETA = overallETA;
+
+    def setProgress(self, progress, fieldValues = []):
+        self._fieldValues = fieldValues;
+        if (self._overallETA == True):
+            self._progress = progress
+            self._time = time();
+            if (self._progressSetCount == 0):
+                self._prevProgress = self._progress;
+                self._prevTime = self._time;
+        else:
+            self._prevProgress = self._progress;
+            self._prevTime = self._time;
+            self._progress = progress;
+            self._time = time();
+        self._progressSetCount += 1
+
+    def incrProgress(self):
+        self.setProgress(self._progress + 1);
+
+    def toString(self):
+        ret = ""
+        ret += str(self._getETA()) + " seconds left"
+        for f,v in zip(self._fieldNames, self._fieldValues):
+            ret += ", %s=%s" % (str(f),str(v))
+        return ret;
+
+    def _getETA(self):
+        if (self._progressSetCount < 2):
+            return "N/A"
+        diff = self._progress - self._prevProgress;
+        t_diff = Decimal(self._time - self._prevTime);
+        if (t_diff < 0.001 or diff <= 0):
+            return "N/A"
+        rate = Decimal(diff)/t_diff
+        remaining = Decimal(self._limit - self._progress);
+        return round(remaining/rate, 2);
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/prox.py b/VNFs/DPPD-PROX/helper-scripts/dpi/prox.py
new file mode 100644
index 00000000..60ef7592
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/prox.py
@@ -0,0 +1,253 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import threading
+from time import *
+from proxsocket import *
+from remotesystem import *
+
+class ProxStarter:
+    def __init__(self, remoteSystem, cmd):
+	self._remoteSystem = remoteSystem
+	self._cmd = cmd
+	self._thread = None
+	self._prox = None;
+	self._result = None;
+	self._startDuration = None
+
+    def startThreaded(self):
+	self._start_thread = threading.Thread(target = self._run, args = (self, 1))
+        self._start_thread.start();
+
+    def joinThreaded(self):
+	self._start_thread.join();
+	return self._result;
+
+    def getResult(self):
+	return self._result;
+
+    def getStartDuration(self):
+	return self._startDuration;
+    def getProx(self):
+        return self._prox;
+
+    def _run(self, a, b):
+	before = time.time()
+	self._remoteSystem.run("sudo killall -w -q -9 prox")
+
+	self._result = self._remoteSystem.run(self._cmd);
+
+	sleep(1)
+	after = time.time()
+	self._startDuration = after - before;
+
+class StatsCmd(object):
+    def __init__(self, prox):
+        self._cmd = ""
+        self._parts = []
+        self._beforeParts = []
+        self._prox = prox;
+
+    def sendRecv(self):
+        cmd = self.getCmd()
+        reply = self._prox._send(cmd)._recv()
+        self.setReply(reply)
+
+    def add(self, stats):
+        if (len(self._cmd) != 0):
+            self._cmd += ","
+        self._cmd += stats
+
+        if (len(self._parts) == 0):
+            self._beforeParts += [0]
+        else:
+            before = self._parts[-1] + self._beforeParts[-1];
+            self._beforeParts += [before]
+
+        self._parts += [stats.count(",") + 1];
+
+    def getCmd(self):
+        return "stats " + self._cmd;
+
+    def setReply(self, reply):
+        self._reply = reply.split(",");
+
+    def getResult(self, idx):
+        start = self._beforeParts[idx];
+        end = start + self._parts[idx];
+        return self._reply[start:end]
+
+class Prox(object):
+    def __init__(self, systemConfig):
+        self._systemConfig = systemConfig;
+        self._proxStarter = None
+
+        user = self._systemConfig._user
+        ip = self._systemConfig._ip
+        self._remoteSystem = remoteSystem(user, ip);
+
+        self.resetArguments()
+
+    def resetArguments(self):
+        self._args = []
+
+    def addArgument(self, arg):
+        self._args.append(arg);
+
+    def startFork(self):
+        cmd = self.getCmd();
+        self._proxStarter = ProxStarter(self._remoteSystem, cmd)
+        self._proxStarter.startThreaded();
+
+    def startJoin(self):
+        ret = self.startJoinNoConnect();
+        self._connectSocket();
+        self._querySetup();
+        return self._proxStarter.getStartDuration();
+
+    def startJoinNoConnect(self):
+        return self._proxStarter.joinThreaded();
+
+    def getCmd(self):
+        proxDir = self._systemConfig.getProxDir();
+        cfgFile = self._systemConfig.getCfgFile();
+
+        cmd = "cd " + proxDir + "; "
+        cmd += "sudo ./build/prox "
+        cmd += "-f " + cfgFile
+
+        for arg in self._args:
+            cmd += " " + arg
+        return cmd
+
+    def getLog(self):
+        proxDir = self._systemConfig.getProxDir()
+        cmd = "cat " + proxDir + "/prox.log";
+	return self._remoteSystem.run(cmd)["out"];
+
+    def getIP(self):
+        return self._systemConfig._ip;
+
+    def getHz(self):
+        return self._hz;
+
+    def getBeg(self):
+        return self._beg;
+
+    def getPorts(self):
+        return self._ports;
+
+    def getIerrors(self):
+        sc = StatsCmd(self)
+        sc.add(self._buildIerrorsCmd());
+        sc.sendRecv()
+        return self._parseIerrorsReply(sc.getResult(0));
+
+    def _parseIerrorsReply(self, rep):
+        tot_ierrors = 0;
+        for e in rep:
+            tot_ierrors += int(e);
+        return tot_ierrors;
+
+    def _buildIerrorsCmd(self):
+        cmd = ""
+        for port in self._ports:
+            if (len(cmd)):
+                cmd += ","
+            cmd += "port(%s).ierrors" % str(port)
+        return cmd;
+
+    def waitCmdFinished(self):
+        self._send("stats hz")._recv();
+
+    def waitAllLinksUp(self):
+        link_down = True;
+        while (link_down):
+            link_down = False;
+            for port in self._ports:
+                cmd = "port link state %s" % str(port)
+                link_state = self._send(cmd)._recv();
+                if (link_state == "down"):
+                    link_down = True;
+                    print "Link down on port " + str(port) + ", waiting one second"
+                    break;
+            sleep(1);
+
+    def startAllCores(self):
+        self._send("start all");
+
+    def stopAllCores(self):
+        self._send("stop all");
+
+    def forceQuit(self):
+        self._send("quit_force")._recv();
+
+    def killProx(self):
+        self._remoteSystem.run("sudo killall -w -q -9 prox")
+
+    def getTsc(self):
+        return self._getTsc();
+
+    def _getTsc(self):
+        return int(self._send("stats global.tsc")._recv());
+
+    def scpStatsDump(self, dst):
+        proxDir = self._systemConfig.getProxDir()
+
+        src = proxDir + "/stats_dump";
+        print "Copying " + src + " to " + dst
+        self._remoteSystem.scp(src, dst);
+
+    def _querySetup(self):
+        print "Query setup on " + str(self.getIP())
+        self._queryHz()
+        self._queryBeg()
+        self._queryPorts()
+        self._querySetup2()
+
+    def _querySetup2(self):
+        print "running query 2"
+        pass
+
+    def quitProx(self):
+        self._send("quit")._recv();
+
+    def _queryHz(self):
+        self._hz = int(self._send("stats hz")._recv());
+
+    def _queryBeg(self):
+        self._beg = self._getTsc();
+
+    def _queryPorts(self):
+        self._ports = []
+        port_info_all = self._send("port info all")._recv();
+        port_info_list = port_info_all.split(',');
+
+        for port_info in port_info_list:
+            if (len(port_info) > 0):
+                self._ports.append(int(port_info.split(":")[0]));
+
+    def _connectSocket(self):
+        self._proxSocket = ProxSocket(self.getIP())
+
+    def _send(self, msg):
+        self._proxSocket.send(msg);
+        return self
+
+    def _recv(self):
+        return self._proxSocket.recv();
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/proxdpisut.py b/VNFs/DPPD-PROX/helper-scripts/dpi/proxdpisut.py
new file mode 100644
index 00000000..aae900b0
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/proxdpisut.py
@@ -0,0 +1,61 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from prox import *
+from remotesystem import *
+from time import *
+from decimal import *
+
+class ProxDpiSut(Prox):
+    def __init__(self, ts, coreCount):
+        super(ProxDpiSut, self).__init__(ts)
+
+        self._setDefaultArguments();
+        self._setDpiCoreCount(coreCount);
+
+    def _setDefaultArguments(self):
+        self.addArgument("-e");
+        self.addArgument("-t");
+        self.addArgument("-k");
+        self.addArgument("-d");
+        self.addArgument("-r 0.01");
+
+    def _setDpiCoreCount(self, count):
+        self.addArgument("-q dpi_core_count=" + str(count))
+
+    def _querySetup2(self):
+        self._query_cores();
+
+    def _query_cores(self):
+        print "querying cores"
+        self._wk = self._get_core_list("$wk");
+
+    def _get_core_list(self, var):
+        ret = []
+        result = self._send("echo " + var)._recv();
+        for e in result.split(","):
+            ret += [e];
+        return ret;
+
+    def getTsc(self):
+        cmd = "stats task.core(%s).task(0).tsc" % self._wk[-1]
+        res = int(self._send(cmd)._recv());
+        if (res == 0):
+            return self._getTsc();
+        else:
+            return res;
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/proxdpitester.py b/VNFs/DPPD-PROX/helper-scripts/dpi/proxdpitester.py
new file mode 100644
index 00000000..19b08c92
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/proxdpitester.py
@@ -0,0 +1,258 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from prox import *
+from remotesystem import *
+from time import *
+from decimal import *
+from timeseriespoint import *
+
+class TestParameters:
+    def __init__(self, max_setup_rate, total_connections, ss):
+        self.max_setup_rate = max_setup_rate;
+        self.total_connections = total_connections;
+        self.ss = ss;
+
+    def toString(self):
+        ret = ""
+        ret += "\tMaximum setup rate          = %d\n" % self.max_setup_rate
+        ret += "\tTotal number of connections = %d\n" % self.total_connections
+        ret += "\tSpeed scaling               = %s\n" % str(self.ss)
+        return ret;
+
+    def getPerSystem(self, count):
+        msr = self.max_setup_rate / count
+        cnn = self.total_connections / count
+        return TestParameters(msr, cnn, self.ss);
+
+    def getConnections(self):
+        return self.total_connections;
+
+class ProxDpiTester(Prox):
+    TENGIGABITBYTESPERSECOND = 1250000000
+
+    def __init__(self, ts, testParam, ID):
+        super(ProxDpiTester, self).__init__(ts)
+
+	self._sc = None
+	self._lastTot = None
+	self._prevTot = None;
+	self._prevBytesClient = None
+	self._lastBytesClient = None
+	self._prevBytesTxMeassurement = None
+	self._lastBytesTxMeassurement = None
+
+	self._setDefaultArguments();
+	self._setMsr(testParam.max_setup_rate)
+	self._setConnections(testParam.total_connections);
+	self._setSpeedScaling(testParam.ss);
+	self._setID(ID);
+
+    def _setDefaultArguments(self):
+        self.addArgument("-e")
+        self.addArgument("-t")
+        self.addArgument("-k")
+        self.addArgument("-d")
+        self.addArgument("-r 0.01");
+
+    def _setMsr(self, msr):
+        self.addArgument("-q max_setup_rate=" + str(msr))
+
+    def _setConnections(self, connections):
+        self.addArgument("-q connections=" + str(connections))
+
+    def _setID(self, ID):
+        self.addArgument("-q test_system_id=" + str(ID))
+
+    def _setSpeedScaling(self, ss):
+        self.addArgument("-q ss=" + str(ss))
+
+    def _querySetup2(self):
+        self._query_client_ports();
+        self._query_server_ports();
+        self._query_cores();
+
+    def _query_client_ports(self):
+        self._client_ports = []
+        for i in range(0, len(self._ports), 2):
+            self._client_ports.append(self._ports[i]);
+
+    def _query_server_ports(self):
+        self._server_ports = []
+        for i in range(1, len(self._ports), 2):
+            self._server_ports.append(self._ports[i]);
+
+    def _query_cores(self):
+        self._query_ld();
+        self._query_servers();
+        self._query_clients();
+
+    def _query_ld(self):
+        self._ld = self._get_core_list("$all_ld");
+
+    def _query_servers(self):
+        self._servers = self._get_core_list("$all_servers")
+
+    def _query_clients(self):
+        self._clients = self._get_core_list("$all_clients")
+
+    def _get_core_list(self, var):
+        ret = []
+        result = self._send("echo " + var)._recv();
+        for e in result.split(","):
+            ret += [e];
+        return ret;
+
+    def start_all_ld(self):
+        self._send("start $all_ld");
+
+    def start_all_workers(self):
+        self._send("start $all_workers");
+
+    def stop_all_ld(self):
+        self._send("stop $all_ld");
+
+    def stop_all_workers(self):
+        self._send("stop $all_workers");
+
+    def update_stats(self):
+        if (self._sc is None):
+            self._sc = StatsCmd(self)
+            self._sc.add(self._buildTotalConnectionsCmd())
+            self._sc.add(self._buildReTXCmd())
+            self._sc.add(self._buildIerrorsCmd())
+            self._sc.add(self._buildBytesPerPortCmd(self._client_ports, "rx"));
+
+        self._sc.sendRecv()
+
+        self._updateTotalConnections(self._sc.getResult(0))
+        self._updateReTX(self._sc.getResult(1))
+        self._updateIerrors(self._sc.getResult(2))
+        self._update_rates_client_ports(self._sc.getResult(3));
+
+    def _buildTotalConnectionsCmd(self):
+        cmd = "l4gen(%s).tsc" % str(self._clients[0])
+
+        for core in self._clients:
+            if (len(cmd) > 0):
+                cmd += ","
+            cmd += "l4gen(%s).created,l4gen(%s).finished" % (str(core), str(core))
+        return cmd;
+
+    def _updateTotalConnections(self, rep):
+        instant = Decimal(int(rep[0]) - self._beg)/self._hz
+        rep = rep[1:]
+        tot = 0;
+        for i in range(0,len(rep), 2):
+            tot += int(rep[i]) - int(rep[i + 1]);
+
+        prev = self._lastTot;
+        last = TimeSeriesPoint(tot, instant);
+
+        if (prev == None):
+            prev = last;
+
+        self._prevTot = prev
+        self._lastTot = last;
+
+    def _buildReTXCmd(self):
+        cmd = ""
+        for core in self._clients + self._servers:
+            if (len(cmd) > 0):
+                cmd += ","
+            cmd += "l4gen(%s).retx" % str(core)
+        return cmd;
+
+    def _updateReTX(self, rep):
+        retx = 0;
+        for i in rep:
+            retx += int(i);
+        self._retx = retx;
+
+    def _updateIerrors(self, rep):
+        self._ierrors = self._parseIerrorsReply(rep)
+
+    def get_total_connections(self):
+        return self._lastTot.getValue()
+
+    def getCurrentSetupRate(self):
+        return int(self._lastTot.getRateOfChange(self._prevTot));
+
+    def get_total_retx(self):
+        return self._retx
+
+    def get_rates_client_ports(self):
+        return self._calcLinkUtilization(self._prevBytesClient, self._lastBytesClient);
+
+    def getIerrorsCached(self):
+        return self._ierrors;
+
+    def _update_rates_client_ports(self, rep):
+        prevBytes = self._lastBytesClient
+        lastBytes = self._parseTimeSeries(rep);
+
+        if (prevBytes == None):
+            prevBytes = lastBytes;
+
+        self._prevBytesClient = prevBytes;
+        self._lastBytesClient = lastBytes;
+
+    def _getBytesPerPort(self, ports, rxOrTx):
+        sc = StatsCmd(self);
+        sc.add(self._buildBytesPerPortCmd(ports, rxOrTx))
+        sc.sendRecv();
+
+        rep = sc.getResult(0);
+
+        return self._parseTimeSeries(rep);
+
+    def _buildBytesPerPortCmd(self, ports, rxOrTx):
+        cmd = ""
+        for port in ports:
+            if (len(cmd) > 0):
+                cmd += ","
+            cmd += "port(%s).%s.bytes,port(%s).tsc" % (str(port), rxOrTx, str(port));
+        return cmd
+
+    def tx_rate_meassurement(self):
+        prev = self._lastBytesTxMeassurement
+        last = self._getBytesPerPort(self._server_ports, "tx");
+
+        if (prev == None):
+            prev = last;
+
+        self._prevBytesTxMeassurement = prev
+        self._lastBytesTxMeassurement = last
+
+        return self._calcLinkUtilization(prev, last);
+
+    def _parseTimeSeries(self, rep):
+        ret = []
+        for i in range(0, len(rep), 2):
+            val = int(rep[0])
+            instant = Decimal(int(rep[1]) - self._beg)/self._hz
+            ret.append(TimeSeriesPoint(val, instant));
+        return ret;
+
+    def _calcLinkUtilization(self, prev, last):
+        ret = []
+        for i in range(0, len(prev)):
+            bytesPerSecond = last[i].getRateOfChange(prev[i]);
+            linkFraction = Decimal(bytesPerSecond)/self.TENGIGABITBYTESPERSECOND
+            ret.append(round(linkFraction,2));
+        return ret;
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/proxmaxssprobe.py b/VNFs/DPPD-PROX/helper-scripts/dpi/proxmaxssprobe.py
new file mode 100644
index 00000000..27c470c4
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/proxmaxssprobe.py
@@ -0,0 +1,34 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from decimal import *
+from prox import *
+
+class ProxMaxSSProbe(Prox):
+    def __init__(self, ts):
+        super(ProxMaxSSProbe, self).__init__(ts)
+
+    def getMaxSS(self):
+        self.addArgument("-q max_ss_and_quit=true");
+        self.addArgument("-q test_system_id=0");
+        self.startFork();
+        ret = self.startJoinNoConnect();
+        last_occur = ret["out"].rfind("\n") + 1;
+        last_line = ret["out"][last_occur:];
+
+        return Decimal(last_line.split("=")[1])
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/proxsocket.py b/VNFs/DPPD-PROX/helper-scripts/dpi/proxsocket.py
new file mode 100644
index 00000000..fd4cc737
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/proxsocket.py
@@ -0,0 +1,54 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import socket
+
+class ProxSocket:
+    def __init__(self, ip):
+        self._ip = ip;
+        self._dat = ""
+
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            sock.connect((self._ip, 8474))
+        except:
+            raise Exception("Failed to connect to prox on " + self._ip)
+        self._sock = sock;
+
+    def send(self, msg):
+        self._sock.sendall(msg + "\n");
+        return self
+
+    def recv(self):
+        ret_str = "";
+        done = 0;
+        while done == 0:
+            if (len(self._dat) == 0):
+                self._dat = self._sock.recv(256);
+                if (self._dat == ''):
+                    return '';
+
+            while(len(self._dat)):
+                if (self._dat[0] == '\n'):
+                    done = 1
+                    self._dat = self._dat[1:]
+                    break;
+                else:
+                    ret_str += self._dat[0];
+                    self._dat = self._dat[1:]
+        return ret_str;
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/ratedistribution.py b/VNFs/DPPD-PROX/helper-scripts/dpi/ratedistribution.py
new file mode 100644
index 00000000..41d8ad53
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/ratedistribution.py
@@ -0,0 +1,69 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import sys
+from decimal import *
+
+def usage(progName):
+    print "usage: " + progName + " config [up|down]"
+    print " The script reads a lua configuration "
+    print " and outputs a histogram wit 21 buckets."
+    print " The first 20 buckets contain 70th percentile."
+    print " The last bucket contains the remaining items."
+    exit(-1);
+
+if (len(sys.argv) != 3):
+    usage(sys.argv[0])
+
+if (sys.argv[2] == "down"):
+    match = "dn_bps"
+elif (sys.argv[2] == "up"):
+    match = "up_bps"
+else:
+    usage(sys.argv[0])
+
+values = []
+for line in open(sys.argv[1]).readlines():
+    line = line.strip();
+
+    if line.find(match) != -1:
+        v = line.split(" = ")[1].strip(",")
+        values.append(Decimal(v));
+
+values = sorted(values)
+
+treshold = values[int(len(values)*0.7)]
+
+buckets = [0]*21;
+
+for v in values:
+    if (v > treshold):
+        buckets[20] += 1
+    else:
+        buckets[int(v * 20 / treshold)] += 1
+
+stepSize = treshold / 20;
+
+print "# bucket range, count"
+for i in range(len(buckets) - 1):
+    beg = str(int(i * stepSize))
+    end = str(int((i + 1) * stepSize - 1))
+    print beg + "-" + end + "," + str(buckets[i])
+
+i = len(buckets) - 1
+print beg + "+," + str(buckets[i])
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/remotesystem.py b/VNFs/DPPD-PROX/helper-scripts/dpi/remotesystem.py
new file mode 100644
index 00000000..adbb288c
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/remotesystem.py
@@ -0,0 +1,58 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import os
+import time
+import socket
+
+def ssh(user, ip, cmd):
+    # print cmd;
+    ssh_options = ""
+    ssh_options += "-o StrictHostKeyChecking=no "
+    ssh_options += "-o UserKnownHostsFile=/dev/null "
+    ssh_options += "-o LogLevel=quiet "
+    running = os.popen("ssh " + ssh_options + " " + user + "@" + ip + " \"" + cmd + "\"");
+    ret = {};
+    ret['out'] = running.read().strip();
+    ret['ret'] = running.close();
+    if (ret['ret'] == None):
+        ret['ret'] = 0;
+
+    return ret;
+
+def ssh_check_quit(obj, user, ip, cmd):
+    ret = ssh(user, ip, cmd);
+    if (ret['ret'] != 0):
+        obj._err = True;
+        obj._err_str = ret['out'];
+        exit(-1);
+
+class remoteSystem:
+    def __init__(self, user, ip):
+        self._ip          = ip;
+        self._user        = user;
+
+    def run(self, cmd):
+        return ssh(self._user, self._ip, cmd);
+
+    def scp(self, src, dst):
+        running = os.popen("scp " + self._user + "@" + self._ip + ":" + src + " " + dst);
+        return running.close();
+
+    def getIP(self):
+        return self._ip
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/resultprocessor.py b/VNFs/DPPD-PROX/helper-scripts/dpi/resultprocessor.py
new file mode 100644
index 00000000..ad196035
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/resultprocessor.py
@@ -0,0 +1,210 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from sutstatsconsfile import *
+from tsstatsconsfile import *
+from csvwriter import *
+
+class TestResult:
+    class Times:
+        def __init__(self):
+            self.serie = []
+        def addTime(self, val):
+            self.serie.append(val)
+        def getTime(self, i):
+            return self.serie[i]
+
+    def __init__(self, testSystemCount):
+        self.rates = None;
+        self.tsStatsDump = [];
+        self.tsTimes = [];
+        for i in range(testSystemCount):
+            self.tsStatsDump.append("");
+            self.tsTimes.append(TestResult.Times());
+
+        self.sutStatsDump = None;
+        self.sutTime = TestResult.Times();
+
+    def getTSCount(self):
+        return len(self.tsTimes)
+
+    def setTSStatsDump(self, filePaths):
+        self.tsStatsDump = filePaths;
+
+    def setSUTStatsDump(self, filePath):
+        self.sutStatsDump = filePath;
+
+    def getTSStatsDump(self):
+        return self.tsStatsDump;
+
+    def getSUTStatsDump(self):
+        return self.sutStatsDump;
+
+    def addTimeTS(self, times):
+        for i in range(len(times)):
+            self.tsTimes[i].addTime(times[i])
+
+    def addTimeSUT(self, time):
+        self.sutTime.addTime(time);
+
+
+class ResultProcessor:
+    def __init__(self, testResult):
+        self._testResults = testResult;
+
+    def process(self):
+        self._readStatsConsLogs();
+        self._mergeTsStats();
+        self._calcSetupRate();
+
+    def percentHandled(self):
+        converged_tsc = self._testResults.sutTime.getTime(1) - self._testResults.sutTime.getTime(0)
+        end_tsc = self._testResults.sutTime.getTime(2) - self._testResults.sutTime.getTime(0)
+
+        converged = converged_tsc/Decimal(self._sutHz)
+        end = end_tsc/Decimal(self._sutHz);
+
+        rx_converged = -1
+        tx_converged = -1
+        rx_end = -1
+        tx_end = -1
+
+        for entry in self._sutStats:
+            timeStamp = entry[3]
+            if (rx_converged == -1):
+                if (timeStamp > converged):
+                    rx_converged = entry[0]
+                    tx_converged = entry[1] - entry[2]
+                else:
+                    continue;
+            else:
+                if (timeStamp > end):
+                    rx_end = entry[0]
+                    tx_end = entry[1] - entry[2]
+                    break;
+        return (tx_end - tx_converged)/Decimal(rx_end - rx_converged)
+
+    def toFile(self, fileName):
+        outFile = CsvWriter();
+
+        outFile.open(fileName)
+
+        for entry in self._sutStats:
+            timeStamp = round(entry[3], 3);
+            rx = entry[0]
+            tx = entry[1]
+            drop = entry[2]
+
+            outFile.write([timeStamp, rx, tx, drop, "", ""])
+
+        for entry in self._tsStats:
+            timeStamp = round(entry[-1], 3);
+            connections = entry[0]
+            setupRate = entry[3]
+            outFile.write([timeStamp,"","","", connections, setupRate]);
+        outFile.close();
+
+    def _readStatsConsLogs(self):
+        print "Reading SUT stats"
+        self._sutStats = self._readSutStats();
+        print "Reading TS stats"
+        self._tsAllStats = self._readAllTSStats();
+
+    def _mergeTsStats(self):
+        # The first test system is the reference system. The totals
+        # will be accumulated by repeatedly taking the closest
+        # available data from other systems
+        ret = []
+        for entry in self._tsAllStats[0]:
+            ret.append(entry)
+
+        interSampleTime = ret[1][-1] - ret[0][-1];
+
+        mergedSampleCount = 0;
+        if (len(self._tsAllStats) == 1):
+            mergedSampleCount = len(ret)
+
+        for i in range(0, len(self._tsAllStats) - 1):
+            prev = 0;
+            for entry in ret:
+                timeStamp = entry[-1]
+                found = False;
+
+                for idx in range(prev, len(self._tsAllStats[i])):
+                    diff = abs(self._tsAllStats[i][idx][-1] - timeStamp)
+                    if (diff < interSampleTime):
+                        found = True;
+                        prev = idx;
+                        break;
+
+                if (found):
+                    entry[0] += self._tsAllStats[i][prev][0]
+                    entry[1] += self._tsAllStats[i][prev][1]
+                    mergedSampleCount += 1;
+                else:
+                    break;
+
+        self._tsStats = ret[0: mergedSampleCount];
+
+    def _calcSetupRate(self):
+        for i in range(0, len(self._tsStats)):
+            prevCreated = 0
+            prevTime = 0
+            if (i > 0):
+                prevCreated = self._tsStats[i - 1][1];
+                prevTime = self._tsStats[i - 1][-1];
+            curCreated = self._tsStats[i][1];
+            curTime = self._tsStats[i][-1];
+
+            setupRate = (curCreated - prevCreated)/(curTime - prevTime)
+
+            self._tsStats[i].append(setupRate);
+
+
+    def _readSutStats(self):
+        ret = []
+        fileName = self._testResults.getSUTStatsDump();
+        beg = self._testResults.sutTime.getTime(0);
+        f = SutStatsConsFile(fileName, beg);
+        entry = f.readNext();
+        self._sutHz = f.getHz();
+        while (entry is not None):
+            ret.append(entry);
+            entry = f.readNext();
+        f.close();
+        return ret;
+
+    def _readAllTSStats(self):
+        stats = []
+        for i in range(self._testResults.getTSCount()):
+            fileName = self._testResults.getTSStatsDump()[i]
+            beg = self._testResults.tsTimes[i].getTime(0)
+            tsStat = self._readTSStats(fileName, beg)
+            stats.append(tsStat);
+        return stats;
+
+    def _readTSStats(self, fileName, beg):
+        ret = []
+        f = TSStatsConsFile(fileName, beg)
+
+        entry = f.readNext()
+        while (entry is not None):
+            ret.append(entry);
+            entry = f.readNext();
+        f.close()
+        return ret;
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/statsconsfile.py b/VNFs/DPPD-PROX/helper-scripts/dpi/statsconsfile.py
new file mode 100644
index 00000000..a25c1232
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/statsconsfile.py
@@ -0,0 +1,84 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import os
+import struct
+
+class StatsConsFile:
+    def __init__(self, file_name, tsc = None):
+        self._file = open(file_name, "rb");
+        try:
+            data = self._file.read(4*8);
+            dataUnpacked = struct.unpack("<qqqq", data);
+
+            self._hz = dataUnpacked[0]
+            if (tsc is None):
+                self._tsc = dataUnpacked[1]
+            else:
+                self._tsc = tsc;
+
+            self._entryCount = dataUnpacked[2]
+            fieldCount = dataUnpacked[3]
+
+            data = self._file.read(fieldCount);
+            fmt = "b" * fieldCount;
+
+            dataUnpacked = struct.unpack("<" + fmt, data);
+            self._entryFmt = "<";
+            self._entrySize = 0;
+
+            for e in dataUnpacked:
+                if (e == 4):
+                    self._entryFmt += "i"
+                elif (e == 8):
+                    self._entryFmt += "q"
+                else:
+                    raise Exception("Unknown field format: " + str(e))
+                self._entrySize += e
+        except:
+            print "except"
+            self._file.close();
+
+    def setBeg(self, tsc):
+        self._tsc = tsc
+
+    def getBeg(self):
+        return self._tsc;
+
+    def getHz(self):
+        return self._hz
+
+    def readNext(self):
+        ret = []
+        for i in range(self._entryCount):
+            entry = self._readNextEntry()
+            if (entry == None):
+                return None;
+            ret.append(entry);
+        return ret;
+
+    def _readNextEntry(self):
+        try:
+            entry = self._file.read(self._entrySize);
+            entryUnpacked = struct.unpack(self._entryFmt, entry);
+            return list(entryUnpacked)
+        except:
+            return None;
+
+    def close(self):
+        self._file.close();
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/sutstatsconsfile.py b/VNFs/DPPD-PROX/helper-scripts/dpi/sutstatsconsfile.py
new file mode 100644
index 00000000..82bca9a8
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/sutstatsconsfile.py
@@ -0,0 +1,61 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from statsconsfile import *
+from decimal import *
+
+class SutStatsConsFile:
+    def __init__(self, fileName, offset):
+        self.offset = offset;
+        self.statsConsFile = StatsConsFile(fileName)
+
+    def readNext(self):
+        entry = self._readNextEntry();
+
+        if (entry is None):
+            return None;
+
+        while (entry is not None and entry[-1] <= 0):
+            entry = self._readNextEntry();
+        return entry;
+
+    def getHz(self):
+        return self.statsConsFile.getHz();
+
+    def _readNextEntry(self):
+        entry = self.statsConsFile.readNext();
+        if (entry is None):
+            return None;
+
+        rx = 0;
+        tx = 0;
+        drop = 0;
+        last_tsc = 0;
+
+        for i in range(0, len(entry), 2):
+            rx += entry[i][2]
+            tx += entry[i][3]
+            drop += entry[i][4]
+            last_tsc = entry[i][5]
+
+        last_tsc -= self.offset;
+        last_tsc = Decimal(last_tsc) / self.statsConsFile.getHz();
+        return [rx, tx, drop, last_tsc];
+
+    def close(self):
+        self.statsConsFile.close();
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/systemconfig.py b/VNFs/DPPD-PROX/helper-scripts/dpi/systemconfig.py
new file mode 100644
index 00000000..9e35576f
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/systemconfig.py
@@ -0,0 +1,73 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+class SystemConfig:
+    _user = None
+    _ip = None
+    _proxDir = None
+    _cfgFile = None
+    def __init__(self, user, ip, proxDir, configDir):
+        self._user = user;
+        self._ip = ip;
+        self._proxDir = proxDir;
+        self._cfgFile = configDir;
+    def __init__(self, text):
+        self._user = text.split("@")[0];
+        text = text.split("@")[1];
+        self._ip = text.split(":")[0];
+        self._proxDir = text.split(":")[1];
+        self._cfgFile = text.split(":")[2];
+
+    def getUser(self):
+        return self._user;
+
+    def getIP(self):
+        return self._ip;
+
+    def getProxDir(self):
+        return self._proxDir;
+
+    def getCfgFile(self):
+        return self._cfgFile;
+
+    @staticmethod
+    def checkSyntax(text):
+        split = text.split("@");
+        if (len(split) != 2):
+            return SystemConfig.getSyntaxError(text);
+        after = split[1].split(":");
+        if (len(after) != 3):
+            return SystemConfig.getSyntaxError(text);
+        return ""
+    def toString(self):
+        ret = "";
+        ret += "  " + self._user + "@" + self._ip + "\n"
+        ret += "    " + "prox dir: " + self._proxDir + "\n"
+        ret += "    " + "cfg dir: " + self._cfgFile + "\n"
+        return ret;
+
+    @staticmethod
+    def getSyntaxError(text):
+        ret = "Invaild system syntax"
+        ret += ", got: " + str(text)
+        ret += ", expected: " + str(SystemConfig.expectedSyntax())
+        return ret;
+
+    @staticmethod
+    def expectedSyntax():
+        return "user@ip:proxDir:cfgFile"
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/testerset.py b/VNFs/DPPD-PROX/helper-scripts/dpi/testerset.py
new file mode 100644
index 00000000..fe3dce72
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/testerset.py
@@ -0,0 +1,176 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from proxdpitester import *
+
+class testerSet:
+    def __init__(self, test_systems, maxRate, testParam):
+        self._test_systems = [];
+        self._reason = ""
+        self._maxRate = maxRate
+
+        testParamPerSystem = testParam.getPerSystem(len(test_systems));
+
+        for i in range(len(test_systems)):
+            ts = test_systems[i];
+            to_add = ProxDpiTester(ts, testParamPerSystem, i);
+            self.add_test_system(to_add);
+
+    def getCount(self):
+        return len(self._test_systems);
+
+    def add_test_system(self, test_system):
+        self._test_systems.append(test_system);
+
+    def startFork(self):
+        print "Starting test systems:"
+        for ts in self._test_systems:
+            print "\t" + str(ts.getIP())
+            ts.startFork();
+
+    def startJoin(self):
+        for ts in self._test_systems:
+            elapsed = ts.startJoin();
+            if (elapsed == None):
+                print "Failed to start on " + str(ts.getIP())
+            else:
+                print "Started on " + str(ts.getIP())
+        sleep(1);
+
+    def startForkJoin(self):
+        self.startFork();
+        self.startJoin();
+
+    def update_stats(self):
+        for ts in self._test_systems:
+            ts.update_stats();
+
+    def wait_links_up(self):
+        for ts in self._test_systems:
+            ts.waitAllLinksUp();
+        sleep(1);
+
+    def start_cores(self):
+        for ts in self._test_systems:
+            ts.start_all_ld();
+            ts.waitCmdFinished();
+        for ts in self._test_systems:
+            ts.start_all_workers();
+        for ts in self._test_systems:
+            ts.waitCmdFinished();
+
+    def stop_cores(self):
+        for ts in self._test_systems:
+            ts.stop_all_workers();
+            ts.stop_all_ld();
+
+        for ts in self._test_systems:
+            ts.waitCmdFinished();
+
+    def getTsc(self):
+        ret = []
+        for ts in self._test_systems:
+            ret += [ts.getTsc()]
+        return ret;
+
+    def get_setup_rate(self):
+        total = 0;
+        for ts in self._test_systems:
+            total += ts.getCurrentSetupRate();
+        return total
+
+    def get_total_connections(self):
+        total = 0;
+        for ts in self._test_systems:
+            ts_tot_conn = ts.get_total_connections();
+            total += ts_tot_conn
+
+        return total;
+
+    def get_total_retx(self):
+        total = 0;
+        for ts in self._test_systems:
+            total += ts.get_total_retx();
+        return total;
+
+    def getIerrors(self):
+        total = 0;
+        for ts in self._test_systems:
+            total += ts.getIerrorsCached();
+        return total;
+
+    def get_rates(self):
+        rates = [];
+        for ts in self._test_systems:
+            rates += ts.get_rates_client_ports();
+        return rates;
+
+    def tx_rate_meassurement(self):
+        rates = []
+        for ts in self._test_systems:
+            rates += ts.tx_rate_meassurement();
+        return rates;
+
+    def scpStatsDump(self, dst):
+        ret = []
+        for i in range(len(self._test_systems)):
+            dstFileName = dst + str(i);
+            ret.append(dstFileName);
+            self._test_systems[i].scpStatsDump(dstFileName)
+        return ret;
+
+    def conditionsGood(self):
+        tot_retx = self.get_total_retx();
+        rates = self.get_rates();
+        ierrors = self.getIerrors();
+
+        if (tot_retx > 100):
+            self._reason = "Too many reTX (" + str(tot_retx) + ")"
+            return False;
+        if (ierrors > 0):
+            self._reason = "Too many ierrors (" + str(ierrors) + ")"
+            return False;
+        for i in range(0, len(rates)):
+            if (rates[i] > self._maxRate):
+                self._setReason(i, rates)
+                return False;
+        return True;
+
+    def _setReason(self, port, rates):
+        portStr = str(port);
+        rateStr = str(rates[port])
+        maxRateStr = str(self._maxRate);
+        allRatesStr = str(rates);
+
+        fmt = "Rate on port %s = %s > %s, rate on all = %s"
+        self._reason = fmt % (portStr, rateStr, maxRateStr, allRatesStr)
+
+    def getReason(self):
+        return self._reason;
+
+    def quitProx(self):
+        for ts in self._test_systems:
+            ts.quitProx();
+
+    def killProx(self):
+        for ts in self._test_systems:
+            ts.stop_all_workers();
+        for ts in self._test_systems:
+            ts.stop_all_ld();
+        for ts in self._test_systems:
+            ts.killProx();
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/timeseriespoint.py b/VNFs/DPPD-PROX/helper-scripts/dpi/timeseriespoint.py
new file mode 100644
index 00000000..521a0893
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/timeseriespoint.py
@@ -0,0 +1,39 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from decimal import *
+
+class TimeSeriesPoint:
+    def __init__(self, value, instant):
+        self._value = value;
+        self._instant = instant;
+
+    def getValue(self):
+        return self._value;
+
+    def getInstant(self):
+        return self._instant;
+
+    def getRateOfChange(self, other):
+        diff = self.getValue() - other.getValue();
+        t_diff = self.getInstant() - other.getInstant();
+
+        if (diff == 0 or abs(t_diff) <= 0.00001):
+            return Decimal(0)
+        else:
+            return Decimal(diff)/t_diff
diff --git a/VNFs/DPPD-PROX/helper-scripts/dpi/tsstatsconsfile.py b/VNFs/DPPD-PROX/helper-scripts/dpi/tsstatsconsfile.py
new file mode 100644
index 00000000..10e48a68
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/dpi/tsstatsconsfile.py
@@ -0,0 +1,60 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from statsconsfile import *
+from decimal import *
+
+class TSStatsConsFile:
+    def __init__(self, fileName, offset):
+        self.offset = offset;
+        self.statsConsFile = StatsConsFile(fileName)
+
+    def readNext(self):
+        entry = self._readNextEntry();
+        if (entry is None):
+            return None;
+
+        while (entry is not None and entry[-1] <= 0):
+            entry = self._readNextEntry();
+
+        return entry;
+
+    def _readNextEntry(self):
+        entry = self.statsConsFile.readNext();
+        if (entry is None):
+            return None;
+
+        rx = 0;
+        tx = 0;
+        active = 0;
+        created = 0;
+        last_tsc = 0;
+        for i in range(0, len(entry), 2):
+            active += entry[i][2]
+            created += entry[i][3]
+            rx += entry[i][4]
+            tx += entry[i][5]
+            last_tsc = entry[i][6]
+
+        last_tsc -= self.offset;
+        last_tsc = Decimal(last_tsc) / self.statsConsFile.getHz();
+
+        return [active, created, rx, tx, last_tsc];
+
+    def close(self):
+        self.statsConsFile.close();
diff --git a/VNFs/DPPD-PROX/helper-scripts/ipv6_tun/gen_4over6.pl b/VNFs/DPPD-PROX/helper-scripts/ipv6_tun/gen_4over6.pl
new file mode 100755
index 00000000..8e42eeba
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/ipv6_tun/gen_4over6.pl
@@ -0,0 +1,271 @@
+#!/usr/bin/perl
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+use strict vars;
+use Getopt::Long;
+use Pod::Usage;
+use Net::Pcap;
+use Net::Frame::Layer;
+use Net::Frame::Layer::ETH qw(:consts);
+use Net::Frame::Layer::IPv6 qw(:consts);
+use Net::Frame::Layer::IPv4 qw(:consts);
+use Net::Frame::Layer::UDP;
+use Socket qw(AF_INET AF_INET6 inet_ntop inet_pton);
+
+use constant NUM_PACKETS => 30000;
+
+use constant ETHER_ADDR_LEN => 6;
+use constant ETHER_TYPE_LEN => 2;
+use constant ETHER_HDR_LEN => ( 2 * ETHER_ADDR_LEN ) + ETHER_TYPE_LEN;
+use constant ETHER_STATIC_MAC => "78acdddddddd";
+
+use constant UDP_HDR_LEN => 8;
+use constant UDP_STATIC_PORT => 0x6666;
+
+use constant IPv6_HOP_LIMIT => 4;
+use constant IPv6_STATIC_IP => "2222:2222:2222:2222:2222:2222:2222:2222";
+
+use constant IPv4_TIME_TO_LIVE => 32;
+use constant IPv4_STATIC_IP => "68.68.68.68";
+
+srand;
+
+my $type = 'tun';
+my $pkt_count = NUM_PACKETS;
+
+GetOptions(
+	'inet' => sub { $type = 'inet'},
+	'tun' => sub { $type = 'tun'},
+	'count=i'      => \$pkt_count,
+	'in=s' => \(my $in = 'ip6_tun_bind.lua'),
+	'out=s' => \(my $out = 'output.pcap'),
+	'size=s' => \(my $size = 0)
+) or exit;
+
+my $pcap = pcap_open_dead( DLT_EN10MB, 65535 );
+my $dumper = pcap_dump_open($pcap, $out ) or die 'Could not create output file: ' . $out;
+
+if( $type eq 'inet' ) {
+	gen_inet_pcap( $in, $pkt_count );
+}
+if( $type eq 'tun' ) {
+	gen_tun_pcap( $in, $pkt_count );
+}
+
+pcap_close( $pcap );
+
+# Trim string
+sub trim {
+	my ( $str ) = @_;
+
+	$str =~ s/^\s+|\s+$//g;
+
+	return $str;
+}
+
+# Generate random port based on $port and $port_mask
+sub rand_port {
+	my ( $port, $port_mask ) = @_;
+
+	return ( $port | int( rand( 0xFFFF ) & $port_mask ) );
+}
+
+# Generate packet originating from CPE
+sub gen_tun_packet {
+	my ( $sz, $ether, $ipv6, $ipv4, $udp ) = @_;
+
+	my $hdr_ether = Net::Frame::Layer::ETH->new(
+		src => $ether->{'src'},
+		dst => $ether->{'dst'},
+		type => NF_ETH_TYPE_IPv6
+	)->pack;
+
+	my $hdr_ipv6 = Net::Frame::Layer::IPv6->new(
+		nextHeader => NF_IPv6_PROTOCOL_IPIP,
+		hopLimit => IPv6_HOP_LIMIT,
+		src => $ipv6->{'src'},
+		dst => $ipv6->{'dst'},
+		payloadLength => $sz + NF_IPv4_HDR_LEN + UDP_HDR_LEN
+	)->pack;
+
+	my $hdr_ipv4 = Net::Frame::Layer::IPv4->new(
+		length => $sz + UDP_HDR_LEN + NF_IPv4_HDR_LEN,
+		ttl => IPv4_TIME_TO_LIVE,
+		protocol => NF_IPv4_PROTOCOL_UDP,
+		src => $ipv4->{'src'},
+		dst => $ipv4->{'dst'}
+	)->pack;
+
+	my $hdr_udp = Net::Frame::Layer::UDP->new(
+		src => $udp->{'src'},
+		dst => $udp->{'dst'},
+		length => $sz + UDP_HDR_LEN
+	)->pack;
+	
+	my $pkt = pack( "H*", "de" x $sz );
+	$pkt = $hdr_ether . $hdr_ipv6 . $hdr_ipv4 . $hdr_udp . $pkt;
+
+	my $pkt_size = length( $pkt );
+
+	my $hdr = {
+		tv_sec => 0,
+		tv_usec => 0,
+		len => $pkt_size,
+		caplen => $pkt_size
+	};
+
+	return ( $hdr, $pkt );
+}
+
+# Generate packet originating from the internet
+sub gen_inet_packet {
+	my ( $sz, $ether, $ipv4, $udp ) = @_;
+
+	my $hdr_ether = Net::Frame::Layer::ETH->new(
+		src => $ether->{'src'},
+		dst => $ether->{'dst'},
+		type => NF_ETH_TYPE_IPv4
+	)->pack;
+
+	my $hdr_ipv4 = Net::Frame::Layer::IPv4->new(
+		length => $sz + UDP_HDR_LEN + NF_IPv4_HDR_LEN,
+		ttl => IPv4_TIME_TO_LIVE,
+		protocol => NF_IPv4_PROTOCOL_UDP,
+		src => $ipv4->{'src'},
+		dst => $ipv4->{'dst'}
+	)->pack;
+
+	my $hdr_udp = Net::Frame::Layer::UDP->new(
+		src => $udp->{'src'},
+		dst => $udp->{'dst'},
+		length => $sz + UDP_HDR_LEN
+	)->pack;
+	
+	my $pkt = pack( "H*", "de" x $sz );
+	$pkt = $hdr_ether . $hdr_ipv4 . $hdr_udp . $pkt;
+
+	my $pkt_size = length( $pkt );
+
+	my $hdr = {
+		tv_sec => 0,
+		tv_usec => 0,
+		len => $pkt_size,
+		caplen => $pkt_size
+	};
+
+	return ( $hdr, $pkt );
+}
+
+# Read bindings file
+sub read_bindings {
+	my ( $file ) = @_;
+
+	print "Reading bindings file...\n";
+
+	my @rows;
+
+	open my $fh, "<:encoding(utf8)", $file or die $file . ": $!";
+LINE:	while ( my $line = <$fh> ) {
+		next if ($line =~ /^--.*/);  # Skip comments
+		
+		my ($ip6, $mac, $ip4, $port);
+		if ($line =~ /\s*\{.*\},\s*$/) {  # Weak check for a data line...
+
+			$line =~ /ip6\s*=\s*ip6\("([^\)]*)"\)/ && do { $ip6 = trim($1); };
+			unless ( inet_pton( AF_INET6, $ip6 ) ) { print "ERROR - Invalid ipv6: $ip6\n"; next LINE; }
+
+			$line =~ /ip\s*=\s*ip\("([^\)]*)"\)/ && do { $ip4 = trim($1); };
+			unless ( inet_pton( AF_INET, $ip4 ) ) { print "ERROR - Invalid ipv4: $ip4\n"; next LINE; }
+
+			$line =~ /mac\s*=\s*mac\("([^\)]*)"\)/ && do { $mac = trim($1); };
+			unless ( $mac =~ /^([0-9a-f]{2}([:-]|$)){6}$/i ) { print "ERROR - Invalid mac: $mac\n"; next LINE; }
+
+			$line =~ /port\s*=\s*([0-9]*)/ && do { $port = trim($1); };
+			unless ( int($port) ) { print "ERROR - Invalid port number: $port\n"; next LINE; }
+
+			push @rows, {
+				ipv6 => $ip6,
+				mac => $mac,
+				ipv4 => $ip4,
+				port => $port
+			}
+		}
+	}
+	close $fh;
+
+	return @rows;
+}
+
+# Generate packets originating from CPE
+sub gen_tun_pcap {
+	my ( $binding_file, $pkt_count ) = @_;
+	my @bind = read_bindings($binding_file);
+	my $idx = 0;
+	my $row;
+	my $public_port = 0;
+
+	print "Generating $pkt_count Tunnel packets...\n";
+
+	my $max = @bind;
+	for( my $i=0; $i<$pkt_count; $i++ ) {
+
+		$idx = rand $max;
+		$row = @bind[$idx];
+
+		$public_port = rand_port( $row->{port}, 0x3f );
+
+		my ( $hdr, $pkt ) = gen_tun_packet(
+			$size,
+			{ src => $row->{mac}, dst => ETHER_STATIC_MAC },
+			{ src => $row->{ipv6}, dst => IPv6_STATIC_IP },
+			{ src => $row->{ipv4}, dst => IPv4_STATIC_IP },
+			{ src => $public_port, dst => UDP_STATIC_PORT }
+		);
+
+		pcap_dump( $dumper, $hdr, $pkt );
+	}
+}
+
+# Generate packets originating from the internet
+sub gen_inet_pcap {
+	my ( $binding_file, $pkt_count ) = @_;
+	my @bind = read_bindings($binding_file);
+	my $idx = 0;
+	my $row;
+	my $public_port = 0;
+
+	print "Generating $pkt_count Internet packets...\n";
+
+	my $max = @bind;
+	for( my $i=0; $i<$pkt_count; $i++ ) {
+
+		$idx = rand $max;
+		$row = @bind[$idx];
+
+		$public_port = rand_port( $row->{port}, 0x3f );
+
+		my ( $hdr, $pkt ) = gen_inet_packet(
+			$size,
+			{ src => ETHER_STATIC_MAC, dst => $row->{mac} },
+			{ src => IPv4_STATIC_IP, dst => $row->{ipv4} },
+			{ src => UDP_STATIC_PORT, dst => $public_port }
+		);
+
+		pcap_dump( $dumper, $hdr, $pkt );
+	}
+}
diff --git a/VNFs/DPPD-PROX/helper-scripts/ipv6_tun/ipv6_tun_bindings.pl b/VNFs/DPPD-PROX/helper-scripts/ipv6_tun/ipv6_tun_bindings.pl
new file mode 100755
index 00000000..02af5103
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/ipv6_tun/ipv6_tun_bindings.pl
@@ -0,0 +1,266 @@
+#!/usr/bin/perl
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+=head1 NAME
+
+ipv6_tun_bindings.pl
+
+=head1 SYNOPSIS
+
+ ipv6_tun_bindings.pl [-n <num_entries>] [-tun_ip <ipv6>] [-mac <next_hop_mac>] 
+                      [-pub_ip <ipv4>] [-port <begin>-<end>] [-set <num_ports>]
+                      [-suffix <suffix>] [-test <num_entries>] [-sym|-nosym]
+                      [-help]
+
+=head1 DESCRIPTION
+
+This script can be used to generate a binding table for the IPv6 Tunnel
+task implemented in PROX (ipv6_encap and ipv6_decap).
+The entries in this table bind a specific tunnel endpoint (lwB4 in lw4over6
+architecture) to a public IPv4 address and port set.
+The port set is actually derived from the port specified in the table
+and a port bitmask in the PROX task configuration ("lookup port mask").
+
+The ipv6_encap task uses the binding table to know where to tunnel IPv4
+traffic to. The ipv6_decap task uses the table to verify tunnel packets
+have a valid public IPv4 and port combination for the originating tunnel.   
+
+The table uses the Lua syntax so it can be loaded into PROX. Example:
+return {
+   {ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0000"), mac = mac("fe:80:00:00:00:00"), ip = ip("171.205.239.1"), port = 4608},
+   {ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0001"), mac = mac("fe:80:00:00:00:00"), ip = ip("171.205.239.1"), port = 4672},
+   {ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0002"), mac = mac("fe:80:00:00:00:00"), ip = ip("171.205.239.1"), port = 4736},
+   {ip6 = ip6("fe80:0000:0000:0000:0200:00ff:fe00:0003"), mac = mac("fe:80:00:00:00:00"), ip = ip("171.205.239.1"), port = 4800},
+}
+
+The script generates consecutive entries, starting from a given IP address
+and assigning ports within a given range, increasing the port number by a
+fixed amount which should correspond to the port lookup mask being used.
+
+UDF table: In addition to the binding table itself, the script can optionally
+generate accompanying UDF tables for generating test traffic matching the
+binding table. Such UDF tables can then be used in a traffic generation tool.  
+
+=head1 OPTIONS
+
+=over 22
+
+=item -n <num_entries>
+
+How many entries in the binding table
+
+=item -tun_ip <ipv6>
+
+Starting tunnel endpoint IPv6 address (will be incremented)
+
+=item -mac <next_hop_mac>
+
+MAC address of the next hop to reach the tunnel endpoints
+
+=item -pub_ip <ipv4>
+
+Starting public IPv4 address 
+
+=item -port <begin>-<end>
+
+Range of ports where to assign Port Sets
+
+=item -set <num_ports>
+
+Number of ports in set (should be a power of 2 because bitmasking is used
+in lwAFTR)
+
+=item -suffix <suffix>
+
+Filename suffix to use for the generated file(s)
+
+=item -test <num_entries>
+
+Number of random entries to put into test UDF table
+
+=item -sym
+
+Whether the same random entry from the table should be inserted into both
+traffic sides or if different entries should be used
+
+=item -help
+
+Shows the full script documentation.
+
+=back
+
+=head1 AUTHOR
+
+ Copyright(c) 2010-2017 Intel Corporation.
+ All rights reserved.
+
+=cut
+
+
+use strict vars;
+use Getopt::Long;
+use Pod::Usage;
+use Socket qw(AF_INET AF_INET6 inet_ntop inet_pton);
+
+sub parse_ip
+{
+        my ($str, $ip_ref, $family) = @_;
+
+        my $packed = inet_pton($family, $str);
+        return 0 if (!defined($packed));
+
+        if ($family == AF_INET6) {
+                #print unpack("H*", $packed). "\n";
+                my @w = unpack("NNNN", $packed);
+                my ($high, $low) = (($w[0] << 32) | $w[1], ($w[2] << 32) | $w[3]);
+                @$ip_ref = ($high, $low);
+        }
+        else {
+                $$ip_ref = unpack("N", $packed);
+        }
+        return 1;
+}
+
+sub ntop6
+{
+        my ($in) = @_;
+        my $packed = pack('NNNN', $in->[0] >> 32, $in->[0] & 0xffffffff,
+                                  $in->[1] >> 32, $in->[1] & 0xffffffff);
+        return inet_ntop(AF_INET6, $packed);
+}
+
+sub ntop6_expanded
+{
+        my ($in) = @_;
+        return sprintf('%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x',
+                        ($in->[0] >> 48) & 0xffff, ($in->[0] >> 32) & 0xffff,
+                        ($in->[0] >> 16) & 0xffff, ($in->[0]      ) & 0xffff,
+                        ($in->[1] >> 48) & 0xffff, ($in->[1] >> 32) & 0xffff,
+                        ($in->[1] >> 16) & 0xffff, ($in->[1]      ) & 0xffff);
+}
+
+my ($tun_ip_str, $pub_ip_str, $ports_str);
+
+GetOptions(
+        'help'     => sub () { Pod::Usage::pod2usage( -verbose => 2 ); exit; },
+        'n=i'      => \(my $num_B4s = 10),
+        'tun_ip=s' => \(my $tun_ip_str = 'fe80:0000:0000:0000:0200:00ff:0000:0000'),
+        'pub_ip=s' => \(my $pub_ip_str = '171.205.239.1'),
+        'mac=s'    => \(my $next_hop_mac = 'fe:80:00:00:00:00'),
+        'port=s'   => \(my $ports_str='4608-11968'),
+        'set=n'    => \(my $port_set_sz = 64),
+        'suffix=s' => \(my $suffix = ''),
+        'test=n'   => \(my $num_test_lines = 200000),
+        'sym!'     => \(my $symmetric_traffic = TRUE),
+) or pod2usage(-verbose => 1) && exit;
+
+my @tun_ip;
+parse_ip($tun_ip_str, \@tun_ip, AF_INET6) or print("Invalid starting tunnel IP: $tun_ip_str\n") && pod2usage(-verbose => 1) && exit;
+parse_ip($pub_ip_str, \(my $pub_ip), AF_INET) or print("Invalid starting public IP: $pub_ip_str\n") && pod2usage(-verbose => 1) && exit;
+my @port_range;
+if ($ports_str =~ /^([^d]+)\s*\-\s*([^d]+)$/) {
+        @port_range = ($1, $2);
+}
+else { print "Invalid port range: $ports_str\n"; pod2usage(-verbose => 1); exit }
+
+# Summary of input data
+print "File suffix: $suffix\n" if ($suffix);
+print "Starting Tunnel IP: " . ntop6(\@tun_ip) . "\n";
+print "Starting Public IP: ".inet_ntop(AF_INET, pack("N", $pub_ip)) . "\n";
+print "Public Port Range: $port_range[0]-$port_range[1] by blocks of $port_set_sz\n";
+
+my @data;  # Holds generated binding table, so we can later generate test traffic for it
+
+# Binding table for PROX IPv6 Tunnel
+my $filename = 'ip6_tun_bind'.$suffix.'.lua';
+print "\nGenerating binding table with $num_B4s entries into $filename ... ";
+open(my $fh, '>', $filename) or die "Could not open file '$filename' $!";
+print $fh "-- Bindings for lwaftr: lwB4 IPv6 address, next hop MAC address\n";
+print $fh "-- towards lwB4, IPv4 Public address, IPv4 Public Port Set\n";
+print $fh "\n";
+print $fh "return {" . "\n";
+my $port = $port_range[0];
+for (my $B4_id = 0; $B4_id < $num_B4s; $B4_id++) {
+        $data[$B4_id]{'b4_ipv6'} = ntop6_expanded(\@tun_ip);
+        $data[$B4_id]{'pub_ipv4'} = "" . (($pub_ip >> 24) & 0xff) . "." . (($pub_ip >> 16) & 0xff) . "." . (($pub_ip >> 8) & 0xff) . "." . ($pub_ip & 0xff);
+        $data[$B4_id]{'pub_port'} = $port;
+        $data[$B4_id]{'next_hop_mac'} = $next_hop_mac;
+
+        print $fh "   {";
+        print $fh "ip6 = ip6(\"" . $data[$B4_id]{'b4_ipv6'} . "\")";
+        print $fh ", mac = mac(\"" . $data[$B4_id]{'next_hop_mac'} . "\")";
+        print $fh ", ip = ip(\"" . $data[$B4_id]{'pub_ipv4'} . "\")";
+        print $fh ", port = " . $data[$B4_id]{'pub_port'};
+        print $fh "},\n";
+
+        $port += $port_set_sz;
+        if ($port > $port_range[1]) {
+                $pub_ip++;
+                $port = $port_range[0];
+        }
+        
+        # Move to next Tunnel address
+        if (@tun_ip[1] < 0xffffffffffffffff) {
+                @tun_ip[1]++;
+        } else {
+                @tun_ip[0]++;
+                @tun_ip[1] = 0;
+        }
+}
+print $fh "}" . "\n";
+close $fh;
+print "[DONE]\n";
+
+# Test traffic "UDF Tables"
+if ($num_test_lines) {
+        print "Generating $num_test_lines lines of test UDF table into lwAFTR_tun|inet".$suffix.".csv ... ";
+
+        # Tunnel Packets from B4 to lwAFTR 
+        my $filename = 'lwAFTR_tun' . $suffix . '.csv';
+        open(my $fh_tun, '>', $filename) or die "Could not open file '$filename' $!";
+        print $fh_tun "b4_ip,pub_ip,pub_port\n";
+        print $fh_tun "22,66,74\n";  # Offsets
+        print $fh_tun "16,4,2\n";    # Sizes
+        print $fh_tun "6,5,3\n";     # Format (IPv6, IPv4, Decimal)
+        print $fh_tun ",,\n";
+        
+        # Internet Packets towards the lwAFTR, to be sent to corresp lwB4 over tunnel 
+        my $filename = 'lwAFTR_inet' . $suffix . '.csv';
+        open(my $fh_inet, '>', $filename) or die "Could not open file '$filename' $!";
+        print $fh_inet "pub_ip,pub_port\n";
+        print $fh_inet "30,36\n";  # Offsets
+        print $fh_inet "4,2\n";    # Sizes
+        print $fh_inet "5,3\n";     # Format (IPv6, IPv4, Decimal)
+        print $fh_inet ",,\n";
+
+        for (my $i = 0; $i < $num_test_lines; $i++) {
+                my $B4_id = int(rand($num_B4s));
+                my $port = $data[$B4_id]{'pub_port'} + int(rand($port_set_sz)); 
+                printf $fh_tun $data[$B4_id]{'b4_ipv6'} . "," . $data[$B4_id]{'pub_ipv4'} . "," . $port . "\n";
+                
+                if (! $symmetric_traffic) {
+                        $B4_id = int(rand($num_B4s));
+                        $port = $data[$B4_id]{'pub_port'} + int(rand($port_set_sz)); 
+                }
+                printf $fh_inet $data[$B4_id]{'pub_ipv4'} . "," . $port . "\n";
+        }
+        
+        close $fh_tun;
+        close $fh_inet;
+        print "[DONE]\n";
+}
diff --git a/VNFs/DPPD-PROX/helper-scripts/openstackrapid/README b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/README
new file mode 100644
index 00000000..49d819d8
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/README
@@ -0,0 +1,57 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+rapid (Rapid Automated Performance Indication for Dataplane)
+************************************************************
+
+rapid is a set of files offering an easy way to do a sanity check of the
+dataplane performance of an OpenStack environment.
+
+Copy the files in a directory on a machine that can run the OpenStack CLI
+commands and that can reach the OpenStack public network. Also create a qcow2
+image in the same directory with the following characteristics:
+* Name of the qcow2 file should be: rapidVM.qcow2
+  This default name can be changed on the rapid command line
+* Should have DPDK and PROX installed. PROX should be in /root/prox/ directory
+* Image should have cloud-init installed
+
+Source the openrc file of the OpenStack environment so that the OpenStack CLI
+commands can be run:
+  # source openrc
+Now you can run the rapid.py file. Use help for more info on the usage:
+  # ./rapid.py --help
+
+rapid will use the OpenStack CLI to create the flavor, key-pair, network, image,
+stack, ...
+Then it will connect to the 2 VMs that have been instantiated and it will launch
+PROX in both VMs.
+Once that is done it will connect to the PROX tcp socket and start sending
+commands to run the actual test.
+It will print test results on the screen while running.
+The PROX instance in the Generator VM will generate packets which will arrive in
+the PROX instance running on the SUT (System Under Test) VM. The SUT will then
+send the packets back to the generator by swapping source and destination.
+
+Notes about prox_gen_user_data.sh and prox_sut_user_data.sh scripts:
+- These scripts contain commands that will be executed using cloud-init at
+  startup of the VMs. They contain a hard-coded PCI address for the DPDK
+  interface that will be used by PROX. You might want to check that this is
+  actually the right PCI address.
+- These scripts also assume some specific DPDK directory and tools which might
+  change over different DPDK release. They have been tested with DPDK-17.02.
+- These scripts are also assuming that this interface is on the "dpdk-network"
+  network managed by OpenStack.
+
diff --git a/VNFs/DPPD-PROX/helper-scripts/openstackrapid/gen.cfg b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/gen.cfg
new file mode 100644
index 00000000..522eb801
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/gen.cfg
@@ -0,0 +1,64 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[lua]
+dofile("parameters.lua")
+
+[port 0]
+name=p0
+
+[variables]
+$mbs=8
+
+[defaults]
+mempool size=4K
+
+[global]
+name=Basic Gen
+
+[core 0]
+mode=master
+
+[core 1]
+name=p0
+task=0
+mode=gen
+sub mode=l3
+rx ring=yes
+tx port=p0
+bps=1250000000
+pkt inline=00 00 00 00 00 00 00 00 00 00 00 00 08 00 45 00 00 1c 00 01 00 00 40 11 f7 7d ${gen_hex_ip} ${sut_hex_ip} 0b b8 0b b9 00 08 55 7b
+gateway ipv4=${sut_ip}
+local ipv4=${gen_ip}
+min bulk size=$mbs
+;random=XXXXXXXXXXXXXXXX
+;random=0000000000XXXXXX   ; 64 possibilities
+;rand_offset=34   ; SOURCE UDP PORT
+;random=XXXXXXXXXXXXXXXX
+;random=000000000XXXXXXX   ; 128
+;rand_offset=36   ; DESTINTAITON UDP PORT
+
+[core 2]
+task=0
+mode=arp
+rx port=p0,p0,p0,p0
+tx port=p0
+tx cores=1t0
+
diff --git a/VNFs/DPPD-PROX/helper-scripts/openstackrapid/prox_ctrl.py b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/prox_ctrl.py
new file mode 100644
index 00000000..b384e9f0
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/prox_ctrl.py
@@ -0,0 +1,218 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from __future__ import print_function
+
+import os
+import subprocess
+import socket
+
+class prox_ctrl(object):
+    def __init__(self, ip, key=None, user=None):
+        self._ip   = ip
+        self._key  = key
+        self._user = user
+        self._children = []
+        self._proxsock = []
+
+    def ip(self):
+        return self._ip
+
+    def connect(self):
+        """Simply try to run 'true' over ssh on remote system.
+        On failure, raise RuntimeWarning exception when possibly worth
+        retrying, and raise RuntimeError exception otherwise.
+        """
+        return self.run_cmd('true', True)
+
+    def close(self):
+        """Must be called before program termination."""
+        for prox in self._proxsock:
+            prox.quit()
+        children = len(self._children)
+        if children == 0:
+            return
+        if children > 1:
+            print('Waiting for %d child processes to complete ...' % children)
+        for child in self._children:
+            ret = os.waitpid(child[0], os.WNOHANG)
+            if ret[0] == 0:
+                print("Waiting for child process '%s' to complete ..." % child[1])
+                ret = os.waitpid(child[0], 0)
+            rc = ret[1]
+            if os.WIFEXITED(rc):
+                if os.WEXITSTATUS(rc) == 0:
+                    print("Child process '%s' completed successfully" % child[1])
+                else:
+                    print("Child process '%s' returned exit status %d" % (
+                            child[1], os.WEXITSTATUS(rc)))
+            elif os.WIFSIGNALED(rc):
+                print("Child process '%s' exited on signal %d" % (
+                        child[1], os.WTERMSIG(rc)))
+            else:
+                print("Wait status for child process '%s' is 0x%04x" % (
+                        child[1], rc))
+
+    def run_cmd(self, command, _connect=False):
+        """Execute command over ssh on remote system.
+        Wait for remote command completion.
+        Return command output (combined stdout and stderr).
+        _connect argument is reserved for connect() method.
+        """
+        cmd = self._build_ssh(command)
+        try:
+            return subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        except subprocess.CalledProcessError as ex:
+            if _connect and ex.returncode == 255:
+                raise RuntimeWarning(ex.output.strip())
+            raise RuntimeError('ssh returned exit status %d:\n%s'
+                    % (ex.returncode, ex.output.strip()))
+
+    def fork_cmd(self, command, name=None):
+        """Execute command over ssh on remote system, in a child process.
+        Do not wait for remote command completion.
+        Return child process id.
+        """
+        if name is None:
+            name = command
+        cmd = self._build_ssh(command)
+        pid = os.fork()
+        if (pid != 0):
+            # In the parent process
+            self._children.append((pid, name))
+            return pid
+        # In the child process: use os._exit to terminate
+        try:
+            # Actually ignore output on success, but capture stderr on failure
+            subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        except subprocess.CalledProcessError as ex:
+            raise RuntimeError("Child process '%s' failed:\n"
+                    'ssh returned exit status %d:\n%s'
+                    % (name, ex.returncode, ex.output.strip()))
+        os._exit(0)
+
+    def prox_sock(self, port=8474):
+        """Connect to the PROX instance on remote system.
+        Return a prox_sock object on success, None on failure.
+        """
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            sock.connect((self._ip, port))
+            prox = prox_sock(sock)
+            self._proxsock.append(prox)
+            return prox
+        except:
+            return None
+
+    def scp_put(self, src, dst):
+        """Copy src file from local system to dst on remote system."""
+        cmd = [ 'scp',
+                '-B',
+                '-oStrictHostKeyChecking=no',
+                '-oUserKnownHostsFile=/dev/null',
+                '-oLogLevel=ERROR' ]
+        if self._key is not None:
+            cmd.extend(['-i', self._key])
+        cmd.append(src)
+        remote = ''
+        if self._user is not None:
+            remote += self._user + '@'
+        remote += self._ip + ':' + dst
+        cmd.append(remote)
+        try:
+            # Actually ignore output on success, but capture stderr on failure
+            subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        except subprocess.CalledProcessError as ex:
+            raise RuntimeError('scp returned exit status %d:\n%s'
+                    % (ex.returncode, ex.output.strip()))
+
+    def _build_ssh(self, command):
+        cmd = [ 'ssh',
+                '-oBatchMode=yes',
+                '-oStrictHostKeyChecking=no',
+                '-oUserKnownHostsFile=/dev/null',
+                '-oLogLevel=ERROR' ]
+        if self._key is not None:
+            cmd.extend(['-i', self._key])
+        remote = ''
+        if self._user is not None:
+            remote += self._user + '@'
+        remote += self._ip
+        cmd.append(remote)
+        cmd.append(command)
+        return cmd
+
+class prox_sock(object):
+    def __init__(self, sock):
+        self._sock = sock
+        self._rcvd = b''
+
+    def quit(self):
+        if self._sock is not None:
+            self._send('quit')
+            self._sock.close()
+            self._sock = None
+
+    def start(self, cores):
+        self._send('start %s' % ','.join(map(str, cores)))
+
+    def stop(self, cores):
+        self._send('stop %s' % ','.join(map(str, cores)))
+
+    def speed(self, speed, cores, tasks=None):
+        if tasks is None:
+            tasks = [ 0 ] * len(cores)
+        elif len(tasks) != len(cores):
+            raise ValueError('cores and tasks must have the same len')
+        for (core, task) in zip(cores, tasks):
+            self._send('speed %s %s %s' % (core, task, speed))
+
+    def reset_stats(self):
+        self._send('reset stats')
+
+    def core_stats(self, cores, task=0):
+        rx = tx = drop = tsc = hz = 0
+        self._send('core stats %s %s' % (','.join(map(str, cores)), task))
+        for core in cores:
+            stats = self._recv().split(',')
+            rx += int(stats[0])
+            tx += int(stats[1])
+            drop += int(stats[2])
+            tsc = int(stats[3])
+            hz = int(stats[4])
+        return rx, tx, drop, tsc, hz
+
+    def set_random(self, cores, task, offset, mask, length):
+        self._send('set random %s %s %s %s %s' % (','.join(map(str, cores)), task, offset, mask, length))
+
+    def _send(self, cmd):
+        """Append LF and send command to the PROX instance."""
+        if self._sock is None:
+            raise RuntimeError("PROX socket closed, cannot send '%s'" % cmd)
+        self._sock.sendall(cmd.encode() + b'\n')
+
+    def _recv(self):
+        """Receive response from PROX instance, and return it with LF removed."""
+        if self._sock is None:
+            raise RuntimeError("PROX socket closed, cannot receive anymore")
+        pos = self._rcvd.find(b'\n')
+        while pos == -1:
+            self._rcvd += self._sock.recv(256)
+            pos = self._rcvd.find(b'\n')
+        rsp = self._rcvd[:pos]
+        self._rcvd = self._rcvd[pos+1:]
+        return rsp.decode()
+
diff --git a/VNFs/DPPD-PROX/helper-scripts/openstackrapid/prox_gen_user_data.sh b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/prox_gen_user_data.sh
new file mode 100644
index 00000000..e7f58a9f
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/prox_gen_user_data.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+echo 128 > /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages
+mount -t hugetlbfs nodev /mnt/huge
+modprobe uio
+insmod /root/dpdk/x86_64-native-linuxapp-gcc/kmod/igb_uio.ko
+/root/dpdk/usertools/dpdk-devbind.py --force --bind igb_uio 00:04.0
+iptables -F
diff --git a/VNFs/DPPD-PROX/helper-scripts/openstackrapid/prox_sut_user_data.sh b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/prox_sut_user_data.sh
new file mode 100644
index 00000000..e7f58a9f
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/prox_sut_user_data.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+echo 128 > /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages
+mount -t hugetlbfs nodev /mnt/huge
+modprobe uio
+insmod /root/dpdk/x86_64-native-linuxapp-gcc/kmod/igb_uio.ko
+/root/dpdk/usertools/dpdk-devbind.py --force --bind igb_uio 00:04.0
+iptables -F
diff --git a/VNFs/DPPD-PROX/helper-scripts/openstackrapid/rapid.py b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/rapid.py
new file mode 100755
index 00000000..1a0ea41c
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/rapid.py
@@ -0,0 +1,445 @@
+#!/usr/bin/python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import sys
+import time
+import subprocess
+import getopt
+from prox_ctrl import prox_ctrl
+
+version="17.04.19"
+stack = "rapidTestEnv" #Default string for stack
+yaml = "rapid.yaml" #Default string for yaml file
+key = "prox" # This is also the default in the yaml file....
+flavor = "prox_flavor" # This is also the default in the yaml file....
+image = "rapidVM" # This is also the default in the yaml file....
+image_file = "rapidVM.qcow2"
+network = "dpdk-network" # This is also the default in the yaml file....
+subnet = "dpdk-subnet" #Hardcoded at this moment
+
+def usage():
+	print("usage: rapid       [--version] [-v]")
+	print("                   [--stack STACK_NAME]")
+	print("                   [--yaml YAML_FILE]")
+	print("                   [--key KEY_NAME]")
+	print("                   [--flavor FLAVOR_NAME]")
+	print("                   [--image IMAGE_NAME]")
+	print("                   [--image_file IMAGE_FILE]")
+	print("                   [--network NETWORK]")
+	print("                   [-h] [--help]")
+	print("")
+	print("Command-line interface to RAPID")
+	print("")
+	print("optional arguments:")
+	print("  -v,  --version           Show program's version number and exit")
+	print("  --stack STACK_NAME       Specify a name for the heat stack. Default is rapidTestEnv.")
+	print("  --yaml YAML_FILE         Specify the yaml file to be used. Default is rapid.yaml.")
+	print("  --key KEY_NAME           Specify the key to be used. Default is prox.")
+	print("  --flavor FLAVOR_NAME     Specify the flavor to be used. Default is prox_flavor.")
+	print("  --image IMAGE_NAME       Specify the image to be used. Default is rapidVM.")
+	print("  --image_file IMAGE_FILE  Specify the image qcow2 file to be used. Default is rapidVM.qcow2.")
+	print("  --network NETWORK        Specify the network name to be used for the dataplane. Default is dpdk-network.")
+	print("  -h, --help               Show help message and exit.")
+	print("")
+	print("To delete the rapid stack, type the following command")
+	print("   openstack stack delete --yes --wait DPTestEnv")
+	print("Note that rapidTestEnv is the default stack name. Replace with STACK_NAME if needed")
+
+try:
+	opts, args = getopt.getopt(sys.argv[1:], "vh", ["version","help", "yaml=","stack=","key=","flavor=","image=","network="])
+except getopt.GetoptError as err:
+	print("===========================================")
+	print str(err)
+	print("===========================================")
+	usage()
+	sys.exit(2)
+if args:
+	usage()
+	sys.exit(2)
+for opt, arg in opts:
+	if opt in ("-h", "--help"):
+		usage()
+		sys.exit()
+	if opt in ("-v", "--version"):
+		print("Rapid Automated Performance Indication for Dataplane "+version)
+		sys.exit()
+	if opt in ("--stack"):
+		stack = arg
+		print ("Using '"+stack+"' as name for the stack")
+	elif opt in ("--yaml"):
+		yaml = arg
+		print ("Using stack: "+yaml)
+	elif opt in ("--key"):
+		key = arg
+		print ("Using key: "+key)
+	elif opt in ("--flavor"):
+		flavor = arg
+		print ("Using flavor: "+flavor)
+	elif opt in ("--image"):
+		image = arg
+		print ("Using image: "+image)
+	elif opt in ("--image_file"):
+		image_file = arg
+		print ("Using qcow2 file: "+image_file)
+	elif opt in ("--network"):
+		network = arg
+		print ("Using network: "+ network)
+
+print("Checking image: "+image)
+cmd = 'openstack image show '+image+' |grep "status " | tr -s " " | cut -d" " -f 4'
+ImageExist = subprocess.check_output(cmd , shell=True).strip()
+if ImageExist == 'active':
+	print("Image already available")
+else:
+	print('Creating image ...')
+	cmd = 'openstack image create --disk-format qcow2 --container-format bare --public --file ./'+image_file+ ' ' +image+' |grep "status " | tr -s " " | cut -d" " -f 4'
+	ImageExist = subprocess.check_output(cmd , shell=True).strip()
+	if ImageExist == 'active':
+		print('Image created and active')
+		cmd = 'openstack image set --property hw_vif_multiqueue_enabled="true" ' +image
+		subprocess.check_call(cmd , shell=True)
+	else :
+		raise Exception("Failed to create image")
+
+print("Checking key: "+key)
+cmd = 'openstack keypair show '+key+' |grep "name " | tr -s " " | cut -d" " -f 4'
+KeyExist = subprocess.check_output(cmd , shell=True).strip()
+if KeyExist == key:
+	print("Key already installed")
+else:
+	print('Creating key ...')
+	cmd = 'openstack keypair create '+ key + '>' +key+'.pem'
+	subprocess.check_call(cmd , shell=True)
+	cmd = 'chmod 600 ' +key+'.pem'
+	subprocess.check_call(cmd , shell=True)
+	cmd = 'openstack keypair show '+key+' |grep "name " | tr -s " " | cut -d" " -f 4'
+	KeyExist = subprocess.check_output(cmd , shell=True).strip()
+	if KeyExist == key:
+		print("Key created")
+	else :
+		raise Exception("Failed to create key: " + key)
+
+print("Checking flavor: "+flavor)
+cmd = 'openstack flavor show '+flavor+' |grep "name " | tr -s " " | cut -d" " -f 4'
+FlavorExist = subprocess.check_output(cmd , shell=True).strip()
+if FlavorExist == flavor:
+	print("Flavor already installed")
+else:
+	print('Creating flavor ...')
+	cmd = 'openstack flavor create '+flavor+' --ram 8192 --disk 80 --vcpus 4 |grep "name " | tr -s " " | cut -d" " -f 4'
+	FlavorExist = subprocess.check_output(cmd , shell=True).strip()
+	if FlavorExist == flavor:
+		cmd = 'openstack flavor set '+ flavor +' --property hw:mem_page_size="large" --property hw:cpu_policy="dedicated" --property hw:cpu_threads_policy="isolate"'
+		subprocess.check_call(cmd , shell=True)
+		print("Flavor created")
+	else :
+		raise Exception("Failed to create flavor: " + flavor)
+
+print("Checking network: "+network)
+cmd = 'openstack network show '+network+' |grep "status " | tr -s " " | cut -d" " -f 4'
+NetworkExist = subprocess.check_output(cmd , shell=True).strip()
+if NetworkExist == 'ACTIVE':
+	print("Network already active")
+else:
+	print('Creating network ...')
+	cmd = 'openstack network create '+network+' |grep "status " | tr -s " " | cut -d" " -f 4'
+	NetworkExist = subprocess.check_output(cmd , shell=True).strip()
+	if NetworkExist == 'ACTIVE':
+		print("Network created")
+	else :
+		raise Exception("Failed to create network: " + network)
+
+print("Checking subnet: "+subnet)
+cmd = 'neutron subnet-show '+ subnet+' |grep "name " | tr -s " " | cut -d" " -f 4'
+SubnetExist = subprocess.check_output(cmd , shell=True).strip()
+if SubnetExist == subnet:
+	print("Subnet already exists")
+else:
+	print('Creating subnet ...')
+	cmd = 'neutron subnet-create --name '+ subnet+ ' ' +network+' 10.10.10.0/24 |grep "name " | tr -s " " | cut -d" " -f 4'
+	SubnetExist = subprocess.check_output(cmd , shell=True).strip()
+	if SubnetExist == subnet:
+		print("Subnet created")
+	else :
+		raise Exception("Failed to create subnet: " + subnet)
+
+print("Checking Stack: "+stack)
+cmd = 'openstack stack show '+stack+' |grep "stack_status " | tr -s " " | cut -d" " -f 4'
+StackRunning = subprocess.check_output(cmd , shell=True).strip()
+if StackRunning == '':
+	print('Creating Stack ...')
+	cmd = 'openstack stack create -t '+ yaml +  ' --parameter flavor="'+flavor  +'" --parameter key="'+ key + '" --parameter image="'+image  + '" --parameter dpdk_network="'+network+'" --wait '+stack +' |grep "stack_status " | tr -s " " | cut -d" " -f 4'
+	StackRunning = subprocess.check_output(cmd , shell=True).strip()
+if StackRunning != 'CREATE_COMPLETE':
+	raise Exception("Failed to create stack")
+
+print('Stack running')
+genName=stack+'-gen'
+sutName=stack+'-sut'
+cmd = 'nova list | grep  '+ genName +' | tr -s " " | cut -d " " -f 4'
+genVMName = subprocess.check_output(cmd , shell=True).strip()
+print('Generator: '+ genVMName)
+cmd = 'nova list | grep  '+ sutName +' | tr -s " " | cut -d " " -f 4'
+sutVMName = subprocess.check_output(cmd , shell=True).strip()
+print('SUT:       '+ sutVMName)
+cmd='nova show ' + genVMName + ' | grep "dpdk-network" | tr -s " " | cut -d" " -f 5'
+genDPIP = subprocess.check_output(cmd , shell=True).strip()
+cmd='nova show ' + genVMName + ' | grep "admin_internal_net" | tr -s " " | cut -d" " -f 6'
+genAdminIP = subprocess.check_output(cmd , shell=True).strip()
+cmd='nova show ' + sutVMName + ' | grep "dpdk-network" | tr -s " " | cut -d" " -f 5'
+sutDPIP = subprocess.check_output(cmd , shell=True).strip()
+cmd='nova show ' + sutVMName + ' | grep "admin_internal_net" | tr -s " " | cut -d" " -f 6'
+sutAdminIP = subprocess.check_output(cmd , shell=True).strip()
+
+#========================================================================
+def connect_socket(client):
+	attempts = 1
+	print("Trying to connect to PROX (just launched) on %s, attempt: %d"
+			% (client.ip(), attempts))
+	sock = None
+	while True:
+		sock = client.prox_sock()
+		if sock is not None:
+			break
+		attempts += 1
+		if attempts > 20:
+			raise Exception("Failed to connect to PROX on %s after %d attempts"
+					% (client.ip(), attempts))
+		time.sleep(10)
+		print("Trying to connect to PROX (just launched) on %s, attempt: %d"
+				% (client.ip(), attempts))
+	print("Connected to PROX on %s" % client.ip())
+	return sock
+
+def connect_client(client):
+	attempts = 1
+	print ("Trying to connect to VM which was just launched on %s, attempt: %d"
+			% (client.ip(), attempts))
+	while True:
+		try:
+			client.connect()
+			break
+		except RuntimeWarning, ex:
+			attempts += 1
+			if attempts > 20:
+				raise Exception("Failed to connect to VM after %d attempts:\n%s"
+						% (attempts, ex))
+			time.sleep(15)
+			print ("Trying to connect to VM which was just launched on %s, attempt: %d"
+					% (client.ip(), attempts))
+	print("Connected to VM on %s" % client.ip())
+
+
+def run_testA():
+	global genclient
+	global sutclient
+	ip = genDPIP.split('.')
+	hexgenDPIP=hex(int(ip[0]))[2:].zfill(2) + ' ' + hex(int(ip[1]))[2:].zfill(2) + ' ' + hex(int(ip[2]))[2:].zfill(2) + ' ' + hex(int(ip[3]))[2:].zfill(2)
+	ip = sutDPIP.split('.')
+	hexsutDPIP=hex(int(ip[0]))[2:].zfill(2) + ' ' + hex(int(ip[1]))[2:].zfill(2) + ' ' + hex(int(ip[2]))[2:].zfill(2) + ' ' + hex(int(ip[3]))[2:].zfill(2)
+	with open("parameters.lua", "w") as f:
+		f.write('gen_hex_ip="'+hexgenDPIP+'"\n')
+		f.write('sut_hex_ip="'+hexsutDPIP+'"\n')
+		f.write('gen_ip="'+genDPIP+'"\n')
+		f.write('sut_ip="'+sutDPIP+'"\n')
+		f.close
+	genclient.scp_put('./gen.cfg', '/root/gen.cfg')
+	sutclient.scp_put('./sut.cfg', '/root/sut.cfg')
+	genclient.scp_put('./parameters.lua', '/root/parameters.lua')
+	sutclient.scp_put('./parameters.lua', '/root/parameters.lua')
+	print("Config files copied")
+	cmd = '/root/prox/build/prox -e -t -o cli -f /root/gen.cfg'
+	genclient.fork_cmd(cmd, 'PROX GEN')
+	cmd = '/root/prox/build/prox -t -o cli -f /root/sut.cfg'
+	sutclient.fork_cmd(cmd, 'PROX SUT')
+	gensock = connect_socket(genclient)
+	sutsock = connect_socket(sutclient)
+	new_speed = 100
+	attempts = 0
+	cores = [1,2]
+	gencores = [1]
+	gensock.reset_stats()
+	sutsock.reset_stats()
+	gensock.start([2])
+	print("+---------------------------------------------------------------------------------------------------------+")
+	print("| Generator is sending UDP (1 flow) packets (64 bytes) to SUT. SUT sends packets back                     |")
+	print("+------+-----------------+----------------+----------------+----------------+----------------+------------+")
+	print("| Test | Speed requested | Req to Generate|  Sent by Gen   | Forward by SUT |  Rec. by Gen   | Result     |")
+	print("+------+-----------------+----------------+----------------+----------------+----------------+------------+")
+	while (new_speed > 0.1):
+		attempts += 1
+		# Start generating packets at requested speed (in % of a 10Gb/s link)
+		gensock.speed(new_speed, gencores)
+		gensock.start(gencores)
+		time.sleep(1)
+		# Get statistics now that the generation is stable and NO ARP messages any more
+		old_sut_rx, old_sut_tx, old_sut_drop, old_sut_tsc, sut_tsc_hz = sutsock.core_stats([1])
+		old_rx, old_tx, old_drop, old_tsc, tsc_hz = gensock.core_stats(cores)
+		time.sleep(10)
+		# Get statistics after some execution time
+		new_rx, new_tx, new_drop, new_tsc, tsc_hz = gensock.core_stats(cores)
+		new_sut_rx, new_sut_tx, new_sut_drop, new_sut_tsc, sut_tsc_hz = sutsock.core_stats([1])
+		time.sleep(1)
+		# Stop generating
+		gensock.stop(gencores)
+		drop = new_drop-old_drop # drop is all packets dropped by all tasks. This includes packets dropped at the generator task + packets dropped by the nop task. In steady state, this equals to the number of packets received by this VM
+		rx = new_rx - old_rx     # rx is all packets received by the nop task = all packets received in the gen VM
+		tx = new_tx - old_tx  	 # tx is all generated packets actually accepted by the interface
+		tsc = new_tsc - old_tsc  # time difference between the 2 measurements, expressed in cycles.
+		sut_rx = new_sut_rx - old_sut_rx
+		sut_tx = new_sut_tx - old_sut_tx
+		sut_tsc = new_sut_tsc - old_sut_tsc
+		if (tx == 0):
+			raise Exception("TX = 0")
+		drop_rate = round(((drop-rx) * 100.0)/(tx+drop-rx),1)
+		pps_req_tx = round((tx+drop-rx)*tsc_hz*1.0/(tsc*1000000),5)
+		pps_tx = round(tx*tsc_hz*1.0/(tsc*1000000),5)
+		pps_rx = round(rx*tsc_hz*1.0/(tsc*1000000),5)
+		pps_sut_tx = round(sut_tx*sut_tsc_hz*1.0/(sut_tsc*1000000),5)
+		if ((drop_rate) < 1):
+			# This will stop the test when number of dropped packets is below a certain percentage
+			print("+------+-----------------+----------------+----------------+----------------+----------------+------------+")
+			print('|{:>5}'.format(str(attempts))+" | "+ '{:>14}'.format(str(new_speed)) + '% | '+ '{:>9}'.format(str(pps_req_tx))+' Mpps | '+ '{:>9}'.format(str(pps_tx)) +' Mpps | ' + '{:>9}'.format(str(pps_sut_tx)) +' Mpps | '+ '{:>9}'.format(str(pps_rx))+" Mpps | SUCCESS    |")
+			print("+------+-----------------+----------------+----------------+----------------+----------------+------------+")
+			break
+		else:
+			print('|{:>5}'.format(str(attempts))+" | "+ '{:>14}'.format(str(new_speed)) + '% | '+ '{:>9}'.format(str(pps_req_tx))+' Mpps | '+ '{:>9}'.format(str(pps_tx)) +' Mpps | ' + '{:>9}'.format(str(pps_sut_tx)) +' Mpps | '+ '{:>9}'.format(str(pps_rx))+" Mpps | FAILED     |")
+		# Following calculates the ratio for the new speed to be applied
+		# On the Y axis, we will find the ratio, a number between 0 and 1
+		# On the x axis, we find the % of dropped packets, a number between 0 and 100
+		# 2 lines are drawn and we take the minumun of these lines to calculate the ratio
+		# One line goes through (0,y0) and (p,q)
+		# The second line goes through (p,q) and (100,y100)
+		y0=0.99
+		y100=0.1
+		p=15
+		q=.9
+		ratio = min((q-y0)/p*drop_rate+y0,(q-y100)/(p-100)*drop_rate+q-p*(q-y100)/(p-100))
+		new_speed = (int(new_speed*ratio*100)+0.5)/100
+	gensock.quit()
+	sutsock.quit()
+	time.sleep(2)
+	print("")
+
+def run_testB():
+	global genclient
+	global sutclient
+	ip = genDPIP.split('.')
+	hexgenDPIP=hex(int(ip[0]))[2:].zfill(2) + ' ' + hex(int(ip[1]))[2:].zfill(2) + ' ' + hex(int(ip[2]))[2:].zfill(2) + ' ' + hex(int(ip[3]))[2:].zfill(2)
+	ip = sutDPIP.split('.')
+	hexsutDPIP=hex(int(ip[0]))[2:].zfill(2) + ' ' + hex(int(ip[1]))[2:].zfill(2) + ' ' + hex(int(ip[2]))[2:].zfill(2) + ' ' + hex(int(ip[3]))[2:].zfill(2)
+	with open("parameters.lua", "w") as f:
+		f.write('gen_hex_ip="'+hexgenDPIP+'"\n')
+		f.write('sut_hex_ip="'+hexsutDPIP+'"\n')
+		f.write('gen_ip="'+genDPIP+'"\n')
+		f.write('sut_ip="'+sutDPIP+'"\n')
+		f.close
+	genclient.scp_put('./gen.cfg', '/root/gen.cfg')
+	sutclient.scp_put('./sut.cfg', '/root/sut.cfg')
+	genclient.scp_put('./parameters.lua', '/root/parameters.lua')
+	sutclient.scp_put('./parameters.lua', '/root/parameters.lua')
+	print("Config files copied")
+	cmd = '/root/prox/build/prox -e -t -o cli -f /root/gen.cfg'
+	genclient.fork_cmd(cmd, 'PROX GEN')
+	cmd = '/root/prox/build/prox -t -o cli -f /root/sut.cfg'
+	sutclient.fork_cmd(cmd, 'PROX SUT')
+	gensock = connect_socket(genclient)
+	sutsock = connect_socket(sutclient)
+	print("+----------------------------------------------------------------------------------------------+")
+	print("| UDP, 64 bytes, different number of flows by randomizing SRC & DST UDP port                   |")
+	print("+--------+-----------------+----------------+----------------+----------------+----------------+")
+	print("| Flows  | Speed requested | Req to Generate|  Sent by Gen   | Forward by SUT |  Rec. by Gen   |")
+	print("+--------+-----------------+----------------+----------------+----------------+----------------+")
+	cores = [1,2]
+	gencores = [1]
+	gensock.start([2])
+	new_speed = 100
+	# To generate a desired number of flows, PROX will randomize the bits in source and destination ports, as specified by the bit masks in the flows variable. 
+	flows={128:['0000000000000XXX','000000000000XXXX'],1024:['00000000000XXXXX','00000000000XXXXX'],8192:['0000000000XXXXXX','000000000XXXXXXX'],65535:['00000000XXXXXXXX','00000000XXXXXXXX'],524280:['0000000XXXXXXXXX','000000XXXXXXXXXX']}
+	for flow_number in sorted(flows.iterkeys()):
+		#new_speed = 100 Commented out: Not starting from 100% since we are trying more flows, so speed will not be higher than the speed achieved in previous loop
+		attempts = 0
+		gensock.reset_stats()
+		sutsock.reset_stats()
+		source_port,destination_port = flows[flow_number]
+		gensock.set_random(gencores,0,34,source_port,2)
+		gensock.set_random(gencores,0,36,destination_port,2)
+		while (new_speed > 0.1):
+			attempts += 1
+			# Start generating packets at requested speed (in % of a 10Gb/s link)
+			gensock.speed(new_speed, gencores)
+			gensock.start(gencores)
+			time.sleep(1)
+			# Get statistics now that the generation is stable and NO ARP messages any more
+			old_sut_rx, old_sut_tx, old_sut_drop, old_sut_tsc, sut_tsc_hz = sutsock.core_stats([1])
+			old_rx, old_tx, old_drop, old_tsc, tsc_hz = gensock.core_stats(cores)
+			time.sleep(10)
+			# Get statistics after some execution time
+			new_rx, new_tx, new_drop, new_tsc, tsc_hz = gensock.core_stats(cores)
+			new_sut_rx, new_sut_tx, new_sut_drop, new_sut_tsc, sut_tsc_hz = sutsock.core_stats([1])
+			time.sleep(1)
+			# Stop generating
+			gensock.stop(gencores)
+			drop = new_drop-old_drop # drop is all packets dropped by all tasks. This includes packets dropped at the generator task + packets dropped by the nop task. In steady state, this equals to the number of packets received by this VM
+			rx = new_rx - old_rx     # rx is all packets received by the nop task = all packets received in the gen VM
+			tx = new_tx - old_tx  	 # tx is all generated packets actually accepted by the interface
+			tsc = new_tsc - old_tsc  # time difference between the 2 measurements, expressed in cycles.
+			sut_rx = new_sut_rx - old_sut_rx
+			sut_tx = new_sut_tx - old_sut_tx
+			sut_tsc = new_sut_tsc - old_sut_tsc
+			if (tx == 0):
+				raise Exception("TX = 0")
+			drop_rate = round(((drop-rx) * 100.0)/(tx+drop-rx),1)
+			pps_req_tx = round((tx+drop-rx)*tsc_hz*1.0/(tsc*1000000),5)
+			pps_tx = round(tx*tsc_hz*1.0/(tsc*1000000),5)
+			pps_rx = round(rx*tsc_hz*1.0/(tsc*1000000),5)
+			pps_sut_tx = round(sut_tx*sut_tsc_hz*1.0/(sut_tsc*1000000),5)
+			if ((drop_rate) < 1):
+				# This will stop the test when number of dropped packets is below a certain percentage
+				print('|{:>7}'.format(str(flow_number))+" | "+ '{:>14}'.format(str(new_speed)) + '% | '+ '{:>9}'.format(str(pps_req_tx))+' Mpps | '+ '{:>9}'.format(str(pps_tx)) +' Mpps | ' + '{:>9}'.format(str(pps_sut_tx)) +' Mpps | '+ '{:>9}'.format(str(pps_rx))+" Mpps |")
+				print("+--------+-----------------+----------------+----------------+----------------+----------------+")
+				break
+			# Following calculates the ratio for the new speed to be applied
+			# On the Y axis, we will find the ratio, a number between 0 and 1
+			# On the x axis, we find the % of dropped packets, a number between 0 and 100
+			# 2 lines are drawn and we take the minumun of these lines to calculate the ratio
+			# One line goes through (0,y0) and (p,q)
+			# The second line goes through (p,q) and (100,y100)
+			y0=0.99
+			y100=0.1
+			p=15
+			q=.9
+			ratio = min((q-y0)/p*drop_rate+y0,(q-y100)/(p-100)*drop_rate+q-p*(q-y100)/(p-100))
+			new_speed = (int(new_speed*ratio*100)+0.5)/100
+	gensock.quit()
+	sutsock.quit()
+	time.sleep(2)
+	print("")
+
+#========================================================================
+genclient = prox_ctrl(genAdminIP, key+'.pem')
+connect_client(genclient)
+sutclient = prox_ctrl(sutAdminIP, key+'.pem')
+connect_client(sutclient)
+#####################################################################################
+run_testA()
+run_testB()
+#####################################################################################
+genclient.close()
+sutclient.close()
+
diff --git a/VNFs/DPPD-PROX/helper-scripts/openstackrapid/rapid.yaml b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/rapid.yaml
new file mode 100644
index 00000000..eab957f5
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/rapid.yaml
@@ -0,0 +1,105 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+heat_template_version: 2016-04-08
+description: RAPID stack (Rapid Automated Performance Indication for Dataplane)
+parameters:
+  image:
+    type: string
+    label: Image name or ID
+    description: Image to be used for compute instance
+    default: RapidVM
+  flavor:
+    type: string
+    label: Flavor
+    description: Type of instance (flavor) to be used
+    default: prox_flavor
+  key:
+    type: string
+    label: Key name
+    description: Name of key-pair to be used for compute instance
+    default: prox
+  dpdk_network:
+    type: string
+    label: Private network name or ID
+    description: Network to attach instance to.
+    default: dpdk-network
+  private_network:
+    type: string
+    label: Private network name or ID
+    description: Network to attach instance to.
+    default: admin_internal_net
+  availability_zone:
+    type: string
+    description: The Availability Zone to launch the instance.
+    default: nova
+
+resources:
+  sut:
+    type: OS::Nova::Server
+    properties:
+      availability_zone: { get_param: availability_zone }
+      user_data:
+        get_file: prox_sut_user_data.sh
+      key_name: { get_param: key }
+      image: { get_param: image }
+      flavor: { get_param: flavor }
+      networks:
+        - network: { get_param: private_network }
+        - network: { get_param: dpdk_network }
+  gen:
+    type: OS::Nova::Server
+    properties:
+      availability_zone: { get_param: availability_zone }
+      user_data:
+        get_file: prox_gen_user_data.sh
+      key_name: { get_param: key }
+      image: { get_param: image }
+      flavor: { get_param: flavor }
+      networks:
+        - network: { get_param: private_network }
+        - network: { get_param: dpdk_network }
+
+  sut_floating_ip:
+    type: OS::Nova::FloatingIP
+    properties:
+      pool: admin_floating_net
+
+  gen_floating_ip:
+    type: OS::Nova::FloatingIP
+    properties:
+      pool: admin_floating_net
+
+  sut_association:
+    type: OS::Nova::FloatingIPAssociation
+    properties:
+      floating_ip: { get_resource: sut_floating_ip }
+      server_id: { get_resource: sut }
+
+  gen_association:
+    type: OS::Nova::FloatingIPAssociation
+    properties:
+      floating_ip: { get_resource: gen_floating_ip }
+      server_id: { get_resource: gen }
+
+outputs:
+  sut_ip:
+    description: IP address of the instance
+    value: { get_attr: [sut, first_address] }
+  gen_ip:
+    description: IP address of the instance
+    value: { get_attr: [gen, first_address] }
+
diff --git a/VNFs/DPPD-PROX/helper-scripts/openstackrapid/sut.cfg b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/sut.cfg
new file mode 100644
index 00000000..2937a749
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/openstackrapid/sut.cfg
@@ -0,0 +1,51 @@
+;;
+;; Copyright (c) 2010-2017 Intel Corporation
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;     http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+;;
+
+[eal options]
+-n=4 ; force number of memory channels
+no-output=no ; disable DPDK debug output
+
+[lua]
+dofile("parameters.lua")
+
+[port 0]
+name=if0
+mac=hardware
+
+[defaults]
+mempool size=2K
+
+[global]
+name=NOP forwarding
+
+[core 0]
+mode=master
+
+[core 1]
+name=swap
+task=0
+mode=arp
+sub mode=local
+rx port=if0
+tx port=if0
+tx cores=1t1
+local ipv4=${sut_ip}
+task=1
+mode=swap
+rx ring=yes
+tx port=if0
+drop=no
+
diff --git a/VNFs/DPPD-PROX/helper-scripts/start_vm.py b/VNFs/DPPD-PROX/helper-scripts/start_vm.py
new file mode 100755
index 00000000..7af7df9c
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/start_vm.py
@@ -0,0 +1,143 @@
+#!/bin/env python2.7
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+from os import system
+from os import fork, _exit
+from subprocess import check_output
+import socket
+from time import sleep
+import json
+import sys
+
+# This script starts qemu with the CPU layout specified by the cores
+# array below. Each element in the array represents a core. To enable
+# hyper-threading (i.e. two logical cores per core), each element in
+# the array should be an array of length two. The values stored inside
+# the array define to which host cores the guest cores should be
+# affinitized. All arguments of this script are passed to qemu
+# directly. Porting an existing qemu command line setup to make use of
+# this script requires removing the -smp parameters and -qmp
+# parameters if those were used. These are built by the script based
+# on the cores array.
+
+# After successfully starting qemu, this script will connect through
+# QMP and affinitize all cores within the VM to match cores on the
+# host.
+
+execfile("./vm-cores.py")
+
+def build_mask(cores):
+    ret = 0;
+    for core in cores:
+        for thread in core:
+            ret += 1 << thread;
+    return ret;
+
+n_cores = len(cores);
+n_threads = len(cores[0]);
+
+mask = str(hex((build_mask(cores))))
+
+smp_str = str(n_cores*n_threads)
+smp_str += ",cores=" + str(n_cores)
+smp_str += ",sockets=1"
+smp_str += ",threads=" + str(n_threads)
+
+try:
+    qmp_sock = check_output(["mktemp", "--tmpdir", "qmp-sock-XXXX"]).strip()
+except:
+    qmp_sock = "/tmp/qmp-sock"
+
+qemu_cmdline = ""
+qemu_cmdline += "taskset " + mask + " qemu-system-x86_64 -smp " + smp_str
+qemu_cmdline += " -qmp unix:" + qmp_sock + ",server,nowait"
+qemu_cmdline += " -daemonize"
+
+for a in sys.argv[1:]:
+    qemu_cmdline += " " + a
+
+try:
+    pid = fork()
+except OSError, e:
+    sys.exit("Failed to fork: " + e.strerror)
+
+if (pid != 0):
+    # In the parent process
+    ret = system(qemu_cmdline)
+    if (ret != 0):
+        sys.exit("Failed to run QEMU: exit status " + str(ret) + ". Command line was:\n" + qemu_cmdline)
+    # Parent process done
+    sys.exit(0)
+
+# In the child process: use _exit to terminate
+retry = 0
+s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+while (retry < 10):
+    sleep(1);
+    try:
+        s.connect(qmp_sock)
+        print "Connected to QMP"
+        break;
+    except:
+        pass
+    retry = retry + 1
+    print "Failed to connect to QMP, attempt " + str(retry)
+if (retry >= 10):
+    print "Failed to connect to QMP"
+    _exit(1)
+
+# skip info about protocol
+dat = s.recv(100000)
+# need to run qmp_capabilities before next command works
+s.send("{\"execute\" : \"qmp_capabilities\" }")
+dat = s.recv(100000)
+# Get the PID for each guest core
+s.send("{\"execute\" : \"query-cpus\"}")
+dat = s.recv(100000)
+a = json.loads(dat)["return"];
+
+if (len(a) != n_cores*n_threads):
+    print "Configuration mismatch: " + str(len(a)) + " vCPU reported by QMP, instead of expected " + str(n_cores*n_threads)
+    _exit(1)
+print "QMP reported " + str(len(a)) + " vCPU, as expected"
+
+if (n_threads == 1):
+    idx = 0;
+    for core in a:
+        cm  = str(hex(1 << cores[idx][0]))
+        pid = str(core["thread_id"])
+        system("taskset -p " + cm + " " + pid + " > /dev/null")
+        idx = idx + 1
+elif (n_threads == 2):
+    idx = 0;
+    prev = 0;
+    for core in a:
+        cm  = str(hex(1 << cores[idx][prev]))
+        pid = str(core["thread_id"])
+        system("taskset -p " + cm + " " + pid + " > /dev/null")
+        prev = prev + 1;
+        if (prev == 2):
+            idx = idx + 1;
+            prev = 0
+else:
+    print "Not implemented yet: more than 2 threads per core"
+    _exit(1)
+
+print "Core affinitization completed"
+_exit(0)
+
diff --git a/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_BNG_8ports.py b/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_BNG_8ports.py
new file mode 100755
index 00000000..f26d0db6
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_BNG_8ports.py
@@ -0,0 +1,457 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import socket
+import sys
+import os
+from time import *
+from datetime import  datetime
+from optparse import OptionParser
+import time
+from remote_system import *
+from math import log
+
+# General parameters
+accuracy = 0.1 	# in percent of line rate
+max_dropped = 0.1		# in percent
+all_pkt_size = [64,128,256,512,1024,1280,1494]
+all_ip_src = [0,6,12,18]
+all_ip_dst = [0,6,12,18]
+
+# Stear parameters
+step_time = 0.001		# in seconds
+step_delta = 10		# in percent of line rate
+
+##### Use case 1: packet loss and latency #####
+low_steps_delta_for_loss = 0.01                 # Use increment of 0.01% from 0 to low_steps
+medium_steps_delta_for_loss = 0.1               # Use increment of 0.1% from low_steps to medium_steps
+normal_steps_delta_for_loss = 1.0               # Use increment of 1% from medium_steps till 100%
+low_steps = 0.1 
+medium_steps = 1.0 
+
+# Prox parameters
+tx_port0 = [4]
+tx_port1 = [6]
+tx_port2 = [8]
+tx_port3 = [10]
+tx_port4 = [12]
+tx_port5 = [14]
+tx_port6 = [16]
+tx_port7 = [18]
+tx_task = 0
+
+all_rx_cores = [20,22,24,26,28,30,32,34]
+rx_lat_cores = [20,22,24,26,28,30,32,34]
+rx_task = 0
+
+# Some variables, do not change
+
+# Program arguments
+parser = OptionParser()
+parser.add_option("-d", "--duration", dest="test_duration", help="Duration of each steps", metavar="integer", default=10)
+parser.add_option("-s", "--speed", dest="init_speed", help="Initial speed", metavar="integer", default=100)
+parser.add_option("-r", "--run", dest="run", help="Run test", metavar="integer", default=0)
+parser.add_option("-c", "--configure", dest="configure", help="Configure Test", metavar="integer", default=0)
+(options, args) = parser.parse_args()
+
+init_speed = int(options.init_speed)
+test_duration = int(options.test_duration)
+configure = int(options.configure)
+run = int(options.run)
+
+nb_cores_per_interface = len(tx_port0)
+max_speed = (100.0/nb_cores_per_interface)
+init_speed = (init_speed * 1.0/nb_cores_per_interface)
+accuracy = (accuracy * 1.0/nb_cores_per_interface)
+normal_steps_delta_for_loss = (normal_steps_delta_for_loss /nb_cores_per_interface)
+medium_steps_delta_for_loss = (medium_steps_delta_for_loss /nb_cores_per_interface)
+low_steps_delta_for_loss = (low_steps_delta_for_loss /nb_cores_per_interface)
+medium_steps = (medium_steps /nb_cores_per_interface)
+low_steps = (low_steps /nb_cores_per_interface)
+
+max_dropped = max_dropped / 100
+
+def to_str(arr):
+    ret = ""
+    first = 1;
+    for a in arr:
+        if (first == 0):
+            ret += ","
+
+        ret += str(a)
+        first = 0;
+    return ret;
+
+tx_cores_cpe = tx_port0 + tx_port1 + tx_port2 + tx_port3 
+tx_cores_inet = tx_port4 + tx_port5 + tx_port6 + tx_port7
+tx_cores = tx_cores_cpe + tx_cores_inet
+
+def send_all_pkt_size(cores, pkt_size):
+    for c in cores:
+        sock.sendall("pkt_size " + str(c) + " 0 " + str(pkt_size) + "\n");
+
+def send_all_value(cores, offset, value, len):
+    for c in cores:
+        sock.sendall("set value " + str(c) + " 0 " + str(offset) + " " + str(value) + " " + str(len)+ "\n");
+
+def send_all_random(cores, offset, rand_str, len):
+    for c in cores:
+        sock.sendall("set random " + str(c) + " 0 " + str(offset) + " " + str(rand_str) + " " + str(len)+ "\n");
+        #print("set random " + str(c) + " 0 " + str(offset) + " " + str(rand_str) + " " + str(len)+ "\n");
+
+def send_all_speed(cores, speed_perc):
+    for c in cores:
+        sock.sendall("speed " + str(c) + " 0 " + str(speed_perc) + "\n");
+
+def send_reset_random():
+        sock.sendall("reset randoms all" + "\n");
+
+def send_reset_value():
+        sock.sendall("reset values all" + "\n");
+
+def rx_stats(tx_cores, tx_task, rx_cores, rx_task):
+	rx = tx = drop = tsc = tsc_hs = ierrors = 0
+	for e in tx_cores:
+		sock.sendall("core stats " + str(e) + " " + str(tx_task) +  "\n")
+		recv = recv_once()
+		rx += int(recv.split(",")[0])
+		tx += int(recv.split(",")[1])
+		drop += int(recv.split(",")[2])
+		tsc = int(recv.split(",")[3])
+		tsc_hz = int(recv.split(",")[4])
+	for e in rx_cores:
+		sock.sendall("core stats " + str(e) + " " + str(rx_task) +  "\n")
+		recv = recv_once()
+		rx += int(recv.split(",")[0])
+		tx += int(recv.split(",")[1])
+		drop += int(recv.split(",")[2])
+		tsc = int(recv.split(",")[3])
+		tsc_hz = int(recv.split(",")[4])
+	# Also get the ierrors as generators might be the bottleneck...
+	sock.sendall("tot ierrors tot\n")
+	recv = recv_once()
+	ierrors += int(recv.split(",")[0])
+	rx+=ierrors
+	return rx,tx,drop,tsc,tsc_hz
+
+def lat_stats(cores,task):
+	lat_min = [0 for e in range(127)]
+	lat_max = [0 for e in range(127)]
+	lat_avg = [0 for e in range(127)]
+	for e in cores:
+		sock.sendall("lat stats " + str(e) + " " + str(task) + " " +  "\n")
+		recv = recv_once()
+		lat_min[e] = int(recv.split(",")[0])
+		lat_max[e] = int(recv.split(",")[1])
+		lat_avg[e] = int(recv.split(",")[2])
+	return lat_min, lat_max, lat_avg
+
+def recv_once():
+    ret_str = "";
+    done = 0;
+    while done == 0:
+        dat = sock.recv(256);
+        i = 0;
+        while(i < len(dat)):
+            if (dat[i] == '\n'):
+                done = 1
+            else:
+                ret_str += dat[i];
+            i = i + 1;
+    return ret_str
+
+def set_pkt_sizes(tx_cores, p):
+	send_all_pkt_size(tx_cores, p-4)
+	# For all cores, need to adapt IP Length (byte 16) and UDP Length (byte 38) to pkt size
+	send_all_value(tx_cores, 16, p - 18, 2)		# 14 for MAC (12) EthType (2) 
+	send_all_value(tx_cores, 38, p - 38, 2)		# 34 for MAC (12) EthType (2) IP (20)
+
+def set_pkt_sizes_cpe(tx_cores, p):
+	send_all_pkt_size(tx_cores, p-4)
+	# For all cores, need to adapt IP Length (byte 16) and UDP Length (byte 38) to pkt size
+	send_all_value(tx_cores, 24, p - 26, 2)		# 22 for QinQ (8) MAC (12) EthType (2) 
+	send_all_value(tx_cores, 46, p - 46, 2)		# 42 for QinQ (8) MAC (12) EthType (2) IP (20)
+
+def set_pkt_sizes_inet(tx_cores, p):
+	send_all_pkt_size(tx_cores, p+24-4)
+	# For all cores, need to adapt IP Length (byte 16) and UDP Length (byte 38) to pkt size
+	send_all_value(tx_cores, 20, p + 2, 2)		# 14 for MAC (12) EthType (2) 
+	send_all_value(tx_cores, 48, p - 26, 2)		# 14 for MAC (12) EthType (2) 
+	send_all_value(tx_cores, 70, p - 46, 2)		# 34 for MAC (12) EthType (2) IP (20)
+
+def run_measure_throughput(speed, speed_cpe):
+	done = 0
+	# Intialize tests by stopping cores and resetting stats
+	step=0
+	steps_done = 0
+	sock.sendall("start " + to_str(all_rx_cores) + "\n")
+	sleep(2)
+	sock.sendall("stop " + to_str(all_rx_cores) + "\n")
+	sock.sendall("reset stats\n")
+	print "Speed    = " + str(speed * nb_cores_per_interface) 
+	sleep(1);
+	
+	send_all_speed(tx_cores, step);
+
+	# Now starting the steps. First go to the common speed, then increase steps for the faster one.
+	sock.sendall("start " + to_str(tx_cores) + "," + to_str(rx_lat_cores) + "\n")
+	while (steps_done == 0):
+		sleep(step_time)
+		if (step + step_delta <= speed):
+			step+=step_delta
+		else:
+			steps_done = 1;
+		send_all_speed(tx_cores, step)
+	
+	# Steps are now OK.  Set speed
+	send_all_speed(tx_cores_inet, speed);
+	send_all_speed(tx_cores_cpe, speed_cpe);
+	sleep(2);
+
+	# Getting statistics to calculate PPS at right speed....
+	rx_pps_beg,tx_pps_beg,drop_pps_beg,tsc_pps_beg,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
+	sleep(test_duration);
+
+	# Collect statistics before test stops...and stop the test. Important to get stats before stopping as stops take some time...
+	rx_pps_end,tx_pps_end,drop_pps_end,tsc_pps_end,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
+	lat_min,lat_max,lat_avg = lat_stats(rx_lat_cores, rx_task)
+	sock.sendall("stop " + to_str(tx_cores) + "\n")
+	sock.sendall("start " + to_str(all_rx_cores) + "\n")
+	sleep(3);
+	sock.sendall("stop " + to_str(all_rx_cores) + "\n")
+	
+	rx_end, tx_end,drop_end,tsc_end,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
+	rx = rx_pps_end - rx_pps_beg
+	tsc = tsc_pps_end - tsc_pps_beg
+	mpps = rx / (tsc/float(tsc_hz)) / 1000000
+	tx = tx_pps_end - tx_pps_beg
+	tx_mpps = tx / (tsc/float(tsc_hz)) / 1000000
+	
+	#print "Runtime = " +  str((tsc)/float(tsc_hz));
+	if (tx_end == 0):
+		dropped_tot = tx_end - rx_end
+		dropped_pct = 0
+	else:
+		dropped_tot = tx_end - rx_end
+		dropped_pct = ((dropped_tot) * 1.0) / tx_end
+
+	if (dropped_tot > 0):
+		if (dropped_pct >= max_dropped):
+			print "** FAILED **: lost " + str(100*dropped_pct) + "% packets RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end)
+		else:
+			print "OK but lost " + str(100*dropped_pct) + "% packets RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end)
+	else:
+		if (dropped_tot < 0):
+			print "Something wrong happened - received more packets than transmitted"
+		else:
+			print "**   OK   **: RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end) 
+	print "MPPS = " + str(mpps)
+	print "===================================================="
+	return dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg
+
+def write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_flows, lat_min, lat_max, lat_avg):
+	f.write(str(pkt_size) + "; " + str(tx_mpps) + "; " + str(mpps) + "; " + str(100 * dropped_pct) + "; " + str(dropped_tot) + "; " + str(speed * nb_cores_per_interface) + "; " + str(number_flows) +  "; " )
+	for e in rx_lat_cores:
+		f.write(str(lat_min[e]) + "; " + str(lat_max[e]) + "; " + str(lat_avg[e]) + "; ")
+	f.write("\n");
+	f.flush()
+
+def run_dicho_search(number_flows, pkt_size):
+	previous_success_speed = 0.0
+	previous_error_speed = max_speed
+	speed = init_speed * 1.0
+	done = 0;
+	good_tx_mpps = 0
+	good_mpps = 0
+	good_dropped_pct = 0
+	good_dropped_tot = 0
+	good_speed = 0
+	good_lat_min = [0 for e in range(127)]
+	good_lat_max = [0 for e in range(127)]
+	good_lat_avg = [0 for e in range(127)]
+
+	while done == 0:
+		speed_cpe = (speed * (pkt_size + 20)) / (pkt_size + 24 + 20)
+		dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg = run_measure_throughput(speed, speed_cpe)
+		if ((dropped_tot >= 0) and (dropped_pct <= max_dropped)):
+			good_tx_mpps = tx_mpps
+			good_mpps = mpps
+			good_dropped_pct = dropped_pct
+			good_dropped_tot = dropped_tot
+			good_speed = speed
+			good_lat_min = lat_min
+			good_lat_max = lat_max
+			good_lat_avg = lat_avg
+			write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_flows, lat_min, lat_max, lat_avg);
+			write_results(f_all, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_flows, lat_min, lat_max, lat_avg);
+		else:
+			write_results(f_all, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_flows, lat_min, lat_max, lat_avg);
+
+		if ((speed == max_speed) and (dropped_pct <= max_dropped)):
+			write_results(f_minimal, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_flows, lat_min, lat_max, lat_avg);
+			done = 1
+		if (dropped_pct <= max_dropped):
+			previous_success_speed = speed
+			if (speed > max_speed - accuracy):
+				speed = max_speed
+			else:
+				if (previous_error_speed - speed < accuracy):
+					write_results(f_minimal, pkt_size, good_tx_mpps, good_mpps, good_dropped_pct, good_dropped_tot, good_speed, nb_cores_per_interface, number_flows, good_lat_min, good_lat_max, good_lat_avg);
+					done = 1
+				else:
+					speed = speed + (previous_error_speed - speed)/2;
+		else:
+			previous_error_speed = speed
+			if (speed - previous_success_speed < accuracy):
+				write_results(f_minimal, pkt_size, good_tx_mpps, good_mpps, good_dropped_pct, good_dropped_tot, good_speed, nb_cores_per_interface, number_flows, good_lat_min, good_lat_max, good_lat_avg);
+				done = 1	
+			else:
+				speed  = speed - (speed - previous_success_speed) / 2;
+
+	
+def set_source_destination_ip(nb_sources, nb_destinations):
+	# Destination addressese: "00XXXXXX" "XXXXXXXX" "XXXXXXXX" "XXXXXX10"
+	# Starting with 00 to be in class A and skipping 0.x.y.z and 127.x.y.z
+	# Ending with 10 to avoid x.y.z.0 and x.y.z.255
+
+	dst_mask = "10"
+	for i in range (nb_destinations):
+		dst_mask = "X" + str(dst_mask)
+	for i in range (32 - nb_destinations - 2):
+		dst_mask = "0" + str(dst_mask)
+	
+	src_mask = "10"
+	for i in range (nb_sources):
+		src_mask = "X" + str(src_mask)
+	for i in range (32 - nb_sources - 2):
+		src_mask = "0" + str(src_mask)
+	
+	for c in tx_port0:
+		send_all_random([c], 26, src_mask, 4)
+		send_all_random([c], 30, dst_mask, 4)
+	for c in tx_port1:
+		send_all_random([c], 26, src_mask, 4)
+		send_all_random([c], 30, dst_mask, 4)
+	for c in tx_port2:
+		send_all_random([c], 26, src_mask, 4)
+		send_all_random([c], 30, dst_mask, 4)
+	for c in tx_port3:
+		send_all_random([c], 26, src_mask, 4)
+		send_all_random([c], 30, dst_mask, 4)
+	for c in tx_port4:
+		send_all_random([c], 26, src_mask, 4)
+		send_all_random([c], 30, dst_mask, 4)
+	for c in tx_port5:
+		send_all_random([c], 26, src_mask, 4)
+		send_all_random([c], 30, dst_mask, 4)
+	for c in tx_port6:
+		send_all_random([c], 26, src_mask, 4)
+		send_all_random([c], 30, dst_mask, 4)
+	for c in tx_port7:
+		send_all_random([c], 26, src_mask, 4)
+		send_all_random([c], 30, dst_mask, 4)
+		
+#========================================================================
+class TestDefinition():
+    "Stores test parameters"
+    def __init__(self, number_ip_src, number_ip_dst, pkt_size):
+        self.number_ip_src = number_ip_src
+        self.number_ip_dst = number_ip_dst
+        self.pkt_size = pkt_size
+
+#========================================================================
+def run_use_case(number_ip_src, number_ip_dst, pkt_size):
+	number_flows = (2 ** number_ip_src) * (2 ** number_ip_dst)
+#	send_reset_random()
+#	send_reset_value()
+#	set_source_destination_ip(number_ip_src, number_ip_dst)
+	set_pkt_sizes_inet(tx_cores_inet, pkt_size)
+	set_pkt_sizes_cpe(tx_cores_cpe, pkt_size)
+	print "Running test with pkt size= " + str(pkt_size) + " number_ip_src = " + str(number_ip_src) + " number_ip_dst = " + str(number_ip_dst) + " Number flows = " + str(number_flows) + "; \n"
+	run_dicho_search(number_flows, pkt_size)
+	sleep(3)
+
+#========================================================================
+def run_all_use_cases():
+	use_case_nb = 1
+	# Connect to dppd 
+	file_path = '/tmp/prox.sock'
+	sock.connect(file_path)
+
+	f.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
+	f_all.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
+	f_minimal.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
+	f.flush();
+	f_all.flush();
+	f_minimal.flush();
+
+	# Starting tests
+	print "Stopping all cores and resetting all values and randoms before starting\n"
+	sock.sendall("stop " + to_str(all_rx_cores) + "\n")
+	sock.sendall("stop " + to_str(tx_cores) + "\n")
+	#sock.sendall("stop all")
+	sock.sendall("reset stats\n")
+	sleep(3);
+	for line in file_tests:
+		info = line.split(';')
+		if (info[0][0] == '#'):
+			continue
+		if (info[0][0] == ''):
+			break
+		number_ip_src = int(info[0])
+		number_ip_dst = int(info[1])
+		pkt_size = int(info[2])
+		run_use_case(number_ip_src, number_ip_dst, pkt_size)
+
+#========================================================================
+def configure_use_case():
+	Tests = []
+	number_ip_dst = 0
+	number_ip_src = 0
+	for pkt_size in all_pkt_size:
+		Tests.append(TestDefinition(number_ip_src, number_ip_dst, pkt_size))
+
+	pkt_size = 64
+	while (pkt_size < 1494):
+		Tests.append(TestDefinition(number_ip_src, number_ip_dst, pkt_size))
+		pkt_size = (pkt_size *11) / 10
+
+	file_tests = open('test_description.txt', 'w')
+	file_tests.write("# Number_ip_src; number_ip_dst; pkt_size; \n")
+	for test in Tests:
+		file_tests.write(str(test.number_ip_src) + "; " + str(test.number_ip_dst) + "; " + str(test.pkt_size) + "; " + ";\n")
+	file_tests.close()
+
+#========================================================================
+if ((configure == 0) and (run == 0)):
+	print "Nothing to do - please use -r 1 or -c 1"
+if (configure == 1):
+	configure_use_case()
+if (run == 1):
+	print "****************************************************************************************************************"
+	print "** Running Characterization with " + str(test_duration) + " seconds steps and starting at " + str(init_speed)   + " percent of line rate **"
+	print "****************************************************************************************************************"
+	sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+	f_all = open('all_results.txt', 'w')
+	f = open('detailed_results.txt', 'w')
+	f_minimal = open('minimal_results.txt', 'w')
+	file_tests = open('test_description.txt', 'r')
+	run_all_use_cases()
+	f.close();
+	sock.close();
+
diff --git a/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_vRouter.py b/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_vRouter.py
new file mode 100755
index 00000000..f4d211f6
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_vRouter.py
@@ -0,0 +1,681 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import socket
+import sys
+import os
+from time import *
+from datetime import  datetime
+from optparse import OptionParser
+import time
+from remote_system import *
+from math import log
+
+# General parameters
+accuracy = 0.1 	# in percent of line rate
+max_dropped = 0.001		# in percent
+all_pkt_size = [64,128,256,512,1024,1280,1518]
+#all_pkt_size = [64]
+
+# vRouter parameters, in case commands must be sent
+vRouter_host = "192.168.1.96" 
+
+# Stear parameters
+step_time = 0.01		# in seconds
+step_delta = 0.025		# in percent of line rate
+
+# Use case dependent parameters
+##### Use case 0: influence of number of routes and next hops #####
+max_number_next_hops = 256			# Maximum number of next-hops per interface
+max_number_routes = 8192			# Maximum number of routes per interface
+max_number_addresses_local_network = 262144
+
+##### Use case 1: packet loss and latency #####
+low_steps_delta_for_loss = 0.01                 # Use increment of 0.01% from 0 to low_steps
+medium_steps_delta_for_loss = 0.1               # Use increment of 0.1% from low_steps to medium_steps
+normal_steps_delta_for_loss = 1.0               # Use increment of 1% from medium_steps till 100%
+low_steps = 0.1 
+medium_steps = 1.0 
+
+# Prox parameters
+tx_port4 = [19,27,55,63]
+tx_port5 = [20,28,56,64]
+tx_port6 = [21,29,57,65]
+tx_port7 = [22,30,58,66]
+tx_port2 = [23,31,59,67]
+tx_port3 = [24,32,60,68]
+tx_port0 = [25,33,61,69]
+tx_port1 = [26,34,62,70]
+tx_task = 0
+
+all_rx_cores = [1,2,3,4,5,6,7,10]
+rx_lat_cores = [1,2,3,4,5,6,7,10]
+rx_task = 1
+
+# Some variables, do not change
+
+# Program arguments
+parser = OptionParser()
+parser.add_option("-d", "--duration", dest="test_duration", help="Duration of each steps", metavar="integer", default=10)
+parser.add_option("-s", "--speed", dest="init_speed", help="Initial speed", metavar="integer", default=100)
+parser.add_option("-u", "--use-case", dest="use_case", help="Use Case Number", metavar="integer", default=0)
+parser.add_option("-r", "--run", dest="run", help="Run test", metavar="integer", default=0)
+parser.add_option("-c", "--configure", dest="configure", help="Configure Test", metavar="integer", default=0)
+(options, args) = parser.parse_args()
+
+init_speed = int(options.init_speed)
+test_duration = int(options.test_duration)
+use_case = int(options.use_case)
+configure = int(options.configure)
+run = int(options.run)
+
+nb_cores_per_interface = len(tx_port0)
+max_speed = (100.0/nb_cores_per_interface)
+init_speed = (init_speed * 1.0/nb_cores_per_interface)
+accuracy = (accuracy * 1.0/nb_cores_per_interface)
+normal_steps_delta_for_loss = (normal_steps_delta_for_loss /nb_cores_per_interface)
+medium_steps_delta_for_loss = (medium_steps_delta_for_loss /nb_cores_per_interface)
+low_steps_delta_for_loss = (low_steps_delta_for_loss /nb_cores_per_interface)
+medium_steps = (medium_steps /nb_cores_per_interface)
+low_steps = (low_steps /nb_cores_per_interface)
+
+max_dropped = max_dropped / 100
+
+def to_str(arr):
+    ret = ""
+    first = 1;
+    for a in arr:
+        if (first == 0):
+            ret += ","
+
+        ret += str(a)
+        first = 0;
+    return ret;
+
+tx_cores = tx_port0 + tx_port1 + tx_port2 + tx_port3 + tx_port4 + tx_port5 + tx_port6 + tx_port7
+
+def send_all_pkt_size(cores, pkt_size):
+    for c in cores:
+        sock.sendall("pkt_size " + str(c) + " 0 " + str(pkt_size) + "\n");
+
+def send_all_value(cores, offset, value, len):
+    for c in cores:
+        sock.sendall("set value " + str(c) + " 0 " + str(offset) + " " + str(value) + " " + str(len)+ "\n");
+
+def send_all_random(cores, offset, rand_str, len):
+    for c in cores:
+        sock.sendall("set random " + str(c) + " 0 " + str(offset) + " " + str(rand_str) + " " + str(len)+ "\n");
+        #print("set random " + str(c) + " 0 " + str(offset) + " " + str(rand_str) + " " + str(len)+ "\n");
+
+def send_all_speed(cores, speed_perc):
+    for c in cores:
+        sock.sendall("speed " + str(c) + " 0 " + str(speed_perc) + "\n");
+
+def send_reset_random():
+        sock.sendall("reset randoms all" + "\n");
+
+def send_reset_value():
+        sock.sendall("reset values all" + "\n");
+
+def rx_stats(tx_cores, tx_task, rx_cores, rx_task):
+	rx = tx = drop = tsc = tsc_hs = ierrors = 0
+	for e in tx_cores:
+		sock.sendall("core stats " + str(e) + " " + str(tx_task) +  "\n")
+		recv = recv_once()
+		rx += int(recv.split(",")[0])
+		tx += int(recv.split(",")[1])
+		drop += int(recv.split(",")[2])
+		tsc = int(recv.split(",")[3])
+		tsc_hz = int(recv.split(",")[4])
+	for e in rx_cores:
+		sock.sendall("core stats " + str(e) + " " + str(rx_task) +  "\n")
+		recv = recv_once()
+		rx += int(recv.split(",")[0])
+		tx += int(recv.split(",")[1])
+		drop += int(recv.split(",")[2])
+		tsc = int(recv.split(",")[3])
+		tsc_hz = int(recv.split(",")[4])
+	# Also get the ierrors as generators might be the bottleneck...
+	sock.sendall("tot ierrors tot\n")
+	recv = recv_once()
+	ierrors += int(recv.split(",")[0])
+	rx+=ierrors
+	return rx,tx,drop,tsc,tsc_hz
+
+def lat_stats(cores,task):
+	lat_min = [0 for e in range(127)]
+	lat_max = [0 for e in range(127)]
+	lat_avg = [0 for e in range(127)]
+	for e in cores:
+		sock.sendall("lat stats " + str(e) + " " + str(task) + " " +  "\n")
+		recv = recv_once()
+		lat_min[e] = int(recv.split(",")[0])
+		lat_max[e] = int(recv.split(",")[1])
+		lat_avg[e] = int(recv.split(",")[2])
+	return lat_min, lat_max, lat_avg
+
+def recv_once():
+    ret_str = "";
+    done = 0;
+    while done == 0:
+        dat = sock.recv(256);
+        i = 0;
+        while(i < len(dat)):
+            if (dat[i] == '\n'):
+                done = 1
+            else:
+                ret_str += dat[i];
+            i = i + 1;
+    return ret_str
+
+def wait_vRouter_restarted(host):
+	while (1):
+		ret = os.system("ping " + host + " -c 1 > /dev/null")
+		if ret == 0:
+			print "still up..."
+		else:
+			break;
+		sleep(1)
+	
+	while (1):
+		ret = os.system("ping " + host + " -c 1 > /dev/null")
+		if (ret == 0):
+			print "UP"
+			break;
+		else:
+			print "still down..."
+			sleep(1)
+
+def reload_vRouter_config(config):
+	print "connecting to vRouter...and copying " + str(config)
+	sut = remote_system("root", vRouter_host)
+	cmd = "cp /config/prox/" + str(config) + " /config/config.boot"
+	sut.run(cmd)
+	print "Rebooting system at " + str(datetime.now().time())
+	sut.run_forked("reboot")
+	sleep(5)
+	wait_vRouter_restarted(vRouter_host)
+	print "Waiting for last startup scripts to start..."
+	last_script = "l2tp"
+	while(1):
+		dmesg = str(sut.run("dmesg"))
+		if last_script in dmesg:
+			print "found l2tp - UP"
+			break;
+		sleep(1)
+	print "vRouter started - waiting 5 last seconds before starting test"
+	sleep(5)
+	print datetime.now().time()
+
+def set_pkt_sizes(tx_cores, p):
+	send_all_pkt_size(tx_cores, p-4)
+	# For all cores, need to adapt IP Length (byte 16) and UDP Length (byte 38) to pkt size
+	send_all_value(tx_cores, 16, p - 18, 2)		# 14 for MAC (12) EthType (2) 
+	send_all_value(tx_cores, 38, p - 38, 2)		# 34 for MAC (12) EthType (2) IP (20)
+
+def run_measure_throughput(speed):
+	done = 0
+	# Intialize tests by stopping cores and resetting stats
+	step=0
+	steps_done = 0
+	sock.sendall("start " + to_str(all_rx_cores) + "\n")
+	sleep(2)
+	sock.sendall("stop " + to_str(all_rx_cores) + "\n")
+	sock.sendall("reset stats\n")
+	print "Speed    = " + str(speed * nb_cores_per_interface) 
+	sleep(1);
+	
+	send_all_speed(tx_cores, step);
+
+	# Now starting the steps. First go to the common speed, then increase steps for the faster one.
+	sock.sendall("start " + to_str(tx_cores) + "," + to_str(rx_lat_cores) + "\n")
+	while (steps_done == 0):
+		sleep(step_time)
+		if (step + step_delta <= speed):
+			step+=step_delta
+		else:
+			steps_done = 1;
+		send_all_speed(tx_cores, step)
+	
+	# Steps are now OK.  Set speed
+	send_all_speed(tx_cores, speed);
+	sleep(2);
+
+	# Getting statistics to calculate PPS at right speed....
+	rx_pps_beg,tx_pps_beg,drop_pps_beg,tsc_pps_beg,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
+	sleep(test_duration);
+
+	# Collect statistics before test stops...and stop the test. Important to get stats before stopping as stops take some time...
+	rx_pps_end,tx_pps_end,drop_pps_end,tsc_pps_end,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
+	lat_min,lat_max,lat_avg = lat_stats(rx_lat_cores, rx_task)
+	sock.sendall("stop " + "," + to_str(tx_cores) + "\n")
+	sock.sendall("start " + to_str(all_rx_cores) + "\n")
+	sleep(3);
+	sock.sendall("stop " + to_str(all_rx_cores) + "\n")
+	
+	rx_end, tx_end,drop_end,tsc_end,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
+	rx = rx_pps_end - rx_pps_beg
+	tsc = tsc_pps_end - tsc_pps_beg
+	mpps = rx / (tsc/float(tsc_hz)) / 1000000
+	tx = tx_pps_end - tx_pps_beg
+	tx_mpps = tx / (tsc/float(tsc_hz)) / 1000000
+	
+	#print "Runtime = " +  str((tsc)/float(tsc_hz));
+	if (tx_end == 0):
+		dropped_tot = tx_end - rx_end
+		dropped_pct = 0
+	else:
+		dropped_tot = tx_end - rx_end
+		dropped_pct = ((dropped_tot) * 1.0) / tx_end
+
+	if (dropped_tot > 0):
+		if (dropped_pct >= max_dropped):
+			print "** FAILED **: lost " + str(100*dropped_pct) + "% packets RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end)
+		else:
+			print "OK but lost " + str(100*dropped_pct) + "% packets RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end)
+	else:
+		if (dropped_tot < 0):
+			print "Something wrong happened - received more packets than transmitted"
+		else:
+			print "**   OK   **: RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end) 
+	print "MPPS = " + str(mpps)
+	print "===================================================="
+	return dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg
+
+def write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg):
+	f.write(str(pkt_size) + "; " + str(tx_mpps) + "; " + str(mpps) + "; " + str(100 * dropped_pct) + "; " + str(dropped_tot) + "; " + str(speed * nb_cores_per_interface) + "; " + str(number_next_hops) + "; " + str(number_routes) + "; " + str(traffic) + "; ")
+	for e in rx_lat_cores:
+		f.write(str(lat_min[e]) + "; " + str(lat_max[e]) + "; " + str(lat_avg[e]) + "; ")
+	f.write("\n");
+	f.flush()
+
+def run_loss_graph(number_next_hops, number_routes, pkt_size, traffic):
+	speed = init_speed * 1.0
+	done = 0;
+	while done == 0:
+		dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg = run_measure_throughput(speed)
+		write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+		if (speed <= low_steps_delta_for_loss):
+			done = 1
+			return
+		if (speed >= (medium_steps+normal_steps_delta_for_loss)):
+			speed -= normal_steps_delta_for_loss
+		else:
+			if (speed >= (low_steps+medium_steps_delta_for_loss)):
+				speed -= medium_steps_delta_for_loss
+			else:
+				speed -= low_steps_delta_for_loss
+
+def run_dicho_search(number_next_hops, number_routes, pkt_size, traffic):
+	previous_success_speed = 0.0
+	previous_error_speed = max_speed
+	speed = init_speed * 1.0
+	done = 0;
+	good_tx_mpps = 0
+	good_mpps = 0
+	good_dropped_pct = 0
+	good_dropped_tot = 0
+	good_speed = 0
+	good_lat_min = [0 for e in range(127)]
+	good_lat_max = [0 for e in range(127)]
+	good_lat_avg = [0 for e in range(127)]
+
+	while done == 0:
+		dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg = run_measure_throughput(speed)
+		if ((dropped_tot >= 0) and (dropped_pct <= max_dropped)):
+			good_tx_mpps = tx_mpps
+			good_mpps = mpps
+			good_dropped_pct = dropped_pct
+			good_dropped_tot = dropped_tot
+			good_speed = speed
+			good_lat_min = lat_min
+			good_lat_max = lat_max
+			good_lat_avg = lat_avg
+			write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+			write_results(f_all, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+		else:
+			write_results(f_all, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+
+		if ((speed == max_speed) and (dropped_pct <= max_dropped)):
+			write_results(f_minimal, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+			done = 1
+		if (dropped_pct <= max_dropped):
+			previous_success_speed = speed
+			if (speed > max_speed - accuracy):
+				speed = max_speed
+			else:
+				if (previous_error_speed - speed < accuracy):
+					write_results(f_minimal, pkt_size, good_tx_mpps, good_mpps, good_dropped_pct, good_dropped_tot, good_speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, good_lat_min, good_lat_max, good_lat_avg);
+					done = 1
+				else:
+					speed = speed + (previous_error_speed - speed)/2;
+		else:
+			previous_error_speed = speed
+			if (speed - previous_success_speed < accuracy):
+				write_results(f_minimal, pkt_size, good_tx_mpps, good_mpps, good_dropped_pct, good_dropped_tot, good_speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, good_lat_min, good_lat_max, good_lat_avg);
+				done = 1	
+			else:
+				speed  = speed - (speed - previous_success_speed) / 2;
+
+	
+def set_destination_ip(use_case, nb_destinations, traffic):
+	# minimmum 8 routes i.e. 1 per interface 
+	# Destination addressese: "00XXXYY1" "Z00ZZ0ZZ" "AA0AA0AA" "BBBBBB10"
+	# Where X = interface id. Starting with 00 to be in class A and skipping 0.x.y.z and 127.x.y.z
+	# Y, Z and A = additional routes
+	# B = IP in routes. 10 to avoid x.y.z.0 and x.y.z.255
+	# Gaps in A and B to void "too good" distributions e.g. using LPM and 
+	# First changing Y
+
+	mask = ""
+	for i in range (2):
+       		mask = str(mask)+"0"
+	end_mask = ""
+	if (use_case != 2):
+		end_mask = "XXXXXX10"		# Last 8 bits
+
+		if (nb_destinations == 1):
+			end_mask = "0010000000000000000" + str(end_mask)
+		if (nb_destinations == 2):
+			end_mask = "X010000000000000000" + str(end_mask)
+		if (nb_destinations == 4):
+			end_mask = "XX10000000000000000" + str(end_mask)
+		if (nb_destinations == 8):
+			end_mask = "XX1X000000000000000" + str(end_mask)
+		elif (nb_destinations == 16):
+			end_mask = "XX1X00X000000000000" + str(end_mask)
+		elif (nb_destinations == 32):
+			end_mask = "XX1X00XX00000000000" + str(end_mask)
+		elif (nb_destinations == 64):
+			end_mask = "XX1X00XX0X000000000" + str(end_mask)
+		elif (nb_destinations == 128):
+			end_mask = "XX1X00XX0XX00000000" + str(end_mask)
+		elif (nb_destinations == 256):
+			end_mask = "XX1X00XX0XXX0000000" + str(end_mask)
+		elif (nb_destinations == 512):
+			end_mask = "XX1X00XX0XXXX000000" + str(end_mask)
+		elif (nb_destinations == 1024):
+			end_mask = "XX1X00XX0XXXX0X0000" + str(end_mask)
+		elif (nb_destinations == 2048):
+			end_mask = "XX1X00XX0XXXX0XX000" + str(end_mask)
+		elif (nb_destinations == 4096):
+			end_mask = "XX1X00XX0XXXX0XX0X0" + str(end_mask)
+		elif (nb_destinations == 8192):
+			end_mask = "XX1X00XX0XXXX0XX0XX" + str(end_mask)
+	else:
+		if (nb_destinations <= 64 * 1):
+			end_mask = "0010000000000000000"
+			n_dest = int(log(nb_destinations, 2))
+			for i in range (n_dest):
+				end_mask = str(end_mask) + "X"
+			for i in range (6 - n_dest):
+				end_mask = str(end_mask) + "0"
+			end_mask = str(end_mask) + "10"
+		else:
+			end_mask = "XXXXXX10"		# Last 8 bits
+
+		if (nb_destinations == 64 * 2):
+			end_mask = "001X000000000000000" + str(end_mask)
+		elif (nb_destinations == 64 * 4):
+			end_mask = "001X00X000000000000" + str(end_mask)
+		elif (nb_destinations == 64 * 8):
+			end_mask = "001X00XX00000000000" + str(end_mask)
+		elif (nb_destinations == 64 * 16):
+			end_mask = "001X00XX0X000000000" + str(end_mask)
+		elif (nb_destinations == 64 * 32):
+			end_mask = "001X00XX0XX00000000" + str(end_mask)
+		elif (nb_destinations == 64 * 64):
+			end_mask = "001X00XX0XXX0000000" + str(end_mask)
+		elif (nb_destinations == 64 * 128):
+			end_mask = "001X00XX0XXXX000000" + str(end_mask)
+		elif (nb_destinations == 64 * 256):
+			end_mask = "001X00XX0XXXX0X0000" + str(end_mask)
+		elif (nb_destinations == 64 * 512):
+			end_mask = "001X00XX0XXXX0XX000" + str(end_mask)
+		elif (nb_destinations == 64 * 1024):
+			end_mask = "001X00XX0XXXX0XX0X0" + str(end_mask)
+		elif (nb_destinations == 64 * 2048):
+			end_mask = "001X00XX0XXXX0XX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 4096):
+			end_mask = "001XX0XX0XXXX0XX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 8192):
+			end_mask = "001XXXXX0XXXX0XX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 16384):
+			end_mask = "001XXXXXXXXXX0XX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 32768):
+			end_mask = "001XXXXXXXXXXXXX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 65536):
+			end_mask = "001XXXXXXXXXXXXXXXX" + str(end_mask)
+	
+	if (traffic == 0):	# One-to-one. From odd interface to even interface and vice versa, no QPI cross
+		mask1 = str(mask) + "001" + str(end_mask)
+		mask2 = str(mask) + "000" + str(end_mask)
+		mask3 = str(mask) + "011" + str(end_mask)
+		mask4 = str(mask) + "010" + str(end_mask)
+		mask5 = str(mask) + "101" + str(end_mask)
+		mask6 = str(mask) + "100" + str(end_mask)
+		mask7 = str(mask) + "111" + str(end_mask)
+		mask8 = str(mask) + "110" + str(end_mask)
+
+	elif (traffic == 1):	# Full mesh within QPI (i.e. 1 to 4)
+		mask1 = str(mask) + "0XX" + str(end_mask)
+		mask2 = str(mask) + "0XX" + str(end_mask)
+		mask3 = str(mask) + "0XX" + str(end_mask)
+		mask4 = str(mask) + "0XX" + str(end_mask)
+		mask5 = str(mask) + "1XX" + str(end_mask)
+		mask6 = str(mask) + "1XX" + str(end_mask)
+		mask7 = str(mask) + "1XX" + str(end_mask)
+		mask8 = str(mask) + "1XX" + str(end_mask)
+	
+	elif (traffic == 2):	# One to one, crossing QPI (100% QPI)
+		mask1 = str(mask) + "100" + str(end_mask)
+		mask2 = str(mask) + "101" + str(end_mask)
+		mask3 = str(mask) + "110" + str(end_mask)
+		mask4 = str(mask) + "111" + str(end_mask)
+		mask5 = str(mask) + "000" + str(end_mask)
+		mask6 = str(mask) + "001" + str(end_mask)
+		mask7 = str(mask) + "010" + str(end_mask)
+		mask8 = str(mask) + "011" + str(end_mask)
+
+	elif (traffic == 3):	# 1 to 4 crossing QPI (100% QPI)
+		mask1 = str(mask) + "1XX" + str(end_mask)
+		mask2 = str(mask) + "1XX" + str(end_mask)
+		mask3 = str(mask) + "1XX" + str(end_mask)
+		mask4 = str(mask) + "1XX" + str(end_mask)
+		mask5 = str(mask) + "0XX" + str(end_mask)
+		mask6 = str(mask) + "0XX" + str(end_mask)
+		mask7 = str(mask) + "0XX" + str(end_mask)
+		mask8 = str(mask) + "0XX" + str(end_mask)
+
+	elif (traffic == 4):	# 1 to 4 (50% QPI)
+		mask1 = str(mask) + "XX1" + str(end_mask)
+		mask2 = str(mask) + "XX0" + str(end_mask)
+		mask3 = str(mask) + "XX1" + str(end_mask)
+		mask4 = str(mask) + "XX0" + str(end_mask)
+		mask5 = str(mask) + "XX1" + str(end_mask)
+		mask6 = str(mask) + "XX0" + str(end_mask)
+		mask7 = str(mask) + "XX1" + str(end_mask)
+		mask8 = str(mask) + "XX0" + str(end_mask)
+
+	elif (traffic == 5):	# Full mesh (50% QPI)
+		mask1 = str(mask) + "XXX" + str(end_mask)
+		mask2 = str(mask) + "XXX" + str(end_mask)
+		mask3 = str(mask) + "XXX" + str(end_mask)
+		mask4 = str(mask) + "XXX" + str(end_mask)
+		mask5 = str(mask) + "XXX" + str(end_mask)
+		mask6 = str(mask) + "XXX" + str(end_mask)
+		mask7 = str(mask) + "XXX" + str(end_mask)
+		mask8 = str(mask) + "XXX" + str(end_mask)
+
+	for c in tx_port0:
+		send_all_random([c], 30, mask1, 4)
+	for c in tx_port1:
+		send_all_random([c], 30, mask2, 4)
+	for c in tx_port2:
+		send_all_random([c], 30, mask3, 4)
+	for c in tx_port3:
+		send_all_random([c], 30, mask4, 4)
+	for c in tx_port4:
+		send_all_random([c], 30, mask5, 4)
+	for c in tx_port5:
+		send_all_random([c], 30, mask6, 4)
+	for c in tx_port6:
+		send_all_random([c], 30, mask7, 4)
+	for c in tx_port7:
+		send_all_random([c], 30, mask8, 4)
+	for c in tx_cores:
+		send_all_random([c], 34, "0XXXXXXXXXXXXX10", 2)
+		send_all_random([c], 36, "0XXXXXXXXXXXXX10", 2)
+		
+#========================================================================
+class TestDefinition():
+    "Stores test parameters"
+    def __init__(self, use_case, next_hops, number_routes, pkt_size, traffic, reload):
+        self.use_case = use_case
+        self.next_hops = next_hops
+        self.number_routes = number_routes
+        self.pkt_size = pkt_size
+        self.traffic = traffic
+        self.reload = reload
+
+#========================================================================
+# Use case 0 increases input load and measure output load => show dropped packets at low loads, show overload behavior
+# Use case 1 and use case 2 run dichotomic searches, searching for 0 packet loss (or whaever loss is configured)
+# Use case 1 shows the effect of number of routes and next-hops
+# Use case 2 shows the effect of the number of destination, using a fixed (low) number of routes and next-hops
+#========================================================================
+def run_use_case(use_case, number_next_hops, number_routes, pkt_size, traffic, reload):
+	if (reload):
+		if (use_case == 2):
+			config = "config.1_1" + "_" + str(use_case) + ".boot"
+		else:
+			config = "config." + str(number_routes) + "_" + str(number_next_hops) + ".boot"
+		reload_vRouter_config(config)
+	send_reset_random()
+	send_reset_value()
+	set_destination_ip(use_case, number_routes, traffic)
+	set_pkt_sizes(tx_cores, pkt_size)
+	print "Running test with pkt size= " + str(pkt_size) + " Next hops = " + str(number_next_hops) + "; number of routes = " + str(number_routes) + "; Traffic = " + str(traffic) + " \n"
+	if (use_case == 0):
+		run_loss_graph(number_next_hops, number_routes, pkt_size, traffic)
+	else:
+		run_dicho_search(number_next_hops, number_routes, pkt_size, traffic)
+	sleep(3)
+
+#========================================================================
+def run_all_use_cases():
+	use_case_nb = 1
+	# Connect to dppd 
+	file_path = '/tmp/prox.sock'
+	sock.connect(file_path)
+
+	f.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
+	f_all.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
+	f_minimal.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
+	f.flush();
+	f_all.flush();
+	f_minimal.flush();
+
+	# Starting tests
+	print "Stopping all cores and resetting all values and randoms before starting\n"
+	sock.sendall("stop all")
+	sock.sendall("reset stats\n")
+	sleep(3);
+	for line in file_tests:
+		info = line.split(';')
+		if (info[0][0] == '#'):
+			continue
+		if (info[0][0] == ''):
+			break
+		use_case = int(info[0])
+		next_hops = int(info[1])
+		number_routes = int(info[2])
+		pkt_size = int(info[3])
+		traffic = int(info[4])
+		reload = int(info[5])
+		print str(use_case_nb) + " : Running use case " + str(use_case) + " next_hops = " + str(next_hops) + " routes = " + str(number_routes) + " pkt_size = " + str(pkt_size) + " traffic = " + str(traffic) + " reload = " + str(reload)
+		run_use_case(use_case, next_hops, number_routes, pkt_size, traffic, reload)
+		use_case_nb = use_case_nb + 1
+
+#========================================================================
+def configure_use_case(use_case):
+	Tests = []
+	if (use_case == 0):
+		for pkt_size in all_pkt_size:
+			Tests.append(TestDefinition("0", "1", "1", pkt_size, "0", "1"))
+		for pkt_size in all_pkt_size:
+			Tests.append(TestDefinition("0", "1", "1", pkt_size, "1", "1"))
+	if (use_case == 1):
+		number_next_hops = 1
+		reload = 0
+
+		number_routes = number_next_hops	# At least same number of routes that number of next hops
+		while number_routes <= max_number_routes:
+			reload = 1
+			for traffic in range(6):
+				for pkt_size in all_pkt_size:
+					Tests.append(TestDefinition(use_case, number_next_hops, number_routes, pkt_size, traffic, reload))
+					reload = 0
+			if (number_routes < max_number_routes / 2):
+				number_routes = number_routes * 4
+			else:
+				number_routes = number_routes * 2
+
+		number_routes = max_number_next_hops
+		while number_next_hops <= max_number_next_hops:
+			reload = 1
+			for traffic in range(6):
+				for pkt_size in all_pkt_size:
+					Tests.append(TestDefinition(use_case, number_next_hops, number_routes, pkt_size, traffic, reload))
+					reload = 0
+			number_next_hops = number_next_hops * 2
+	if (use_case == 2):
+		number_next_hops = 1
+		reload = 1
+		for traffic in range(6):
+			nb_destinations = 1
+			while nb_destinations <= max_number_addresses_local_network:
+				for pkt_size in all_pkt_size:
+					Tests.append(TestDefinition(use_case, number_next_hops, nb_destinations, pkt_size, traffic, reload))
+					reload = 0
+				nb_destinations = nb_destinations * 2
+			reload = 1
+
+	file_tests = open('test_description.txt', 'w')
+	file_tests.write("# Use case; next_hops; routes; pkt_size; traffic; reload;\n")
+	for test in Tests:
+		file_tests.write(str(test.use_case) + "; " + str(test.next_hops) + "; " +  str(test.number_routes) + "; " + str(test.pkt_size) + "; " + str(test.traffic) + "; " + str(test.reload) + ";\n")
+	file_tests.close()
+
+#========================================================================
+if ((configure == 0) and (run == 0)):
+	print "Nothing to do - please use -r 1 or -c 1"
+if (configure == 1):
+	configure_use_case(use_case)
+if (run == 1):
+	print "****************************************************************************************************************"
+	print "** Running vRouter Characterization with " + str(test_duration) + " seconds steps and starting at " + str(init_speed)   + " percent of line rate **"
+	print "****************************************************************************************************************"
+	sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+	f_all = open('all_results.txt', 'w')
+	f = open('detailed_results.txt', 'w')
+	f_minimal = open('minimal_results.txt', 'w')
+	file_tests = open('test_description.txt', 'r')
+	run_all_use_cases()
+	f.close();
+	sock.close();
diff --git a/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_vRouter_4_ports.py b/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_vRouter_4_ports.py
new file mode 100755
index 00000000..95eb9811
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_vRouter_4_ports.py
@@ -0,0 +1,681 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import socket
+import sys
+import os
+from time import *
+from datetime import  datetime
+from optparse import OptionParser
+import time
+from remote_system import *
+from math import log
+
+# General parameters
+accuracy = 0.1 	# in percent of line rate
+max_dropped = 0.001		# in percent
+all_pkt_size = [64,128,256,512,1024,1280,1518]
+#all_pkt_size = [64]
+
+# vRouter parameters, in case commands must be sent
+vRouter_host = "192.168.1.96" 
+
+# Stear parameters
+step_time = 0.01		# in seconds
+step_delta = 0.025		# in percent of line rate
+
+# Use case dependent parameters
+##### Use case 0: influence of number of routes and next hops #####
+max_number_next_hops = 256			# Maximum number of next-hops per interface
+max_number_routes = 8192			# Maximum number of routes per interface
+max_number_addresses_local_network = 262144
+
+##### Use case 1: packet loss and latency #####
+low_steps_delta_for_loss = 0.01                 # Use increment of 0.01% from 0 to low_steps
+medium_steps_delta_for_loss = 0.1               # Use increment of 0.1% from low_steps to medium_steps
+normal_steps_delta_for_loss = 1.0               # Use increment of 1% from medium_steps till 100%
+low_steps = 0.1 
+medium_steps = 1.0 
+
+# Prox parameters
+tx_port0 = [19,27,55,63]
+tx_port1 = [20,28,56,64]
+tx_port2 = [21,29,57,65]
+tx_port3 = [22,30,58,66]
+tx_port4 = []
+tx_port5 = []
+tx_port6 = []
+tx_port7 = []
+tx_task = 0
+
+all_rx_cores = [23,24,25,26]
+rx_lat_cores = [23,24,25,26]
+rx_task = 1
+
+# Some variables, do not change
+
+# Program arguments
+parser = OptionParser()
+parser.add_option("-d", "--duration", dest="test_duration", help="Duration of each steps", metavar="integer", default=10)
+parser.add_option("-s", "--speed", dest="init_speed", help="Initial speed", metavar="integer", default=100)
+parser.add_option("-u", "--use-case", dest="use_case", help="Use Case Number", metavar="integer", default=0)
+parser.add_option("-r", "--run", dest="run", help="Run test", metavar="integer", default=0)
+parser.add_option("-c", "--configure", dest="configure", help="Configure Test", metavar="integer", default=0)
+(options, args) = parser.parse_args()
+
+init_speed = int(options.init_speed)
+test_duration = int(options.test_duration)
+use_case = int(options.use_case)
+configure = int(options.configure)
+run = int(options.run)
+
+nb_cores_per_interface = len(tx_port0)
+max_speed = (100.0/nb_cores_per_interface)
+init_speed = (init_speed * 1.0/nb_cores_per_interface)
+accuracy = (accuracy * 1.0/nb_cores_per_interface)
+normal_steps_delta_for_loss = (normal_steps_delta_for_loss /nb_cores_per_interface)
+medium_steps_delta_for_loss = (medium_steps_delta_for_loss /nb_cores_per_interface)
+low_steps_delta_for_loss = (low_steps_delta_for_loss /nb_cores_per_interface)
+medium_steps = (medium_steps /nb_cores_per_interface)
+low_steps = (low_steps /nb_cores_per_interface)
+
+max_dropped = max_dropped / 100
+
+def to_str(arr):
+    ret = ""
+    first = 1;
+    for a in arr:
+        if (first == 0):
+            ret += ","
+
+        ret += str(a)
+        first = 0;
+    return ret;
+
+tx_cores = tx_port0 + tx_port1 + tx_port2 + tx_port3 + tx_port4 + tx_port5 + tx_port6 + tx_port7
+
+def send_all_pkt_size(cores, pkt_size):
+    for c in cores:
+        sock.sendall("pkt_size " + str(c) + " 0 " + str(pkt_size) + "\n");
+
+def send_all_value(cores, offset, value, len):
+    for c in cores:
+        sock.sendall("set value " + str(c) + " 0 " + str(offset) + " " + str(value) + " " + str(len)+ "\n");
+
+def send_all_random(cores, offset, rand_str, len):
+    for c in cores:
+        sock.sendall("set random " + str(c) + " 0 " + str(offset) + " " + str(rand_str) + " " + str(len)+ "\n");
+        #print("set random " + str(c) + " 0 " + str(offset) + " " + str(rand_str) + " " + str(len)+ "\n");
+
+def send_all_speed(cores, speed_perc):
+    for c in cores:
+        sock.sendall("speed " + str(c) + " 0 " + str(speed_perc) + "\n");
+
+def send_reset_random():
+        sock.sendall("reset randoms all" + "\n");
+
+def send_reset_value():
+        sock.sendall("reset values all" + "\n");
+
+def rx_stats(tx_cores, tx_task, rx_cores, rx_task):
+	rx = tx = drop = tsc = tsc_hs = ierrors = 0
+	for e in tx_cores:
+		sock.sendall("core stats " + str(e) + " " + str(tx_task) +  "\n")
+		recv = recv_once()
+		rx += int(recv.split(",")[0])
+		tx += int(recv.split(",")[1])
+		drop += int(recv.split(",")[2])
+		tsc = int(recv.split(",")[3])
+		tsc_hz = int(recv.split(",")[4])
+	for e in rx_cores:
+		sock.sendall("core stats " + str(e) + " " + str(rx_task) +  "\n")
+		recv = recv_once()
+		rx += int(recv.split(",")[0])
+		tx += int(recv.split(",")[1])
+		drop += int(recv.split(",")[2])
+		tsc = int(recv.split(",")[3])
+		tsc_hz = int(recv.split(",")[4])
+	# Also get the ierrors as generators might be the bottleneck...
+	sock.sendall("tot ierrors tot\n")
+	recv = recv_once()
+	ierrors += int(recv.split(",")[0])
+	rx+=ierrors
+	return rx,tx,drop,tsc,tsc_hz
+
+def lat_stats(cores,task):
+	lat_min = [0 for e in range(127)]
+	lat_max = [0 for e in range(127)]
+	lat_avg = [0 for e in range(127)]
+	for e in cores:
+		sock.sendall("lat stats " + str(e) + " " + str(task) + " " +  "\n")
+		recv = recv_once()
+		lat_min[e] = int(recv.split(",")[0])
+		lat_max[e] = int(recv.split(",")[1])
+		lat_avg[e] = int(recv.split(",")[2])
+	return lat_min, lat_max, lat_avg
+
+def recv_once():
+    ret_str = "";
+    done = 0;
+    while done == 0:
+        dat = sock.recv(256);
+        i = 0;
+        while(i < len(dat)):
+            if (dat[i] == '\n'):
+                done = 1
+            else:
+                ret_str += dat[i];
+            i = i + 1;
+    return ret_str
+
+def wait_vRouter_restarted(host):
+	while (1):
+		ret = os.system("ping " + host + " -c 1 > /dev/null")
+		if ret == 0:
+			print "still up..."
+		else:
+			break;
+		sleep(1)
+	
+	while (1):
+		ret = os.system("ping " + host + " -c 1 > /dev/null")
+		if (ret == 0):
+			print "UP"
+			break;
+		else:
+			print "still down..."
+			sleep(1)
+
+def reload_vRouter_config(config):
+	print "connecting to vRouter...and copying " + str(config)
+	sut = remote_system("root", vRouter_host)
+	cmd = "cp /config/prox/" + str(config) + " /config/config.boot"
+	sut.run(cmd)
+	print "Rebooting system at " + str(datetime.now().time())
+	sut.run_forked("reboot")
+	sleep(5)
+	wait_vRouter_restarted(vRouter_host)
+	print "Waiting for last startup scripts to start..."
+	last_script = "l2tp"
+	while(1):
+		dmesg = str(sut.run("dmesg"))
+		if last_script in dmesg:
+			print "found l2tp - UP"
+			break;
+		sleep(1)
+	print "vRouter started - waiting 5 last seconds before starting test"
+	sleep(5)
+	print datetime.now().time()
+
+def set_pkt_sizes(tx_cores, p):
+	send_all_pkt_size(tx_cores, p-4)
+	# For all cores, need to adapt IP Length (byte 16) and UDP Length (byte 38) to pkt size
+	send_all_value(tx_cores, 16, p - 18, 2)		# 14 for MAC (12) EthType (2) 
+	send_all_value(tx_cores, 38, p - 38, 2)		# 34 for MAC (12) EthType (2) IP (20)
+
+def run_measure_throughput(speed):
+	done = 0
+	# Intialize tests by stopping cores and resetting stats
+	step=0
+	steps_done = 0
+	sock.sendall("start " + to_str(all_rx_cores) + "\n")
+	sleep(2)
+	sock.sendall("stop " + to_str(all_rx_cores) + "\n")
+	sock.sendall("reset stats\n")
+	print "Speed    = " + str(speed * nb_cores_per_interface) 
+	sleep(1);
+	
+	send_all_speed(tx_cores, step);
+
+	# Now starting the steps. First go to the common speed, then increase steps for the faster one.
+	sock.sendall("start " + to_str(tx_cores) + "," + to_str(rx_lat_cores) + "\n")
+	while (steps_done == 0):
+		sleep(step_time)
+		if (step + step_delta <= speed):
+			step+=step_delta
+		else:
+			steps_done = 1;
+		send_all_speed(tx_cores, step)
+	
+	# Steps are now OK.  Set speed
+	send_all_speed(tx_cores, speed);
+	sleep(2);
+
+	# Getting statistics to calculate PPS at right speed....
+	rx_pps_beg,tx_pps_beg,drop_pps_beg,tsc_pps_beg,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
+	sleep(test_duration);
+
+	# Collect statistics before test stops...and stop the test. Important to get stats before stopping as stops take some time...
+	rx_pps_end,tx_pps_end,drop_pps_end,tsc_pps_end,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
+	lat_min,lat_max,lat_avg = lat_stats(rx_lat_cores, rx_task)
+	sock.sendall("stop " + "," + to_str(tx_cores) + "\n")
+	sock.sendall("start " + to_str(all_rx_cores) + "\n")
+	sleep(3);
+	sock.sendall("stop " + to_str(all_rx_cores) + "\n")
+	
+	rx_end, tx_end,drop_end,tsc_end,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
+	rx = rx_pps_end - rx_pps_beg
+	tsc = tsc_pps_end - tsc_pps_beg
+	mpps = rx / (tsc/float(tsc_hz)) / 1000000
+	tx = tx_pps_end - tx_pps_beg
+	tx_mpps = tx / (tsc/float(tsc_hz)) / 1000000
+	
+	#print "Runtime = " +  str((tsc)/float(tsc_hz));
+	if (tx_end == 0):
+		dropped_tot = tx_end - rx_end
+		dropped_pct = 0
+	else:
+		dropped_tot = tx_end - rx_end
+		dropped_pct = ((dropped_tot) * 1.0) / tx_end
+
+	if (dropped_tot > 0):
+		if (dropped_pct >= max_dropped):
+			print "** FAILED **: lost " + str(100*dropped_pct) + "% packets RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end)
+		else:
+			print "OK but lost " + str(100*dropped_pct) + "% packets RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end)
+	else:
+		if (dropped_tot < 0):
+			print "Something wrong happened - received more packets than transmitted"
+		else:
+			print "**   OK   **: RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end) 
+	print "MPPS = " + str(mpps)
+	print "===================================================="
+	return dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg
+
+def write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg):
+	f.write(str(pkt_size) + "; " + str(tx_mpps) + "; " + str(mpps) + "; " + str(100 * dropped_pct) + "; " + str(dropped_tot) + "; " + str(speed * nb_cores_per_interface) + "; " + str(number_next_hops) + "; " + str(number_routes) + "; " + str(traffic) + "; ")
+	for e in rx_lat_cores:
+		f.write(str(lat_min[e]) + "; " + str(lat_max[e]) + "; " + str(lat_avg[e]) + "; ")
+	f.write("\n");
+	f.flush()
+
+def run_loss_graph(number_next_hops, number_routes, pkt_size, traffic):
+	speed = init_speed * 1.0
+	done = 0;
+	while done == 0:
+		dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg = run_measure_throughput(speed)
+		write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+		if (speed <= low_steps_delta_for_loss):
+			done = 1
+			return
+		if (speed >= (medium_steps+normal_steps_delta_for_loss)):
+			speed -= normal_steps_delta_for_loss
+		else:
+			if (speed >= (low_steps+medium_steps_delta_for_loss)):
+				speed -= medium_steps_delta_for_loss
+			else:
+				speed -= low_steps_delta_for_loss
+
+def run_dicho_search(number_next_hops, number_routes, pkt_size, traffic):
+	previous_success_speed = 0.0
+	previous_error_speed = max_speed
+	speed = init_speed * 1.0
+	done = 0;
+	good_tx_mpps = 0
+	good_mpps = 0
+	good_dropped_pct = 0
+	good_dropped_tot = 0
+	good_speed = 0
+	good_lat_min = [0 for e in range(127)]
+	good_lat_max = [0 for e in range(127)]
+	good_lat_avg = [0 for e in range(127)]
+
+	while done == 0:
+		dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg = run_measure_throughput(speed)
+		if ((dropped_tot >= 0) and (dropped_pct <= max_dropped)):
+			good_tx_mpps = tx_mpps
+			good_mpps = mpps
+			good_dropped_pct = dropped_pct
+			good_dropped_tot = dropped_tot
+			good_speed = speed
+			good_lat_min = lat_min
+			good_lat_max = lat_max
+			good_lat_avg = lat_avg
+			write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+			write_results(f_all, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+		else:
+			write_results(f_all, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+
+		if ((speed == max_speed) and (dropped_pct <= max_dropped)):
+			write_results(f_minimal, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
+			done = 1
+		if (dropped_pct <= max_dropped):
+			previous_success_speed = speed
+			if (speed > max_speed - accuracy):
+				speed = max_speed
+			else:
+				if (previous_error_speed - speed < accuracy):
+					write_results(f_minimal, pkt_size, good_tx_mpps, good_mpps, good_dropped_pct, good_dropped_tot, good_speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, good_lat_min, good_lat_max, good_lat_avg);
+					done = 1
+				else:
+					speed = speed + (previous_error_speed - speed)/2;
+		else:
+			previous_error_speed = speed
+			if (speed - previous_success_speed < accuracy):
+				write_results(f_minimal, pkt_size, good_tx_mpps, good_mpps, good_dropped_pct, good_dropped_tot, good_speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, good_lat_min, good_lat_max, good_lat_avg);
+				done = 1	
+			else:
+				speed  = speed - (speed - previous_success_speed) / 2;
+
+	
+def set_destination_ip(use_case, nb_destinations, traffic):
+	# minimmum 8 routes i.e. 1 per interface 
+	# Destination addressese: "00XXXYY1" "Z00ZZ0ZZ" "AA0AA0AA" "BBBBBB10"
+	# Where X = interface id. Starting with 00 to be in class A and skipping 0.x.y.z and 127.x.y.z
+	# Y, Z and A = additional routes
+	# B = IP in routes. 10 to avoid x.y.z.0 and x.y.z.255
+	# Gaps in A and B to void "too good" distributions e.g. using LPM and 
+	# First changing Y
+
+	mask = ""
+	for i in range (2):
+       		mask = str(mask)+"0"
+	end_mask = ""
+	if (use_case != 2):
+		end_mask = "XXXXXX10"		# Last 8 bits
+
+		if (nb_destinations == 1):
+			end_mask = "0010000000000000000" + str(end_mask)
+		if (nb_destinations == 2):
+			end_mask = "X010000000000000000" + str(end_mask)
+		if (nb_destinations == 4):
+			end_mask = "XX10000000000000000" + str(end_mask)
+		if (nb_destinations == 8):
+			end_mask = "XX1X000000000000000" + str(end_mask)
+		elif (nb_destinations == 16):
+			end_mask = "XX1X00X000000000000" + str(end_mask)
+		elif (nb_destinations == 32):
+			end_mask = "XX1X00XX00000000000" + str(end_mask)
+		elif (nb_destinations == 64):
+			end_mask = "XX1X00XX0X000000000" + str(end_mask)
+		elif (nb_destinations == 128):
+			end_mask = "XX1X00XX0XX00000000" + str(end_mask)
+		elif (nb_destinations == 256):
+			end_mask = "XX1X00XX0XXX0000000" + str(end_mask)
+		elif (nb_destinations == 512):
+			end_mask = "XX1X00XX0XXXX000000" + str(end_mask)
+		elif (nb_destinations == 1024):
+			end_mask = "XX1X00XX0XXXX0X0000" + str(end_mask)
+		elif (nb_destinations == 2048):
+			end_mask = "XX1X00XX0XXXX0XX000" + str(end_mask)
+		elif (nb_destinations == 4096):
+			end_mask = "XX1X00XX0XXXX0XX0X0" + str(end_mask)
+		elif (nb_destinations == 8192):
+			end_mask = "XX1X00XX0XXXX0XX0XX" + str(end_mask)
+	else:
+		if (nb_destinations <= 64 * 1):
+			end_mask = "0010000000000000000"
+			n_dest = int(log(nb_destinations, 2))
+			for i in range (n_dest):
+				end_mask = str(end_mask) + "X"
+			for i in range (6 - n_dest):
+				end_mask = str(end_mask) + "0"
+			end_mask = str(end_mask) + "10"
+		else:
+			end_mask = "XXXXXX10"		# Last 8 bits
+
+		if (nb_destinations == 64 * 2):
+			end_mask = "001X000000000000000" + str(end_mask)
+		elif (nb_destinations == 64 * 4):
+			end_mask = "001X00X000000000000" + str(end_mask)
+		elif (nb_destinations == 64 * 8):
+			end_mask = "001X00XX00000000000" + str(end_mask)
+		elif (nb_destinations == 64 * 16):
+			end_mask = "001X00XX0X000000000" + str(end_mask)
+		elif (nb_destinations == 64 * 32):
+			end_mask = "001X00XX0XX00000000" + str(end_mask)
+		elif (nb_destinations == 64 * 64):
+			end_mask = "001X00XX0XXX0000000" + str(end_mask)
+		elif (nb_destinations == 64 * 128):
+			end_mask = "001X00XX0XXXX000000" + str(end_mask)
+		elif (nb_destinations == 64 * 256):
+			end_mask = "001X00XX0XXXX0X0000" + str(end_mask)
+		elif (nb_destinations == 64 * 512):
+			end_mask = "001X00XX0XXXX0XX000" + str(end_mask)
+		elif (nb_destinations == 64 * 1024):
+			end_mask = "001X00XX0XXXX0XX0X0" + str(end_mask)
+		elif (nb_destinations == 64 * 2048):
+			end_mask = "001X00XX0XXXX0XX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 4096):
+			end_mask = "001XX0XX0XXXX0XX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 8192):
+			end_mask = "001XXXXX0XXXX0XX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 16384):
+			end_mask = "001XXXXXXXXXX0XX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 32768):
+			end_mask = "001XXXXXXXXXXXXX0XX" + str(end_mask)
+		elif (nb_destinations == 64 * 65536):
+			end_mask = "001XXXXXXXXXXXXXXXX" + str(end_mask)
+	
+	if (traffic == 0):	# One-to-one. From odd interface to even interface and vice versa, no QPI cross
+		mask1 = str(mask) + "001" + str(end_mask)
+		mask2 = str(mask) + "000" + str(end_mask)
+		mask3 = str(mask) + "011" + str(end_mask)
+		mask4 = str(mask) + "010" + str(end_mask)
+		mask5 = str(mask) + "101" + str(end_mask)
+		mask6 = str(mask) + "100" + str(end_mask)
+		mask7 = str(mask) + "111" + str(end_mask)
+		mask8 = str(mask) + "110" + str(end_mask)
+
+	elif (traffic == 1):	# Full mesh within QPI (i.e. 1 to 4)
+		mask1 = str(mask) + "0XX" + str(end_mask)
+		mask2 = str(mask) + "0XX" + str(end_mask)
+		mask3 = str(mask) + "0XX" + str(end_mask)
+		mask4 = str(mask) + "0XX" + str(end_mask)
+		mask5 = str(mask) + "1XX" + str(end_mask)
+		mask6 = str(mask) + "1XX" + str(end_mask)
+		mask7 = str(mask) + "1XX" + str(end_mask)
+		mask8 = str(mask) + "1XX" + str(end_mask)
+	
+	elif (traffic == 2):	# One to one, crossing QPI (100% QPI)
+		mask1 = str(mask) + "100" + str(end_mask)
+		mask2 = str(mask) + "101" + str(end_mask)
+		mask3 = str(mask) + "110" + str(end_mask)
+		mask4 = str(mask) + "111" + str(end_mask)
+		mask5 = str(mask) + "000" + str(end_mask)
+		mask6 = str(mask) + "001" + str(end_mask)
+		mask7 = str(mask) + "010" + str(end_mask)
+		mask8 = str(mask) + "011" + str(end_mask)
+
+	elif (traffic == 3):	# 1 to 4 crossing QPI (100% QPI)
+		mask1 = str(mask) + "1XX" + str(end_mask)
+		mask2 = str(mask) + "1XX" + str(end_mask)
+		mask3 = str(mask) + "1XX" + str(end_mask)
+		mask4 = str(mask) + "1XX" + str(end_mask)
+		mask5 = str(mask) + "0XX" + str(end_mask)
+		mask6 = str(mask) + "0XX" + str(end_mask)
+		mask7 = str(mask) + "0XX" + str(end_mask)
+		mask8 = str(mask) + "0XX" + str(end_mask)
+
+	elif (traffic == 4):	# 1 to 4 (50% QPI)
+		mask1 = str(mask) + "XX1" + str(end_mask)
+		mask2 = str(mask) + "XX0" + str(end_mask)
+		mask3 = str(mask) + "XX1" + str(end_mask)
+		mask4 = str(mask) + "XX0" + str(end_mask)
+		mask5 = str(mask) + "XX1" + str(end_mask)
+		mask6 = str(mask) + "XX0" + str(end_mask)
+		mask7 = str(mask) + "XX1" + str(end_mask)
+		mask8 = str(mask) + "XX0" + str(end_mask)
+
+	elif (traffic == 5):	# Full mesh (50% QPI)
+		mask1 = str(mask) + "XXX" + str(end_mask)
+		mask2 = str(mask) + "XXX" + str(end_mask)
+		mask3 = str(mask) + "XXX" + str(end_mask)
+		mask4 = str(mask) + "XXX" + str(end_mask)
+		mask5 = str(mask) + "XXX" + str(end_mask)
+		mask6 = str(mask) + "XXX" + str(end_mask)
+		mask7 = str(mask) + "XXX" + str(end_mask)
+		mask8 = str(mask) + "XXX" + str(end_mask)
+
+	for c in tx_port0:
+		send_all_random([c], 30, mask1, 4)
+	for c in tx_port1:
+		send_all_random([c], 30, mask2, 4)
+	for c in tx_port2:
+		send_all_random([c], 30, mask3, 4)
+	for c in tx_port3:
+		send_all_random([c], 30, mask4, 4)
+	for c in tx_port4:
+		send_all_random([c], 30, mask5, 4)
+	for c in tx_port5:
+		send_all_random([c], 30, mask6, 4)
+	for c in tx_port6:
+		send_all_random([c], 30, mask7, 4)
+	for c in tx_port7:
+		send_all_random([c], 30, mask8, 4)
+	for c in tx_cores:
+		send_all_random([c], 34, "0XXXXXXXXXXXXX10", 2)
+		send_all_random([c], 36, "0XXXXXXXXXXXXX10", 2)
+
+#========================================================================
+class TestDefinition():
+    "Stores test parameters"
+    def __init__(self, use_case, next_hops, number_routes, pkt_size, traffic, reload):
+        self.use_case = use_case
+        self.next_hops = next_hops
+        self.number_routes = number_routes
+        self.pkt_size = pkt_size
+        self.traffic = traffic
+        self.reload = reload
+
+#========================================================================
+# Use case 0 increases input load and measure output load => show dropped packets at low loads, show overload behavior
+# Use case 1 and use case 2 run dichotomic searches, searching for 0 packet loss (or whaever loss is configured)
+# Use case 1 shows the effect of number of routes and next-hops
+# Use case 2 shows the effect of the number of destination, using a fixed (low) number of routes and next-hops
+#========================================================================
+def run_use_case(use_case, number_next_hops, number_routes, pkt_size, traffic, reload):
+	if (reload):
+		if (use_case == 2):
+			config = "config.1_1" + "_" + str(use_case) + ".boot"
+		else:
+			config = "config." + str(number_routes) + "_" + str(number_next_hops) + ".boot"
+		reload_vRouter_config(config)
+	send_reset_random()
+	send_reset_value()
+	set_destination_ip(use_case, number_routes, traffic)
+	set_pkt_sizes(tx_cores, pkt_size)
+	print "Running test with pkt size= " + str(pkt_size) + " Next hops = " + str(number_next_hops) + "; number of routes = " + str(number_routes) + "; Traffic = " + str(traffic) + " \n"
+	if (use_case == 0):
+		run_loss_graph(number_next_hops, number_routes, pkt_size, traffic)
+	else:
+		run_dicho_search(number_next_hops, number_routes, pkt_size, traffic)
+	sleep(3)
+
+#========================================================================
+def run_all_use_cases():
+	use_case_nb = 1
+	# Connect to dppd 
+	file_path = '/tmp/prox.sock'
+	sock.connect(file_path)
+
+	f.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
+	f_all.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
+	f_minimal.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
+	f.flush();
+	f_all.flush();
+	f_minimal.flush();
+
+	# Starting tests
+	print "Stopping all cores and resetting all values and randoms before starting\n"
+	sock.sendall("stop all")
+	sock.sendall("reset stats\n")
+	sleep(3);
+	for line in file_tests:
+		info = line.split(';')
+		if (info[0][0] == '#'):
+			continue
+		if (info[0][0] == ''):
+			break
+		use_case = int(info[0])
+		next_hops = int(info[1])
+		number_routes = int(info[2])
+		pkt_size = int(info[3])
+		traffic = int(info[4])
+		reload = int(info[5])
+		print str(use_case_nb) + " : Running use case " + str(use_case) + " next_hops = " + str(next_hops) + " routes = " + str(number_routes) + " pkt_size = " + str(pkt_size) + " traffic = " + str(traffic) + " reload = " + str(reload)
+		run_use_case(use_case, next_hops, number_routes, pkt_size, traffic, reload)
+		use_case_nb = use_case_nb + 1
+
+#========================================================================
+def configure_use_case(use_case):
+	Tests = []
+	if (use_case == 0):
+		for pkt_size in all_pkt_size:
+			Tests.append(TestDefinition("0", "1", "1", pkt_size, "0", "1"))
+		for pkt_size in all_pkt_size:
+			Tests.append(TestDefinition("0", "1", "1", pkt_size, "1", "1"))
+	if (use_case == 1):
+		number_next_hops = 1
+		reload = 0
+
+		number_routes = number_next_hops	# At least same number of routes that number of next hops
+		while number_routes <= max_number_routes:
+			reload = 1
+			for traffic in range(6):
+				for pkt_size in all_pkt_size:
+					Tests.append(TestDefinition(use_case, number_next_hops, number_routes, pkt_size, traffic, reload))
+					reload = 0
+			if (number_routes < max_number_routes / 2):
+				number_routes = number_routes * 4
+			else:
+				number_routes = number_routes * 2
+
+		number_routes = max_number_next_hops
+		while number_next_hops <= max_number_next_hops:
+			reload = 1
+			for traffic in range(6):
+				for pkt_size in all_pkt_size:
+					Tests.append(TestDefinition(use_case, number_next_hops, number_routes, pkt_size, traffic, reload))
+					reload = 0
+			number_next_hops = number_next_hops * 2
+	if (use_case == 2):
+		number_next_hops = 1
+		reload = 1
+		for traffic in range(6):
+			nb_destinations = 1
+			while nb_destinations <= max_number_addresses_local_network:
+				for pkt_size in all_pkt_size:
+					Tests.append(TestDefinition(use_case, number_next_hops, nb_destinations, pkt_size, traffic, reload))
+					reload = 0
+				nb_destinations = nb_destinations * 2
+			reload = 1
+
+	file_tests = open('test_description.txt', 'w')
+	file_tests.write("# Use case; next_hops; routes; pkt_size; traffic; reload;\n")
+	for test in Tests:
+		file_tests.write(str(test.use_case) + "; " + str(test.next_hops) + "; " +  str(test.number_routes) + "; " + str(test.pkt_size) + "; " + str(test.traffic) + "; " + str(test.reload) + ";\n")
+	file_tests.close()
+
+#========================================================================
+if ((configure == 0) and (run == 0)):
+	print "Nothing to do - please use -r 1 or -c 1"
+if (configure == 1):
+	configure_use_case(use_case)
+if (run == 1):
+	print "****************************************************************************************************************"
+	print "** Running vRouter Characterization with " + str(test_duration) + " seconds steps and starting at " + str(init_speed)   + " percent of line rate **"
+	print "****************************************************************************************************************"
+	sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+	f_all = open('all_results.txt', 'w')
+	f = open('detailed_results.txt', 'w')
+	f_minimal = open('minimal_results.txt', 'w')
+	file_tests = open('test_description.txt', 'r')
+	run_all_use_cases()
+	f.close();
+	sock.close();
diff --git a/VNFs/DPPD-PROX/helper-scripts/testvRouter/create_interfaces_and_routes.pl b/VNFs/DPPD-PROX/helper-scripts/testvRouter/create_interfaces_and_routes.pl
new file mode 100755
index 00000000..b8baa46b
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/testvRouter/create_interfaces_and_routes.pl
@@ -0,0 +1,90 @@
+#!/bin/env perl
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+# This script creates four sets of files: 2 sets for use case 0 and 1
+# (which use the same configuration) and 2 for use case 2.
+# Each use case is defined by 2 sets of configuration files.
+# interface.txt contains the IP addresses of the DPDK fast path interfaces.
+# route.x.y.txt contains the routing table for different configurations
+# with x being number of routes and y number of next_hops.
+# Those interface.txt and route.x.y.txt files should then be converted
+# to fit the syntax of vRouter configuration files.
+
+use strict;
+my $max_nb_routes = 8192;
+my $max_nb_next_hops = 1024;
+my $max_nb_interfaces = 4;
+my $nb_next_hops = 1;
+my ($interface, $a1, $a2, $a3, $a4, $fh, $output_route);
+
+# Create interface configuration for use case 0 and 1
+my $interface_config = "interface.txt";
+open($fh, '>', $interface_config) or die "Could not open file '$interface_config' $!";
+print $fh "# interface IP address/prefix\n";
+for ($interface = 0; $interface < $max_nb_interfaces; $interface++) {
+	print $fh ($interface+64).".0.0.240/24\n";	
+}
+close $fh;
+
+# Create interface configuration for use case 2
+my $interface_config = "interface_use_case_2.txt";
+open($fh, '>', $interface_config) or die "Could not open file '$interface_config' $!";
+print $fh "# interface IP address/prefix\n";
+for ($interface = 0; $interface < $max_nb_interfaces; $interface++) {
+	print $fh ($interface * 8 + 1).".0.0.240/5\n";	
+}
+close $fh;
+
+# Create routes configuration for use case 0 and 1
+while ($nb_next_hops <= $max_nb_next_hops) {
+	my $nb_routes_per_interface = $nb_next_hops;
+	while ($nb_routes_per_interface <= $max_nb_routes) {
+		$output_route = "route.".$nb_routes_per_interface.".".$nb_next_hops.".txt";
+		open($fh, '>', $output_route) or die "Could not open file '$output_route' $!";
+		print $fh "# destination/prefix;nex-hop\n";
+
+		for (my $route_nb = 0; $route_nb < $nb_routes_per_interface; $route_nb++) {
+			for ($interface = 0; $interface < $max_nb_interfaces; $interface++) {
+				$a1 = $interface * 8 + 1 + (($route_nb & 1) << 2) + ($route_nb & 2);
+				$a2 = (($route_nb & 4) << 5) + (($route_nb & 8) << 1) + (($route_nb & 0x10) >> 1) + (($route_nb & 0x20) >> 4) + (($route_nb & 0x40) >> 6);
+				$a3 = (($route_nb & 0x80)) + (($route_nb & 0x100) >> 2) + (($route_nb & 0x200) >> 5) + (($route_nb & 0x400) >> 7) + (($route_nb & 0x800) >> 10) + (($route_nb & 0x1000) >> 12);
+				$a4 = 0;
+				print $fh $a1.".".$a2.".".$a3.".".$a4."/24;";
+				print $fh ($interface+64).".0.".(($route_nb % $nb_next_hops) >> 7).".".(1 + (($route_nb % $nb_next_hops) & 0x7f)) ."\n";
+			}
+		}
+		$nb_routes_per_interface = $nb_routes_per_interface * 2;
+	}
+	$nb_next_hops = $nb_next_hops * 2;		
+}
+close $fh;
+
+# Create routes configuration for use case 2
+$output_route = "route.1.1.use_case_2.txt";
+open($fh, '>', $output_route) or die "Could not open file '$output_route' $!";
+print $fh "# destination/prefix;nex-hop\n";
+
+for ($interface = 0; $interface < $max_nb_interfaces; $interface++) {
+	$a1 = $interface + 64 ;
+	$a2 = 0;
+	$a3 = 0;
+	$a4 = 0;
+	print $fh $a1.".".$a2.".".$a3.".".$a4."/24;";
+	print $fh ($interface * 8 + 1).".0.0.1\n";
+}
+close $fh;
diff --git a/VNFs/DPPD-PROX/helper-scripts/testvRouter/remote_system.py b/VNFs/DPPD-PROX/helper-scripts/testvRouter/remote_system.py
new file mode 100755
index 00000000..f00ab77b
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/testvRouter/remote_system.py
@@ -0,0 +1,57 @@
+#!/bin/env python
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+import os
+import thread
+import time
+import socket
+
+def ssh(user, ip, cmd):
+    # print cmd;
+    ssh_options = ""
+    ssh_options += "-o StrictHostKeyChecking=no "
+    ssh_options += "-o UserKnownHostsFile=/dev/null "
+    ssh_options += "-o LogLevel=quiet "
+    running = os.popen("ssh " + ssh_options + " " + user + "@" + ip + " \"" + cmd + "\"");
+    ret = {};
+    ret['out'] = running.read().strip();
+    ret['ret'] = running.close();
+    if (ret['ret'] == None):
+        ret['ret'] = 0;
+
+    return ret;
+
+def ssh_check_quit(obj, user, ip, cmd):
+    ret = ssh(user, ip, cmd);
+    if (ret['ret'] != 0):
+        obj._err = True;
+        obj._err_str = ret['out'];
+        exit(-1);
+
+class remote_system:
+    def __init__(self, user, ip):
+        self._ip          = ip;
+        self._user        = user;
+    def run(self, cmd):
+        return ssh(self._user, self._ip, cmd);
+    def run_forked(self, cmd):
+        thread.start_new_thread(ssh, (self._user, self._ip, cmd));
+        return 0;
+    def scp(self, src, dst):
+        running = os.popen("scp " + self._user + "@" + self._ip + ":" + src + " " + dst);
+        return running.close();
diff --git a/VNFs/DPPD-PROX/helper-scripts/trailing.sh b/VNFs/DPPD-PROX/helper-scripts/trailing.sh
new file mode 100755
index 00000000..5b64b1d7
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/trailing.sh
@@ -0,0 +1,69 @@
+#!/bin/bash
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+bad_lines=$(grep -nHr -e "[[:space:]]$" *.c *.h gen/*.cfg config/*.cfg)
+
+if [ -n "$bad_lines" ]; then
+    echo "Found trailing white-spaces:"
+    echo $bad_lines
+    exit 1;
+fi
+
+for f in *.c *.h gen/*.cfg config/*.cfg; do
+    result=$(tail -n 1 $f | grep "^$" | wc -l)
+
+    if [ "$result" == "1" ]; then
+        echo "Trailing newlines at end of file $f"
+        exit 1
+    fi
+done;
+
+prev="dummy"
+function findDuplicate() {
+    line=1
+    while read p; do
+	if [ "$prev" == "" ]; then
+	    if [ "$p" == "" ]; then
+		echo "duplicate empty line at $1:$line"
+		bad=1
+	    fi
+	fi
+	prev=$p
+	let "line+=1"
+    done <$1
+}
+
+bad=0
+for f in *.c *.h; do
+    findDuplicate $f
+done;
+
+if [ "$bad" != "0" ]; then
+    exit 1
+fi
+
+tab="	"
+bad_lines=$(grep -nHr -e "^$tab$tab$tab$tab$tab$tab$tab" *.c *.h | head -n1)
+
+if [ -n "$bad_lines" ]; then
+    echo "Code nested too deep:"
+    echo $bad_lines
+    exit 1;
+fi
+
+exit 0
diff --git a/VNFs/DPPD-PROX/helper-scripts/vm-cores.py b/VNFs/DPPD-PROX/helper-scripts/vm-cores.py
new file mode 100644
index 00000000..de794998
--- /dev/null
+++ b/VNFs/DPPD-PROX/helper-scripts/vm-cores.py
@@ -0,0 +1,20 @@
+#!/bin/env python2.7
+
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+cores = [[0,20], [1,21], [2,22], [3,23], [4,24], [5,25], [6,26], [7,27], [8,28], [9,29]]
+
diff --git a/VNFs/DPPD-PROX/input.c b/VNFs/DPPD-PROX/input.c
new file mode 100644
index 00000000..bb956bcd
--- /dev/null
+++ b/VNFs/DPPD-PROX/input.c
@@ -0,0 +1,105 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+#include <rte_common.h>
+
+#include "clock.h"
+#include "input.h"
+
+static struct input *inputs[32];
+static int n_inputs;
+static int max_input_fd;
+
+int reg_input(struct input *in)
+{
+	if (n_inputs == sizeof(inputs)/sizeof(inputs[0]))
+		return -1;
+
+	for (int i = 0; i < n_inputs; ++i) {
+		if (inputs[i] == in)
+			return -1;
+	}
+	inputs[n_inputs++] = in;
+	max_input_fd = RTE_MAX(in->fd, max_input_fd);
+
+	return 0;
+}
+
+void unreg_input(struct input *in)
+{
+	int rm, i;
+
+	for (rm = 0; rm < n_inputs; ++rm) {
+		if (inputs[rm] == in) {
+			break;
+		}
+	}
+
+	if (rm == n_inputs)
+		return ;
+
+	for (i = rm + 1; i < n_inputs; ++i) {
+		inputs[i - 1] = inputs[i];
+	}
+
+	n_inputs--;
+	max_input_fd = 0;
+	for (i = 0; i < n_inputs; ++i) {
+		max_input_fd = RTE_MAX(inputs[i]->fd, max_input_fd);
+	}
+}
+
+static int tsc_diff_to_tv(uint64_t beg, uint64_t end, struct timeval *tv)
+{
+	if (end < beg) {
+		return -1;
+	}
+
+	uint64_t diff = end - beg;
+	tsc_to_tv(tv, diff);
+	return 0;
+}
+
+void input_proc_until(uint64_t deadline)
+{
+	struct timeval tv;
+	fd_set in_fd;
+	int ret = 1;
+
+	/* Keep checking for input until select() returned 0 (timeout
+	   occurred before input was read) or current time has passed
+	   the deadline (which occurs when time progresses past the
+	   deadline between return of select() and the next
+	   iteration). */
+	while (ret != 0 && tsc_diff_to_tv(rte_rdtsc(), deadline, &tv) == 0) {
+		FD_ZERO(&in_fd);
+
+		for (int i = 0; i < n_inputs; ++i) {
+			FD_SET(inputs[i]->fd, &in_fd);
+		}
+
+		ret = select(max_input_fd + 1, &in_fd, NULL, NULL, &tv);
+
+		if (ret > 0) {
+			for (int i = 0; i < n_inputs; ++i) {
+				if (FD_ISSET(inputs[i]->fd, &in_fd)) {
+					inputs[i]->proc_input(inputs[i]);
+				}
+			}
+		}
+	}
+}
diff --git a/VNFs/DPPD-PROX/input.h b/VNFs/DPPD-PROX/input.h
new file mode 100644
index 00000000..06f6b653
--- /dev/null
+++ b/VNFs/DPPD-PROX/input.h
@@ -0,0 +1,35 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _INPUT_H_
+#define _INPUT_H_
+
+#include <inttypes.h>
+
+struct input {
+	int fd;
+	/* Function to be called when data is available on the fd */
+	void (*proc_input)(struct input *input);
+	void (*reply)(struct input *input, const char *buf, size_t len);
+	void (*history)(struct input *input);
+};
+
+int reg_input(struct input *in);
+void unreg_input(struct input *in);
+
+void input_proc_until(uint64_t deadline);
+
+#endif /* _INPUT_H_ */
diff --git a/VNFs/DPPD-PROX/input_conn.c b/VNFs/DPPD-PROX/input_conn.c
new file mode 100644
index 00000000..63e6511e
--- /dev/null
+++ b/VNFs/DPPD-PROX/input_conn.c
@@ -0,0 +1,236 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include "input_conn.h"
+#include "input.h"
+#include "run.h"
+#include "cmd_parser.h"
+
+static struct input tcp_server;
+int tcp_server_started;
+static struct input uds_server;
+int uds_server_started;
+
+/* Active clients */
+struct client_conn {
+	struct input input;
+	int          enabled;
+	int          n_buf;
+	char         buf[32768];
+};
+
+struct client_conn clients[32];
+
+static int start_listen_tcp(void)
+{
+	struct sockaddr_in server;
+	int ret, sock;
+	int optval = 1;
+
+	memset(&server, 0, sizeof(server));
+	sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+
+	if (sock == -1)
+		return -1;
+
+	server.sin_family = AF_INET;
+	server.sin_port = ntohs(8474);
+	server.sin_addr.s_addr = ntohl(INADDR_ANY);
+
+	ret = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(int));
+
+	if (ret)
+		return -1;
+
+	if (bind(sock, (struct sockaddr *) &server, sizeof(server)) == -1)
+		return -1;
+
+	if (listen(sock, 1) == -1)
+		return -1;
+
+	return sock;
+}
+
+static int start_listen_uds(void)
+{
+	int sock;
+	struct sockaddr_un server = {
+		.sun_path = "/tmp/prox.sock",
+		.sun_family = AF_UNIX
+	};
+
+	sock = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (sock == -1)
+		return -1;
+
+	/* Unlink can fail, i.e. when /tmp/prox.sock does not
+	   exists. This is not fatal. */
+	unlink(server.sun_path);
+
+	if (bind(sock, (struct sockaddr *) &server, sizeof(server)) == -1)
+		return -1;
+
+	if (listen(sock, 1) == -1)
+		return -1;
+
+	return sock;
+}
+
+static void write_client(struct input *input, const char *buf, size_t len)
+{
+	int ret;
+
+	while ((ret = write(input->fd, buf, len)) != (int)len) {
+		buf += ret;
+		len -= ret;
+	}
+}
+
+static void handle_client(struct input* client_input)
+{
+	char cur[1024];
+	size_t i;
+	int ret;
+	struct client_conn *c = NULL;
+
+	/* Get the client structure that uses this input */
+	for (i = 0; i < sizeof(clients)/sizeof(clients[0]); ++i) {
+		if (&clients[i].input == client_input) {
+			c = &clients[i];
+			break;
+		}
+	}
+
+	/* handle_client function called non-tcp client */
+	if (c == NULL)
+		return ;
+
+	ret = read(c->input.fd, cur, sizeof(cur));
+
+	if (ret == 0) {
+		c->enabled = 0;
+		unreg_input(&c->input);
+		return ;
+	}
+
+	/* Scan in data until \n (\r skipped if followed by \n) */
+	for (int i = 0; i < ret; ++i) {
+		if (cur[i] == '\r' && i + 1 < ret && cur[i + 1] == '\n')
+			continue;
+
+		if (cur[i] == '\n') {
+			c->buf[c->n_buf] = 0;
+			if (c->n_buf)
+				cmd_parser_parse(c->buf, client_input);
+			c->n_buf = 0;
+		}
+		else if (c->n_buf + 1 < (int)sizeof(c->buf))
+			c->buf[c->n_buf++] = cur[i];
+		else
+			c->n_buf = 0;
+	}
+}
+
+static void handle_new_client(struct input* server)
+{
+	size_t i;
+
+	int new_client = accept(server->fd, NULL, NULL);
+
+	for (i = 0; i < sizeof(clients)/sizeof(clients[0]); ++i) {
+		if (clients[i].enabled == 0) {
+			break;
+		}
+	}
+
+	if (i == sizeof(clients)/sizeof(clients[0])) {
+		close(new_client);
+		return ;
+	}
+
+	clients[i].enabled = 1;
+	clients[i].n_buf = 0;
+	clients[i].input.fd = new_client;
+	clients[i].input.reply = server->reply;
+	clients[i].input.proc_input = handle_client;
+
+	reg_input(&clients[i].input);
+}
+
+int reg_input_tcp(void)
+{
+	int fd;
+
+	if (tcp_server_started)
+		return -1;
+	if ((fd = start_listen_tcp()) < 0)
+		return -1;
+
+	tcp_server.fd = fd;
+	tcp_server.proc_input = handle_new_client;
+	tcp_server.reply = write_client;
+	if (reg_input(&tcp_server) != 0) {
+		close(fd);
+		return -1;
+	}
+	tcp_server_started = 1;
+	return 0;
+}
+
+int reg_input_uds(void)
+{
+	int fd;
+
+	if (uds_server_started)
+		return -1;
+
+	if ((fd = start_listen_uds()) < 0)
+		return -1;
+
+	uds_server.fd = fd;
+	uds_server.proc_input = handle_new_client;
+	uds_server.reply = write_client;
+	if (reg_input(&uds_server) != 0) {
+		close(fd);
+		return -1;
+	}
+	uds_server_started = 1;
+	return 0;
+}
+
+void unreg_input_tcp(void)
+{
+	if (!tcp_server_started)
+		return;
+	tcp_server_started = 0;
+	close(tcp_server.fd);
+	unreg_input(&tcp_server);
+}
+
+void unreg_input_uds(void)
+{
+	if (!uds_server_started)
+		return;
+	uds_server_started = 0;
+	close(tcp_server.fd);
+	unreg_input(&tcp_server);
+}
diff --git a/VNFs/DPPD-PROX/input_conn.h b/VNFs/DPPD-PROX/input_conn.h
new file mode 100644
index 00000000..98e9af45
--- /dev/null
+++ b/VNFs/DPPD-PROX/input_conn.h
@@ -0,0 +1,27 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _INPUT_CONN_H_
+#define _INPUT_CONN_H_
+
+/* Returns 0 on success, -1 otherwise. */
+int reg_input_tcp(void);
+int reg_input_uds(void);
+
+void unreg_input_tcp(void);
+void unreg_input_uds(void);
+
+#endif /* _INPUT_CONN_H_ */
diff --git a/VNFs/DPPD-PROX/input_curses.c b/VNFs/DPPD-PROX/input_curses.c
new file mode 100644
index 00000000..6f79869b
--- /dev/null
+++ b/VNFs/DPPD-PROX/input_curses.c
@@ -0,0 +1,325 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "log.h"
+#include "input.h"
+#include "display.h"
+#include "run.h"
+#include "cmd_parser.h"
+#include "input_curses.h"
+#include "histedit.h"
+
+static EditLine *el;
+static History *hist;
+
+static struct input input_curses;
+static int tabbed;
+
+static void show_history(struct input *input)
+{
+	HistEvent event;
+
+	history(hist, &event, H_LAST);
+
+	do {
+		plog_info("%s", event.str); /* event.str contains newline */
+	} while (history(hist, &event, H_PREV) != -1);
+}
+
+static int complete(__attribute__((unused)) int ch)
+{
+	const LineInfo *li;
+	size_t len;
+	size_t n_match = 0;
+	char complete_cmd[128] = {0};
+	int complete_cmd_partial = 0;
+
+	li = el_line(el);
+	for (size_t i = 0; i < cmd_parser_n_cmd(); ++i) {
+		len = li->lastchar - li->buffer;
+		if (strncmp(cmd_parser_cmd(i), li->buffer, len) == 0) {
+			if (n_match) {
+				size_t cur_len = strlen(complete_cmd);
+				for (size_t j = 0; j < cur_len; ++j) {
+					if (complete_cmd[j] != cmd_parser_cmd(i)[j]) {
+						complete_cmd[j] = 0;
+						complete_cmd_partial = 1;
+						break;
+					}
+				}
+			}
+			else {
+				strcpy(complete_cmd, cmd_parser_cmd(i));
+			}
+
+			n_match++;
+		}
+	}
+
+	/* Complete only if there are more characters known than
+	   currently entered. */
+	if (n_match && len < strlen(complete_cmd)) {
+		el_deletestr(el, li->cursor - li->buffer);
+		el_insertstr(el, complete_cmd);
+		if (!complete_cmd_partial)
+			el_insertstr(el, " ");
+
+		return CC_REDISPLAY;
+	}
+	else if (tabbed) {
+		int printed = 0;
+		for (size_t i = 0; i < cmd_parser_n_cmd(); ++i) {
+			len = li->lastchar - li->buffer;
+			if (strncmp(cmd_parser_cmd(i), li->buffer, len) == 0) {
+				plog_info("%-23s", cmd_parser_cmd(i));
+				printed++;
+			}
+			if (printed == 4) {
+				printed = 0;
+				plog_info("\n");
+			}
+		}
+		if (printed)
+			plog_info("\n");
+	}
+	else {
+		tabbed = 1;
+	}
+
+	return CC_REDISPLAY;
+}
+
+/* Returns non-zero if stdin is readable */
+static int peek_stdin(void)
+{
+	int tmp;
+	fd_set in_fd;
+	struct timeval tv;
+
+	tv.tv_sec = 0;
+	tv.tv_usec = 10000;
+
+	FD_ZERO(&in_fd);
+	FD_SET(fileno(stdin), &in_fd);
+	tmp = select(fileno(stdin) + 1, &in_fd, NULL, NULL, &tv);
+	return FD_ISSET(fileno(stdin), &in_fd);
+}
+
+static int get_char(EditLine *e, char *c)
+{
+	*c = display_getch();
+
+	/* If no characters have been entered, number keys switch the
+	   screen and '0' resets stats. This is provided as a
+	   fall-back in case F-keys do not function. The keys are
+	   intercepted before returning control to libedit. */
+	if (*c >= '0' && *c <= '9') {
+		const LineInfo *li;
+
+		li = el_line(e);
+		if (li->lastchar == li->buffer) {
+			if (*c >= '1') {
+				display_screen(*c - '0' - 1);
+				return 0;
+			}
+			else {
+				cmd_parser_parse("reset stats", &input_curses);
+				return 0;
+			}
+		}
+	}
+	if (*c == '=') {
+		toggle_display_screen();
+		return 0;
+	}
+
+	/* Escape by itself is the first character used for more
+	   complex escape sequences like F-keys. libedit can't be used
+	   to detect both ESC as a unitary key and more complex
+	   sequences starting ESC at the same time. */
+	if (*c == 27 && !peek_stdin()) {
+		quit();
+		return 0;
+	}
+	else if (*c != 9) {
+		tabbed = 0;
+	}
+
+	return 1;
+}
+
+static void proc_keyboard(struct input *input)
+{
+	const char *line;
+	const LineInfo *li;
+	HistEvent hist_event;
+	int len;
+
+	line = el_gets(el, &len);
+	li = el_line(el);
+
+	if (len == 0 || line == NULL) {
+		display_cmd("", 0, 0);
+		return;
+	} else if (len > 0) {
+		if (len == 1 && line[0] == '\n') {
+			display_print_page();
+			el_set(el, EL_UNBUFFERED, 0);
+			el_set(el, EL_UNBUFFERED, 1);
+			return;
+		}
+		if (line[len-1] == '\n') {
+			if (hist) {
+				history(hist, &hist_event, H_ENTER, line);
+			}
+
+			char *line2 = strndup(line, len);
+			line2[len - 1] = 0; /* replace \n */
+			cmd_parser_parse(line2, input);
+			free(line2);
+
+			el_set(el, EL_UNBUFFERED, 0);
+			el_set(el, EL_UNBUFFERED, 1);
+			display_cmd("", 0, 0);
+			return;
+		}
+		if (line[len-1] == 4) {
+			return; /* should quit*/
+		}
+	}
+	else {
+		if (errno) {
+                       return;
+		}
+		display_cmd("", 0, 0);
+		return;
+	}
+	display_cmd(line, len, li->cursor - li->buffer);
+}
+
+static int key_f1(__attribute__((unused)) int ch) {display_screen(0); return CC_REDISPLAY;}
+static int key_f2(__attribute__((unused)) int ch) {display_screen(1); return CC_REDISPLAY;}
+static int key_f3(__attribute__((unused)) int ch) {display_screen(2); return CC_REDISPLAY;}
+static int key_f4(__attribute__((unused)) int ch) {display_screen(3); return CC_REDISPLAY;}
+static int key_f5(__attribute__((unused)) int ch) {display_screen(4); return CC_REDISPLAY;}
+static int key_f6(__attribute__((unused)) int ch) {display_screen(5); return CC_REDISPLAY;}
+static int key_f7(__attribute__((unused)) int ch) {display_screen(6); return CC_REDISPLAY;}
+static int key_f8(__attribute__((unused)) int ch) {display_screen(7); return CC_REDISPLAY;}
+static int key_f9(__attribute__((unused)) int ch) {display_screen(8); return CC_REDISPLAY;}
+static int key_f10(__attribute__((unused)) int ch) {display_screen(9); return CC_REDISPLAY;}
+static int key_f11(__attribute__((unused)) int ch) {display_screen(10); return CC_REDISPLAY;}
+static int key_f12(__attribute__((unused)) int ch) {display_screen(11); return CC_REDISPLAY;}
+
+static int key_page_up(__attribute__((unused)) int ch) {display_page_up(); return CC_REDISPLAY;}
+static int key_page_down(__attribute__((unused)) int ch) {display_page_down(); return CC_REDISPLAY;}
+
+static void setup_el(void)
+{
+	int pty;
+	FILE *dev_pty;
+	HistEvent hist_event;
+
+	/* Open a pseudo-terminal for use in libedit. This is required
+	   since the library checks if it is using a tty. If the file
+	   descriptor does not represent a tty, the library disables
+	   editing. */
+
+	pty = posix_openpt(O_RDWR);
+	/* TODO: On error (posix_openpt() < 0), fall-back to
+	   non-libedit implementation. */
+	grantpt(pty);
+	unlockpt(pty);
+	dev_pty = fdopen(pty, "wr");
+
+	el = el_init("", dev_pty, dev_pty, dev_pty);
+
+	el_set(el, EL_EDITOR, "emacs");
+
+	el_set(el, EL_ADDFN, "complete", "Command completion", complete);
+
+	el_set(el, EL_ADDFN, "key_f1", "Switch to screen 1", key_f1);
+	el_set(el, EL_ADDFN, "key_f2", "Switch to screen 2", key_f2);
+	el_set(el, EL_ADDFN, "key_f3", "Switch to screen 3", key_f3);
+	el_set(el, EL_ADDFN, "key_f4", "Switch to screen 4", key_f4);
+	el_set(el, EL_ADDFN, "key_f5", "Switch to screen 5", key_f5);
+	el_set(el, EL_ADDFN, "key_f6", "Switch to screen 6", key_f6);
+	el_set(el, EL_ADDFN, "key_f7", "Switch to screen 7", key_f7);
+	el_set(el, EL_ADDFN, "key_f8", "Switch to screen 8", key_f8);
+	el_set(el, EL_ADDFN, "key_f9", "Switch to screen 9", key_f5);
+	el_set(el, EL_ADDFN, "key_f10", "Switch to screen 10", key_f6);
+	el_set(el, EL_ADDFN, "key_f11", "Switch to screen 11", key_f7);
+	el_set(el, EL_ADDFN, "key_f12", "Switch to screen 12", key_f8);
+
+	el_set(el, EL_ADDFN, "key_page_up", "Page up", key_page_up);
+	el_set(el, EL_ADDFN, "key_page_down", "Page down", key_page_down);
+
+	el_set(el, EL_BIND, "^I", "complete", NULL);
+	el_set(el, EL_BIND, "^r", "em-inc-search-prev", NULL);
+
+	el_set(el, EL_BIND, "^[[11~", "key_f1", NULL);
+	el_set(el, EL_BIND, "^[[12~", "key_f2", NULL);
+	el_set(el, EL_BIND, "^[[13~", "key_f3", NULL);
+	el_set(el, EL_BIND, "^[[14~", "key_f4", NULL);
+	el_set(el, EL_BIND, "^[[15~", "key_f5", NULL);
+	el_set(el, EL_BIND, "^[[17~", "key_f6", NULL);
+	el_set(el, EL_BIND, "^[[18~", "key_f7", NULL);
+	el_set(el, EL_BIND, "^[[19~", "key_f8", NULL);
+	el_set(el, EL_BIND, "^[[20~", "key_f9", NULL);
+	el_set(el, EL_BIND, "^[[21~", "key_f10", NULL);
+	el_set(el, EL_BIND, "^[[23~", "key_f11", NULL);
+	el_set(el, EL_BIND, "^[[24~", "key_f12", NULL);
+
+	el_set(el, EL_BIND, "^[OP", "key_f1", NULL);
+	el_set(el, EL_BIND, "^[OQ", "key_f2", NULL);
+	el_set(el, EL_BIND, "^[OR", "key_f3", NULL);
+	el_set(el, EL_BIND, "^[OS", "key_f4", NULL);
+
+	el_set(el, EL_BIND, "^[[5~", "key_page_up", NULL);
+	el_set(el, EL_BIND, "^[[6~", "key_page_down", NULL);
+
+	hist = history_init();
+	if (hist) {
+		history(hist, &hist_event, H_SETSIZE, 1000);
+		el_set(el, EL_HIST, history, hist);
+	}
+	el_set(el, EL_UNBUFFERED, 1);
+	el_set(el, EL_GETCFN, get_char);
+}
+
+void reg_input_curses(void)
+{
+	setup_el();
+
+	input_curses.fd = fileno(stdin);
+	input_curses.proc_input = proc_keyboard;
+	input_curses.history = show_history;
+
+	reg_input(&input_curses);
+}
+
+void unreg_input_curses(void)
+{
+	history_end(hist);
+	el_end(el);
+
+	unreg_input(&input_curses);
+}
diff --git a/VNFs/DPPD-PROX/input_curses.h b/VNFs/DPPD-PROX/input_curses.h
new file mode 100644
index 00000000..8b682646
--- /dev/null
+++ b/VNFs/DPPD-PROX/input_curses.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _INPUT_CURSES_H_
+#define _INPUT_CURSES_H_
+
+void reg_input_curses(void);
+void unreg_input_curses(void);
+
+#endif /* _INPUT_CURSES_H_ */
diff --git a/VNFs/DPPD-PROX/ip6_addr.h b/VNFs/DPPD-PROX/ip6_addr.h
new file mode 100644
index 00000000..f9b56c19
--- /dev/null
+++ b/VNFs/DPPD-PROX/ip6_addr.h
@@ -0,0 +1,26 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _IP6_ADDR_H_
+#define _IP6_ADDR_H_
+
+#include <inttypes.h>
+
+struct ipv6_addr {
+	uint8_t bytes[16];
+};
+
+#endif /* _IP6_ADDR_H_ */
diff --git a/VNFs/DPPD-PROX/ip_subnet.c b/VNFs/DPPD-PROX/ip_subnet.c
new file mode 100644
index 00000000..dc6ab1ac
--- /dev/null
+++ b/VNFs/DPPD-PROX/ip_subnet.c
@@ -0,0 +1,45 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "ip_subnet.h"
+#include "prox_assert.h"
+
+uint32_t ip4_subet_get_n_hosts(const struct ip4_subnet *sn)
+{
+	PROX_ASSERT(sn->prefix <= 32 && sn->prefix >= 1);
+	return 1 << (32 - sn->prefix);
+}
+
+int ip4_subnet_to_host(const struct ip4_subnet *sn, uint32_t host_index, uint32_t *ret_ip)
+{
+	PROX_ASSERT(ip4_subnet_is_valid(sn));
+
+	if (host_index >= ip4_subet_get_n_hosts(sn)) {
+		return -1;
+	}
+
+	*ret_ip = sn->ip + host_index;
+	return 0;
+}
+
+int ip4_subnet_is_valid(const struct ip4_subnet *sn)
+{
+	if (sn->prefix == 0) {
+		return sn->ip == 0;
+	}
+
+	return (sn->ip & ~(((int)(1 << 31)) >> (sn->prefix - 1))) == 0;
+}
diff --git a/VNFs/DPPD-PROX/ip_subnet.h b/VNFs/DPPD-PROX/ip_subnet.h
new file mode 100644
index 00000000..126efb18
--- /dev/null
+++ b/VNFs/DPPD-PROX/ip_subnet.h
@@ -0,0 +1,48 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _IP_SUBNET_H_
+#define _IP_SUBNET_H_
+
+#include <inttypes.h>
+
+struct ip4_subnet {
+	uint32_t ip;
+	uint8_t prefix; /* always in range [1,32] inclusive */
+};
+
+struct ip6_subnet {
+	uint8_t ip[16];
+	uint8_t prefix; /* always in range [1,128] inclusive */
+};
+
+/* Returns number of hosts (assuming that network address and
+   broadcast address are both hosts) within the subnet. */
+uint32_t ip4_subet_get_n_hosts(const struct ip4_subnet *sn);
+
+/* Allows to get a specific host within a subnet. Note that the
+   network address and broadcast address are both considered to
+   "hosts". Setting host_index to 0 returns the network address and
+   setting the host_index to the last host within the subnet returns
+   the broadcast. To get all addresses with the subnet, loop
+   host_index from 0 to ip_subnet_get_n_hosts(). */
+int ip4_subnet_to_host(const struct ip4_subnet* sn, uint32_t host_index, uint32_t* ret_ip);
+
+/* Check if IP address is a network address (i.e. all bits outside the
+   prefix are set to 0). */
+int ip4_subnet_is_valid(const struct ip4_subnet* sn);
+
+#endif /* _IP_SUBNET_H_ */
diff --git a/VNFs/DPPD-PROX/kv_store_expire.h b/VNFs/DPPD-PROX/kv_store_expire.h
new file mode 100644
index 00000000..c930af55
--- /dev/null
+++ b/VNFs/DPPD-PROX/kv_store_expire.h
@@ -0,0 +1,198 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_hash_crc.h>
+#include <stdint.h>
+
+#include "prox_malloc.h"
+
+#define KV_STORE_BUCKET_DEPTH 8
+
+struct kv_store_expire_entry {
+	/* if set to 0, the entry is disabled */
+	uint64_t timeout;
+	/* Memory contains the key, followed by the actual value. */
+	uint8_t  mem[0];
+};
+
+struct kv_store_expire {
+	size_t key_size;
+	size_t entry_size;
+	size_t bucket_mask;
+	size_t bucket_size;
+	uint64_t timeout;
+
+	void (*expire)(void *entry_value);
+
+	uint8_t mem[0];
+};
+
+static struct kv_store_expire *kv_store_expire_create(uint32_t n_entries, size_t key_size, size_t value_size, int socket, void (*expire)(void *entry_value), uint64_t timeout)
+{
+	struct kv_store_expire *ret;
+	size_t memsize = 0;
+	size_t bucket_size;
+	size_t entry_size;
+
+	if (!rte_is_power_of_2(n_entries))
+		n_entries = rte_align32pow2(n_entries);
+	entry_size = sizeof(struct kv_store_expire_entry) + key_size + value_size;
+
+	memsize += sizeof(struct kv_store_expire);
+	memsize += entry_size * n_entries;
+
+	ret = prox_zmalloc(memsize, socket);
+	if (ret == NULL)
+		return NULL;
+
+	ret->bucket_mask = n_entries / KV_STORE_BUCKET_DEPTH - 1;
+	ret->bucket_size = entry_size * KV_STORE_BUCKET_DEPTH;
+	ret->entry_size = entry_size;
+	ret->key_size = key_size;
+	ret->expire = expire;
+	ret->timeout = timeout;
+
+	return ret;
+}
+
+static size_t kv_store_expire_size(struct kv_store_expire *kv_store)
+{
+	return (kv_store->bucket_mask + 1) * KV_STORE_BUCKET_DEPTH;
+}
+
+static void entry_set_timeout(struct kv_store_expire_entry *entry, uint64_t timeout)
+{
+	entry->timeout = timeout;
+}
+
+static struct kv_store_expire_entry *entry_next(struct kv_store_expire *kv_store, struct kv_store_expire_entry *entry)
+{
+	return (struct kv_store_expire_entry *)((uint8_t *)entry + kv_store->entry_size);
+}
+
+static void *entry_key(__attribute__((unused)) struct kv_store_expire *kv_store, struct kv_store_expire_entry *entry)
+{
+	return (uint8_t *)entry->mem;
+}
+
+static void *entry_value(struct kv_store_expire *kv_store, struct kv_store_expire_entry *entry)
+{
+	return (uint8_t *)entry->mem + kv_store->key_size;
+}
+
+static struct kv_store_expire_entry *kv_store_expire_get_first(struct kv_store_expire *kv_store)
+{
+	return (struct kv_store_expire_entry *)&kv_store->mem[0];
+}
+
+static struct kv_store_expire_entry *kv_store_expire_get_first_in_bucket(struct kv_store_expire *kv_store, void *key)
+{
+	uint32_t key_hash = rte_hash_crc(key, kv_store->key_size, 0);
+	uint32_t bucket_idx = key_hash & kv_store->bucket_mask;
+
+	return (struct kv_store_expire_entry *)&kv_store->mem[bucket_idx * kv_store->bucket_size];
+}
+
+static int entry_key_matches(struct kv_store_expire *kv_store, struct kv_store_expire_entry *entry, void *key)
+{
+	return !memcmp(entry_key(kv_store, entry), key, kv_store->key_size);
+}
+
+static struct kv_store_expire_entry *kv_store_expire_get(struct kv_store_expire *kv_store, void *key, uint64_t now)
+{
+	struct kv_store_expire_entry *entry = kv_store_expire_get_first_in_bucket(kv_store, key);
+
+	for (int i = 0; i < KV_STORE_BUCKET_DEPTH; ++i) {
+		if (entry->timeout && entry->timeout >= now) {
+			if (entry_key_matches(kv_store, entry, key)) {
+				entry->timeout = now + kv_store->timeout;
+				return entry;
+			}
+		}
+		entry = entry_next(kv_store, entry);
+	}
+	return NULL;
+}
+
+static struct kv_store_expire_entry *kv_store_expire_put(struct kv_store_expire *kv_store, void *key, uint64_t now)
+{
+	struct kv_store_expire_entry *e = kv_store_expire_get_first_in_bucket(kv_store, key);
+
+	for (int i = 0; i < KV_STORE_BUCKET_DEPTH; ++i) {
+		if (e->timeout && e->timeout >= now) {
+			e = entry_next(kv_store, e);
+			continue;
+		}
+		if (!e->timeout) {
+			kv_store->expire(entry_value(kv_store, e));
+		}
+
+		rte_memcpy(entry_key(kv_store, e), key, kv_store->key_size);
+		e->timeout = now + kv_store->timeout;
+		return e;
+	}
+
+	return NULL;
+}
+
+/* If the entry is not found, a put operation is tried and if that
+   succeeds, that entry is returned. The bucket is full if NULL Is
+   returned. */
+static struct kv_store_expire_entry *kv_store_expire_get_or_put(struct kv_store_expire *kv_store, void *key, uint64_t now)
+{
+	struct kv_store_expire_entry *entry = kv_store_expire_get_first_in_bucket(kv_store, key);
+	struct kv_store_expire_entry *v = NULL;
+
+	for (int i = 0; i < KV_STORE_BUCKET_DEPTH; ++i) {
+		if (entry->timeout && entry->timeout >= now) {
+			if (entry_key_matches(kv_store, entry, key)) {
+				entry->timeout = now + kv_store->timeout;
+				return entry;
+			}
+		}
+		else {
+			v = v? v : entry;
+		}
+		entry = entry_next(kv_store, entry);
+	}
+
+	if (v) {
+		if (entry->timeout)
+			kv_store->expire(entry_value(kv_store, v));
+		rte_memcpy(entry_key(kv_store, v), key, kv_store->key_size);
+		v->timeout = now + kv_store->timeout;
+		return v;
+	}
+
+	return NULL;
+}
+
+static size_t kv_store_expire_expire_all(struct kv_store_expire *kv_store)
+{
+	struct kv_store_expire_entry *entry = kv_store_expire_get_first(kv_store);
+	size_t elems = kv_store_expire_size(kv_store);
+	size_t expired = 0;
+
+	do {
+		if (entry->timeout) {
+			kv_store->expire(entry_value(kv_store, entry));
+			entry->timeout = 0;
+			expired++;
+		}
+		entry = entry_next(kv_store, entry);
+	} while (--elems);
+	return expired;
+}
diff --git a/VNFs/DPPD-PROX/lconf.c b/VNFs/DPPD-PROX/lconf.c
new file mode 100644
index 00000000..88d8f4f9
--- /dev/null
+++ b/VNFs/DPPD-PROX/lconf.c
@@ -0,0 +1,355 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "prox_malloc.h"
+#include "lconf.h"
+#include "rx_pkt.h"
+#include "tx_pkt.h"
+#include "log.h"
+#include "quit.h"
+#include "prox_cfg.h"
+
+struct lcore_cfg *lcore_cfg;
+/* only used at initialization time */
+struct lcore_cfg  lcore_cfg_init[RTE_MAX_LCORE];
+
+static int core_targ_next_from(struct lcore_cfg **lconf, struct task_args **targ, struct lcore_cfg *lcore_cfg, const int with_master)
+{
+	uint32_t lcore_id, task_id;
+
+	if (*lconf && *targ) {
+		lcore_id = *lconf - lcore_cfg;
+		task_id = *targ - lcore_cfg[lcore_id].targs;
+
+		if (task_id + 1 < lcore_cfg[lcore_id].n_tasks_all) {
+			*targ = &lcore_cfg[lcore_id].targs[task_id + 1];
+			return 0;
+		} else {
+			if (prox_core_next(&lcore_id, with_master))
+				return -1;
+			*lconf = &lcore_cfg[lcore_id];
+			*targ = &lcore_cfg[lcore_id].targs[0];
+			return 0;
+		}
+	} else {
+		lcore_id = -1;
+
+		if (prox_core_next(&lcore_id, with_master))
+			return -1;
+		*lconf = &lcore_cfg[lcore_id];
+		*targ = &lcore_cfg[lcore_id].targs[0];
+		return 0;
+	}
+}
+
+int core_targ_next(struct lcore_cfg **lconf, struct task_args **targ, const int with_master)
+{
+	return core_targ_next_from(lconf, targ, lcore_cfg, with_master);
+}
+
+int core_targ_next_early(struct lcore_cfg **lconf, struct task_args **targ, const int with_master)
+{
+	return core_targ_next_from(lconf, targ, lcore_cfg_init, with_master);
+}
+
+struct task_args *core_targ_get(uint32_t lcore_id, uint32_t task_id)
+{
+	return &lcore_cfg[lcore_id].targs[task_id];
+}
+
+void lcore_cfg_alloc_hp(void)
+{
+	size_t mem_size = RTE_MAX_LCORE * sizeof(struct lcore_cfg);
+
+	lcore_cfg = prox_zmalloc(mem_size, rte_socket_id());
+	PROX_PANIC(lcore_cfg == NULL, "Could not allocate memory for core control structures\n");
+	rte_memcpy(lcore_cfg, lcore_cfg_init, mem_size);
+
+	/* get thread ID for master core */
+	lcore_cfg[rte_lcore_id()].thread_id = pthread_self();
+}
+
+int lconf_run(__attribute__((unused)) void *dummy)
+{
+	uint32_t lcore_id = rte_lcore_id();
+	struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+	/* get thread ID, and set cancellation type to asynchronous */
+	lconf->thread_id = pthread_self();
+	int ret = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+	if (ret != 0)
+		plog_warn("pthread_setcanceltype() failed on core %u: %i\n", lcore_id, ret);
+
+	plog_info("Entering main loop on core %u\n", lcore_id);
+	return lconf->thread_x(lconf);
+}
+
+static void msg_stop(struct lcore_cfg *lconf)
+{
+	int idx = -1;
+	struct task_base *t = NULL;
+
+	if (lconf->msg.task_id == -1) {
+		for (int i = 0; i < lconf->n_tasks_all; ++i) {
+			if (lconf->task_is_running[i]) {
+				lconf->task_is_running[i] = 0;
+				t = lconf->tasks_all[i];
+				if (t->aux->stop)
+				    t->aux->stop(t);
+			}
+		}
+		lconf->n_tasks_run = 0;
+
+		if (t && t->aux->stop_last)
+			t->aux->stop_last(t);
+	}
+	else {
+		for (int i = 0; i < lconf->n_tasks_run; ++i) {
+			if (lconf_get_task_id(lconf, lconf->tasks_run[i]) == lconf->msg.task_id) {
+				idx = i;
+			}
+			else if (idx != -1) {
+				lconf->tasks_run[idx] = lconf->tasks_run[i];
+
+				idx++;
+			}
+		}
+		lconf->task_is_running[lconf->msg.task_id] = 0;
+
+		t = lconf->tasks_all[lconf->msg.task_id];
+		if (t->aux->stop)
+			t->aux->stop(t);
+		lconf->n_tasks_run--;
+		if (lconf->n_tasks_run == 0 && t->aux->stop_last)
+			t->aux->stop_last(t);
+	}
+}
+
+static void msg_start(struct lcore_cfg *lconf)
+{
+	int idx = 1;
+	struct task_base *t = NULL;
+
+	if (lconf->msg.task_id == -1) {
+		for (int i = 0; i < lconf->n_tasks_all; ++i) {
+			t = lconf->tasks_run[i] = lconf->tasks_all[i];
+			lconf->task_is_running[i] = 1;
+			if (lconf->n_tasks_run == 0 && t->aux->start_first) {
+				t->aux->start_first(t);
+				lconf->n_tasks_run = 1;
+			}
+			if (t->aux->start)
+				t->aux->start(t);
+		}
+		lconf->n_tasks_run = lconf->n_tasks_all;
+	}
+	else if (lconf->n_tasks_run == 0) {
+		t = lconf->tasks_run[0] = lconf->tasks_all[lconf->msg.task_id];
+		lconf->n_tasks_run = 1;
+		lconf->task_is_running[lconf->msg.task_id] = 1;
+
+		if (t->aux->start_first)
+			t->aux->start_first(t);
+		if (t->aux->start)
+			t->aux->start(t);
+	}
+	else {
+		for (int i = lconf->n_tasks_run - 1; i >= 0; --i) {
+			idx = lconf_get_task_id(lconf, lconf->tasks_run[i]);
+			if (idx == lconf->msg.task_id) {
+				break;
+			}
+			else if (idx > lconf->msg.task_id) {
+				lconf->tasks_run[i + 1] = lconf->tasks_run[i];
+				if (i == 0) {
+					lconf->tasks_run[i] = lconf->tasks_all[lconf->msg.task_id];
+					lconf->n_tasks_run++;
+					break;
+				}
+			}
+			else {
+				lconf->tasks_run[i + 1] = lconf->tasks_all[lconf->msg.task_id];
+				lconf->n_tasks_run++;
+				break;
+			}
+		}
+		lconf->task_is_running[lconf->msg.task_id] = 1;
+
+		if (lconf->tasks_all[lconf->msg.task_id]->aux->start)
+			lconf->tasks_all[lconf->msg.task_id]->aux->start(lconf->tasks_all[lconf->msg.task_id]);
+	}
+}
+
+int lconf_do_flags(struct lcore_cfg *lconf)
+{
+	struct task_base *t;
+	int ret = 0;
+
+	switch (lconf->msg.type) {
+	case LCONF_MSG_STOP:
+		msg_stop(lconf);
+		ret = -1;
+		break;
+	case LCONF_MSG_START:
+		msg_start(lconf);
+		ret = -1;
+		break;
+	case LCONF_MSG_DUMP_RX:
+	case LCONF_MSG_DUMP_TX:
+	case LCONF_MSG_DUMP:
+		t = lconf->tasks_all[lconf->msg.task_id];
+
+		if (lconf->msg.val) {
+			if (lconf->msg.type == LCONF_MSG_DUMP ||
+			    lconf->msg.type == LCONF_MSG_DUMP_RX) {
+				t->aux->task_rt_dump.n_print_rx = lconf->msg.val;
+
+				task_base_add_rx_pkt_function(t, rx_pkt_dump);
+			}
+
+			if (lconf->msg.type == LCONF_MSG_DUMP ||
+			    lconf->msg.type == LCONF_MSG_DUMP_TX) {
+				t->aux->task_rt_dump.n_print_tx = lconf->msg.val;
+				if (t->aux->tx_pkt_orig)
+					t->tx_pkt = t->aux->tx_pkt_orig;
+				t->aux->tx_pkt_orig = t->tx_pkt;
+				t->tx_pkt = tx_pkt_dump;
+			}
+		}
+		break;
+	case LCONF_MSG_TRACE:
+		t = lconf->tasks_all[lconf->msg.task_id];
+
+		if (lconf->msg.val) {
+			t->aux->task_rt_dump.n_trace = lconf->msg.val;
+
+			if (task_base_get_original_rx_pkt_function(t) != rx_pkt_dummy) {
+				task_base_add_rx_pkt_function(t, rx_pkt_trace);
+				if (t->aux->tx_pkt_orig)
+					t->tx_pkt = t->aux->tx_pkt_orig;
+				t->aux->tx_pkt_orig = t->tx_pkt;
+				t->tx_pkt = tx_pkt_trace;
+			} else {
+				t->aux->task_rt_dump.n_print_tx = lconf->msg.val;
+				if (t->aux->tx_pkt_orig)
+					t->tx_pkt = t->aux->tx_pkt_orig;
+				t->aux->tx_pkt_orig = t->tx_pkt;
+				t->tx_pkt = tx_pkt_dump;
+			}
+		}
+		break;
+	case LCONF_MSG_RX_DISTR_START:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+			task_base_add_rx_pkt_function(t, rx_pkt_distr);
+			memset(t->aux->rx_bucket, 0, sizeof(t->aux->rx_bucket));
+			lconf->flags |= LCONF_FLAG_RX_DISTR_ACTIVE;
+		}
+		break;
+	case LCONF_MSG_TX_DISTR_START:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+
+			t->aux->tx_pkt_orig = t->tx_pkt;
+			t->tx_pkt = tx_pkt_distr;
+			memset(t->aux->tx_bucket, 0, sizeof(t->aux->tx_bucket));
+			lconf->flags |= LCONF_FLAG_TX_DISTR_ACTIVE;
+		}
+		break;
+	case LCONF_MSG_RX_DISTR_STOP:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+			task_base_del_rx_pkt_function(t, rx_pkt_distr);
+			lconf->flags &= ~LCONF_FLAG_RX_DISTR_ACTIVE;
+		}
+		break;
+	case LCONF_MSG_TX_DISTR_STOP:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+			if (t->aux->tx_pkt_orig) {
+				t->tx_pkt = t->aux->tx_pkt_orig;
+				t->aux->tx_pkt_orig = NULL;
+				lconf->flags &= ~LCONF_FLAG_TX_DISTR_ACTIVE;
+			}
+		}
+		break;
+	case LCONF_MSG_RX_DISTR_RESET:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+
+			memset(t->aux->rx_bucket, 0, sizeof(t->aux->rx_bucket));
+		}
+		break;
+	case LCONF_MSG_TX_DISTR_RESET:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+
+			memset(t->aux->tx_bucket, 0, sizeof(t->aux->tx_bucket));
+		}
+		break;
+	case LCONF_MSG_RX_BW_START:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+			task_base_add_rx_pkt_function(t, rx_pkt_bw);
+			lconf->flags |= LCONF_FLAG_RX_BW_ACTIVE;
+		}
+		break;
+	case LCONF_MSG_RX_BW_STOP:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+			task_base_del_rx_pkt_function(t, rx_pkt_bw);
+			lconf->flags &= ~LCONF_FLAG_RX_BW_ACTIVE;
+		}
+		break;
+	case LCONF_MSG_TX_BW_START:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+
+			t->aux->tx_pkt_orig = t->tx_pkt;
+			t->tx_pkt = tx_pkt_bw;
+			lconf->flags |= LCONF_FLAG_TX_BW_ACTIVE;
+		}
+		break;
+	case LCONF_MSG_TX_BW_STOP:
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			t = lconf->tasks_all[task_id];
+			if (t->aux->tx_pkt_orig) {
+				t->tx_pkt = t->aux->tx_pkt_orig;
+				t->aux->tx_pkt_orig = NULL;
+				lconf->flags &= ~LCONF_FLAG_TX_BW_ACTIVE;
+			}
+		}
+		break;
+	}
+
+	lconf_unset_req(lconf);
+	return ret;
+}
+
+int lconf_get_task_id(const struct lcore_cfg *lconf, const struct task_base *task)
+{
+	for (int i = 0; i < lconf->n_tasks_all; ++i) {
+		if (lconf->tasks_all[i] == task)
+			return i;
+	}
+
+	return -1;
+}
+
+int lconf_task_is_running(const struct lcore_cfg *lconf, uint8_t task_id)
+{
+	return lconf->task_is_running[task_id];
+}
diff --git a/VNFs/DPPD-PROX/lconf.h b/VNFs/DPPD-PROX/lconf.h
new file mode 100644
index 00000000..4bfa705d
--- /dev/null
+++ b/VNFs/DPPD-PROX/lconf.h
@@ -0,0 +1,145 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _LCONF_H_
+#define _LCONF_H_
+
+#include "task_init.h"
+#include "stats.h"
+
+enum lconf_msg_type {
+	LCONF_MSG_STOP,
+	LCONF_MSG_START,
+	LCONF_MSG_DUMP,
+	LCONF_MSG_TRACE,
+	LCONF_MSG_DUMP_RX,
+	LCONF_MSG_DUMP_TX,
+	LCONF_MSG_RX_DISTR_START,
+	LCONF_MSG_RX_DISTR_STOP,
+	LCONF_MSG_RX_DISTR_RESET,
+	LCONF_MSG_TX_DISTR_START,
+	LCONF_MSG_TX_DISTR_STOP,
+	LCONF_MSG_TX_DISTR_RESET,
+	LCONF_MSG_RX_BW_START,
+	LCONF_MSG_RX_BW_STOP,
+	LCONF_MSG_TX_BW_START,
+	LCONF_MSG_TX_BW_STOP,
+};
+
+struct lconf_msg {
+	/* Set by master core (if not set), unset by worker after consumption. */
+	uint32_t            req;
+	enum lconf_msg_type type;
+	int                 task_id;
+	int                 val;
+};
+
+#define LCONF_FLAG_RX_DISTR_ACTIVE 0x00000001
+#define LCONF_FLAG_RUNNING         0x00000002
+#define LCONF_FLAG_TX_DISTR_ACTIVE 0x00000004
+#define LCONF_FLAG_RX_BW_ACTIVE    0x00000008
+#define LCONF_FLAG_TX_BW_ACTIVE    0x00000010
+
+struct lcore_cfg {
+	/* All tasks running at the moment. This is empty when the core is stopped. */
+	struct task_base	*tasks_run[MAX_TASKS_PER_CORE];
+	uint8_t			n_tasks_run;
+
+	void (*flush_queues[MAX_TASKS_PER_CORE])(struct task_base *tbase);
+
+	void (*period_func)(void *data);
+	void                    *period_data;
+	/* call periodic_func after periodic_timeout cycles */
+	uint64_t                period_timeout;
+
+	uint64_t                ctrl_timeout;
+	void (*ctrl_func_m[MAX_TASKS_PER_CORE])(struct task_base *tbase, void **data, uint16_t n_msgs);
+	struct rte_ring         *ctrl_rings_m[MAX_TASKS_PER_CORE];
+
+	void (*ctrl_func_p[MAX_TASKS_PER_CORE])(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+	struct rte_ring         *ctrl_rings_p[MAX_TASKS_PER_CORE];
+
+	struct lconf_msg        msg __attribute__((aligned(4)));
+	struct task_base	*tasks_all[MAX_TASKS_PER_CORE];
+	int                     task_is_running[MAX_TASKS_PER_CORE];
+	uint8_t			n_tasks_all;
+	pthread_t		thread_id;
+
+	/* Following variables are not accessed in main loop */
+	uint32_t		flags;
+	uint8_t			active_task;
+	uint8_t			id;
+	char			name[MAX_NAME_SIZE];
+	struct task_args        targs[MAX_TASKS_PER_CORE];
+	int (*thread_x)(struct lcore_cfg *lconf);
+	uint32_t		cache_set;
+} __rte_cache_aligned;
+
+extern struct lcore_cfg     *lcore_cfg;
+extern struct lcore_cfg      lcore_cfg_init[];
+
+/* This function is only run on low load (when no bulk was sent within
+   last drain_timeout (16kpps if DRAIN_TIMEOUT = 2 ms) */
+static inline void lconf_flush_all_queues(struct lcore_cfg *lconf)
+{
+	struct task_base *task;
+
+	for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+		task = lconf->tasks_all[task_id];
+		if (!(task->flags & FLAG_TX_FLUSH) || (task->flags & FLAG_NEVER_FLUSH)) {
+			task->flags |= FLAG_TX_FLUSH;
+			continue;
+		}
+		lconf->flush_queues[task_id](task);
+	}
+}
+
+static inline void lconf_set_req(struct lcore_cfg *lconf)
+{
+	(*(volatile uint32_t *)&lconf->msg.req) = 1;
+}
+
+static inline void lconf_unset_req(struct lcore_cfg *lconf)
+{
+	(*(volatile uint32_t *)&lconf->msg.req) = 0;
+}
+
+static inline int lconf_is_req(struct lcore_cfg *lconf)
+{
+	return (*(volatile uint32_t *)&lconf->msg.req);
+}
+
+/* Returns non-zero when terminate has been requested */
+int lconf_do_flags(struct lcore_cfg *lconf);
+
+int lconf_get_task_id(const struct lcore_cfg *lconf, const struct task_base *task);
+int lconf_task_is_running(const struct lcore_cfg *lconf, uint8_t task_id);
+
+int lconf_run(void *dummy);
+
+void lcore_cfg_alloc_hp(void);
+
+/* Returns the next active lconf/targ pair. If *lconf = NULL, the
+   first active lconf/targ pair is returned. If the last lconf/targ
+   pair is passed, the function returns non-zero. */
+int core_targ_next(struct lcore_cfg **lconf, struct task_args **targ, const int with_master);
+/* Same as above, but uses non-huge page memory (used before
+   lcore_cfg_alloc_hp is called). */
+int core_targ_next_early(struct lcore_cfg **lconf, struct task_args **targ, const int with_master);
+
+struct task_args *core_targ_get(uint32_t lcore_id, uint32_t task_id);
+
+#endif /* _LCONF_H_ */
diff --git a/VNFs/DPPD-PROX/local_mbuf.h b/VNFs/DPPD-PROX/local_mbuf.h
new file mode 100644
index 00000000..c65086cc
--- /dev/null
+++ b/VNFs/DPPD-PROX/local_mbuf.h
@@ -0,0 +1,62 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _LOCAL_MBUF_H_
+#define _LOCAL_MBUF_H_
+#define LOCAL_MBUF_COUNT 64
+
+struct local_mbuf {
+	struct rte_mempool *mempool;
+	uint32_t           n_new_pkts;
+	struct rte_mbuf    *new_pkts[LOCAL_MBUF_COUNT];
+};
+
+static struct rte_mbuf **local_mbuf_take(struct local_mbuf *local_mbuf, uint32_t count)
+{
+	PROX_ASSERT(local_mbuf->n_new_pkts >= count);
+
+	const uint32_t start_pos = local_mbuf->n_new_pkts - count;
+	struct rte_mbuf **ret = &local_mbuf->new_pkts[start_pos];
+
+	local_mbuf->n_new_pkts -= count;
+	return ret;
+}
+
+static int local_mbuf_refill(struct local_mbuf *local_mbuf)
+{
+	const uint32_t fill = LOCAL_MBUF_COUNT - local_mbuf->n_new_pkts;
+	struct rte_mbuf **fill_mbuf = &local_mbuf->new_pkts[local_mbuf->n_new_pkts];
+
+	if (rte_mempool_get_bulk(local_mbuf->mempool, (void **)fill_mbuf, fill) < 0)
+		return -1;
+	local_mbuf->n_new_pkts += fill;
+	return 0;
+}
+
+/* Ensures that count or more mbufs are available. Returns pointer to
+   count allocated mbufs or NULL if not enough mbufs are available. */
+static struct rte_mbuf **local_mbuf_refill_and_take(struct local_mbuf *local_mbuf, uint32_t count)
+{
+	PROX_ASSERT(count <= LOCAL_MBUF_COUNT);
+	if (local_mbuf->n_new_pkts >= count)
+		return local_mbuf_take(local_mbuf, count);
+
+	if (local_mbuf_refill(local_mbuf) == 0)
+		return local_mbuf_take(local_mbuf, count);
+	return NULL;
+}
+
+#endif /* _LOCAL_MBUF_H_ */
diff --git a/VNFs/DPPD-PROX/log.c b/VNFs/DPPD-PROX/log.c
new file mode 100644
index 00000000..cd8ee002
--- /dev/null
+++ b/VNFs/DPPD-PROX/log.c
@@ -0,0 +1,398 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <string.h>
+#include <rte_cycles.h>
+#include <rte_lcore.h>
+#include <rte_ether.h>
+#include <rte_ip.h>
+#include <rte_mbuf.h>
+
+#include "log.h"
+#include "display.h"
+#include "etypes.h"
+#include "prox_cfg.h"
+
+static pthread_mutex_t file_mtx = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+int log_lvl = PROX_MAX_LOG_LVL;
+static uint64_t tsc_off;
+static FILE *fp;
+static int n_warnings = 0;
+char last_warn[5][1024];
+int get_n_warnings(void)
+{
+#if PROX_MAX_LOG_LVL < PROX_LOG_WARN
+	return -1;
+#endif
+	return n_warnings;
+}
+
+const char *get_warning(int i)
+{
+#if PROX_MAX_LOG_LVL < PROX_LOG_WARN
+	return NULL;
+#endif
+	if (i > 0 || i < -4)
+		return NULL;
+	return last_warn[(n_warnings - 1 + i + 5) % 5];
+}
+
+static void store_warning(const char *warning)
+{
+	strncpy(last_warn[n_warnings % 5], warning, sizeof(last_warn[0]));
+	n_warnings++;
+}
+
+void plog_init(const char *log_name, int log_name_pid)
+{
+	pid_t pid;
+	char buf[128];
+
+	if (*log_name == 0) {
+		if (log_name_pid)
+			snprintf(buf, sizeof(buf), "%s-%u.log", "prox", getpid());
+		else
+			strncpy(buf, "prox.log", sizeof(buf));
+	}
+	else {
+		strncpy(buf, log_name, sizeof(buf));
+	}
+
+	fp = fopen(buf, "w");
+
+	tsc_off = rte_rdtsc() + 2500000000;
+}
+
+int plog_set_lvl(int lvl)
+{
+	if (lvl <= PROX_MAX_LOG_LVL) {
+		log_lvl = lvl;
+		return 0;
+	}
+
+	return -1;
+}
+
+static void file_lock(void)
+{
+	pthread_mutex_lock(&file_mtx);
+}
+
+static void file_unlock(void)
+{
+	pthread_mutex_unlock(&file_mtx);
+}
+
+void file_print(const char *str)
+{
+	file_lock();
+	if (fp != NULL) {
+		fputs(str, fp);
+		fflush(fp);
+	}
+	file_unlock();
+}
+static void plog_buf(const char* buf)
+{
+	if (prox_cfg.logbuf) {
+		file_lock();
+		if (prox_cfg.logbuf_pos + strlen(buf) + 1 < prox_cfg.logbuf_size) {
+			memcpy(prox_cfg.logbuf + prox_cfg.logbuf_pos, buf, strlen(buf));
+			prox_cfg.logbuf_pos += strlen(buf);
+		}
+		file_unlock();
+	} else {
+		file_print(buf);
+#ifdef PROX_STATS
+		display_print(buf);
+#else
+	/* ncurses never initialized */
+		fputs(buf, stdout);
+		fflush(stdout);
+#endif
+	}
+}
+
+static const char* lvl_to_str(int lvl, int always)
+{
+	switch (lvl) {
+	case PROX_LOG_ERR:  return "error ";
+	case PROX_LOG_WARN: return "warn ";
+	case PROX_LOG_INFO: return always? "info " : "";
+	case PROX_LOG_DBG:  return "debug ";
+	default: return "?";
+	}
+}
+
+#define DUMP_PKT_LEN 128
+static	int dump_pkt(char *dst, size_t dst_size, const struct rte_mbuf *mbuf)
+{
+	const struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, const struct ether_hdr *);
+	const struct ipv4_hdr *dpip = (const struct ipv4_hdr *)(peth + 1);
+	const uint8_t *pkt_bytes = (const uint8_t *)peth;
+	const uint16_t len = rte_pktmbuf_pkt_len(mbuf);
+	size_t str_len = 0;
+
+	if (peth->ether_type == ETYPE_IPv4)
+		str_len = snprintf(dst, dst_size, "pkt_len=%u, Eth=%x, Proto=%#06x",
+			   	len, peth->ether_type, dpip->next_proto_id);
+	else
+		str_len = snprintf(dst, dst_size, "pkt_len=%u, Eth=%x",
+				len, peth->ether_type);
+
+	for (uint16_t i = 0; i < len && i < DUMP_PKT_LEN && str_len < dst_size; ++i) {
+		if (i % 16 == 0) {
+			str_len += snprintf(dst + str_len, dst_size - str_len, "\n%04x  ", i);
+		}
+		else if (i % 8 == 0) {
+			str_len += snprintf(dst + str_len, dst_size - str_len, " ");
+		}
+		str_len += snprintf(dst + str_len, dst_size - str_len, "%02x ", pkt_bytes[i]);
+	}
+	if (str_len < dst_size)
+		snprintf(dst + str_len, dst_size - str_len, "\n");
+	return str_len + 1;
+}
+
+static int vplog(int lvl, const char *format, va_list ap, const struct rte_mbuf *mbuf, int extended)
+{
+	char buf[32768];
+	uint64_t hz, rtime_tsc, rtime_sec, rtime_usec;
+	int ret = 0;
+
+	if (lvl > log_lvl)
+		return ret;
+
+	if (format == NULL && mbuf == NULL)
+		return ret;
+
+	*buf = 0;
+	if (extended) {
+		hz = rte_get_tsc_hz();
+		rtime_tsc = rte_rdtsc() - tsc_off;
+		rtime_sec = rtime_tsc / hz;
+		rtime_usec = (rtime_tsc - rtime_sec * hz) / (hz / 1000000);
+		ret += snprintf(buf, sizeof(buf) - ret, "%2"PRIu64".%06"PRIu64" C%u %s%s",
+				rtime_sec, rtime_usec, rte_lcore_id(), lvl_to_str(lvl, 1), format? " " : "");
+	}
+	else {
+		ret += snprintf(buf, sizeof(buf) - ret, "%s%s", lvl_to_str(lvl, 0), format? " " : "");
+	}
+
+	if (format) {
+		ret--;
+		ret += vsnprintf(buf + ret, sizeof(buf) - ret, format, ap);
+	}
+
+	if (mbuf) {
+		ret--;
+		ret += dump_pkt(buf + ret, sizeof(buf) - ret, mbuf);
+	}
+	plog_buf(buf);
+
+	if (lvl == PROX_LOG_WARN) {
+		store_warning(buf);
+	}
+	return ret;
+}
+
+#if PROX_MAX_LOG_LVL >= PROX_LOG_INFO
+int plog_info(const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_INFO, fmt, ap, NULL, 0);
+	va_end(ap);
+	return ret;
+}
+
+int plogx_info(const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_INFO, fmt, ap, NULL, 1);
+	va_end(ap);
+	return ret;
+}
+
+int plogd_info(const struct rte_mbuf *mbuf, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_INFO, fmt, ap, mbuf, 0);
+	va_end(ap);
+	return ret;
+}
+
+int plogdx_info(const struct rte_mbuf *mbuf, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_INFO, fmt, ap, mbuf, 1);
+	va_end(ap);
+	return ret;
+}
+#endif
+
+#if PROX_MAX_LOG_LVL >= PROX_LOG_ERR
+int plog_err(const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_ERR, fmt, ap, NULL, 0);
+	va_end(ap);
+	return ret;
+}
+
+int plogx_err(const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_ERR, fmt, ap, NULL, 1);
+	va_end(ap);
+	return ret;
+}
+
+int plogd_err(const struct rte_mbuf *mbuf, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_ERR, fmt, ap, mbuf, 1);
+	va_end(ap);
+	return ret;
+}
+
+int plogdx_err(const struct rte_mbuf *mbuf, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_ERR, fmt, ap, mbuf, 1);
+	va_end(ap);
+
+	return ret;
+}
+#endif
+
+#if PROX_MAX_LOG_LVL >= PROX_LOG_WARN
+int plog_warn(const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_WARN, fmt, ap, NULL, 0);
+	va_end(ap);
+	return ret;
+}
+
+int plogx_warn(const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_WARN, fmt, ap, NULL, 1);
+	va_end(ap);
+	return ret;
+}
+
+int plogd_warn(const struct rte_mbuf *mbuf, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_WARN, fmt, ap, mbuf, 0);
+	va_end(ap);
+	return ret;
+}
+
+int plogdx_warn(const struct rte_mbuf *mbuf, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_WARN, fmt, ap, mbuf, 1);
+	va_end(ap);
+	return ret;
+}
+#endif
+
+#if PROX_MAX_LOG_LVL >= PROX_LOG_DBG
+int plog_dbg(const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_DBG, fmt, ap, NULL, 0);
+	va_end(ap);
+	return ret;
+}
+
+int plogx_dbg(const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_DBG, fmt, ap, NULL, 1);
+	va_end(ap);
+	return ret;
+}
+
+int plogd_dbg(const struct rte_mbuf *mbuf, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_DBG, fmt, ap, mbuf, 0);
+	va_end(ap);
+	return ret;
+}
+
+int plogdx_dbg(const struct rte_mbuf *mbuf, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = vplog(PROX_LOG_DBG, fmt, ap, mbuf, 1);
+	va_end(ap);
+	return ret;
+}
+#endif
diff --git a/VNFs/DPPD-PROX/log.h b/VNFs/DPPD-PROX/log.h
new file mode 100644
index 00000000..a5dcf47a
--- /dev/null
+++ b/VNFs/DPPD-PROX/log.h
@@ -0,0 +1,88 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _LOG_H_
+#define _LOG_H_
+
+#define PROX_LOG_ERR  0
+#define PROX_LOG_WARN 1
+#define PROX_LOG_INFO 2
+#define PROX_LOG_DBG  3
+
+#if PROX_MAX_LOG_LVL > PROX_LOG_DBG
+#error Highest supported log level is 3
+#endif
+
+int get_n_warnings(void);
+/* Return previous warnings, only stores last 5 warnings and invalid i return NULL*/
+const char* get_warning(int i);
+
+struct rte_mbuf;
+
+#if PROX_MAX_LOG_LVL >= PROX_LOG_ERR
+int plog_err(const char *fmt, ...) __attribute__((format(printf, 1, 2), cold));
+int plogx_err(const char *fmt, ...) __attribute__((format(printf, 1, 2), cold));
+int plogd_err(const struct rte_mbuf *mbuf, const char *fmt, ...) __attribute__((format(printf, 2, 3), cold));
+int plogdx_err(const struct rte_mbuf *mbuf, const char *fmt, ...) __attribute__((format(printf, 2, 3), cold));
+#else
+__attribute__((format(printf, 1, 2))) static inline int plog_err(__attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 1, 2))) static inline int plogx_err(__attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 2, 3))) static inline int plogd_err(__attribute__((unused)) const struct rte_mbuf *mbuf, __attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 2, 3))) static inline int plogdx_err(__attribute__((unused)) const struct rte_mbuf *mbuf, __attribute__((unused)) const char *fmt, ...) {return 0;}
+#endif
+
+#if PROX_MAX_LOG_LVL >= PROX_LOG_WARN
+int plog_warn(const char *fmt, ...) __attribute__((format(printf, 1, 2), cold));
+int plogx_warn(const char *fmt, ...) __attribute__((format(printf, 1, 2), cold));
+int plogd_warn(const struct rte_mbuf *mbuf, const char *fmt, ...) __attribute__((format(printf, 2, 3), cold));
+int plogdx_warn(const struct rte_mbuf *mbuf, const char *fmt, ...) __attribute__((format(printf, 2, 3), cold));
+#else
+__attribute__((format(printf, 1, 2))) static inline int plog_warn(__attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 1, 2))) static inline int plogx_warn(__attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 2, 3))) static inline int plogd_warn(__attribute__((unused)) const struct rte_mbuf *mbuf, __attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 2, 3))) static inline int plogdx_warn(__attribute__((unused)) const struct rte_mbuf *mbuf, __attribute__((unused)) const char *fmt, ...) {return 0;}
+#endif
+
+#if PROX_MAX_LOG_LVL >= PROX_LOG_INFO
+int plog_info(const char *fmt, ...) __attribute__((format(printf, 1, 2), cold));
+int plogx_info(const char *fmt, ...) __attribute__((format(printf, 1, 2), cold));
+int plogd_info(const struct rte_mbuf *mbuf, const char *fmt, ...) __attribute__((format(printf, 2, 3), cold));
+int plogdx_info(const struct rte_mbuf *mbuf, const char *fmt, ...) __attribute__((format(printf, 2, 3), cold));
+#else
+__attribute__((format(printf, 1, 2))) static inline int plog_info(__attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 1, 2))) static inline int plogx_info(__attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 2, 3))) static inline int plogd_info(__attribute__((unused)) const struct rte_mbuf *mbuf, __attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 2, 3))) static inline int plogdx_info(__attribute__((unused)) const struct rte_mbuf *mbuf, __attribute__((unused)) const char *fmt, ...) {return 0;}
+#endif
+
+#if PROX_MAX_LOG_LVL >= PROX_LOG_DBG
+int plog_dbg(const char *fmt, ...) __attribute__((format(printf, 1, 2), cold));
+int plogx_dbg(const char *fmt, ...) __attribute__((format(printf, 1, 2), cold));
+int plogd_dbg(const struct rte_mbuf *mbuf, const char *fmt, ...) __attribute__((format(printf, 2, 3), cold));
+int plogdx_dbg(const struct rte_mbuf *mbuf, const char *fmt, ...) __attribute__((format(printf, 2, 3), cold));
+#else
+__attribute__((format(printf, 1, 2))) static inline int plog_dbg(__attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 1, 2))) static inline int plogx_dbg(__attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 2, 3))) static inline int plogd_dbg(__attribute__((unused)) const struct rte_mbuf *mbuf, __attribute__((unused)) const char *fmt, ...) {return 0;}
+__attribute__((format(printf, 2, 3))) static inline int plogdx_dbg(__attribute__((unused)) const struct rte_mbuf *mbuf, __attribute__((unused)) const char *fmt, ...) {return 0;}
+#endif
+
+void plog_init(const char *log_name, int log_name_pid);
+void file_print(const char *str);
+
+int plog_set_lvl(int lvl);
+
+#endif /* _LOG_H_ */
diff --git a/VNFs/DPPD-PROX/lua_compat.h b/VNFs/DPPD-PROX/lua_compat.h
new file mode 100644
index 00000000..c8c21225
--- /dev/null
+++ b/VNFs/DPPD-PROX/lua_compat.h
@@ -0,0 +1,48 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _LUA_COMPAT_H_
+#define _LUA_COMPAT_H_
+
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+
+#if LUA_VERSION_NUM < 503
+#include <float.h>
+static int lua_isinteger(lua_State *L, int idx)
+{
+	if (!lua_isnumber(L, idx)) {
+		return -1;
+	}
+
+	double whole = lua_tonumber(L, idx);
+	whole -= lua_tointeger(L, idx);
+	return whole < DBL_EPSILON && whole >= -DBL_EPSILON ;
+}
+#endif
+
+#if LUA_VERSION_NUM < 502
+static int lua_len(lua_State *L, int idx)
+{
+       int len = lua_objlen(L, idx);
+
+       lua_pushnumber(L, len);
+       return len;
+}
+#endif
+
+#endif /* _LUA_COMPAT_H_ */
diff --git a/VNFs/DPPD-PROX/main.c b/VNFs/DPPD-PROX/main.c
new file mode 100644
index 00000000..28533c78
--- /dev/null
+++ b/VNFs/DPPD-PROX/main.c
@@ -0,0 +1,993 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <locale.h>
+#include <unistd.h>
+#include <signal.h>
+
+#include <rte_cycles.h>
+#include <rte_atomic.h>
+#include <rte_table_hash.h>
+#include <rte_memzone.h>
+#include <rte_errno.h>
+
+#include "prox_malloc.h"
+#include "run.h"
+#include "main.h"
+#include "log.h"
+#include "quit.h"
+#include "clock.h"
+#include "defines.h"
+#include "version.h"
+#include "prox_args.h"
+#include "prox_assert.h"
+#include "prox_cfg.h"
+#include "prox_shared.h"
+#include "prox_port_cfg.h"
+#include "toeplitz.h"
+#include "hash_utils.h"
+#include "handle_lb_net.h"
+#include "prox_cksum.h"
+#include "thread_nop.h"
+#include "thread_generic.h"
+#include "thread_pipeline.h"
+#include "cqm.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#endif
+
+uint8_t lb_nb_txrings = 0xff;
+struct rte_ring *ctrl_rings[RTE_MAX_LCORE*MAX_TASKS_PER_CORE];
+
+static void __attribute__((noreturn)) prox_usage(const char *prgname)
+{
+	plog_info("\nUsage: %s [-f CONFIG_FILE] [-a|-e] [-m|-s|-i] [-w DEF] [-u] [-t]\n"
+		  "\t-f CONFIG_FILE : configuration file to load, ./prox.cfg by default\n"
+		  "\t-l LOG_FILE : log file name, ./prox.log by default\n"
+		  "\t-p : include PID in log file name if default log file is used\n"
+		  "\t-o DISPLAY: Set display to use, can be 'curses' (default), 'cli' or 'none'\n"
+		  "\t-v verbosity : initial logging verbosity\n"
+		  "\t-a : autostart all cores (by default)\n"
+		  "\t-e : don't autostart\n"
+		  "\t-n : Create NULL devices instead of using PCI devices, useful together with -i\n"
+		  "\t-m : list supported task modes and exit\n"
+		  "\t-s : check configuration file syntax and exit\n"
+		  "\t-i : check initialization sequence and exit\n"
+		  "\t-u : Listen on UDS /tmp/prox.sock\n"
+		  "\t-t : Listen on TCP port 8474\n"
+		  "\t-q : Pass argument to Lua interpreter, useful to define variables\n"
+		  "\t-w : define variable using syntax varname=value\n"
+		  "\t     takes precedence over variables defined in CONFIG_FILE\n"
+		  "\t-k : Log statistics to file \"stats_dump\" in current directory\n"
+		  "\t-d : Run as daemon, the parent process will block until PROX is not initialized\n"
+		  "\t-z : Ignore CPU topology, implies -i\n"
+		  "\t-r : Change initial screen refresh rate. If set to a lower than 0.001 seconds,\n"
+		  "\t	  screen refreshing will be disabled\n"
+		  , prgname);
+	exit(EXIT_FAILURE);
+}
+
+static void check_mixed_normal_pipeline(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	uint32_t lcore_id = -1;
+
+	while (prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+
+		int all_thread_nop = 1;
+		int generic = 0;
+		int pipeline = 0;
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			struct task_args *targ = &lconf->targs[task_id];
+			all_thread_nop = all_thread_nop &&
+				targ->task_init->thread_x == thread_nop;
+
+			pipeline = pipeline || targ->task_init->thread_x == thread_pipeline;
+			generic = generic || targ->task_init->thread_x == thread_generic;
+		}
+		PROX_PANIC(generic && pipeline, "Can't run both pipeline and normal thread on same core\n");
+
+		if (all_thread_nop)
+			lconf->thread_x = thread_nop;
+		else {
+			lconf->thread_x = thread_generic;
+		}
+	}
+}
+
+static void check_missing_rx(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+
+	while (core_targ_next(&lconf, &targ, 0) == 0) {
+		PROX_PANIC((targ->flags & TASK_ARG_RX_RING) && targ->rx_rings[0] == 0 && !targ->tx_opt_ring_task,
+			   "Configuration Error - Core %u task %u Receiving from ring, but nobody xmitting to this ring\n", lconf->id, targ->id);
+		if (targ->nb_rxports == 0 && targ->nb_rxrings == 0) {
+			PROX_PANIC(!task_init_flag_set(targ->task_init, TASK_FEATURE_NO_RX),
+				   "\tCore %u task %u: no rx_ports and no rx_rings configured while required by mode %s\n", lconf->id, targ->id, targ->task_init->mode_str);
+		}
+	}
+}
+
+static void check_cfg_consistent(void)
+{
+	check_missing_rx();
+	check_mixed_normal_pipeline();
+}
+
+static void plog_all_rings(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+
+	while (core_targ_next(&lconf, &targ, 0) == 0) {
+		for (uint8_t ring_idx = 0; ring_idx < targ->nb_rxrings; ++ring_idx) {
+			plog_info("\tCore %u, task %u, rx_ring[%u] %p\n", lconf->id, targ->id, ring_idx, targ->rx_rings[ring_idx]);
+		}
+	}
+}
+
+static int chain_flag_state(struct task_args *targ, uint64_t flag, int is_set)
+{
+	if (task_init_flag_set(targ->task_init, flag) == is_set)
+		return 1;
+
+	int ret = 0;
+
+	for (uint32_t i = 0; i < targ->n_prev_tasks; ++i) {
+		ret = chain_flag_state(targ->prev_tasks[i], flag, is_set);
+		if (ret)
+			return 1;
+	}
+	return 0;
+}
+
+static void configure_if_tx_queues(struct task_args *targ, uint8_t socket)
+{
+	uint8_t if_port;
+
+	for (uint8_t i = 0; i < targ->nb_txports; ++i) {
+		if_port = targ->tx_port_queue[i].port;
+
+		PROX_PANIC(if_port == OUT_DISCARD, "port misconfigured, exiting\n");
+
+		PROX_PANIC(!prox_port_cfg[if_port].active, "\tPort %u not used, skipping...\n", if_port);
+
+		int dsocket = prox_port_cfg[if_port].socket;
+		if (dsocket != -1 && dsocket != socket) {
+			plog_warn("TX core on socket %d while device on socket %d\n", socket, dsocket);
+		}
+
+		if (prox_port_cfg[if_port].tx_ring[0] == '\0') {  // Rings-backed port can use single queue
+			targ->tx_port_queue[i].queue = prox_port_cfg[if_port].n_txq;
+			prox_port_cfg[if_port].n_txq++;
+		} else {
+			prox_port_cfg[if_port].n_txq = 1;
+			targ->tx_port_queue[i].queue = 0;
+		}
+		/* Set the ETH_TXQ_FLAGS_NOREFCOUNT flag if none of
+		   the tasks up to the task transmitting to the port
+		   does not use refcnt. */
+		if (!chain_flag_state(targ, TASK_FEATURE_TXQ_FLAGS_REFCOUNT, 1)) {
+			prox_port_cfg[if_port].tx_conf.txq_flags |= ETH_TXQ_FLAGS_NOREFCOUNT;
+			plog_info("\t\tEnabling No refcnt on port %d\n", if_port);
+		}
+		else {
+			plog_info("\t\tRefcnt used on port %d\n", if_port);
+		}
+
+		/* By default OFFLOAD is enabled, but if the whole
+		   chain has NOOFFLOADS set all the way until the
+		   first task that receives from a port, it will be
+		   disabled for the destination port. */
+		if (chain_flag_state(targ, TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS, 1)) {
+			prox_port_cfg[if_port].tx_conf.txq_flags |= ETH_TXQ_FLAGS_NOOFFLOADS;
+			plog_info("\t\tDisabling TX offloads on port %d\n", if_port);
+		} else {
+			plog_info("\t\tEnabling TX offloads on port %d\n", if_port);
+		}
+
+		/* By default NOMULTSEGS is disabled, as drivers/NIC might split packets on RX
+		   It should only be enabled when we know for sure that the RX does not split packets.
+		   Set the ETH_TXQ_FLAGS_NOMULTSEGS flag if none of the tasks up to the task
+		   transmitting to the port does not use multsegs. */
+		if (!chain_flag_state(targ, TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS, 0)) {
+			prox_port_cfg[if_port].tx_conf.txq_flags |= ETH_TXQ_FLAGS_NOMULTSEGS;
+			plog_info("\t\tEnabling No MultiSegs on port %d\n", if_port);
+		}
+		else {
+			plog_info("\t\tMultiSegs used on port %d\n", if_port);
+		}
+	}
+}
+
+static void configure_if_rx_queues(struct task_args *targ, uint8_t socket)
+{
+	for (int i = 0; i < targ->nb_rxports; i++) {
+		uint8_t if_port = targ->rx_port_queue[i].port;
+
+		if (if_port == OUT_DISCARD) {
+			return;
+		}
+
+		PROX_PANIC(!prox_port_cfg[if_port].active, "Port %u not used, aborting...\n", if_port);
+
+		if(prox_port_cfg[if_port].rx_ring[0] != '\0') {
+			prox_port_cfg[if_port].n_rxq = 0;
+		}
+
+		targ->rx_port_queue[i].queue = prox_port_cfg[if_port].n_rxq;
+		prox_port_cfg[if_port].pool[targ->rx_port_queue[i].queue] = targ->pool;
+		prox_port_cfg[if_port].pool_size[targ->rx_port_queue[i].queue] = targ->nb_mbuf - 1;
+		prox_port_cfg[if_port].n_rxq++;
+
+		int dsocket = prox_port_cfg[if_port].socket;
+		if (dsocket != -1 && dsocket != socket) {
+			plog_warn("RX core on socket %d while device on socket %d\n", socket, dsocket);
+		}
+	}
+}
+
+static void configure_if_queues(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+	uint8_t socket;
+
+	while (core_targ_next(&lconf, &targ, 0) == 0) {
+		socket = rte_lcore_to_socket_id(lconf->id);
+
+		configure_if_tx_queues(targ, socket);
+		configure_if_rx_queues(targ, socket);
+	}
+}
+
+static const char *gen_ring_name(void)
+{
+	static char retval[] = "XX";
+	static const char* ring_names =
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+		"abcdefghijklmnopqrstuvwxyz"
+		"[\\]^_`!\"#$%&'()*+,-./:;<="
+		">?@{|}0123456789";
+	static int idx2 = 0;
+
+	int idx = idx2;
+
+	retval[0] = ring_names[idx % strlen(ring_names)];
+	idx /= strlen(ring_names);
+	retval[1] = idx ? ring_names[(idx - 1) % strlen(ring_names)] : 0;
+
+	idx2++;
+
+	return retval;
+}
+
+static int task_is_master(struct task_args *targ)
+{
+	return !targ->lconf;
+}
+
+struct ring_init_stats {
+	uint32_t n_pkt_rings;
+	uint32_t n_ctrl_rings;
+	uint32_t n_opt_rings;
+};
+
+static uint32_t ring_init_stats_total(const struct ring_init_stats *ris)
+{
+	return ris->n_pkt_rings + ris->n_ctrl_rings + ris->n_opt_rings;
+}
+
+static uint32_t count_incoming_tasks(uint32_t lcore_worker, uint32_t dest_task)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+	uint32_t ret = 0;
+	struct core_task ct;
+
+	while (core_targ_next(&lconf, &targ, 0) == 0) {
+		for (uint8_t idxx = 0; idxx < MAX_PROTOCOLS; ++idxx) {
+			for (uint8_t ridx = 0; ridx < targ->core_task_set[idxx].n_elems; ++ridx) {
+				ct = targ->core_task_set[idxx].core_task[ridx];
+
+				if (dest_task == ct.task && lcore_worker == ct.core)
+					ret++;
+			}
+		}
+	}
+	return ret;
+}
+
+static struct rte_ring *get_existing_ring(uint32_t lcore_id, uint32_t task_id)
+{
+	if (!prox_core_active(lcore_id, 0))
+		return NULL;
+
+	struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+	if (task_id >= lconf->n_tasks_all)
+		return NULL;
+
+	if (lconf->targs[task_id].nb_rxrings == 0)
+		return NULL;
+
+	return lconf->targs[task_id].rx_rings[0];
+}
+
+static void init_ring_between_tasks(struct lcore_cfg *lconf, struct task_args *starg,
+				    const struct core_task ct, uint8_t ring_idx, int idx,
+				    struct ring_init_stats *ris)
+{
+	uint8_t socket;
+	struct rte_ring *ring = NULL;
+	struct lcore_cfg *lworker;
+	struct task_args *dtarg;
+
+	PROX_ASSERT(prox_core_active(ct.core, 0));
+	lworker = &lcore_cfg[ct.core];
+
+	/* socket used is the one that the sending core resides on */
+	socket = rte_lcore_to_socket_id(lconf->id);
+
+	plog_info("\t\tCreating ring on socket %u with size %u\n"
+		  "\t\t\tsource core, task and socket = %u, %u, %u\n"
+		  "\t\t\tdestination core, task and socket = %u, %u, %u\n"
+		  "\t\t\tdestination worker id = %u\n",
+		  socket, starg->ring_size,
+		  lconf->id, starg->id, socket,
+		  ct.core, ct.task, rte_lcore_to_socket_id(ct.core),
+		  ring_idx);
+
+	if (ct.type) {
+		struct rte_ring **dring = NULL;
+
+		if (ct.type == CTRL_TYPE_MSG)
+			dring = &lworker->ctrl_rings_m[ct.task];
+		else if (ct.type == CTRL_TYPE_PKT) {
+			dring = &lworker->ctrl_rings_p[ct.task];
+			starg->flags |= TASK_ARG_CTRL_RINGS_P;
+		}
+
+		if (*dring == NULL)
+			ring = rte_ring_create(gen_ring_name(), starg->ring_size, socket, RING_F_SC_DEQ);
+		else
+			ring = *dring;
+		PROX_PANIC(ring == NULL, "Cannot create ring to connect I/O core %u with worker core %u\n", lconf->id, ct.core);
+
+		starg->tx_rings[starg->tot_n_txrings_inited] = ring;
+		starg->tot_n_txrings_inited++;
+		*dring = ring;
+		if (lconf->id == prox_cfg.master) {
+			ctrl_rings[ct.core*MAX_TASKS_PER_CORE + ct.task] = ring;
+		}
+
+		plog_info("\t\tCore %u task %u to -> core %u task %u ctrl_ring %s %p %s\n",
+			  lconf->id, starg->id, ct.core, ct.task, ct.type == CTRL_TYPE_PKT?
+			  "pkt" : "msg", ring, ring->name);
+		ris->n_ctrl_rings++;
+		return;
+	}
+
+	dtarg = &lworker->targs[ct.task];
+	lworker->targs[ct.task].worker_thread_id = ring_idx;
+	PROX_ASSERT(dtarg->flags & TASK_ARG_RX_RING);
+	PROX_ASSERT(ct.task < lworker->n_tasks_all);
+
+	/* If all the following conditions are met, the ring can be
+	   optimized away. */
+	if (!task_is_master(starg) && starg->lconf->id == dtarg->lconf->id &&
+	    starg->nb_txrings == 1 && idx == 0 && dtarg->task &&
+	    dtarg->tot_rxrings == 1 && starg->task == dtarg->task - 1) {
+		plog_info("\t\tOptimizing away ring on core %u from task %u to task %u\n",
+			  dtarg->lconf->id, starg->task, dtarg->task);
+		/* No need to set up ws_mbuf. */
+		starg->tx_opt_ring = 1;
+		/* During init of destination task, the buffer in the
+		   source task will be initialized. */
+		dtarg->tx_opt_ring_task = starg;
+		ris->n_opt_rings++;
+		++dtarg->nb_rxrings;
+		return;
+	}
+
+	int ring_created = 1;
+	/* Only create multi-producer rings if configured to do so AND
+	   there is only one task sending to the task */
+	if ((prox_cfg.flags & DSF_MP_RINGS && count_incoming_tasks(ct.core, ct.task) > 1)
+		|| (prox_cfg.flags & DSF_ENABLE_BYPASS)) {
+		ring = get_existing_ring(ct.core, ct.task);
+
+		if (ring) {
+			plog_info("\t\tCore %u task %u creatign MP ring %p to core %u task %u\n",
+				  lconf->id, starg->id, ring, ct.core, ct.task);
+			ring_created = 0;
+		}
+		else {
+			ring = rte_ring_create(gen_ring_name(), starg->ring_size, socket, RING_F_SC_DEQ);
+			plog_info("\t\tCore %u task %u using MP ring %p from core %u task %u\n",
+				  lconf->id, starg->id, ring, ct.core, ct.task);
+		}
+	}
+	else
+		ring = rte_ring_create(gen_ring_name(), starg->ring_size, socket, RING_F_SP_ENQ | RING_F_SC_DEQ);
+
+	PROX_PANIC(ring == NULL, "Cannot create ring to connect I/O core %u with worker core %u\n", lconf->id, ct.core);
+
+	starg->tx_rings[starg->tot_n_txrings_inited] = ring;
+	starg->tot_n_txrings_inited++;
+
+	if (ring_created) {
+		PROX_ASSERT(dtarg->nb_rxrings < MAX_RINGS_PER_TASK);
+		dtarg->rx_rings[dtarg->nb_rxrings] = ring;
+		++dtarg->nb_rxrings;
+	}
+	dtarg->nb_slave_threads = starg->core_task_set[idx].n_elems;
+	dtarg->lb_friend_core = lconf->id;
+	dtarg->lb_friend_task = starg->id;
+	plog_info("\t\tWorker thread %d has core %d, task %d as a lb friend\n", ct.core, lconf->id, starg->id);
+	plog_info("\t\tCore %u task %u tx_ring[%u] -> core %u task %u rx_ring[%u] %p %s %u WT\n",
+		  lconf->id, starg->id, ring_idx, ct.core, ct.task, dtarg->nb_rxrings, ring, ring->name,
+		  dtarg->nb_slave_threads);
+	++ris->n_pkt_rings;
+}
+
+static void init_rings(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *starg;
+	struct ring_init_stats ris = {0};
+
+	while (core_targ_next(&lconf, &starg, 1) == 0) {
+		plog_info("\t*** Initializing rings on core %u, task %u ***\n", lconf->id, starg->id);
+		for (uint8_t idx = 0; idx < MAX_PROTOCOLS; ++idx) {
+			for (uint8_t ring_idx = 0; ring_idx < starg->core_task_set[idx].n_elems; ++ring_idx) {
+				PROX_ASSERT(ring_idx < MAX_WT_PER_LB);
+				PROX_ASSERT(starg->tot_n_txrings_inited < MAX_RINGS_PER_TASK);
+
+				struct core_task ct = starg->core_task_set[idx].core_task[ring_idx];
+				init_ring_between_tasks(lconf, starg, ct, ring_idx, idx, &ris);
+			}
+		}
+	}
+
+	plog_info("\tInitialized %d rings:\n"
+		  "\t\tNumber of packet rings: %u\n"
+		  "\t\tNumber of control rings: %u\n"
+		  "\t\tNumber of optimized rings: %u\n",
+		  ring_init_stats_total(&ris),
+		  ris.n_pkt_rings,
+		  ris.n_ctrl_rings,
+		  ris.n_opt_rings);
+}
+
+static void shuffle_mempool(struct rte_mempool* mempool, uint32_t nb_mbuf)
+{
+	struct rte_mbuf** pkts = prox_zmalloc(nb_mbuf * sizeof(*pkts), rte_socket_id());
+	uint64_t got = 0;
+
+	while (rte_mempool_get_bulk(mempool, (void**)(pkts + got), 1) == 0)
+		++got;
+
+	while (got) {
+		int idx;
+		do {
+			idx = rand() % nb_mbuf - 1;
+		} while (pkts[idx] == 0);
+
+		rte_mempool_put_bulk(mempool, (void**)&pkts[idx], 1);
+		pkts[idx] = 0;
+		--got;
+	};
+	prox_free(pkts);
+}
+
+static void setup_mempools_unique_per_socket(void)
+{
+	uint32_t flags = 0;
+	char name[64];
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+
+	struct rte_mempool     *pool[MAX_SOCKETS];
+	uint32_t mbuf_count[MAX_SOCKETS] = {0};
+	uint32_t nb_cache_mbuf[MAX_SOCKETS] = {0};
+	uint32_t mbuf_size[MAX_SOCKETS] = {0};
+
+	while (core_targ_next_early(&lconf, &targ, 0) == 0) {
+		PROX_PANIC(targ->task_init == NULL, "task_init = NULL, is mode specified for core %d, task %d ?\n", lconf->id, targ->id);
+		uint8_t socket = rte_lcore_to_socket_id(lconf->id);
+		PROX_ASSERT(socket < MAX_SOCKETS);
+
+		if (targ->mbuf_size_set_explicitely)
+			flags = MEMPOOL_F_NO_SPREAD;
+		if ((!targ->mbuf_size_set_explicitely) && (targ->task_init->mbuf_size != 0)) {
+			targ->mbuf_size = targ->task_init->mbuf_size;
+		}
+		if (targ->rx_port_queue[0].port != OUT_DISCARD) {
+			struct prox_port_cfg* port_cfg = &prox_port_cfg[targ->rx_port_queue[0].port];
+			PROX_ASSERT(targ->nb_mbuf != 0);
+			mbuf_count[socket] += targ->nb_mbuf;
+			if (nb_cache_mbuf[socket] == 0)
+				nb_cache_mbuf[socket] = targ->nb_cache_mbuf;
+			else {
+				PROX_PANIC(nb_cache_mbuf[socket] != targ->nb_cache_mbuf,
+					   "all mbuf_cache must have the same size if using a unique mempool per socket\n");
+			}
+			if (mbuf_size[socket] == 0)
+				mbuf_size[socket] = targ->mbuf_size;
+			else {
+				PROX_PANIC(mbuf_size[socket] != targ->mbuf_size,
+					   "all mbuf_size must have the same size if using a unique mempool per socket\n");
+			}
+			if ((!targ->mbuf_size_set_explicitely) && (strcmp(port_cfg->short_name, "vmxnet3") == 0)) {
+				if (mbuf_size[socket] < MBUF_SIZE + RTE_PKTMBUF_HEADROOM)
+					mbuf_size[socket] = MBUF_SIZE + RTE_PKTMBUF_HEADROOM;
+			}
+		}
+	}
+	for (int i = 0 ; i < MAX_SOCKETS; i++) {
+		if (mbuf_count[i] != 0) {
+			sprintf(name, "socket_%u_pool", i);
+			pool[i] = rte_mempool_create(name,
+						     mbuf_count[i] - 1, mbuf_size[i],
+						     nb_cache_mbuf[i],
+						     sizeof(struct rte_pktmbuf_pool_private),
+						     rte_pktmbuf_pool_init, NULL,
+						     prox_pktmbuf_init, NULL,
+						     i, flags);
+			PROX_PANIC(pool[i] == NULL, "\t\tError: cannot create mempool for socket %u\n", i);
+			plog_info("\t\tMempool %p size = %u * %u cache %u, socket %d\n", pool[i],
+				  mbuf_count[i], mbuf_size[i], nb_cache_mbuf[i], i);
+
+			if (prox_cfg.flags & DSF_SHUFFLE) {
+				shuffle_mempool(pool[i], mbuf_count[i]);
+			}
+		}
+	}
+
+	lconf = NULL;
+	while (core_targ_next_early(&lconf, &targ, 0) == 0) {
+		uint8_t socket = rte_lcore_to_socket_id(lconf->id);
+
+		if (targ->rx_port_queue[0].port != OUT_DISCARD) {
+			/* use this pool for the interface that the core is receiving from */
+			/* If one core receives from multiple ports, all the ports use the same mempool */
+			targ->pool = pool[socket];
+			/* Set the number of mbuf to the number of the unique mempool, so that the used and free work */
+			targ->nb_mbuf = mbuf_count[socket];
+			plog_info("\t\tMempool %p size = %u * %u cache %u, socket %d\n", targ->pool,
+				  targ->nb_mbuf, mbuf_size[socket], targ->nb_cache_mbuf, socket);
+		}
+	}
+}
+
+static void setup_mempool_for_rx_task(struct lcore_cfg *lconf, struct task_args *targ)
+{
+	const uint8_t socket = rte_lcore_to_socket_id(lconf->id);
+	struct prox_port_cfg *port_cfg = &prox_port_cfg[targ->rx_port_queue[0].port];
+	const struct rte_memzone *mz;
+	struct rte_mempool *mp = NULL;
+	uint32_t flags = 0;
+	char memzone_name[64];
+	char name[64];
+
+	/* mbuf size can be set
+	 *  - from config file (highest priority, overwriting any other config) - should only be used as workaround
+	 *  - through each 'mode', overwriting the default mbuf_size
+	 *  - defaulted to MBUF_SIZE i.e. 1518 Bytes
+	 * Except is set expliciteky, ensure that size is big enough for vmxnet3 driver
+	 */
+	if (targ->mbuf_size_set_explicitely) {
+		flags = MEMPOOL_F_NO_SPREAD;
+		/* targ->mbuf_size already set */
+	}
+	else if (targ->task_init->mbuf_size != 0) {
+		/* mbuf_size not set through config file but set through mode */
+		targ->mbuf_size = targ->task_init->mbuf_size;
+	}
+	else if (strcmp(port_cfg->short_name, "vmxnet3") == 0) {
+		if (targ->mbuf_size < MBUF_SIZE + RTE_PKTMBUF_HEADROOM)
+			targ->mbuf_size = MBUF_SIZE + RTE_PKTMBUF_HEADROOM;
+	}
+
+	/* allocate memory pool for packets */
+	PROX_ASSERT(targ->nb_mbuf != 0);
+
+	if (targ->pool_name[0] == '\0') {
+		sprintf(name, "core_%u_port_%u_pool", lconf->id, targ->id);
+	}
+
+	snprintf(memzone_name, sizeof(memzone_name)-1, "MP_%s", targ->pool_name);
+	mz = rte_memzone_lookup(memzone_name);
+
+	if (mz != NULL) {
+		mp = (struct rte_mempool*)mz->addr;
+
+		targ->nb_mbuf = mp->size;
+		targ->pool = mp;
+	}
+
+#ifdef RTE_LIBRTE_IVSHMEM_FALSE
+	if (mz != NULL && mp != NULL && mp->phys_addr != mz->ioremap_addr) {
+		/* Init mbufs with ioremap_addr for dma */
+		mp->phys_addr = mz->ioremap_addr;
+		mp->elt_pa[0] = mp->phys_addr + (mp->elt_va_start - (uintptr_t)mp);
+
+		struct prox_pktmbuf_reinit_args init_args;
+		init_args.mp = mp;
+		init_args.lconf = lconf;
+
+		uint32_t elt_sz = mp->elt_size + mp->header_size + mp->trailer_size;
+		rte_mempool_obj_iter((void*)mp->elt_va_start, mp->size, elt_sz, 1,
+				     mp->elt_pa, mp->pg_num, mp->pg_shift, prox_pktmbuf_reinit, &init_args);
+	}
+#endif
+
+	/* Use this pool for the interface that the core is
+	   receiving from if one core receives from multiple
+	   ports, all the ports use the same mempool */
+	if (targ->pool == NULL) {
+		plog_info("\t\tCreating mempool with name '%s'\n", name);
+		targ->pool = rte_mempool_create(name,
+						targ->nb_mbuf - 1, targ->mbuf_size,
+						targ->nb_cache_mbuf,
+						sizeof(struct rte_pktmbuf_pool_private),
+						rte_pktmbuf_pool_init, NULL,
+						prox_pktmbuf_init, lconf,
+						socket, flags);
+	}
+
+	PROX_PANIC(targ->pool == NULL,
+		   "\t\tError: cannot create mempool for core %u port %u: %s\n", lconf->id, targ->id, rte_strerror(rte_errno));
+
+	plog_info("\t\tMempool %p size = %u * %u cache %u, socket %d\n", targ->pool,
+		  targ->nb_mbuf, targ->mbuf_size, targ->nb_cache_mbuf, socket);
+	if (prox_cfg.flags & DSF_SHUFFLE) {
+		shuffle_mempool(targ->pool, targ->nb_mbuf);
+	}
+}
+
+static void setup_mempools_multiple_per_socket(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+
+	while (core_targ_next_early(&lconf, &targ, 0) == 0) {
+		PROX_PANIC(targ->task_init == NULL, "task_init = NULL, is mode specified for core %d, task %d ?\n", lconf->id, targ->id);
+		if (targ->rx_port_queue[0].port == OUT_DISCARD)
+			continue;
+		setup_mempool_for_rx_task(lconf, targ);
+	}
+}
+
+static void setup_mempools(void)
+{
+	if (prox_cfg.flags & UNIQUE_MEMPOOL_PER_SOCKET)
+		setup_mempools_unique_per_socket();
+	else
+		setup_mempools_multiple_per_socket();
+}
+
+static void set_task_lconf(void)
+{
+	struct lcore_cfg *lconf;
+	uint32_t lcore_id = -1;
+
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			lconf->targs[task_id].lconf = lconf;
+		}
+	}
+}
+
+static void set_dest_threads(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+
+	while (core_targ_next(&lconf, &targ, 0) == 0) {
+		for (uint8_t idx = 0; idx < MAX_PROTOCOLS; ++idx) {
+			for (uint8_t ring_idx = 0; ring_idx < targ->core_task_set[idx].n_elems; ++ring_idx) {
+				struct core_task ct = targ->core_task_set[idx].core_task[ring_idx];
+
+				struct task_args *dest_task = core_targ_get(ct.core, ct.task);
+				dest_task->prev_tasks[dest_task->n_prev_tasks++] = targ;
+			}
+		}
+	}
+}
+
+static void setup_all_task_structs_early_init(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+
+	plog_info("\t*** Calling early init on all tasks ***\n");
+	while (core_targ_next(&lconf, &targ, 0) == 0) {
+		if (targ->task_init->early_init) {
+			targ->task_init->early_init(targ);
+		}
+	}
+}
+
+static void setup_all_task_structs(void)
+{
+	struct lcore_cfg *lconf;
+	uint32_t lcore_id = -1;
+
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			lconf->tasks_all[task_id] = init_task_struct(&lconf->targs[task_id]);
+		}
+	}
+}
+
+static void init_port_activate(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+	uint8_t port_id = 0;
+
+	while (core_targ_next_early(&lconf, &targ, 0) == 0) {
+		for (int i = 0; i < targ->nb_rxports; i++) {
+			port_id = targ->rx_port_queue[i].port;
+			prox_port_cfg[port_id].active = 1;
+		}
+
+		for (int i = 0; i < targ->nb_txports; i++) {
+			port_id = targ->tx_port_queue[i].port;
+			prox_port_cfg[port_id].active = 1;
+		}
+	}
+}
+
+/* Initialize cores and allocate mempools */
+static void init_lcores(void)
+{
+	struct lcore_cfg *lconf = 0;
+	uint32_t lcore_id = -1;
+
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		uint8_t socket = rte_lcore_to_socket_id(lcore_id);
+		PROX_PANIC(socket + 1 > MAX_SOCKETS, "Can't configure core %u (on socket %u). MAX_SOCKET is set to %d\n", lcore_id, socket, MAX_SOCKETS);
+	}
+
+	/* need to allocate mempools as the first thing to use the lowest possible address range */
+	plog_info("=== Initializing mempools ===\n");
+	setup_mempools();
+
+	lcore_cfg_alloc_hp();
+
+	set_dest_threads();
+	set_task_lconf();
+
+	plog_info("=== Initializing port addresses ===\n");
+	init_port_addr();
+
+	plog_info("=== Initializing queue numbers on cores ===\n");
+	configure_if_queues();
+
+	plog_info("=== Initializing rings on cores ===\n");
+	init_rings();
+
+	plog_info("=== Checking configuration consistency ===\n");
+	check_cfg_consistent();
+
+	plog_all_rings();
+
+	setup_all_task_structs_early_init();
+	plog_info("=== Initializing tasks ===\n");
+	setup_all_task_structs();
+}
+
+static int setup_prox(int argc, char **argv)
+{
+	if (prox_read_config_file() != 0 ||
+	    prox_setup_rte(argv[0]) != 0) {
+		return -1;
+	}
+
+	if (prox_cfg.flags & DSF_CHECK_SYNTAX) {
+		plog_info("=== Configuration file syntax has been checked ===\n\n");
+		exit(EXIT_SUCCESS);
+	}
+
+	init_port_activate();
+	plog_info("=== Initializing rte devices ===\n");
+	if (!(prox_cfg.flags & DSF_USE_DUMMY_DEVICES))
+		init_rte_ring_dev();
+	init_rte_dev(prox_cfg.flags & DSF_USE_DUMMY_DEVICES);
+	plog_info("=== Calibrating TSC overhead ===\n");
+	clock_init();
+	plog_info("\tTSC running at %"PRIu64" Hz\n", rte_get_tsc_hz());
+
+	init_lcores();
+	plog_info("=== Initializing ports ===\n");
+	init_port_all();
+
+	if (prox_cfg.logbuf_size) {
+		prox_cfg.logbuf = prox_zmalloc(prox_cfg.logbuf_size, rte_socket_id());
+		PROX_PANIC(prox_cfg.logbuf == NULL, "Failed to allocate memory for logbuf with size = %d\n", prox_cfg.logbuf_size);
+	}
+
+	if (prox_cfg.flags & DSF_CHECK_INIT) {
+		plog_info("=== Initialization sequence completed ===\n\n");
+		exit(EXIT_SUCCESS);
+	}
+
+	/* Current way that works to disable DPDK logging */
+	FILE *f = fopen("/dev/null", "r");
+	rte_openlog_stream(f);
+	plog_info("=== PROX started ===\n");
+	return 0;
+}
+
+static int success = 0;
+static void siguser_handler(int signal)
+{
+	if (signal == SIGUSR1)
+		success = 1;
+	else
+		success = 0;
+}
+
+static void sigabrt_handler(__attribute__((unused)) int signum)
+{
+	/* restore default disposition for SIGABRT and SIGPIPE */
+	signal(SIGABRT, SIG_DFL);
+	signal(SIGPIPE, SIG_DFL);
+
+	/* ignore further Ctrl-C */
+	signal(SIGINT, SIG_IGN);
+
+	/* more drastic exit on tedious termination signal */
+	plog_info("Aborting...\n");
+	if (lcore_cfg != NULL) {
+		uint32_t lcore_id;
+		pthread_t thread_id, tid0, tid = pthread_self();
+		memset(&tid0, 0, sizeof(tid0));
+
+		/* cancel all threads except current one */
+		lcore_id = -1;
+		while (prox_core_next(&lcore_id, 1) == 0) {
+			thread_id = lcore_cfg[lcore_id].thread_id;
+			if (pthread_equal(thread_id, tid0))
+				continue;
+			if (pthread_equal(thread_id, tid))
+				continue;
+			pthread_cancel(thread_id);
+		}
+
+		/* wait for cancelled threads to terminate */
+		lcore_id = -1;
+		while (prox_core_next(&lcore_id, 1) == 0) {
+			thread_id = lcore_cfg[lcore_id].thread_id;
+			if (pthread_equal(thread_id, tid0))
+				continue;
+			if (pthread_equal(thread_id, tid))
+				continue;
+			pthread_join(thread_id, NULL);
+		}
+	}
+
+	/* close ncurses */
+	display_end();
+
+	/* close ports on termination signal */
+	close_ports_atexit();
+
+	/* terminate now */
+	abort();
+}
+
+static void sigterm_handler(int signum)
+{
+	/* abort on second Ctrl-C */
+	if (signum == SIGINT)
+		signal(SIGINT, sigabrt_handler);
+
+	/* gracefully quit on harmless termination signal */
+	/* ports will subsequently get closed at resulting exit */
+	quit();
+}
+
+int main(int argc, char **argv)
+{
+	/* set en_US locale to print big numbers with ',' */
+	setlocale(LC_NUMERIC, "en_US.utf-8");
+
+	if (prox_parse_args(argc, argv) != 0){
+		prox_usage(argv[0]);
+	}
+
+	plog_init(prox_cfg.log_name, prox_cfg.log_name_pid);
+	plog_info("=== " PROGRAM_NAME " " VERSION_STR " ===\n");
+	plog_info("\tUsing DPDK %s\n", rte_version() + sizeof(RTE_VER_PREFIX));
+	read_rdt_info();
+
+	if (prox_cfg.flags & DSF_LIST_TASK_MODES) {
+		/* list supported task modes and exit */
+		tasks_list();
+		return EXIT_SUCCESS;
+	}
+
+	/* close ports at normal exit */
+	atexit(close_ports_atexit);
+	/* gracefully quit on harmless termination signals */
+	signal(SIGHUP, sigterm_handler);
+	signal(SIGINT, sigterm_handler);
+	signal(SIGQUIT, sigterm_handler);
+	signal(SIGTERM, sigterm_handler);
+	signal(SIGUSR1, sigterm_handler);
+	signal(SIGUSR2, sigterm_handler);
+	/* more drastic exit on tedious termination signals */
+	signal(SIGABRT, sigabrt_handler);
+	signal(SIGPIPE, sigabrt_handler);
+
+	if (prox_cfg.flags & DSF_DAEMON) {
+		signal(SIGUSR1, siguser_handler);
+		signal(SIGUSR2, siguser_handler);
+		plog_info("=== Running in Daemon mode ===\n");
+		plog_info("\tForking child and waiting for setup completion\n");
+
+		pid_t ppid = getpid();
+		pid_t pid = fork();
+		if (pid < 0) {
+			plog_err("Failed to fork process to run in daemon mode\n");
+			return EXIT_FAILURE;
+		}
+
+		if (pid == 0) {
+			fclose(stdin);
+			fclose(stdout);
+			fclose(stderr);
+			if (setsid() < 0) {
+				kill(ppid, SIGUSR2);
+				return EXIT_FAILURE;
+			}
+			if (setup_prox(argc, argv) != 0) {
+				kill(ppid, SIGUSR2);
+				return EXIT_FAILURE;
+			}
+			else {
+				kill(ppid, SIGUSR1);
+				run(prox_cfg.flags);
+				return EXIT_SUCCESS;
+			}
+		}
+		else {
+			/* Before exiting the parent, wait until the
+			   child process has finished setting up */
+			pause();
+			if (prox_cfg.logbuf) {
+				file_print(prox_cfg.logbuf);
+			}
+			return success? EXIT_SUCCESS : EXIT_FAILURE;
+		}
+	}
+
+	if (setup_prox(argc, argv) != 0)
+		return EXIT_FAILURE;
+	run(prox_cfg.flags);
+	return EXIT_SUCCESS;
+}
diff --git a/VNFs/DPPD-PROX/main.h b/VNFs/DPPD-PROX/main.h
new file mode 100644
index 00000000..5daef700
--- /dev/null
+++ b/VNFs/DPPD-PROX/main.h
@@ -0,0 +1,41 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _MAIN_H_
+#define _MAIN_H_
+
+#include <rte_version.h>
+#include "hash_entry_types.h"
+#ifdef RTE_EXEC_ENV_BAREMETAL
+#error A linuxapp configuration target is required!
+#endif
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,7,0,0)
+#error At least Intel(R) DPDK version 1.7.0 is required
+#endif
+
+#ifndef __INTEL_COMPILER
+#if __GNUC__ == 4 && __GNUC_MINOR__ < 7
+#error Only GCC versions 4.7 and above supported
+#endif
+#endif
+
+struct rte_ring;
+// in main.c
+extern uint8_t port_status[];
+extern struct rte_ring *ctrl_rings[];
+
+#endif /* _MAIN_H_ */
diff --git a/VNFs/DPPD-PROX/mbuf_utils.h b/VNFs/DPPD-PROX/mbuf_utils.h
new file mode 100644
index 00000000..22d57a39
--- /dev/null
+++ b/VNFs/DPPD-PROX/mbuf_utils.h
@@ -0,0 +1,57 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _MBUF_UTILS_H_
+#define _MBUF_UTILS_H_
+
+#include <string.h>
+
+#include <rte_ip.h>
+#include <rte_version.h>
+#include <rte_ether.h>
+
+static void init_mbuf_seg(struct rte_mbuf *mbuf)
+{
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+	mbuf->nb_segs = 1;
+#else
+	mbuf->pkt.nb_segs = 1;
+#endif
+	rte_mbuf_refcnt_set(mbuf, 1);
+}
+
+static uint16_t pkt_len_to_wire_size(uint16_t pkt_len)
+{
+	return (pkt_len < 60? 60 : pkt_len) + ETHER_CRC_LEN + 20;
+}
+
+static uint16_t mbuf_wire_size(const struct rte_mbuf *mbuf)
+{
+	uint16_t pkt_len = rte_pktmbuf_pkt_len(mbuf);
+
+	return pkt_len_to_wire_size(pkt_len);
+}
+
+static uint16_t mbuf_calc_padlen(const struct rte_mbuf *mbuf, void *pkt, struct ipv4_hdr *ipv4)
+{
+	uint16_t pkt_len = rte_pktmbuf_pkt_len(mbuf);
+	uint16_t ip_offset = (uint8_t *)ipv4 - (uint8_t*)pkt;
+	uint16_t ip_total_len = rte_be_to_cpu_16(ipv4->total_length);
+
+	return pkt_len - ip_total_len - ip_offset;
+}
+
+#endif /* _MBUF_UTILS_H_ */
diff --git a/VNFs/DPPD-PROX/mpls.h b/VNFs/DPPD-PROX/mpls.h
new file mode 100644
index 00000000..93f3e3d5
--- /dev/null
+++ b/VNFs/DPPD-PROX/mpls.h
@@ -0,0 +1,33 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _MPLS_H_
+#define _MPLS_H_
+
+struct mpls_hdr {
+	union {
+		struct {
+			uint16_t lbl_h;     /* Label */
+			uint8_t bos: 1;     /* Bottom of Stack */
+			uint8_t cos: 3;     /* Class of Service */
+			uint8_t lbl_l: 4;   /* Label */
+			uint8_t ttl;        /* Time to Live, 64 */
+		};
+		uint32_t bytes;
+	};
+} __attribute__((__packed__));
+
+#endif /* _MPLS_H_ */
diff --git a/VNFs/DPPD-PROX/msr.c b/VNFs/DPPD-PROX/msr.c
new file mode 100644
index 00000000..194d4c75
--- /dev/null
+++ b/VNFs/DPPD-PROX/msr.c
@@ -0,0 +1,80 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <inttypes.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+
+#include "msr.h"
+#include "log.h"
+
+int msr_fd[RTE_MAX_LCORE];
+int n_msr_fd;
+int msr_init(void)
+{
+	char msr_path[1024];
+
+	if (n_msr_fd) {
+		return 0;
+	}
+
+	for (uint32_t i = 0; i < sizeof(msr_fd)/sizeof(*msr_fd); ++i, n_msr_fd = i) {
+		snprintf(msr_path, sizeof(msr_path), "/dev/cpu/%u/msr", i);
+		msr_fd[i] = open(msr_path, O_RDWR);
+		if (msr_fd[i] < 0) {
+			return i == 0? -1 : 0;
+		}
+	}
+
+	return 0;
+}
+
+void msr_cleanup(void)
+{
+	for (int i = 0; i < n_msr_fd; ++i) {
+		close(msr_fd[i]);
+	}
+
+	n_msr_fd = 0;
+}
+
+int msr_read(uint64_t *ret, int lcore_id, off_t offset)
+{
+	if (lcore_id > n_msr_fd) {
+		return -1;
+	}
+
+	if (0 > pread(msr_fd[lcore_id], ret, sizeof(uint64_t), offset)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+int msr_write(int lcore_id, uint64_t val, off_t offset)
+{
+	if (lcore_id > n_msr_fd) {
+		return -1;
+	}
+
+	if (sizeof(uint64_t) != pwrite(msr_fd[lcore_id], &val, sizeof(uint64_t), offset)) {
+		return -1;
+	}
+	plog_dbg("\t\tmsr_write(core %d, offset %x, val %lx)\n", lcore_id, (int)offset, val);
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/msr.h b/VNFs/DPPD-PROX/msr.h
new file mode 100644
index 00000000..a8a46c86
--- /dev/null
+++ b/VNFs/DPPD-PROX/msr.h
@@ -0,0 +1,24 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <inttypes.h>
+#include <fcntl.h>
+
+int msr_init(void);
+void msr_cleanup(void);
+
+int msr_read(uint64_t *ret, int lcore_id, off_t offset);
+int msr_write(int lcore_id, uint64_t val, off_t offset);
diff --git a/VNFs/DPPD-PROX/parse_utils.c b/VNFs/DPPD-PROX/parse_utils.c
new file mode 100644
index 00000000..d258c591
--- /dev/null
+++ b/VNFs/DPPD-PROX/parse_utils.c
@@ -0,0 +1,1420 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <ctype.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdarg.h>
+
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+
+#include "quit.h"
+#include "cfgfile.h"
+#include "ip6_addr.h"
+#include "parse_utils.h"
+#include "prox_globals.h"
+#include "prox_cfg.h"
+#include "log.h"
+#include "prox_lua.h"
+#include "prox_lua_types.h"
+
+#define MAX_NB_PORT_NAMES PROX_MAX_PORTS
+#define MAX_LEN_PORT_NAME 24
+#define MAX_LEN_VAR_NAME  24
+#define MAX_LEN_VAL       512
+#define MAX_NB_VARS       32
+
+#if MAX_WT_PER_LB > MAX_INDEX
+#error MAX_WT_PER_LB > MAX_INDEX
+#endif
+
+/* The CPU topology of the system is used to parse "socket
+   notation". This notation allows to refer to cores on specific
+   sockets and the hyper-thread of those cores. The CPU topology is
+   loaded only if the socket notation is used at least once. */
+
+struct cpu_topology {
+	int socket[MAX_SOCKETS][RTE_MAX_LCORE][2];
+	uint32_t n_cores[MAX_SOCKETS];
+	uint32_t n_sockets;
+};
+
+struct cpu_topology cpu_topo;
+
+struct port_name {
+	uint32_t id;
+	char     name[MAX_LEN_PORT_NAME];
+};
+
+static struct port_name port_names[MAX_NB_PORT_NAMES];
+static uint8_t nb_port_names;
+
+struct var {
+	uint8_t  cli;
+	char     name[MAX_LEN_VAR_NAME];
+	char     val[MAX_LEN_VAL];
+};
+
+static struct var vars[MAX_NB_VARS];
+static uint8_t nb_vars;
+
+static char format_err_str[256];
+static const char *err_str = "";
+
+const char *get_parse_err(void)
+{
+	return err_str;
+}
+
+static int read_cpu_topology(void);
+
+static int parse_core(int *socket, int *core, int *ht, const char* str);
+
+static void set_errf(const char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+	vsnprintf(format_err_str, sizeof(format_err_str), format, ap);
+	va_end(ap);
+	err_str = format_err_str;
+}
+
+static struct var *var_lookup(const char *name)
+{
+	for (uint8_t i = 0; i < nb_vars; ++i) {
+		if (!strcmp(name, vars[i].name)) {
+			return &vars[i];
+		}
+	}
+	return NULL;
+}
+
+static int parse_single_var(char *val, size_t len, const char *name)
+{
+	struct var *match;
+
+	match = var_lookup(name);
+	if (match) {
+		if (strlen(match->val) + 1 > len) {
+			set_errf("Variables '%s' with value '%s' is too long\n",
+				 match->name, match->val);
+			return -1;
+		}
+		strncpy(val, match->val, len);
+		return 0;
+	}
+	else {
+		/* name + 1 to skip leading '$' */
+		if (lua_to_string(prox_lua(), GLOBAL, name + 1, val, len) >= 0)
+			return 0;
+	}
+
+	set_errf("Variable '%s' not defined!", name);
+	return 1;
+}
+
+/* Replace $... and each occurrence of ${...} with variable values */
+int parse_vars(char *val, size_t len, const char *name)
+{
+	static char result[MAX_CFG_STRING_LEN];
+	static char cur_var[MAX_CFG_STRING_LEN];
+	char parsed[2048];
+	size_t name_len = strlen(name);
+	enum parse_vars_state {NO_VAR, WHOLE_VAR, INLINE_VAR} state = NO_VAR;
+	size_t result_len = 0;
+	size_t start_var = 0;
+
+	memset(result, 0, sizeof(result));
+	PROX_PANIC(name_len > sizeof(result), "\tUnable to parse var %s: too long\n", name);
+
+	for (size_t i = 0; i < name_len; ++i) {
+		switch (state) {
+		case NO_VAR:
+			if (name[i] == '$') {
+				if (i != name_len - 1 && name[i + 1] == '{') {
+					start_var = i + 2;
+					state = INLINE_VAR;
+					i = i + 1;
+				}
+				else if (i == 0 && i != name_len - 1) {
+					state = WHOLE_VAR;
+				}
+				else {
+					set_errf("Invalid variable syntax");
+					return -1;
+				}
+			}
+			else {
+				result[result_len++] = name[i];
+			}
+			break;
+		case INLINE_VAR:
+			if (name[i] == '}') {
+				cur_var[0] = '$';
+				size_t var_len = i - start_var;
+				if (var_len == 0) {
+					set_errf("Empty variable are not allowed");
+					return -1;
+				}
+
+				strncpy(&cur_var[1], &name[start_var], var_len);
+				cur_var[1 + var_len] = 0;
+				if (parse_single_var(parsed, sizeof(parsed), cur_var)) {
+					return -1;
+				}
+				strcpy(&result[result_len], parsed);
+				result_len += strlen(parsed);
+				state = NO_VAR;
+			}
+			else if (i == name_len - 1) {
+				set_errf("Invalid variable syntax, expected '}'.");
+				return -1;
+			}
+			break;
+		case WHOLE_VAR:
+			if (i == name_len - 1) {
+				return parse_single_var(val, len, name);
+			}
+			break;
+		}
+	}
+	strncpy(val, result, len);
+
+	return 0;
+}
+
+int parse_int_mask(uint32_t *val, uint32_t *mask, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+	char *mask_str;
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	mask_str = strchr(str, '&');
+
+	if (mask_str == NULL) {
+		set_errf("Missing '&' when parsing mask");
+		return -2;
+	}
+
+	*mask_str = 0;
+
+	if (parse_int(val, str))
+		return -1;
+	if (parse_int(mask, mask_str + 1))
+		return -1;
+
+	return 0;
+}
+
+int parse_range(uint32_t* lo, uint32_t* hi, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+	char *dash;
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	dash = strstr(str, "-");
+
+	if (dash == NULL) {
+		set_errf("Missing '-' when parsing mask");
+		return -2;
+	}
+
+	*dash = 0;
+
+	if (parse_int(lo, str))
+		return -1;
+	if (parse_int(hi, dash + 1))
+		return -1;
+
+	int64_t tmp = strtol(str, 0, 0);
+	if (tmp > UINT32_MAX) {
+		set_errf("Integer is bigger than %u", UINT32_MAX);
+		return -1;
+	}
+	if (tmp < 0) {
+		set_errf("Integer is negative");
+		return -2;
+	}
+
+	*lo = tmp;
+
+	tmp = strtol(dash + 1, 0, 0);
+	if (tmp > UINT32_MAX) {
+		set_errf("Integer is bigger than %u", UINT32_MAX);
+		return -1;
+	}
+	if (tmp < 0) {
+		set_errf("Integer is negative");
+		return -2;
+	}
+
+	*hi = tmp;
+
+	if (*lo > *hi) {
+		set_errf("Low boundary is above high boundary in range");
+		return -2;
+	}
+
+	return 0;
+}
+
+int parse_ip(uint32_t *addr, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	char *ip_parts[5];
+
+	if (strlen(str) > MAX_STR_LEN_PROC) {
+		set_errf("String too long (max supported: %d)", MAX_STR_LEN_PROC);
+		return -2;
+	}
+
+	if (4 != rte_strsplit(str, strlen(str), ip_parts, 5, '.')) {
+		set_errf("Expecting 4 octets in ip.");
+		return -1;
+	}
+
+	uint32_t val;
+	for (uint8_t i = 0; i < 4; ++i) {
+		val = atoi(ip_parts[i]);
+		if (val > 255) {
+			set_errf("Maximum value for octet is 255 but octet %u is %u", i, val);
+			return -1;
+		}
+		*addr = *addr << 8 | val;
+	}
+	return 0;
+}
+
+int parse_ip4_cidr(struct ip4_subnet *val, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+	char *slash;
+	int prefix;
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	slash = strstr(str, "/");
+
+	if (slash == NULL) {
+		set_errf("Missing '/' when parsing CIDR notation");
+		return -2;
+	}
+
+	*slash = 0;
+	prefix = atoi(slash + 1);
+	val->prefix = prefix;
+
+	if (prefix > 32) {
+		set_errf("Prefix %d is too big", prefix);
+		return -2;
+	}
+	if (prefix < 1) {
+		set_errf("Prefix %d is too small", prefix);
+	}
+	if (parse_ip(&val->ip, str))
+		return -2;
+
+	/* Apply mask making all bits outside the prefix zero */
+	val->ip &= ((int)(1 << 31)) >> (prefix - 1);
+
+	return 0;
+}
+
+int parse_ip6_cidr(struct ip6_subnet *val, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+	char *slash;
+	int prefix;
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	slash = strstr(str, "/");
+
+	if (slash == NULL) {
+		set_errf("Missing '/' when parsing CIDR notation");
+		return -2;
+	}
+
+	*slash = 0;
+	prefix = atoi(slash + 1);
+	val->prefix = prefix;
+
+	parse_ip6((struct ipv6_addr *)&val->ip, str);
+
+	/* Apply mask making all bits outside the prefix zero */
+
+	int p = 120;
+	int cnt = 0;
+
+	while (p >= prefix) {
+		val->ip[15-cnt] = 0;
+		p -= 8;
+		cnt++;
+	}
+
+	if (prefix % 8 != 0) {
+		val->ip[15-cnt] &= ((int8_t)(1 << 7)) >> ((prefix %8) - 1);
+	}
+
+	return 0;
+}
+
+int parse_ip6(struct ipv6_addr *addr, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+	char *addr_parts[9];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	uint8_t ret = rte_strsplit(str, strlen(str), addr_parts, 9, ':');
+
+	if (ret == 9) {
+		set_errf("Invalid IPv6 address");
+		return -1;
+	}
+
+	uint8_t omitted = 0;
+
+	for (uint8_t i = 0, j = 0; i < ret; ++i, ++j) {
+		if (*addr_parts[i] == 0) {
+			if (omitted == 0) {
+				set_errf("Can only omit zeros once");
+				return -1;
+			}
+			omitted = 1;
+			j += 8 - ret;
+		}
+		else {
+			uint16_t w = strtoll(addr_parts[i], NULL, 16);
+			addr->bytes[j++] = (w >> 8) & 0xff;
+			addr->bytes[j] = w & 0xff;
+		}
+	}
+	return 0;
+}
+
+int parse_mac(struct ether_addr *ether_addr, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+	char *addr_parts[7];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	uint8_t ret = rte_strsplit(str, strlen(str), addr_parts, 7, ':');
+
+	if (ret != 6) {
+		set_errf("Invalid MAC address format");
+		return -1;
+	}
+
+	for (uint8_t i = 0; i < 6; ++i) {
+		if (2 != strlen(addr_parts[i])) {
+			set_errf("Invalid MAC address format");
+			return -1;
+		}
+		ether_addr->addr_bytes[i] = strtol(addr_parts[i], NULL, 16);
+	}
+
+	return 0;
+}
+
+char* get_cfg_key(char *str)
+{
+	char *pkey = strchr(str, '=');
+
+	if (pkey == NULL) {
+		return NULL;
+	}
+	*pkey++ = '\0';
+
+	/* remove leading spaces */
+	while (isspace(*pkey)) {
+		pkey++;
+	}
+	if (*pkey == '\0') { /* an empty key */
+		return NULL;
+	}
+
+	return pkey;
+}
+
+void strip_spaces(char *strings[], const uint32_t count)
+{
+	for (uint32_t i = 0; i < count; ++i) {
+		while (isspace(strings[i][0])) {
+			++strings[i];
+		}
+		size_t len = strlen(strings[i]);
+
+		while (len && isspace(strings[i][len - 1])) {
+			strings[i][len - 1] = '\0';
+			--len;
+		}
+	}
+}
+
+int is_virtualized(void)
+{
+	char buf[1024]= "/proc/cpuinfo";
+	int virtualized = 0;
+	FILE* fd = fopen(buf, "r");
+	if (fd == NULL) {
+		set_errf("Could not open %s", buf);
+		return -1;
+	}
+	while (fgets(buf, sizeof(buf), fd) != NULL) {
+		if ((strstr(buf, "flags") != NULL) && (strstr(buf, "hypervisor") != NULL))
+			virtualized = 1;
+	}
+	fclose(fd);
+	return virtualized;
+}
+
+static int get_phys_core(uint32_t *dst, int lcore_id)
+{
+	uint32_t ret;
+	char buf[1024];
+	snprintf(buf, sizeof(buf), "/sys/devices/system/cpu/cpu%u/topology/thread_siblings_list", lcore_id);
+	FILE* ht_fd = fopen(buf, "r");
+
+	if (ht_fd == NULL) {
+		set_errf("Could not open cpu topology %s", buf);
+		return -1;
+	}
+
+	if (fgets(buf, sizeof(buf), ht_fd) == NULL) {
+		set_errf("Could not read cpu topology");
+		return -1;
+	}
+	fclose(ht_fd);
+
+	uint32_t list[2] = {-1,-1};
+	parse_list_set(list, buf, 2);
+
+	*dst = list[0];
+
+	return 0;
+}
+
+static int get_socket(uint32_t core_id, uint32_t *socket)
+{
+	int ret = -1;
+	char buf[1024];
+	snprintf(buf, sizeof(buf), "/sys/devices/system/cpu/cpu%u/topology/physical_package_id", core_id);
+	FILE* fd = fopen(buf, "r");
+
+	if (fd == NULL) {
+		set_errf("%s", buf);
+		return -1;
+	}
+
+	if (fgets(buf, sizeof(buf), fd) != NULL) {
+		ret = atoi(buf);
+	}
+	fclose(fd);
+
+	if (socket)
+		*socket = (ret == -1 ? 0 : ret);
+
+	return 0;
+}
+
+int lcore_to_socket_core_ht(uint32_t lcore_id, char *dst, size_t len)
+{
+	if (cpu_topo.n_sockets == 0) {
+		if (read_cpu_topology() == -1) {
+			return -1;
+		}
+	}
+
+	for (uint32_t s = 0; s < cpu_topo.n_sockets; s++) {
+		for (uint32_t i = 0; i < cpu_topo.n_cores[s]; ++i) {
+			if ((uint32_t)cpu_topo.socket[s][i][0] == lcore_id) {
+				snprintf(dst, len, "%us%u", i, s);
+				return 0;
+			} else if ((uint32_t)cpu_topo.socket[s][i][1] == lcore_id) {
+				snprintf(dst, len, "%us%uh", i, s);
+				return 0;
+			}
+		}
+	}
+
+	return -1;
+}
+
+static int get_lcore_id(uint32_t socket_id, uint32_t core_id, int ht)
+{
+	if (cpu_topo.n_sockets == 0) {
+		if (read_cpu_topology() == -1) {
+			return -1;
+		}
+	}
+
+	if (socket_id == UINT32_MAX)
+		socket_id = 0;
+
+	if (socket_id >= MAX_SOCKETS) {
+		set_errf("Socket id %d too high (max allowed is %d)", MAX_SOCKETS);
+		return -1;
+	}
+	if (core_id >= RTE_MAX_LCORE) {
+		set_errf("Core id %d too high (max allowed is %d)", RTE_MAX_LCORE);
+		return -1;
+	}
+	if (socket_id >= cpu_topo.n_sockets) {
+		set_errf("Current CPU topology reported that there are %u CPU sockets, CPU topology = %u socket(s), %u physical cores per socket, %u thread(s) per physical core",
+			 cpu_topo.n_sockets, cpu_topo.n_sockets, cpu_topo.n_cores[0], cpu_topo.socket[0][0][1] == -1? 1: 2);
+		return -1;
+	}
+	if (core_id >= cpu_topo.n_cores[socket_id]) {
+		set_errf("Core %u on socket %u does not exist, CPU topology = %u socket(s), %u physical cores per socket, %u thread(s) per physical core",
+			 core_id, socket_id, cpu_topo.n_sockets, cpu_topo.n_cores[0], cpu_topo.socket[socket_id][0][1] == -1? 1: 2);
+		return -1;
+	}
+	if (cpu_topo.socket[socket_id][core_id][!!ht] == -1) {
+		set_errf("Core %u %son socket %u has no hyper-thread, CPU topology = %u socket(s), %u physical cores per socket, %u thread(s) per physical core",
+			 core_id, ht ? "(hyper-thread) " : "", socket_id, cpu_topo.n_sockets, cpu_topo.n_cores[0], cpu_topo.socket[socket_id][core_id][1] == -1? 1: 2);
+
+		return -1;
+	}
+	return cpu_topo.socket[socket_id][core_id][!!ht];
+}
+
+/* Returns 0 on success, negative on error. Parses the syntax XsYh
+   where sYh is optional. If sY is specified, Y is stored in the
+   socket argument. If, in addition, h is specified, *ht is set to
+   1. In case the input is only a number, socket and ht are set to
+   -1.*/
+static int parse_core(int *socket, int *core, int *ht, const char* str)
+{
+	*socket = -1;
+	*core = -1;
+	*ht = -1;
+
+	char* end;
+
+	*core = strtol(str, &end, 10);
+
+	if (*end == 's') {
+		*socket = 0;
+		*ht = 0;
+
+		if (cpu_topo.n_sockets == 0) {
+			if (read_cpu_topology() == -1) {
+				return -1;
+			}
+		}
+
+		++end;
+		*socket = strtol(end, &end, 10);
+		if (*socket >= MAX_SOCKETS) {
+			set_errf("Socket id %d too high (max allowed is %d)", *socket, MAX_SOCKETS - 1);
+			return -1;
+		}
+
+		if (*end == 'h') {
+			++end;
+			*ht = 1;
+		}
+
+		return 0;
+	}
+
+	if (*end == 'h') {
+		set_errf("Can't find hyper-thread since socket has not been specified");
+		return -1;
+	}
+
+	return 0;
+}
+
+static int parse_task(const char *str, uint32_t *socket, uint32_t *core, uint32_t *task, uint32_t *ht, enum ctrl_type *type)
+{
+	const char *str_beg = str;
+	char *end;
+
+	*core = strtol(str, &end, 10);
+	if (str == end) {
+		set_errf("Expected number to in core-task definition:\n"
+			 "\t(i.e. 5s1t0 for task 0 on core 5 on socket 1)\n"
+			 "\tHave: '%s'.", end);
+		return -1;
+	}
+
+	*task = 0;
+	*socket = -1;
+	*ht = -1;
+	*type = 0;
+
+	str = end;
+
+	if (*str == 's') {
+		str++;
+		*socket = 0;
+		*ht = 0;
+
+		*socket = strtol(str, &end, 10);
+		str = end;
+
+		if (*str == 'h') {
+			str++;
+			*ht = 1;
+		}
+		if (*str == 't') {
+			str++;
+			*task = strtol(str, &end, 10);
+			str = end;
+			if (*str == 'p') {
+				*type = CTRL_TYPE_PKT;
+				str += 1;
+			}
+			else if (*str == 'm') {
+				*type = CTRL_TYPE_MSG;
+				str += 1;
+			}
+		}
+	} else {
+		if (*str == 'h') {
+			set_errf("Can't find hyper-thread since socket has not been specified");
+			return -1;
+		}
+		if (*str == 't') {
+			str++;
+			*task = strtol(str, &end, 10);
+			str = end;
+			if (*str == 'p') {
+				*type = CTRL_TYPE_PKT;
+				str += 1;
+			}
+			else if (*str == 'm') {
+				*type = CTRL_TYPE_MSG;
+				str += 1;
+			}
+		}
+	}
+	return str - str_beg;
+}
+
+static int core_task_set_add(struct core_task_set *val, uint32_t core, uint32_t task, enum ctrl_type type)
+{
+	if (val->n_elems == sizeof(val->core_task)/sizeof(val->core_task[0]))
+		return -1;
+
+	val->core_task[val->n_elems].core = core;
+	val->core_task[val->n_elems].task = task;
+	val->core_task[val->n_elems].type = type;
+	val->n_elems++;
+
+	return 0;
+}
+
+int parse_task_set(struct core_task_set *cts, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+	cts->n_elems = 0;
+
+	char *str3 = str;
+	int ret;
+
+	uint32_t socket_beg, core_beg, task_beg, ht_beg,
+		socket_end, core_end, task_end, ht_end;
+	enum ctrl_type type_beg, type_end;
+	uint32_t task_group_start = -1;
+
+	while (*str3 && *str3 != ' ') {
+		if (*str3 == '(') {
+			task_group_start = cts->n_elems;
+			str3 += 1;
+			continue;
+		}
+		if (*str3 == ')' && *(str3 + 1) == 't') {
+			str3 += 2;
+			char *end;
+			uint32_t t = strtol(str3, &end, 10);
+			enum ctrl_type type = 0;
+			str3 = end;
+
+			if (*str3 == 'p') {
+				type = CTRL_TYPE_PKT;
+				str3 += 1;
+			}
+			else if (*str3 == 'm') {
+				type = CTRL_TYPE_MSG;
+				str3 += 1;
+			}
+
+			for (uint32_t i = task_group_start; i < cts->n_elems; ++i) {
+				cts->core_task[i].task = t;
+				cts->core_task[i].type = type;
+			}
+			continue;
+		}
+		ret = parse_task(str3, &socket_beg, &core_beg, &task_beg, &ht_beg, &type_beg);
+		if (ret < 0)
+			return -1;
+		str3 += ret;
+		socket_end = socket_beg;
+		core_end = core_beg;
+		task_end = task_beg;
+		ht_end = ht_beg;
+		type_end = type_beg;
+
+		if (*str3 == '-') {
+			str3 += 1;
+			ret = parse_task(str3, &socket_end, &core_end, &task_end, &ht_end, &type_end);
+			if (ret < 0)
+				return -1;
+			str3 += ret;
+		}
+
+		if (*str3 == ',')
+			str3 += 1;
+
+		if (socket_end != socket_beg) {
+			set_errf("Same socket must be used in range syntax.");
+			return -1;
+		} else if (ht_beg != ht_end) {
+			set_errf("If 'h' syntax is in range, it must be specified everywhere.\n");
+			return -1;
+		} else if (task_end != task_beg && core_end != core_beg) {
+			set_errf("Same task must be used in range syntax when cores are different.\n");
+			return -1;
+		} else if (task_end < task_beg) {
+			set_errf("Task for end of range must be higher than task for beginning of range.\n");
+			return -1;
+		} else if (type_end != type_beg) {
+			set_errf("Task type for end of range must be the same as  task type for beginning.\n");
+			return -1;
+		} else if (core_end < core_beg) {
+			set_errf("Core for end of range must be higher than core for beginning of range.\n");
+			return -1;
+		}
+
+		for (uint32_t j = core_beg; j <= core_end; ++j) {
+			if (socket_beg != UINT32_MAX && ht_beg != UINT32_MAX)
+				ret = get_lcore_id(socket_beg, j, ht_beg);
+			else
+				ret = j;
+			if (ret < 0)
+				return -1;
+			for (uint32_t k = task_beg; k <= task_end; ++k) {
+				core_task_set_add(cts, ret, k, type_beg);
+			}
+		}
+	}
+	return 0;
+}
+
+int parse_list_set(uint32_t *list, const char *str2, uint32_t max_list)
+{
+	char str[MAX_STR_LEN_PROC];
+	char *parts[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	int n_parts = rte_strsplit(str, strlen(str), parts, MAX_STR_LEN_PROC, ',');
+	size_t list_count = 0;
+
+	for (int i = 0; i < n_parts; ++i) {
+		char *cur_part = parts[i];
+		char *sub_parts[3];
+		int n_sub_parts = rte_strsplit(cur_part, strlen(cur_part), sub_parts, 3, '-');
+		int socket1, socket2;
+		int ht1, ht2;
+		int core1, core2;
+		int ret = 0;
+
+		if (n_sub_parts == 1) {
+			if (parse_core(&socket1, &core1, &ht1, sub_parts[0]))
+				return -1;
+
+			socket2 = socket1;
+			core2 = core1;
+			ht2 = ht1;
+		} else if (n_sub_parts == 2) {
+			if (parse_core(&socket1, &core1, &ht1, sub_parts[0]))
+				return -1;
+			if (parse_core(&socket2, &core2, &ht2, sub_parts[1]))
+				return -1;
+		} else if (n_sub_parts >= 3) {
+			set_errf("Multiple '-' characters in range syntax found");
+			return -1;
+		} else {
+			set_errf("Invalid list syntax");
+			return -1;
+		}
+
+		if (socket1 != socket2) {
+			set_errf("Same socket must be used in range syntax");
+			return -1;
+		}
+		else if (ht1 != ht2) {
+			set_errf("If 'h' syntax is in range, it must be specified everywhere.");
+			return -1;
+		}
+
+		for (int cur_core = core1; cur_core <= core2; ++cur_core) {
+			int effective_core;
+
+			if (socket1 != -1)
+				effective_core = get_lcore_id(socket1, cur_core, ht1);
+			else
+				effective_core = cur_core;
+
+			if (list_count >= max_list) {
+				set_errf("Too many elements in list\n");
+				return -1;
+			}
+			list[list_count++] = effective_core;
+		}
+	}
+
+	return list_count;
+}
+
+int parse_kmg(uint32_t* val, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	char c = str[strlen(str) - 1];
+	*val = atoi(str);
+
+	switch (c) {
+	case 'G':
+		if (*val >> 22)
+			return -2;
+		*val <<= 10;
+	case 'M':
+		if (*val >> 22)
+			return -2;
+		*val <<= 10;
+	case 'K':
+		if (*val >> 22)
+			return -2;
+		*val <<= 10;
+		break;
+	default:
+		/* only support optional KMG suffix */
+		if (c < '0' || c > '9') {
+			set_errf("Unknown syntax for KMG suffix '%c' (expected K, M or G)", c);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int parse_bool(uint32_t* val, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	if (!strcmp(str, "yes")) {
+		*val = 1;
+		return 0;
+	}
+	else if (!strcmp(str, "no")) {
+		*val = 0;
+		return 0;
+	}
+	set_errf("Unknown syntax for bool '%s' (expected yes or no)", str);
+	return -1;
+}
+
+int parse_flag(uint32_t* val, uint32_t flag, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	uint32_t tmp;
+	if (parse_bool(&tmp, str))
+		return -1;
+
+	if (tmp)
+		*val |= flag;
+	else
+		*val &= ~flag;
+
+	return 0;
+}
+
+int parse_int(uint32_t* val, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	int64_t tmp = strtol(str, 0, 0);
+	if (tmp > UINT32_MAX) {
+		set_errf("Integer is bigger than %u", UINT32_MAX);
+		return -1;
+	}
+	if (tmp < 0) {
+		set_errf("Integer is negative");
+		return -2;
+	}
+	*val = tmp;
+
+	return 0;
+}
+
+int parse_float(float* val, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	float tmp = strtof(str, 0);
+	if ((tmp >= HUGE_VALF) || (tmp <= -HUGE_VALF)) {
+		set_errf("Unable to parse float\n");
+		return -1;
+	}
+	*val = tmp;
+
+	return 0;
+}
+
+int parse_u64(uint64_t* val, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	errno = 0;
+	uint64_t tmp = strtoul(str, NULL, 0);
+	if (errno != 0) {
+		set_errf("Invalid u64 '%s' (%s)", str, strerror(errno));
+		return -2;
+	}
+	*val = tmp;
+
+	return 0;
+}
+
+int parse_str(char* dst, const char *str2, size_t max_len)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	if (strlen(str) > max_len - 1) {
+		set_errf("String too long (%u > %u)", strlen(str), max_len - 1);
+		return -2;
+	}
+
+	strncpy(dst, str, max_len);
+	return 0;
+}
+
+int parse_path(char *dst, const char *str, size_t max_len)
+{
+	if (parse_str(dst, str, max_len))
+		return -1;
+	if (access(dst, F_OK)) {
+                set_errf("Invalid file '%s' (%s)", dst, strerror(errno));
+		return -1;
+	}
+	return 0;
+}
+
+int parse_port_name(uint32_t *val, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	for (uint8_t i = 0; i < nb_port_names; ++i) {
+		if (!strcmp(str, port_names[i].name)) {
+			*val = port_names[i].id;
+			return 0;
+		}
+	}
+	set_errf("Port with name %s not defined", str);
+	return 1;
+}
+
+int parse_port_name_list(uint32_t *val, uint32_t* tot, uint8_t max_vals, const char *str2)
+{
+	char *elements[PROX_MAX_PORTS + 1];
+	char str[MAX_STR_LEN_PROC];
+	uint32_t cur;
+	int ret;
+
+	if (parse_str(str, str2, sizeof(str)))
+		return -1;
+
+	ret = rte_strsplit(str, strlen(str), elements, PROX_MAX_PORTS + 1, ',');
+
+	if (ret == PROX_MAX_PORTS + 1 || ret > max_vals) {
+		set_errf("Too many ports in port list");
+		return -1;
+	}
+
+	strip_spaces(elements, ret);
+	for (uint8_t i = 0; i < ret; ++i) {
+		if (parse_port_name(&cur, elements[i])) {
+			return -1;
+		}
+		val[i] = cur;
+	}
+	if (tot) {
+		*tot = ret;
+	}
+	return 0;
+}
+
+int parse_remap(uint8_t *mapping, const char *str)
+{
+	char *elements[PROX_MAX_PORTS + 1];
+	char *elements2[PROX_MAX_PORTS + 1];
+	char str_cpy[MAX_STR_LEN_PROC];
+	uint32_t val;
+	int ret, ret2;
+
+	if (strlen(str) > MAX_STR_LEN_PROC) {
+		set_errf("String too long (max supported: %d)", MAX_STR_LEN_PROC);
+		return -2;
+	}
+	strncpy(str_cpy, str, MAX_STR_LEN_PROC);
+
+	ret = rte_strsplit(str_cpy, strlen(str_cpy), elements, PROX_MAX_PORTS + 1, ',');
+	if (ret <= 0) {
+		set_errf("Invalid remap syntax");
+		return -1;
+	}
+	else if (ret > PROX_MAX_PORTS) {
+		set_errf("Too many remaps");
+		return -2;
+	}
+
+	strip_spaces(elements, ret);
+	for (uint8_t i = 0; i < ret; ++i) {
+		ret2 = rte_strsplit(elements[i], strlen(elements[i]), elements2, PROX_MAX_PORTS + 1, '|');
+		strip_spaces(elements2, ret2);
+		if (ret2 > PROX_MAX_PORTS) {
+			set_errf("Too many remaps");
+			return -2;
+		}
+		for (uint8_t j = 0; j < ret2; ++j) {
+			if (parse_port_name(&val, elements2[j])) {
+				return -1;
+			}
+
+			/* This port will be mapped to the i'th
+			   element specified before remap=. */
+			mapping[val] = i;
+		}
+	}
+
+	return ret;
+}
+
+int add_port_name(uint32_t val, const char *str2)
+{
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	struct port_name* pn;
+
+	if (nb_port_names == MAX_NB_PORT_NAMES) {
+		set_errf("Too many ports defined (can define %d)", MAX_NB_PORT_NAMES);
+		return -1;
+	}
+
+	for (uint8_t i = 0; i < nb_port_names; ++i) {
+		/* each port has to have a unique name*/
+		if (!strcmp(str, port_names[i].name)) {
+			set_errf("Port with name %s is already defined", str);
+			return -2;
+		}
+	}
+
+	pn = &port_names[nb_port_names];
+	strncpy(pn->name, str, sizeof(pn->name));
+	pn->id = val;
+
+	++nb_port_names;
+	return 0;
+}
+
+int set_self_var(const char *str)
+{
+	for (uint8_t i = 0; i < nb_vars; ++i) {
+		if (!strcmp("$self", vars[i].name)) {
+			sprintf(vars[i].val, "%s", str);
+			return 0;
+		}
+	}
+
+	struct var *v = &vars[nb_vars];
+
+	strncpy(v->name, "$self", strlen("$self"));
+	sprintf(v->val, "%s", str);
+	nb_vars++;
+
+	return 0;
+}
+
+int add_var(const char* name, const char *str2, uint8_t cli)
+{
+	struct var* v;
+
+	char str[MAX_STR_LEN_PROC];
+
+	if (parse_vars(str, sizeof(str), str2))
+		return -1;
+
+	if (strlen(name) == 0 || strlen(name) == 1) {
+		set_errf("Can't define variables with empty name");
+		return -1;
+	}
+
+	if (name[0] != '$') {
+		set_errf("Each variable should start with the $ character");
+		return -1;
+	}
+
+	if (nb_vars == MAX_NB_VARS) {
+		set_errf("Too many variables defined (can define %d)", MAX_NB_VARS);
+		return -2;
+	}
+
+	for (uint8_t i = 0; i < nb_vars; ++i) {
+		if (!strcmp(name, vars[i].name)) {
+
+			/* Variables defined through program arguments
+			   take precedence. */
+			if (!cli && vars[i].cli) {
+				return 0;
+			}
+
+			set_errf("Variable with name %s is already defined", name);
+			return -3;
+		}
+	}
+
+	v = &vars[nb_vars];
+	PROX_PANIC(strlen(name) > sizeof(v->name), "\tUnable to parse var %s: too long\n", name);
+	PROX_PANIC(strlen(str) > sizeof(v->val), "\tUnable to parse var %s=%s: too long\n", name,str);
+	strncpy(v->name, name, sizeof(v->name));
+	strncpy(v->val, str, sizeof(v->val));
+	v->cli = cli;
+
+	++nb_vars;
+	return 0;
+}
+
+static int read_cores_present(uint32_t *cores, int max_cores, int *res)
+{
+	FILE* fd = fopen("/sys/devices/system/cpu/present", "r");
+	char buf[1024];
+
+	if (fd == NULL) {
+		set_errf("Could not opening file /sys/devices/system/cpu/present");
+		return -1;
+	}
+
+	if (fgets(buf, sizeof(buf), fd) == NULL) {
+		set_errf("Could not read cores range");
+		return -1;
+	}
+
+	fclose(fd);
+
+	int ret = parse_list_set(cores, buf, max_cores);
+
+	if (ret < 0)
+		return -1;
+
+	*res = ret;
+	return 0;
+}
+
+static int set_dummy_topology(void)
+{
+	int core_count = 0;
+
+	for (int s = 0; s < MAX_SOCKETS; s++) {
+		for (int i = 0; i < 32; ++i) {
+			cpu_topo.socket[s][i][0] = core_count++;
+			cpu_topo.socket[s][i][1] = core_count++;
+			cpu_topo.n_cores[s]++;
+		}
+	}
+	cpu_topo.n_sockets = MAX_SOCKETS;
+	return 0;
+}
+
+static int read_cpu_topology(void)
+{
+	if (cpu_topo.n_sockets != 0)
+		return 0;
+	if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO)
+		return set_dummy_topology();
+
+	uint32_t cores[RTE_MAX_LCORE];
+	int n_cores = 0;
+
+	if (read_cores_present(cores, sizeof(cores)/sizeof(cores[0]), &n_cores) != 0)
+		return -1;
+
+	for (int s = 0; s < MAX_SOCKETS; s++) {
+		for (int i = 0; i < RTE_MAX_LCORE; ++i) {
+			cpu_topo.socket[s][i][0] = -1;
+			cpu_topo.socket[s][i][1] = -1;
+		}
+	}
+
+	for (int i = 0; i < n_cores; ++i) {
+		uint32_t socket_id, lcore_id, phys;
+
+		lcore_id = cores[i];
+		if (get_socket(lcore_id, &socket_id) != 0)
+			return -1;
+		if (socket_id >= MAX_SOCKETS) {
+			set_errf("Can't read CPU topology due too high socket ID (max allowed is %d)",
+				 MAX_SOCKETS);
+			return -1;
+		}
+		if (socket_id >= cpu_topo.n_sockets) {
+			cpu_topo.n_sockets = socket_id + 1;
+		}
+		if (get_phys_core(&phys, lcore_id) != 0)
+			return -1;
+		if (phys >= RTE_MAX_LCORE) {
+			set_errf("Core ID %u too high", phys);
+			return -1;
+		}
+
+		if (cpu_topo.socket[socket_id][phys][0] == -1) {
+			cpu_topo.socket[socket_id][phys][0] = lcore_id;
+			cpu_topo.n_cores[socket_id]++;
+		}
+		else if (cpu_topo.socket[socket_id][phys][1] == -1) {
+			cpu_topo.socket[socket_id][phys][1] = lcore_id;
+		}
+		else {
+			set_errf("Too many core siblings");
+			return -1;
+		}
+	}
+
+	/* There can be holes in the cpu_topo description at this
+	   point. An example for this is a CPU topology where the
+	   lowest core ID of 2 hyper-threads is always an even
+	   number. Before finished up this phase, compact all the
+	   cores to make the numbers consecutive. */
+
+	for (uint32_t i = 0; i < cpu_topo.n_sockets; ++i) {
+		int spread = 0, compact = 0;
+		while (cpu_topo.socket[i][spread][0] == -1)
+			spread++;
+
+		for (uint32_t c = 0; c < cpu_topo.n_cores[i]; ++c) {
+			cpu_topo.socket[i][compact][0] = cpu_topo.socket[i][spread][0];
+			cpu_topo.socket[i][compact][1] = cpu_topo.socket[i][spread][1];
+			compact++;
+			spread++;
+			/* Skip gaps */
+			while (cpu_topo.socket[i][spread][0] == -1)
+				spread++;
+		}
+	}
+
+	return 0;
+}
+
+static int bit_len_valid(uint32_t len, const char *str)
+{
+	if (len > 32) {
+		set_errf("Maximum random length is 32, but length of '%s' is %zu\n", str, len);
+		return 0;
+	}
+	if (len % 8) {
+		plog_err("Random should be multiple of 8 long\n");
+		return 0;
+	}
+	if (len == 0) {
+		plog_err("Random should be at least 1 byte long\n");
+		return 0;
+	}
+	return -1;
+}
+
+int parse_random_str(uint32_t *mask, uint32_t *fixed, uint32_t *len, const char *str)
+{
+	const size_t len_bits = strlen(str);
+
+	if (!bit_len_valid(len_bits, str))
+		return -1;
+
+	*mask = 0;
+	*fixed = 0;
+	*len = len_bits / 8;
+
+	for (uint32_t j = 0; j < len_bits; ++j) {
+		/* Store in the lower bits the value of the rand string (note
+		   that these are the higher bits in LE). */
+		switch (str[j]) {
+		case 'X':
+			*mask |= 1 << (len_bits - 1 - j);
+			break;
+		case '1':
+			*fixed |= 1 << (len_bits - 1 - j);
+			break;
+		case '0':
+			break;
+		default:
+			set_errf("Unexpected %c\n", str[j]);
+			return -1;
+		}
+	}
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/parse_utils.h b/VNFs/DPPD-PROX/parse_utils.h
new file mode 100644
index 00000000..14aee9eb
--- /dev/null
+++ b/VNFs/DPPD-PROX/parse_utils.h
@@ -0,0 +1,121 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PARSE_UTILS_H_
+#define _PARSE_UTILS_H_
+
+#include <inttypes.h>
+#include "ip_subnet.h"
+
+#define MAX_STR_LEN_PROC  (3 * 1518 + 20)
+
+struct ipv6_addr;
+struct ether_addr;
+
+enum ctrl_type {CTRL_TYPE_DP, CTRL_TYPE_MSG, CTRL_TYPE_PKT};
+
+struct core_task {
+	uint32_t core;
+	uint32_t task;
+	enum ctrl_type type;
+};
+
+struct core_task_set {
+	struct core_task core_task[64];
+	uint32_t n_elems;
+};
+
+int parse_vars(char *val, size_t len, const char *name);
+
+int parse_int_mask(uint32_t* val, uint32_t* mask, const char *saddr);
+
+int parse_range(uint32_t* lo, uint32_t* hi, const char *saddr);
+
+/* parses CIDR notation. Note that bits within the address that are
+   outside the subnet (as specified by the prefix) are set to 0. */
+int parse_ip4_cidr(struct ip4_subnet *val, const char *saddr);
+int parse_ip6_cidr(struct ip6_subnet *val, const char *saddr);
+
+int parse_ip(uint32_t *paddr, const char *saddr);
+
+int parse_ip6(struct ipv6_addr *addr, const char *saddr);
+
+int parse_mac(struct ether_addr *paddr, const char *saddr);
+
+/* return error on overflow or invalid suffix*/
+int parse_kmg(uint32_t* val, const char *str);
+
+int parse_bool(uint32_t* val, const char *str);
+
+int parse_flag(uint32_t* val, uint32_t flag, const char *str);
+
+int parse_list_set(uint32_t *list, const char *str, uint32_t max_limit);
+
+int parse_task_set(struct core_task_set *val, const char *str);
+
+int parse_int(uint32_t* val, const char *str);
+int parse_float(float* val, const char *str);
+
+int parse_u64(uint64_t* val, const char *str);
+
+int parse_str(char* dst, const char *str, size_t max_len);
+
+int parse_path(char *dst, const char *str, size_t max_len);
+
+int parse_port_name(uint32_t *val, const char *str);
+
+/* The syntax for random fields is X0010101XXX... where X is a
+   randomized bit and 0, 1 are fixed bit. The resulting mask and fixed
+   arguments are in BE order. */
+int parse_random_str(uint32_t *mask, uint32_t *fixed, uint32_t *len, const char *str);
+
+int parse_port_name_list(uint32_t *val, uint32_t *tot, uint8_t max_vals, const char *str);
+
+/* Parses a comma separated list containing a remapping of ports
+   specified by their name. Hence, all port names referenced from the
+   list have to be added using add_port_name() before this function
+   can be used. The first elements in the list are mapped to 0, the
+   second to 1, etc. Multiple elements can be mapped to the same
+   index. If multiple elements are used, they are separated by
+   pipes. An example would be p0|p1,p2|p3. In this example, p0 and p1
+   both map to 0 and p2 and p3 map both map to 1. The mapping should
+   contain at least enough entries as port ids. */
+int parse_remap(uint8_t *mapping, const char *str);
+
+/* Convert an lcore_id to socket notation */
+int lcore_to_socket_core_ht(uint32_t lcore_id, char *dst, size_t len);
+
+int add_port_name(uint32_t val, const char *str);
+
+/* The $self variable is something that can change its value (i.e. its
+   value represents the core that is currently being parsed). */
+int set_self_var(const char *str);
+
+int add_var(const char* name, const char *val, uint8_t cli);
+
+/* Parses str and returns pointer to the key value */
+char *get_cfg_key(char *str);
+
+/* Changes strings in place. */
+void strip_spaces(char *strings[], const uint32_t count);
+
+/* Contains error string if any of the above returned an error. */
+const char* get_parse_err(void);
+
+/* Returns true if running from  a virtual machine. */
+int is_virtualized(void);
+
+#endif /* _PARSE_UTILS_H_ */
diff --git a/VNFs/DPPD-PROX/pkt_parser.h b/VNFs/DPPD-PROX/pkt_parser.h
new file mode 100644
index 00000000..285d42f9
--- /dev/null
+++ b/VNFs/DPPD-PROX/pkt_parser.h
@@ -0,0 +1,178 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PKT_PARSER_H_
+#define _PKT_PARSER_H_
+
+#include <rte_mbuf.h>
+#include <rte_ether.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+#include <rte_tcp.h>
+#include <rte_byteorder.h>
+
+#include "log.h"
+#include "etypes.h"
+
+struct pkt_tuple {
+	uint32_t src_addr;
+	uint32_t dst_addr;
+	uint8_t proto_id;
+	uint16_t src_port;
+	uint16_t dst_port;
+	uint16_t l2_types[4];
+} __attribute__((packed));
+
+struct l4_meta {
+	uint8_t *l4_hdr;
+	uint8_t *payload;
+	uint16_t len;
+};
+
+static void pkt_tuple_debug2(const struct pkt_tuple *pt)
+{
+	plogx_info("src_ip : %#010x\n", pt->src_addr);
+	plogx_info("dst_ip : %#010x\n", pt->dst_addr);
+	plogx_info("dst_port : %#06x\n", pt->dst_port);
+	plogx_info("src_port : %#06x\n", pt->src_port);
+	plogx_info("proto_id : %#04x\n", pt->proto_id);
+	plogx_info("l2 types: \n");
+	for (int i = 0; i < 4; ++i)
+		plogx_info("  - %#04x\n", pt->l2_types[i]);
+}
+
+static void pkt_tuple_debug(const struct pkt_tuple *pt)
+{
+	plogx_dbg("src_ip : %#010x\n", pt->src_addr);
+	plogx_dbg("dst_ip : %#010x\n", pt->dst_addr);
+	plogx_dbg("dst_port : %#06x\n", pt->dst_port);
+	plogx_dbg("src_port : %#06x\n", pt->src_port);
+	plogx_dbg("proto_id : %#04x\n", pt->proto_id);
+	plogx_dbg("l2 types: \n");
+	for (int i = 0; i < 4; ++i)
+		plogx_dbg("  - %#04x\n", pt->l2_types[i]);
+}
+
+/* Return 0 on success, i.e. packets parsed without any error. */
+static int parse_pkt(struct rte_mbuf *mbuf, struct pkt_tuple *pt, struct l4_meta *l4_meta)
+{
+	struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+	size_t l2_types_count = 0;
+	struct ipv4_hdr* pip = 0;
+
+	/* L2 */
+	pt->l2_types[l2_types_count++] = peth->ether_type;
+
+	switch (peth->ether_type) {
+	case ETYPE_IPv4:
+			pip = (struct ipv4_hdr *)(peth + 1);
+		break;
+	case ETYPE_VLAN: {
+		struct vlan_hdr *vlan = (struct vlan_hdr *)(peth + 1);
+		pt->l2_types[l2_types_count++] = vlan->eth_proto;
+		if (vlan->eth_proto == ETYPE_IPv4) {
+			pip = (struct ipv4_hdr *)(peth + 1);
+		}
+		else if (vlan->eth_proto == ETYPE_VLAN) {
+			struct vlan_hdr *vlan = (struct vlan_hdr *)(peth + 1);
+			pt->l2_types[l2_types_count++] = vlan->eth_proto;
+			if (vlan->eth_proto == ETYPE_IPv4) {
+				pip = (struct ipv4_hdr *)(peth + 1);
+			}
+			else if (vlan->eth_proto == ETYPE_IPv6) {
+				return 1;
+			}
+			else {
+				/* TODO: handle BAD PACKET */
+				return 1;
+			}
+		}
+	}
+		break;
+	case ETYPE_8021ad: {
+		struct vlan_hdr *vlan = (struct vlan_hdr *)(peth + 1);
+		pt->l2_types[l2_types_count++] = vlan->eth_proto;
+		if (vlan->eth_proto == ETYPE_VLAN) {
+			struct vlan_hdr *vlan = (struct vlan_hdr *)(peth + 1);
+			pt->l2_types[l2_types_count++] = vlan->eth_proto;
+			if (vlan->eth_proto == ETYPE_IPv4) {
+				pip = (struct ipv4_hdr *)(peth + 1);
+			}
+			else {
+				return 1;
+			}
+		}
+		else {
+			return 1;
+		}
+	}
+		break;
+	case ETYPE_MPLSU:
+		return -1;
+		break;
+	default:
+		plogx_err("Parsing error: unknown packet ether type = %#06x\n", peth->ether_type);
+		return -1;
+		break;
+	}
+
+	/* L3 */
+	if ((pip->version_ihl >> 4) == 4) {
+
+		if ((pip->version_ihl & 0x0f) != 0x05) {
+			/* TODO: optional fields */
+			return 1;
+		}
+
+		pt->proto_id = pip->next_proto_id;
+		pt->src_addr = pip->src_addr;
+		pt->dst_addr = pip->dst_addr;
+	}
+	else {
+		/* TODO: IPv6 and bad packets */
+		return 1;
+	}
+
+	/* L4 parser */
+	if (pt->proto_id == IPPROTO_UDP) {
+		struct udp_hdr *udp = (struct udp_hdr*)(pip + 1);
+		l4_meta->l4_hdr = (uint8_t*)udp;
+		pt->src_port = udp->src_port;
+		pt->dst_port = udp->dst_port;
+		l4_meta->payload = ((uint8_t*)udp) + sizeof(struct udp_hdr);
+		l4_meta->len = rte_be_to_cpu_16(udp->dgram_len) - sizeof(struct udp_hdr);
+	}
+	else if (pt->proto_id == IPPROTO_TCP) {
+		struct tcp_hdr *tcp = (struct tcp_hdr*)(pip + 1);
+		l4_meta->l4_hdr = (uint8_t*)tcp;
+		pt->src_port = tcp->src_port;
+		pt->dst_port = tcp->dst_port;
+
+		l4_meta->payload = ((uint8_t*)tcp) + ((tcp->data_off >> 4)*4);
+		l4_meta->len = rte_be_to_cpu_16(pip->total_length) - sizeof(struct ipv4_hdr) - ((tcp->data_off >> 4)*4);
+	}
+	else {
+		plog_err("unsupported protocol %d\n", pt->proto_id);
+		return 1;
+	}
+
+	for (; l2_types_count < sizeof(pt->l2_types)/sizeof(pt->l2_types[0]); ++l2_types_count)
+		pt->l2_types[l2_types_count] = 0;
+
+	return 0;
+}
+
+#endif /* _PKT_PARSER_H_ */
diff --git a/VNFs/DPPD-PROX/pkt_prototypes.h b/VNFs/DPPD-PROX/pkt_prototypes.h
new file mode 100644
index 00000000..5d55bacb
--- /dev/null
+++ b/VNFs/DPPD-PROX/pkt_prototypes.h
@@ -0,0 +1,54 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PKT_PROTOTYPES_H_
+#define _PKT_PROTOTYPES_H_
+
+#include <rte_ip.h>
+
+#include "gre.h"
+#include "qinq.h"
+#include "etypes.h"
+
+static const struct gre_hdr gre_hdr_proto = {
+	.type = ETYPE_IPv4,
+	.version = 0,
+	.flags = 0,
+	.recur = 0,
+	.bits = GRE_KEY_PRESENT
+};
+
+static const struct ipv4_hdr tunnel_ip_proto = {
+	.version_ihl = 0x45,
+	.type_of_service = 0,
+	.packet_id = 0,
+	.fragment_offset = 0x40,
+	/* no fragmentation */
+	.time_to_live = 0x40,
+	/* gre protocol type */
+	.next_proto_id = IPPROTO_GRE,
+	.hdr_checksum = 0
+};
+
+static const struct qinq_hdr qinq_proto = {
+	.svlan.vlan_tci = 0,
+	.cvlan.vlan_tci = 0,
+	.svlan.eth_proto = ETYPE_8021ad,
+	.cvlan.eth_proto = ETYPE_VLAN,
+	.ether_type = ETYPE_IPv4
+};
+
+#endif /* _PKT_PROTOTYPES_H_ */
diff --git a/VNFs/DPPD-PROX/prefetch.h b/VNFs/DPPD-PROX/prefetch.h
new file mode 100644
index 00000000..a42afe4a
--- /dev/null
+++ b/VNFs/DPPD-PROX/prefetch.h
@@ -0,0 +1,63 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PREFETCH_H_
+#define _PREFETCH_H_
+
+#include <rte_mbuf.h>
+
+static inline void prefetch_nta(volatile void *p)
+{
+	asm volatile ("prefetchnta %[p]" : [p] "+m" (*(volatile char *)p));
+}
+
+#ifdef PROX_PREFETCH_OFFSET
+#define PREFETCH0(p)		rte_prefetch0(p)
+#define PREFETCH_OFFSET		PROX_PREFETCH_OFFSET
+#else
+#define PREFETCH0(p)		do {} while (0)
+#define PREFETCH_OFFSET		0
+#endif
+
+static inline void prefetch_pkts(__attribute__((unused)) struct rte_mbuf **mbufs, __attribute__((unused)) uint16_t n_pkts)
+{
+#ifdef PROX_PREFETCH_OFFSET
+	for (uint16_t j = 0; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		PREFETCH0(mbufs[j]);
+	}
+	for (uint16_t j = PROX_PREFETCH_OFFSET; j < n_pkts; ++j) {
+		PREFETCH0(mbufs[j]);
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j - PROX_PREFETCH_OFFSET], void*));
+	}
+	for (uint16_t j = n_pkts - PROX_PREFETCH_OFFSET; j < n_pkts; ++j) {
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j], void*));
+	}
+#endif
+}
+
+static inline void prefetch_first(__attribute__((unused)) struct rte_mbuf **mbufs, __attribute__((unused)) uint16_t n_pkts)
+{
+#ifdef PROX_PREFETCH_OFFSET
+	for (uint16_t j = 0; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		PREFETCH0(mbufs[j]);
+	}
+	for (uint16_t j = 1; j < PROX_PREFETCH_OFFSET && j < n_pkts; ++j) {
+		PREFETCH0(rte_pktmbuf_mtod(mbufs[j - 1], void *));
+	}
+#endif
+}
+
+#endif /* _PREFETCH_H_ */
diff --git a/VNFs/DPPD-PROX/prox_args.c b/VNFs/DPPD-PROX/prox_args.c
new file mode 100644
index 00000000..df9a2ca4
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_args.c
@@ -0,0 +1,1975 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <unistd.h>
+#include <string.h>
+
+#include <rte_sched.h>
+#include <rte_string_fns.h>
+#include <rte_version.h>
+
+#include "prox_malloc.h"
+#include "version.h"
+#include "defines.h"
+#include "prox_args.h"
+#include "prox_assert.h"
+#include "prox_cfg.h"
+#include "cfgfile.h"
+#include "quit.h"
+#include "log.h"
+#include "parse_utils.h"
+#include "prox_port_cfg.h"
+#include "defaults.h"
+#include "prox_lua.h"
+#include "cqm.h"
+
+#define MAX_RTE_ARGV 64
+#define MAX_ARG_LEN  64
+
+struct cfg_depr {
+	const char *opt;
+	const char *info;
+};
+
+/* Helper macro */
+#define STR_EQ(s1, s2)	(!strcmp((s1), (s2)))
+
+/* configuration files support */
+static int get_rte_cfg(unsigned sindex, char *str, void *data);
+static int get_global_cfg(unsigned sindex, char *str, void *data);
+static int get_port_cfg(unsigned sindex, char *str, void *data);
+static int get_defaults_cfg(unsigned sindex, char *str, void *data);
+static int get_cache_set_cfg(unsigned sindex, char *str, void *data);
+static int get_var_cfg(unsigned sindex, char *str, void *data);
+static int get_lua_cfg(unsigned sindex, char *str, void *data);
+static int get_core_cfg(unsigned sindex, char *str, void *data);
+
+static const char *cfg_file = DEFAULT_CONFIG_FILE;
+static struct rte_cfg    rte_cfg;
+struct prox_cache_set_cfg  prox_cache_set_cfg[PROX_MAX_CACHE_SET];
+
+static char format_err_str[1024];
+static const char *err_str = "Unknown error";
+
+static struct cfg_section eal_default_cfg = {
+	.name   = "eal options",
+	.parser = get_rte_cfg,
+	.data   = &rte_cfg,
+	.indexp[0]  = 0,
+	.nbindex = 1,
+	.error  = 0
+};
+
+static struct cfg_section port_cfg = {
+	.name   = "port #",
+	.parser = get_port_cfg,
+	.data   = &prox_port_cfg,
+	.indexp[0]  = 0,
+	.nbindex = 1,
+	.error  = 0
+};
+
+static struct cfg_section var_cfg = {
+	.name   = "variables",
+	.parser = get_var_cfg,
+	.data   = 0,
+	.indexp[0]  = 0,
+	.nbindex = 1,
+	.error  = 0
+};
+
+static struct cfg_section cache_set_cfg = {
+	.name   = "cache set #",
+	.parser = get_cache_set_cfg,
+	.data   = &prox_cache_set_cfg,
+	.indexp[0]  = 0,
+	.nbindex = 1,
+	.error  = 0
+};
+
+static struct cfg_section defaults_cfg = {
+	.name   = "defaults",
+	.parser = get_defaults_cfg,
+	.data   = 0,
+	.indexp[0]  = 0,
+	.nbindex = 1,
+	.error  = 0
+};
+
+static struct cfg_section settings_cfg = {
+	.name   = "global",
+	.parser = get_global_cfg,
+	.data   = &prox_cfg,
+	.indexp[0]  = 0,
+	.nbindex = 1,
+	.error  = 0
+};
+
+static struct cfg_section lua_cfg = {
+	.name = "lua",
+	.parser = get_lua_cfg,
+	.raw_lines = 1,
+	.indexp[0] = 0,
+	.nbindex = 1,
+	.error = 0,
+};
+
+static struct cfg_section core_cfg = {
+	.name   = "core #",
+	.parser = get_core_cfg,
+	.data   = lcore_cfg_init,
+	.indexp[0]  = 0,
+	.nbindex = 1,
+	.error  = 0
+};
+
+static void set_errf(const char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+	vsnprintf(format_err_str, sizeof(format_err_str), format, ap);
+	va_end(ap);
+	err_str = format_err_str;
+}
+
+/* [eal options] parser */
+static int get_rte_cfg(__attribute__((unused))unsigned sindex, char *str, void *data)
+{
+	struct rte_cfg *pconfig = (struct rte_cfg *)data;
+
+	if (str == NULL || pconfig == NULL) {
+		return -1;
+	}
+
+	char *pkey = get_cfg_key(str);
+	if (pkey == NULL) {
+		set_errf("Missing key after option");
+		return -1;
+	}
+
+	if (STR_EQ(str, "-m")) {
+		return parse_int(&pconfig->memory, pkey);
+	}
+	if (STR_EQ(str, "-n")) {
+		if (parse_int(&pconfig->force_nchannel, pkey)) {
+			return -1;
+		}
+		if (pconfig->force_nchannel == 0) {
+			set_errf("Invalid number of memory channels");
+			return -1;
+		}
+		return 0;
+	}
+	if (STR_EQ(str, "-r")) {
+		if (parse_int(&pconfig->force_nrank, pkey)) {
+			return -1;
+		}
+		if (pconfig->force_nrank == 0 || pconfig->force_nrank > 16) {
+			set_errf("Invalid number of memory ranks");
+			return -1;
+		}
+		return 0;
+	}
+	/* debug options */
+	if (STR_EQ(str, "no-pci")) {
+		return parse_bool(&pconfig->no_pci, pkey);
+	}
+	if (STR_EQ(str, "no-hpet")) {
+		return parse_bool(&pconfig->no_hpet, pkey);
+	}
+	if (STR_EQ(str, "no-shconf")) {
+		return parse_bool(&pconfig->no_shconf, pkey);
+	}
+	if (STR_EQ(str, "no-huge")) {
+		return parse_bool(&pconfig->no_hugetlbfs, pkey);
+	}
+	if (STR_EQ(str, "no-output")) {
+		return parse_bool(&pconfig->no_output, pkey);
+	}
+
+	if (STR_EQ(str, "huge-dir")) {
+		if (pconfig->hugedir) {
+			free(pconfig->hugedir);
+		}
+		pconfig->hugedir = strdup(pkey);
+		return 0;
+	}
+
+	if (STR_EQ(str, "eal")) {
+		char eal[MAX_STR_LEN_PROC];
+		if (pconfig->eal) {
+			free(pconfig->eal);
+			pconfig->eal = NULL;
+		}
+		if (parse_str(eal, pkey, sizeof(eal)))
+			return -1;
+		pkey = eal;
+		strip_spaces(&pkey, 1);
+		if (*pkey)
+			pconfig->eal = strdup(pkey);
+		return 0;
+	}
+
+	set_errf("Option '%s' is not known", str);
+	return -1;
+}
+
+struct cfg_depr global_cfg_depr[] = {
+	{"virtualization", "This is now set automatically if needed"},
+	{"qinq_tag", "This option is deprecated"},
+	{"wait on quit", "This is now set automatically if needed"},
+	{"version", ""}
+};
+
+const char *get_cfg_dir(void)
+{
+	static char dir[PATH_MAX];
+	size_t end = strlen(cfg_file) - 1;
+	while (end > 0 && cfg_file[end] != '/')
+		end--;
+
+	strncpy(dir, cfg_file, end);
+	return dir;
+}
+
+static int get_lua_cfg(__attribute__((unused)) unsigned sindex, __attribute__((unused)) char *str, __attribute__((unused)) void *data)
+{
+	int status;
+	char cwd[1024];
+	if (NULL == getcwd(cwd, sizeof(cwd))) {
+		set_errf("Failed to get current directory while loading Lua file\n");
+		return -1;
+	}
+	status = chdir(get_cfg_dir());
+	if (status) {
+		set_errf("Failed to change directory to '%s' while loading Lua file\n", get_cfg_dir());
+		return -1;
+	}
+
+	struct lua_State *l = prox_lua();
+
+	char str_cpy[1024];
+	strncpy(str_cpy, str, sizeof(str_cpy));
+	uint32_t len = strlen(str_cpy);
+	str_cpy[len++] = '\n';
+	str_cpy[len++] = 0;
+
+	status = luaL_loadstring(l, str_cpy);
+	if (status) {
+		set_errf("Lua error: '%s'\n", lua_tostring(l, -1));
+		status = chdir(cwd);
+		return -1;
+	}
+
+	status = lua_pcall(l, 0, LUA_MULTRET, 0);
+	if (status) {
+		set_errf("Lua error: '%s'\n", lua_tostring(l, -1));
+		status = chdir(cwd);
+		return -1;
+	}
+
+	status = chdir(cwd);
+	if (status) {
+		set_errf("Failed to restore current directory to '%s' while loading Lua file\n", cwd);
+		return -1;
+	}
+
+	return 0;
+}
+
+/* [global] parser */
+static int get_global_cfg(__attribute__((unused))unsigned sindex, char *str, void *data)
+{
+	struct prox_cfg *pset = (struct prox_cfg *)data;
+
+	if (str == NULL || pset == NULL) {
+		return -1;
+	}
+
+	char *pkey = get_cfg_key(str);
+	if (pkey == NULL) {
+		set_errf("Missing key after option");
+		return -1;
+	}
+
+	for (uint32_t i = 0; i < RTE_DIM(global_cfg_depr); ++i) {
+		if (STR_EQ(str, global_cfg_depr[i].opt)) {
+			set_errf("Option '%s' is deprecated%s%s",
+				 global_cfg_depr[i].opt, strlen(global_cfg_depr[i].info)? ": ": "", global_cfg_depr[i].info);
+			return -1;
+		}
+	}
+
+	if (STR_EQ(str, "name")) {
+		return parse_str(pset->name, pkey, sizeof(pset->name));
+	}
+
+	if (STR_EQ(str, "start time")) {
+		return parse_int(&pset->start_time, pkey);
+	}
+
+	if (STR_EQ(str, "duration time")) {
+		return parse_int(&pset->duration_time, pkey);
+	}
+
+	if (STR_EQ(str, "shuffle")) {
+		return parse_flag(&pset->flags, DSF_SHUFFLE, pkey);
+	}
+	if (STR_EQ(str, "disable cmt")) {
+		return parse_flag(&pset->flags, DSF_DISABLE_CMT, pkey);
+	}
+	if (STR_EQ(str, "mp rings")) {
+		return parse_flag(&pset->flags, DSF_MP_RINGS, pkey);
+	}
+	if (STR_EQ(str, "enable bypass")) {
+		return parse_flag(&pset->flags, DSF_ENABLE_BYPASS, pkey);
+	}
+
+	if (STR_EQ(str, "cpe table map")) {
+		/* The config defined ports through 0, 1, 2 ... which
+		   need to be associated with ports. This is done
+		   through defining it using "cpe table map=" */
+		return parse_port_name_list((uint32_t*)pset->cpe_table_ports, NULL, PROX_MAX_PORTS, pkey);
+	}
+
+	if (STR_EQ(str, "pre cmd")) {
+		return system(pkey);
+	}
+
+	if (STR_EQ(str, "unique mempool per socket")) {
+		return parse_flag(&pset->flags, UNIQUE_MEMPOOL_PER_SOCKET, pkey);
+	}
+
+	if (STR_EQ(str, "log buffer size")) {
+		if (parse_kmg(&pset->logbuf_size, pkey)) {
+			return -1;
+		}
+		plog_info("Logging to buffer with size = %d\n", pset->logbuf_size);
+		return 0;
+	}
+
+	set_errf("Option '%s' is not known", str);
+	return -1;
+}
+
+/* [variable] parser */
+static int get_var_cfg(__attribute__((unused)) unsigned sindex, char *str, __attribute__((unused)) void *data)
+{
+	return add_var(str, get_cfg_key(str), 0);
+}
+
+/* [defaults] parser */
+static int get_defaults_cfg(__attribute__((unused)) unsigned sindex, char *str, __attribute__((unused)) void *data)
+{
+	uint32_t val;
+	char *pkey;
+
+	pkey = get_cfg_key(str);
+	if (pkey == NULL) {
+		set_errf("Missing key after option");
+		return -1;
+	}
+
+	if (STR_EQ(str, "mempool size")) {
+
+		if (parse_kmg(&val, pkey)) {
+			return -1;
+		}
+
+		for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
+			struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
+			cur_lcore_cfg_init->id = lcore_id;
+			for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
+				struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
+				targ->nb_mbuf = val;
+				targ->id = task_id;
+			}
+		}
+		return 0;
+	}
+
+	if (STR_EQ(str, "qinq tag")) {
+		for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
+			struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
+			cur_lcore_cfg_init->id = lcore_id;
+			for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
+				struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
+				parse_int(&targ->qinq_tag, pkey);
+			}
+		}
+		return 0;
+	}
+	if (STR_EQ(str, "memcache size")) {
+
+		if (parse_kmg(&val, pkey)) {
+			return -1;
+		}
+
+		for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
+			struct lcore_cfg *cur_lcore_cfg_init = &lcore_cfg_init[lcore_id];
+			cur_lcore_cfg_init->id = lcore_id;
+			for (uint8_t task_id = 0; task_id < MAX_TASKS_PER_CORE; ++task_id) {
+				struct task_args *targ = &cur_lcore_cfg_init->targs[task_id];
+				targ->nb_cache_mbuf = val;
+			}
+		}
+		return 0;
+	}
+
+	set_errf("Option '%s' is not known", str);
+	return -1;
+}
+
+/* [cache set] parser */
+static int get_cache_set_cfg(unsigned sindex, char *str, void *data)
+{
+	struct prox_cache_set_cfg *cfg = (struct prox_cache_set_cfg *)data;
+
+	uint8_t cur_if = sindex & ~CFG_INDEXED;
+
+	if (cur_if >= PROX_MAX_CACHE_SET) {
+		set_errf("Cache set ID is too high (max allowed %d)", PROX_MAX_CACHE_SET - 1 );
+		return -1;
+	}
+
+	cfg = &prox_cache_set_cfg[cur_if];
+
+	if (str == NULL || data == NULL) {
+		return -1;
+	}
+
+	char *pkey = get_cfg_key(str);
+
+	if (pkey == NULL) {
+		set_errf("Missing key after option");
+		return -1;
+	}
+
+	if (STR_EQ(str, "mask")) {
+                uint32_t val;
+                int err = parse_int(&val, pkey);
+                if (err) {
+                        return -1;
+                }
+                cfg->mask = val;
+                cfg->socket_id = -1;
+		plog_info("\tCache set %d has mask %x\n", cur_if, cfg->mask);
+                return 0;
+	}
+        return 0;
+}
+
+/* [port] parser */
+static int get_port_cfg(unsigned sindex, char *str, void *data)
+{
+	struct prox_port_cfg *cfg = (struct prox_port_cfg *)data;
+
+	uint8_t cur_if = sindex & ~CFG_INDEXED;
+
+	if (cur_if >= PROX_MAX_PORTS) {
+		set_errf("Port ID is too high (max allowed %d)", PROX_MAX_PORTS - 1 );
+		return -1;
+	}
+
+	cfg = &prox_port_cfg[cur_if];
+
+	if (str == NULL || data == NULL) {
+		return -1;
+	}
+
+	char *pkey = get_cfg_key(str);
+
+	if (pkey == NULL) {
+		set_errf("Missing key after option");
+		return -1;
+	}
+
+	if (STR_EQ(str, "mac")) {
+		if (STR_EQ(pkey, "hardware")) {
+			cfg->type = PROX_PORT_MAC_HW;
+		}
+		else if (STR_EQ(pkey, "random")) {
+			cfg->type = PROX_PORT_MAC_RAND;
+		}
+		else {
+			cfg->type = PROX_PORT_MAC_SET;
+			if (parse_mac(&cfg->eth_addr, pkey)) {
+				return -1;
+			}
+		}
+	}
+	else if (STR_EQ(str, "name")) {
+		uint32_t val;
+		strncpy(cfg->name, pkey, MAX_NAME_SIZE);
+		PROX_ASSERT(cur_if < PROX_MAX_PORTS);
+		return add_port_name(cur_if, pkey);
+	}
+	else if (STR_EQ(str, "rx desc")) {
+		return parse_int(&cfg->n_rxd, pkey);
+	}
+	else if (STR_EQ(str, "tx desc")) {
+		return parse_int(&cfg->n_txd, pkey);
+	}
+	else if (STR_EQ(str, "promiscuous")) {
+		uint32_t val;
+		if (parse_bool(&val, pkey)) {
+			return -1;
+		}
+		cfg->promiscuous = val;
+	}
+	else if (STR_EQ(str, "lsc")) {
+		cfg->lsc_set_explicitely = 1;
+		uint32_t val;
+		if (parse_bool(&val, pkey)) {
+			return -1;
+		}
+		cfg->lsc_val = val;
+	}
+	else if (STR_EQ(str, "strip crc")) {
+		uint32_t val;
+		if (parse_bool(&val, pkey)) {
+			return -1;
+		}
+		cfg->port_conf.rxmode.hw_strip_crc = val;
+	}
+	else if (STR_EQ(str, "rss")) {
+		uint32_t val;
+		if (parse_bool(&val, pkey)) {
+			return -1;
+		}
+		if (val) {
+			cfg->port_conf.rxmode.mq_mode = ETH_MQ_RX_RSS;
+			cfg->port_conf.rx_adv_conf.rss_conf.rss_hf = ETH_RSS_IPV4;
+		}
+	}
+	else if (STR_EQ(str, "rx_ring")) {
+		parse_str(cfg->rx_ring, pkey, sizeof(cfg->rx_ring));
+	}
+	else if (STR_EQ(str, "tx_ring")) {
+		parse_str(cfg->tx_ring, pkey, sizeof(cfg->tx_ring));
+	}
+
+	return 0;
+}
+
+static enum police_action str_to_color(const char *str)
+{
+	if (STR_EQ(str, "green"))
+		return ACT_GREEN;
+	if (STR_EQ(str, "yellow"))
+		return ACT_YELLOW;
+	if (STR_EQ(str, "red"))
+		return ACT_RED;
+	if (STR_EQ(str, "drop"))
+		return ACT_DROP;
+	return ACT_INVALID;
+}
+
+struct cfg_depr task_cfg_depr[] = {
+	{"sig", ""},
+};
+
+struct cfg_depr core_cfg_depr[] = {
+	{"do sig", ""},
+	{"lat", ""},
+	{"network side", ""},
+};
+
+/* [core] parser */
+static int get_core_cfg(unsigned sindex, char *str, void *data)
+{
+	char *pkey;
+	struct lcore_cfg *lconf = (struct lcore_cfg *)data;
+
+	if (str == NULL || lconf == NULL || !(sindex & CFG_INDEXED)) {
+		return -1;
+	}
+
+	pkey = get_cfg_key(str);
+	if (pkey == NULL) {
+		set_errf("Missing key after option");
+		return -1;
+	}
+
+	uint32_t ncore = sindex & ~CFG_INDEXED;
+	if (ncore >= RTE_MAX_LCORE) {
+		set_errf("Core index too high (max allowed %d)", RTE_MAX_LCORE - 1);
+		return -1;
+	}
+
+	lconf = &lconf[ncore];
+
+	for (uint32_t i = 0; i < RTE_DIM(core_cfg_depr); ++i) {
+		if (STR_EQ(str, core_cfg_depr[i].opt)) {
+			set_errf("Option '%s' is deprecated%s%s",
+				 core_cfg_depr[i].opt, strlen(core_cfg_depr[i].info)? ": ": "", core_cfg_depr[i].info);
+			return -1;
+		}
+	}
+
+	char buff[128];
+	lcore_to_socket_core_ht(ncore, buff, sizeof(buff));
+	set_self_var(buff);
+	if (STR_EQ(str, "task")) {
+
+		uint32_t val;
+		if (parse_int(&val, pkey)) {
+			return -1;
+		}
+		if (val >= MAX_TASKS_PER_CORE) {
+			set_errf("Too many tasks for core (max allowed %d)", MAX_TASKS_PER_CORE - 1);
+			return -1;
+		}
+		if (val != lconf->n_tasks_all) {
+			set_errf("Task ID skipped or defined twice");
+			return -1;
+		}
+
+		lconf->active_task = val;
+
+		lconf->targs[lconf->active_task].task = lconf->active_task;
+
+		if (lconf->n_tasks_all < lconf->active_task + 1) {
+			lconf->n_tasks_all = lconf->active_task + 1;
+		}
+		return 0;
+	}
+
+	struct task_args *targ = &lconf->targs[lconf->active_task];
+	if (STR_EQ(str, "tx ports from routing table")) {
+		uint32_t vals[PROX_MAX_PORTS];
+		uint32_t n_if;
+		if (!(targ->task_init->flag_features & TASK_FEATURE_ROUTING)) {
+			set_errf("tx port form route not supported mode %s",  targ->task_init->mode_str);
+			return -1;
+		}
+
+		if (parse_port_name_list(vals, &n_if, PROX_MAX_PORTS, pkey)) {
+			return -1;
+		}
+
+		for (uint8_t i = 0; i < n_if; ++i) {
+			targ->tx_port_queue[i].port = vals[i];
+			targ->nb_txports++;
+		}
+		targ->runtime_flags |= TASK_ROUTING;
+		return 0;
+	}
+	if (STR_EQ(str, "tx ports from cpe table")) {
+		uint32_t vals[PROX_MAX_PORTS];
+		int n_remap = -1;
+		uint32_t ret;
+		uint32_t val;
+		char* mapping_str = strstr(pkey, " remap=");
+
+		if (mapping_str != NULL) {
+			*mapping_str = 0;
+			mapping_str += strlen(" remap=");
+			n_remap = parse_remap(targ->mapping, mapping_str);
+		}
+
+		if (parse_port_name_list(vals, &ret, PROX_MAX_PORTS, pkey)) {
+			return -1;
+		}
+
+		if (n_remap != -1 && ret != (uint32_t)n_remap) {
+			set_errf("Expected %d remap elements but had %d", n_remap, ret);
+			return -1;
+		}
+
+		for (uint8_t i = 0; i < ret; ++i) {
+			targ->tx_port_queue[i].port = vals[i];
+
+			/* default mapping this case is port0 -> port0 */
+			if (n_remap == -1) {
+				targ->mapping[vals[i]] = i;
+			}
+		}
+
+		targ->nb_txports = ret;
+
+		return 0;
+	}
+	if (STR_EQ(str, "tx cores from routing table")) {
+		if (!(targ->task_init->flag_features & TASK_FEATURE_ROUTING)) {
+			set_errf("tx port form route not supported mode %s",  targ->task_init->mode_str);
+			return -1;
+		}
+
+		struct core_task_set *cts = &targ->core_task_set[0];
+
+		if (parse_task_set(cts, pkey))
+			return -1;
+
+		if (cts->n_elems > MAX_WT_PER_LB) {
+			set_errf("Maximum worker threads allowed is %u but have %u", MAX_WT_PER_LB, cts->n_elems);
+			return -1;
+		}
+
+		targ->nb_worker_threads = cts->n_elems;
+		targ->nb_txrings = cts->n_elems;
+
+		if (targ->nb_txrings > MAX_RINGS_PER_TASK) {
+			set_errf("Maximum allowed TX rings is %u but have %u", MAX_RINGS_PER_TASK, targ->nb_txrings);
+			return -1;
+		}
+
+		targ->runtime_flags |= TASK_ROUTING;
+		return 0;
+	}
+	if (STR_EQ(str, "tx cores from cpe table")) {
+		struct core_task_set *core_task_set =  &targ->core_task_set[0];
+		int ret, ret2;
+		char *mapping_str;
+
+		mapping_str = strstr(pkey, " remap=");
+		if (mapping_str == NULL) {
+			set_errf("There is no default mapping for tx cores from cpe table. Please specify it through remap=");
+			return -1;
+		}
+		*mapping_str = 0;
+		mapping_str += strlen(" remap=");
+		ret = parse_remap(targ->mapping, mapping_str);
+		if (ret <= 0) {
+			return -1;
+		}
+
+		struct core_task_set *cts = &targ->core_task_set[0];
+
+		if (parse_task_set(cts, pkey))
+			return -1;
+		if (cts->n_elems > MAX_RINGS_PER_TASK) {
+			set_errf("Maximum cores to route to is %u\n", MAX_RINGS_PER_TASK);
+			return -1;
+		}
+
+		targ->nb_txrings = cts->n_elems;
+
+		if (ret != targ->nb_txrings) {
+			set_errf("Expecting same number of remaps as cores\n", str);
+			return -1;
+		}
+		return 0;
+	}
+
+	if (STR_EQ(str, "delay ms")) {
+		if (targ->delay_us) {
+			set_errf("delay ms and delay us are mutually exclusive\n", str);
+			return -1;
+		}
+		uint32_t delay_ms;
+		int rc = parse_int(&delay_ms, pkey);
+		targ->delay_us = delay_ms * 1000;
+		return rc;
+	}
+	if (STR_EQ(str, "delay us")) {
+		if (targ->delay_us) {
+			set_errf("delay ms and delay us are mutually exclusive\n", str);
+			return -1;
+		}
+		return parse_int(&targ->delay_us, pkey);
+	}
+	if (STR_EQ(str, "random delay us")) {
+		return parse_int(&targ->random_delay_us, pkey);
+	}
+	if (STR_EQ(str, "cpe table timeout ms")) {
+		return parse_int(&targ->cpe_table_timeout_ms, pkey);
+	}
+	if (STR_EQ(str, "ctrl path polling frequency")) {
+		int rc = parse_int(&targ->ctrl_freq, pkey);
+		if (rc == 0) {
+			if (targ->ctrl_freq == 0) {
+				set_errf("ctrl frequency must be non null.");
+				return -1;
+			}
+		}
+		return rc;
+	}
+
+	if (STR_EQ(str, "handle arp")) {
+		return parse_flag(&targ->runtime_flags, TASK_CTRL_HANDLE_ARP, pkey);
+	}
+	if (STR_EQ(str, "fast path handle arp")) {
+		return parse_flag(&targ->runtime_flags, TASK_FP_HANDLE_ARP, pkey);
+	}
+	if (STR_EQ(str, "multiple arp")) {
+		return parse_flag(&targ->flags, TASK_MULTIPLE_MAC, pkey);
+	}
+
+	/* Using tx port name, only a _single_ port can be assigned to a task. */
+	if (STR_EQ(str, "tx port")) {
+		if (targ->nb_txports > 0) {
+			set_errf("Only one tx port can be defined per task. Use a LB task or routing instead.");
+			return -1;
+		}
+
+		uint32_t n_if = 0;
+		uint32_t ports[PROX_MAX_PORTS];
+
+		if(parse_port_name_list(ports, &n_if, PROX_MAX_PORTS, pkey)) {
+			return -1;
+		}
+
+		PROX_ASSERT(n_if-1 < PROX_MAX_PORTS);
+
+                for (uint8_t i = 0; i < n_if; ++i) {
+                        targ->tx_port_queue[i].port = ports[i];
+                        targ->nb_txports++;
+                }
+
+		if (n_if > 1) {
+			targ->nb_worker_threads = targ->nb_txports;
+		}
+
+		return 0;
+	}
+	if (STR_EQ(str, "rx ring")) {
+		uint32_t val;
+		int err = parse_bool(&val, pkey);
+		if (!err && val && targ->rx_port_queue[0].port != OUT_DISCARD) {
+			set_errf("Can't read both from internal ring and external port from the same task. Use multiple tasks instead.");
+			return -1;
+		}
+
+		return parse_flag(&targ->flags, TASK_ARG_RX_RING, pkey);
+	}
+	if (STR_EQ(str, "private")) {
+		return parse_bool(&targ->use_src, pkey);
+	}
+	if (STR_EQ(str, "use src ip")) {
+		return parse_bool(&targ->use_src, pkey);
+	}
+	if (STR_EQ(str, "nat table")) {
+		return parse_str(targ->nat_table, pkey, sizeof(targ->nat_table));
+	}
+	if (STR_EQ(str, "rules")) {
+		return parse_str(targ->rules, pkey, sizeof(targ->rules));
+	}
+	if (STR_EQ(str, "route table")) {
+		return parse_str(targ->route_table, pkey, sizeof(targ->route_table));
+	}
+	if (STR_EQ(str, "dscp")) {
+		return parse_str(targ->dscp, pkey, sizeof(targ->dscp));
+	}
+	if (STR_EQ(str, "tun_bindings")) {
+		return parse_str(targ->tun_bindings, pkey, sizeof(targ->tun_bindings));
+	}
+	if (STR_EQ(str, "cpe table")) {
+		return parse_str(targ->cpe_table_name, pkey, sizeof(targ->cpe_table_name));
+	}
+	if (STR_EQ(str, "user table")) {
+		return parse_str(targ->user_table, pkey, sizeof(targ->user_table));
+	}
+	if (STR_EQ(str, "streams")) {
+		return parse_str(targ->streams, pkey, sizeof(targ->streams));
+	}
+	if (STR_EQ(str, "local lpm")) {
+		return parse_flag(&targ->flags, TASK_ARG_LOCAL_LPM, pkey);
+	}
+	if (STR_EQ(str, "drop")) {
+		return parse_flag(&targ->flags, TASK_ARG_DROP, pkey);
+	}
+	if (STR_EQ(str, "loop")) {
+		parse_flag(&targ->loop, 1, pkey);
+		return parse_flag(&targ->loop, 1, pkey);
+	}
+	if (STR_EQ(str, "qinq")) {
+		return parse_flag(&targ->flags, TASK_ARG_QINQ_ACL, pkey);
+	}
+	if (STR_EQ(str, "bps")) {
+		return parse_u64(&targ->rate_bps, pkey);
+	}
+	if (STR_EQ(str, "random")) {
+		return parse_str(targ->rand_str[targ->n_rand_str++], pkey, sizeof(targ->rand_str[0]));
+	}
+	if (STR_EQ(str, "rand_offset")) {
+		if (targ->n_rand_str == 0) {
+			set_errf("No random defined previously (use random=...)");
+			return -1;
+		}
+
+		return parse_int(&targ->rand_offset[targ->n_rand_str - 1], pkey);
+	}
+	if (STR_EQ(str, "keep src mac")) {
+		return parse_flag(&targ->flags, DSF_KEEP_SRC_MAC, pkey);
+	}
+	if (STR_EQ(str, "pcap file")) {
+		return parse_str(targ->pcap_file, pkey, sizeof(targ->pcap_file));
+	}
+	if (STR_EQ(str, "pkt inline")) {
+		char pkey2[MAX_CFG_STRING_LEN];
+		if (parse_str(pkey2, pkey, sizeof(pkey2)) != 0) {
+			set_errf("Error while parsing pkt line, too long\n");
+			return -1;
+		}
+
+		const size_t pkey_len = strlen(pkey2);
+		targ->pkt_size = 0;
+
+		for (size_t i = 0; i < pkey_len; ++i) {
+			if (pkey2[i] == ' ')
+				continue;
+
+			if (i + 1 == pkey_len) {
+				set_errf("Incomplete byte at character %z", i);
+				return -1;
+			}
+
+			uint8_t byte = 0;
+
+			if (pkey2[i] >= '0' && pkey2[i] <= '9') {
+				byte = (pkey2[i] - '0') << 4;
+			}
+			else if (pkey2[i] >= 'a' && pkey2[i] <= 'f') {
+				byte = (pkey2[i] - 'a' + 10) << 4;
+			}
+			else if (pkey2[i] >= 'A' && pkey2[i] <= 'F') {
+				byte = (pkey2[i] - 'A' + 10) << 4;
+			}
+			else {
+				set_errf("Invalid character in pkt inline at byte %d (%c)", i, pkey2[i]);
+				return -1;
+			}
+
+			if (pkey2[i + 1] >= '0' && pkey2[i + 1] <= '9') {
+				byte |= (pkey2[i + 1] - '0');
+			}
+			else if (pkey2[i + 1] >= 'a' && pkey2[i + 1] <= 'f') {
+				byte |= (pkey2[i + 1] - 'a' + 10);
+			}
+			else if (pkey2[i + 1] >= 'A' && pkey2[i + 1] <= 'F') {
+				byte |= (pkey2[i + 1] - 'A' + 10);
+			}
+			else {
+				set_errf("Invalid character in pkt inline at byte %d (%c)", i, pkey2[i + 1]);
+				return -1;
+			}
+			if (targ->pkt_size == sizeof(targ->pkt_inline)) {
+				set_errf("Inline packet definition can't be longer than 1518");
+			}
+
+			targ->pkt_inline[targ->pkt_size++] = byte;
+			i += 1;
+		}
+
+		return 0;
+	}
+	if (STR_EQ(str, "accuracy limit nsec")) {
+		return parse_int(&targ->accuracy_limit_nsec, pkey);
+	}
+	if (STR_EQ(str, "latency bucket size")) {
+		return parse_int(&targ->bucket_size, pkey);
+	}
+	if (STR_EQ(str, "latency buffer size")) {
+		return parse_int(&targ->latency_buffer_size, pkey);
+	}
+	if (STR_EQ(str, "accuracy pos")) {
+		return parse_int(&targ->accur_pos, pkey);
+	}
+	if (STR_EQ(str, "signature")) {
+		return parse_int(&targ->sig, pkey);
+	}
+	if (STR_EQ(str, "signature pos")) {
+		return parse_int(&targ->sig_pos, pkey);
+	}
+	if (STR_EQ(str, "lat pos")) {
+		targ->lat_enabled = 1;
+		return parse_int(&targ->lat_pos, pkey);
+	}
+	if (STR_EQ(str, "packet id pos")) {
+		return parse_int(&targ->packet_id_pos, pkey);
+	}
+	if (STR_EQ(str, "probability")) {
+		float probability;
+		int rc = parse_float(&probability, pkey);
+		if (probability == 0) {
+			set_errf("Probability must be != 0\n");
+			return -1;
+		} else if (probability > 100.0) {
+			set_errf("Probability must be < 100\n");
+			return -1;
+		}
+		targ->probability = probability * 10000;
+		return rc;
+	}
+	if (STR_EQ(str, "concur conn")) {
+		return parse_int(&targ->n_concur_conn, pkey);
+	}
+	if (STR_EQ(str, "max setup rate")) {
+		return parse_int(&targ->max_setup_rate, pkey);
+	}
+	if (STR_EQ(str, "pkt size")) {
+		return parse_int(&targ->pkt_size, pkey);
+	}
+	if (STR_EQ(str, "min bulk size")) {
+		return parse_int(&targ->min_bulk_size, pkey);
+	}
+	if (STR_EQ(str, "max bulk size")) {
+		return parse_int(&targ->max_bulk_size, pkey);
+	}
+	if (STR_EQ(str, "rx port")) {
+		if (targ->flags & TASK_ARG_RX_RING) {
+			set_errf("Can't read both from internal ring and external port from the same task. Use multiple tasks instead.");
+			return -1;
+		}
+		uint32_t vals[PROX_MAX_PORTS];
+		uint32_t n_if;
+
+                if (parse_port_name_list(vals, &n_if, PROX_MAX_PORTS, pkey)) {
+                        return -1;
+                }
+
+                for (uint8_t i = 0; i < n_if; ++i) {
+			PROX_ASSERT(vals[i] < PROX_MAX_PORTS);
+                        targ->rx_port_queue[i].port = vals[i];
+                        targ->nb_rxports++;
+                }
+		return 0;
+	}
+
+	if (STR_EQ(str, "mode")) {
+		/* Check deprecated task modes */
+		char mode[255];
+		int ret = parse_str(mode, pkey, sizeof(mode));
+		if (ret)
+			return ret;
+
+		for (uint32_t i = 0; i < RTE_DIM(task_cfg_depr); ++i) {
+			if (STR_EQ(mode, task_cfg_depr[i].opt)) {
+				set_errf("Task mode '%s' is deprecated%s%s",
+					 task_cfg_depr[i].opt, strlen(task_cfg_depr[i].info)? ": ": "", task_cfg_depr[i].info);
+				return -1;
+			}
+		}
+
+		/* master is a special mode that is always needed (cannot be turned off) */
+		if (STR_EQ(mode, "master")) {
+			prox_cfg.master = ncore;
+			targ->mode = MASTER;
+			if (lconf->n_tasks_all > 1 || targ->task != 0) {
+				set_errf("Master core can only have one task\n");
+				return -1;
+			}
+			return 0;
+		}
+
+		struct task_init* task_init = to_task_init(mode, "");
+		if (task_init) {
+			targ->mode = task_init->mode;
+		}
+		else {
+			set_errf("Task mode '%s' is invalid", mode);
+			tasks_list();
+			return -1;
+		}
+		targ->task_init = task_init;
+		return 0;
+	}
+	if (STR_EQ(str, "users")) {
+		return parse_int(&targ->n_flows, pkey);
+	}
+
+	if (STR_EQ(str, "mark")) {
+		return parse_flag(&targ->runtime_flags, TASK_MARK, pkey);
+	}
+
+	if (STR_EQ(str, "mark green")) {
+		return parse_int(&targ->marking[0], pkey);
+	}
+
+	if (STR_EQ(str, "mark yellow")) {
+		return parse_int(&targ->marking[1], pkey);
+	}
+
+	if (STR_EQ(str, "mark red")) {
+		return parse_int(&targ->marking[2], pkey);
+	}
+
+	if (STR_EQ(str, "tx cores")) {
+		uint8_t dest_task = 0;
+		/* if user did not specify, dest_port is left at default (first type) */
+		uint8_t dest_proto = 0;
+		uint8_t ctrl = CTRL_TYPE_DP;
+		char *task_str = strstr(pkey, "proto=");
+		if (task_str) {
+			task_str += strlen("proto=");
+
+			if (STR_EQ(task_str, "ipv4")) {
+				dest_proto = IPV4;
+			}
+			else if (STR_EQ(task_str, "arp")) {
+				dest_proto = ARP;
+			}
+			else if (STR_EQ(task_str, "ipv6")) {
+				dest_proto = IPV6;
+			}
+			else {
+				set_errf("proto needs to be either ipv4, arp or ipv6");
+				return -1;
+			}
+
+		}
+
+		task_str = strstr(pkey, "task=");
+
+		if (task_str) {
+			--task_str;
+			*task_str = 0;
+			task_str++;
+			task_str += strlen("task=");
+			char *task_str_end = strstr(task_str, " ");
+			if (task_str_end) {
+				*task_str_end = 0;
+			}
+			if (0 == strlen(task_str)) {
+				set_errf("Invalid task= syntax");
+				return -1;
+			}
+
+			switch (task_str[strlen(task_str) - 1]) {
+			case 'p':
+				ctrl = CTRL_TYPE_PKT;
+				break;
+			case 'm':
+				ctrl = CTRL_TYPE_MSG;
+				break;
+			case '\n':
+			case 0:
+				break;
+			default:
+				if (task_str[strlen(task_str) -1] < '0' ||
+				    task_str[strlen(task_str) -1] > '9') {
+					set_errf("Unknown ring type %c.\n",
+						 task_str[strlen(task_str) - 1]);
+					return -1;
+				}
+			}
+
+			dest_task = atoi(task_str);
+			if (dest_task >= MAX_TASKS_PER_CORE) {
+				set_errf("Destination task too high (max allowed %d)", MAX_TASKS_PER_CORE - 1);
+				return -1;
+			}
+		}
+		else {
+			dest_task = 0;
+		}
+
+		struct core_task_set *cts = &targ->core_task_set[dest_proto];
+
+		if (parse_task_set(cts, pkey))
+			return -1;
+
+		if (cts->n_elems > MAX_WT_PER_LB) {
+			set_errf("Too many worker threads (max allowed %d)", MAX_WT_PER_LB - 1);
+			return -1;
+		}
+
+		targ->nb_worker_threads = cts->n_elems;
+		targ->nb_txrings += cts->n_elems;
+
+		return 0;
+	}
+	if (STR_EQ(str, "tx crc")) {
+		return parse_flag(&targ->runtime_flags, TASK_TX_CRC, pkey);
+	}
+	if (STR_EQ(str, "ring size")) {
+		return parse_int(&targ->ring_size, pkey);
+	}
+	if (STR_EQ(str, "mempool size")) {
+		return parse_kmg(&targ->nb_mbuf, pkey);
+	}
+
+	else if (STR_EQ(str, "mbuf size")) {
+		targ->mbuf_size_set_explicitely = 1;
+		return parse_int(&targ->mbuf_size, pkey);
+	}
+	if (STR_EQ(str, "memcache size")) {
+		return parse_kmg(&targ->nb_cache_mbuf, pkey);
+	}
+
+	if (STR_EQ(str, "byte offset")) {
+		return parse_int(&targ->byte_offset, pkey);
+	}
+
+	if (STR_EQ(str, "name")) {
+		return parse_str(lconf->name, pkey, sizeof(lconf->name));
+	}
+	/* MPLS configuration */
+	if (STR_EQ(str, "untag mpls")) {
+		return parse_flag(&targ->runtime_flags, TASK_MPLS_TAGGING, pkey);
+	}
+
+	if (STR_EQ(str, "add mpls")) {
+		return parse_flag(&targ->runtime_flags, TASK_MPLS_TAGGING, pkey);
+	}
+
+	if (STR_EQ(str, "ether type")) {
+		return parse_int(&targ->etype, pkey);
+	}
+
+	if (STR_EQ(str, "cache set")) {
+		return parse_int(&lconf->cache_set, pkey);
+	}
+
+	if (STR_EQ(str, "sub mode")) {
+		const char* mode_str = targ->task_init->mode_str;
+		const char *sub_mode_str = pkey;
+
+		targ->task_init = to_task_init(mode_str, sub_mode_str);
+		if (!targ->task_init) {
+			set_errf("sub mode %s not supported for mode %s", sub_mode_str, mode_str);
+			return -1;
+		}
+		return 0;
+	}
+
+	if (STR_EQ(str, "mempool name")) {
+		return parse_str(targ->pool_name, pkey, sizeof(targ->pool_name));
+	}
+	if (STR_EQ(str, "dpi engine")) {
+		return parse_str(targ->dpi_engine_path, pkey, sizeof(targ->dpi_engine_path));
+	}
+	if (STR_EQ(str, "dpi engine arg")) {
+		return parse_str(targ->dpi_engine_args[targ->n_dpi_engine_args++], pkey,
+				 sizeof(targ->dpi_engine_args[0]));
+	}
+	if (STR_EQ(str, "dst mac")) { /* destination MAC address to be used for packets */
+		if (parse_mac(&targ->edaddr, pkey)) {
+			if (STR_EQ(pkey, "no")) {
+				targ->flags |= TASK_ARG_DO_NOT_SET_DST_MAC;
+				return 0;
+			}
+			if (STR_EQ(pkey, "packet") == 0)
+				return -1;
+			else
+				return 0;
+		}
+		targ->flags |= TASK_ARG_DST_MAC_SET;
+		return 0;
+	}
+	if (STR_EQ(str, "src mac")) {
+		if (parse_mac(&targ->esaddr, pkey)) {
+			if (STR_EQ(pkey, "no")) {
+				targ->flags |= TASK_ARG_DO_NOT_SET_SRC_MAC;
+				return 0;
+			}
+			else if (STR_EQ(pkey, "packet"))
+				return 0;
+			else if (STR_EQ(pkey, "packet")) {
+				targ->flags |= TASK_ARG_HW_SRC_MAC;
+				return 0;
+			} else {
+				return -1;
+			}
+		}
+		targ->flags |= TASK_ARG_SRC_MAC_SET;
+		return 0;
+	}
+	if (STR_EQ(str, "gateway ipv4")) { /* Gateway IP address used when generating */
+		return parse_ip(&targ->gateway_ipv4, pkey);
+	}
+	if (STR_EQ(str, "number of ip")) { /* Gateway IP address used when generating */
+		return parse_int(&targ->number_gen_ip, pkey);
+	}
+	if (STR_EQ(str, "local ipv4")) { /* source IP address to be used for packets */
+		return parse_ip(&targ->local_ipv4, pkey);
+	}
+        if (STR_EQ(str, "local ipv6")) { /* source IPv6 address to be used for packets */
+                return parse_ip6(&targ->local_ipv6, pkey);
+        }
+	if (STR_EQ(str, "number of packets"))
+		return parse_int(&targ->n_pkts, pkey);
+	if (STR_EQ(str, "pipes")) {
+		uint32_t val;
+		int err = parse_int(&val, pkey);
+		if (err)
+			return -1;
+		if (!val || !rte_is_power_of_2(val)) {
+			set_errf("Number of pipes has to be power of 2 and not zero");
+			return -1;
+		}
+
+		targ->qos_conf.port_params.n_pipes_per_subport = val;
+		return 0;
+	}
+	if (STR_EQ(str, "queue size")) {
+		uint32_t val;
+		int err = parse_int(&val, pkey);
+		if (err) {
+			return -1;
+		}
+
+		targ->qos_conf.port_params.qsize[0] = val;
+		targ->qos_conf.port_params.qsize[1] = val;
+		targ->qos_conf.port_params.qsize[2] = val;
+		targ->qos_conf.port_params.qsize[3] = val;
+		return 0;
+	}
+	if (STR_EQ(str, "subport tb rate")) {
+		return parse_int(&targ->qos_conf.subport_params[0].tb_rate, pkey);
+	}
+	if (STR_EQ(str, "subport tb size")) {
+		return parse_int(&targ->qos_conf.subport_params[0].tb_size, pkey);
+	}
+	if (STR_EQ(str, "subport tc 0 rate")) {
+		return parse_int(&targ->qos_conf.subport_params[0].tc_rate[0], pkey);
+	}
+	if (STR_EQ(str, "subport tc 1 rate")) {
+		return parse_int(&targ->qos_conf.subport_params[0].tc_rate[1], pkey);
+	}
+	if (STR_EQ(str, "subport tc 2 rate")) {
+		return parse_int(&targ->qos_conf.subport_params[0].tc_rate[2], pkey);
+	}
+	if (STR_EQ(str, "subport tc 3 rate")) {
+		return parse_int(&targ->qos_conf.subport_params[0].tc_rate[3], pkey);
+	}
+
+	if (STR_EQ(str, "subport tc rate")) {
+		uint32_t val;
+		int err = parse_int(&val, pkey);
+		if (err) {
+			return -1;
+		}
+
+		targ->qos_conf.subport_params[0].tc_rate[0] = val;
+		targ->qos_conf.subport_params[0].tc_rate[1] = val;
+		targ->qos_conf.subport_params[0].tc_rate[2] = val;
+		targ->qos_conf.subport_params[0].tc_rate[3] = val;
+
+		return 0;
+	}
+	if (STR_EQ(str, "subport tc period")) {
+		return parse_int(&targ->qos_conf.subport_params[0].tc_period, pkey);
+	}
+	if (STR_EQ(str, "pipe tb rate")) {
+		return parse_int(&targ->qos_conf.pipe_params[0].tb_rate, pkey);
+	}
+	if (STR_EQ(str, "pipe tb size")) {
+		return parse_int(&targ->qos_conf.pipe_params[0].tb_size, pkey);
+	}
+	if (STR_EQ(str, "pipe tc rate")) {
+		uint32_t val;
+		int err = parse_int(&val, pkey);
+		if (err) {
+			return -1;
+		}
+
+		targ->qos_conf.pipe_params[0].tc_rate[0] = val;
+		targ->qos_conf.pipe_params[0].tc_rate[1] = val;
+		targ->qos_conf.pipe_params[0].tc_rate[2] = val;
+		targ->qos_conf.pipe_params[0].tc_rate[3] = val;
+		return 0;
+	}
+	if (STR_EQ(str, "pipe tc 0 rate")) {
+		return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[0], pkey);
+	}
+	if (STR_EQ(str, "pipe tc 1 rate")) {
+		return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[1], pkey);
+	}
+	if (STR_EQ(str, "pipe tc 2 rate")) {
+		return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[2], pkey);
+	}
+	if (STR_EQ(str, "pipe tc 3 rate")) {
+		return parse_int(&targ->qos_conf.pipe_params[0].tc_rate[3], pkey);
+	}
+	if (STR_EQ(str, "pipe tc period")) {
+		return parse_int(&targ->qos_conf.pipe_params[0].tc_period, pkey);
+	}
+	if (STR_EQ(str, "police action")) {
+		char *in = strstr(pkey, " io=");
+		if (in == NULL) {
+			set_errf("Need to specify io colors using io=in_color,out_color\n");
+			return -1;
+		}
+		*in = 0;
+		in += strlen(" io=");
+
+		char *out = strstr(in, ",");
+		if (out == NULL) {
+			set_errf("Output color not specified\n");
+		}
+		*out = 0;
+		out++;
+
+		enum police_action in_color = str_to_color(in);
+		enum police_action out_color = str_to_color(out);
+
+		if (in_color == ACT_INVALID) {
+			set_errf("Invalid input color %s. Expected green, yellow or red", in);
+			return -1;
+		}
+		if (out_color == ACT_INVALID) {
+			set_errf("Invalid output color %s. Expected green, yellow or red", out);
+			return -1;
+		}
+		enum police_action action = str_to_color(pkey);
+		if (action == ACT_INVALID) {
+			set_errf("Error action %s. Expected green, yellow, red or drop", pkey);
+			return -1;
+		}
+		targ->police_act[in_color][out_color] = action;
+
+		return 0;
+	}
+	if (STR_EQ(str, "qinq tag")) {
+		return parse_int(&targ->qinq_tag, pkey);
+	}
+	if (STR_EQ(str, "cir")) {
+		return parse_int(&targ->cir, pkey);
+	}
+	if (STR_EQ(str, "cbs")) {
+		return parse_int(&targ->cbs, pkey);
+	}
+	if (STR_EQ(str, "pir")) {
+		return parse_int(&targ->pir, pkey);
+	}
+	if (STR_EQ(str, "pbs")) {
+		return parse_int(&targ->pbs, pkey);
+	}
+	if (STR_EQ(str, "ebs")) {
+		return parse_int(&targ->ebs, pkey);
+	}
+	uint32_t queue_id = 0;
+	if (sscanf(str, "queue %d weight", &queue_id) == 1) {
+		uint32_t val;
+		int err = parse_int(&val, pkey);
+		if (err) {
+			return -1;
+		}
+		targ->qos_conf.pipe_params[0].wrr_weights[queue_id] = val;
+		return 0;
+	}
+	if (STR_EQ(str, "classify")) {
+		if (!(targ->task_init->flag_features & TASK_FEATURE_CLASSIFY)) {
+			set_errf("Classify is not supported in '%s' mode", targ->task_init->mode_str);
+			return -1;
+		}
+
+		return parse_flag(&targ->runtime_flags, TASK_CLASSIFY, pkey);
+	}
+	if (STR_EQ(str, "flow table size")) {
+		return parse_int(&targ->flow_table_size, pkey);
+	}
+#ifdef GRE_TP
+	if (STR_EQ(str, "tbf rate")) {
+		return parse_int(&targ->tb_rate, pkey);
+	}
+	if (STR_EQ(str, "tbf size")) {
+		return parse_int(&targ->tb_size, pkey);
+	}
+#endif
+	if (STR_EQ(str, "max rules")) {
+		return parse_int(&targ->n_max_rules, pkey);
+	}
+
+        if (STR_EQ(str, "tunnel hop limit")) {
+                uint32_t val;
+                int err = parse_int(&val, pkey);
+                if (err) {
+                        return -1;
+                }
+                targ->tunnel_hop_limit = val;
+                return 0;
+        }
+
+        if (STR_EQ(str, "lookup port mask")) {
+                uint32_t val;
+                int err = parse_int(&val, pkey);
+                if (err) {
+                        return -1;
+                }
+                targ->lookup_port_mask = val;
+                return 0;
+        }
+
+	set_errf("Option '%s' is not known", str);
+	/* fail on unknown keys */
+	return -1;
+}
+
+static int str_is_number(const char *in)
+{
+	int dot_once = 0;
+
+	for (size_t i = 0; i < strlen(in); ++i) {
+		if (!dot_once && in[i] == '.') {
+			dot_once = 1;
+			continue;
+		}
+
+		if (in[i] < '0' || in[i] > '9')
+			return 0;
+	}
+
+	return 1;
+}
+
+/* command line parameters parsing procedure */
+int prox_parse_args(int argc, char **argv)
+{
+	int i, opt, ret;
+	char *tmp, *tmp2;
+	char tmp3[64];
+
+	/* Default settings */
+	prox_cfg.flags |= DSF_AUTOSTART | DSF_WAIT_ON_QUIT;
+	prox_cfg.ui = PROX_UI_CURSES;
+
+	plog_info("\tCommand line:");
+	for (i = 0; i < argc; ++i) {
+		plog_info(" %s", argv[i]);
+	}
+	plog_info("\n");
+
+	while ((opt = getopt(argc, argv, "f:dnzpo:tkuar:emsiw:l:v:q:")) != EOF) {
+		switch (opt) {
+		case 'f':
+			/* path to config file */
+			cfg_file = optarg;
+			size_t offset = 0;
+			for (size_t i = 0; i < strlen(cfg_file); ++i) {
+				if (cfg_file[i] == '/') {
+					offset = i + 1;
+				}
+			}
+
+			strncpy(prox_cfg.name, cfg_file + offset, MAX_NAME_SIZE);
+			break;
+		case 'v':
+			plog_set_lvl(atoi(optarg));
+			break;
+		case 'l':
+			prox_cfg.log_name_pid = 0;
+			strncpy(prox_cfg.log_name, optarg, MAX_NAME_SIZE);
+			break;
+		case 'p':
+			prox_cfg.log_name_pid = 1;
+			break;
+		case 'k':
+			prox_cfg.use_stats_logger = 1;
+			break;
+		case 'd':
+			prox_cfg.flags |= DSF_DAEMON;
+			prox_cfg.ui = PROX_UI_NONE;
+			break;
+                case 'z':
+                        prox_cfg.flags |= DSF_USE_DUMMY_CPU_TOPO;
+			prox_cfg.flags |= DSF_CHECK_INIT;
+                        break;
+		case 'n':
+			prox_cfg.flags |= DSF_USE_DUMMY_DEVICES;
+			break;
+		case 'r':
+			if (!str_is_number(optarg) || strlen(optarg) > 11)
+				return -1;
+			strncpy(prox_cfg.update_interval_str, optarg, sizeof(prox_cfg.update_interval_str));
+			break;
+		case 'o':
+			if (prox_cfg.flags & DSF_DAEMON)
+				break;
+
+			if (!strcmp(optarg, "curses")) {
+				prox_cfg.ui = PROX_UI_CURSES;
+			}
+			else if (!strcmp(optarg, "cli")) {
+				prox_cfg.ui = PROX_UI_CLI;
+			}
+			else if (!strcmp(optarg, "none")) {
+				prox_cfg.ui = PROX_UI_NONE;
+			}
+			else {
+				plog_err("Invalid local UI '%s', local UI can be 'curses', 'cli' or 'none'.", optarg);
+				return -1;
+			}
+			break;
+		case 'q':
+			if (luaL_loadstring(prox_lua(), optarg)) {
+				set_errf("Lua error: '%s'\n", lua_tostring(prox_lua(), -1));
+				return -1;
+			}
+
+			if (lua_pcall(prox_lua(), 0, LUA_MULTRET, 0)) {
+				set_errf("Lua error: '%s'\n", lua_tostring(prox_lua(), -1));
+				return -1;
+			}
+
+			break;
+		case 'a':
+			/* autostart all cores */
+			prox_cfg.flags |= DSF_AUTOSTART;
+			break;
+		case 'e':
+			/* don't autostart */
+			prox_cfg.flags &= ~DSF_AUTOSTART;
+			break;
+		case 't':
+			prox_cfg.flags |= DSF_LISTEN_TCP;
+			break;
+		case 'u':
+			prox_cfg.flags |= DSF_LISTEN_UDS;
+			break;
+		case 'm':
+			/* list supported task modes and exit */
+			prox_cfg.flags |= DSF_LIST_TASK_MODES;
+			break;
+		case 's':
+			/* check configuration file syntax and exit */
+			prox_cfg.flags |= DSF_CHECK_SYNTAX;
+			break;
+		case 'i':
+			/* check initialization sequence and exit */
+			prox_cfg.flags |= DSF_CHECK_INIT;
+			break;
+		case 'w':
+			tmp = optarg;
+			tmp2 = 0;
+			if (strlen(tmp) >= 3 &&
+			    (tmp2 = strchr(tmp, '='))) {
+				*tmp2 = 0;
+				tmp3[0] = '$';
+				strncpy(tmp3 + 1, tmp, 63);
+				plog_info("\tAdding variable: %s = %s\n", tmp3, tmp2 + 1);
+				ret = add_var(tmp3, tmp2 + 1, 1);
+				if (ret == -2) {
+					plog_err("\tFailed to add variable, too many variables defines\n");
+					return -1;
+				}
+				else if(ret == -3) {
+					plog_err("\tFailed to add variable, already defined\n");
+					return -1;
+				}
+				break;
+			}
+			/* fall-through */
+		default:
+			plog_err("\tUnknown option\n");
+			return -1;
+		}
+	}
+
+	/* reset getopt lib for DPDK */
+	optind = 0;
+
+	return 0;
+}
+
+static int check_cfg(void)
+{
+	/* Sanity check */
+#define RETURN_IF(cond, err)			\
+	if (cond) {				\
+		plog_err(err);			\
+		return -1;			\
+	};
+
+	RETURN_IF(rte_cfg.force_nchannel == 0, "\tError: number of memory channels not specified in [eal options] section\n");
+	RETURN_IF(prox_cfg.master >= RTE_MAX_LCORE, "\tError: No master core specified (one core needs to have mode=master)\n");
+
+#undef RETURN_IF
+
+	return 0;
+}
+
+static int calc_tot_rxrings(void)
+{
+	struct lcore_cfg *slconf, *dlconf;
+	struct task_args *starg, *dtarg;
+	uint32_t dlcore_id;
+	uint8_t dtask_id;
+	struct core_task ct;
+
+	dlconf = NULL;
+	while (core_targ_next_early(&dlconf, &dtarg, 1) == 0) {
+		dtarg->tot_rxrings = 0;
+	}
+
+	slconf = NULL;
+	while (core_targ_next_early(&slconf, &starg, 1) == 0) {
+		for (uint8_t idx = 0; idx < MAX_PROTOCOLS; ++idx) {
+			for (uint8_t ring_idx = 0; ring_idx < starg->core_task_set[idx].n_elems; ++ring_idx) {
+				ct = starg->core_task_set[idx].core_task[ring_idx];
+				if (!prox_core_active(ct.core, 0)) {
+					set_errf("Core %u is disabled but Core %u task %u is sending to it\n",
+						 ct.core, slconf->id, starg->id);
+					return -1;
+				}
+
+				dlconf = &lcore_cfg_init[ct.core];
+
+				if (ct.task >= dlconf->n_tasks_all) {
+					set_errf("Core %u task %u not enabled\n", ct.core, ct.task);
+					return -1;
+				}
+
+				dtarg = &dlconf->targs[ct.task];
+
+				/* Control rings are not relevant at this point. */
+				if (ct.type)
+					continue;
+
+				if (!(dtarg->flags & TASK_ARG_RX_RING)) {
+					set_errf("Core %u task %u is not expecting to receive through a ring\n",
+						 ct.core, ct.task);
+					return -1;
+				}
+
+				dtarg->tot_rxrings++;
+				if (dtarg->tot_rxrings > MAX_RINGS_PER_TASK) {
+					set_errf("Core %u task %u is receiving from too many tasks",
+						 ct.core, ct.task);
+					return -1;
+				}
+			}
+		}
+	}
+
+	return 0;
+}
+
+static void prox_set_core_mask(void)
+{
+	struct lcore_cfg *lconf;
+
+	prox_core_clr();
+	for (uint8_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
+		lconf = &lcore_cfg_init[lcore_id];
+		if (lconf->n_tasks_all > 0 && lconf->targs[0].mode != MASTER) {
+			prox_core_set_active(lcore_id);
+		}
+	}
+}
+
+static int is_using_no_drop(void)
+{
+	uint32_t lcore_id;
+	struct lcore_cfg *lconf;
+	struct task_args *targs;
+
+	lcore_id = -1;
+	while(prox_core_next(&lcore_id, 1) == 0) {
+		lconf = &lcore_cfg_init[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			targs = &lconf->targs[task_id];
+			if (!(targs->flags & TASK_ARG_DROP))
+				return 1;
+		}
+	}
+	return 0;
+}
+
+int prox_read_config_file(void)
+{
+	set_global_defaults(&prox_cfg);
+	set_task_defaults(&prox_cfg, lcore_cfg_init);
+	set_port_defaults();
+	plog_info("=== Parsing configuration file '%s' ===\n", cfg_file);
+	struct cfg_file *pcfg = cfg_open(cfg_file);
+	if (pcfg == NULL) {
+		return -1;
+	}
+
+	struct cfg_section* config_sections[] = {
+		&lua_cfg          ,
+		&var_cfg          ,
+		&eal_default_cfg  ,
+		&cache_set_cfg    ,
+		&port_cfg         ,
+		&defaults_cfg     ,
+		&settings_cfg     ,
+		&core_cfg         ,
+		NULL
+	};
+
+	for (struct cfg_section** section = config_sections; *section != NULL; ++section) {
+		const char* name = (*section)->name;
+		size_t len = strlen(name);
+		plog_info("\t*** Reading [%s] section%s ***\n", name, name[len - 1] == '#'? "s": "");
+		cfg_parse(pcfg, *section);
+
+		if ((*section)->error) {
+			plog_err("At line %u, section [%s], entry %u: '%s'\n\t%s\n"
+				 , pcfg->err_line, pcfg->err_section, pcfg->err_entry + 1, pcfg->cur_line,
+				 strlen(get_parse_err())? get_parse_err() : err_str);
+			cfg_close(pcfg); /* cannot close before printing error, print uses internal buffer */
+			return -1;
+		}
+	}
+
+	cfg_close(pcfg);
+
+	prox_set_core_mask();
+
+	if (is_using_no_drop()) {
+		prox_cfg.flags &= ~DSF_WAIT_ON_QUIT;
+	}
+
+	if (calc_tot_rxrings()) {
+		plog_err("Error in configuration: %s\n", err_str);
+		return -1;
+	}
+
+	return check_cfg();
+}
+
+static void failed_rte_eal_init(__attribute__((unused))const char *prog_name)
+{
+	plog_err("\tError in rte_eal_init()\n");
+}
+
+int prox_setup_rte(const char *prog_name)
+{
+	char *rte_argv[MAX_RTE_ARGV];
+	char  rte_arg[MAX_RTE_ARGV][MAX_ARG_LEN];
+	char tmp[PROX_CM_STR_LEN];
+	/* create mask of used cores */
+	plog_info("=== Setting up RTE EAL ===\n");
+
+	if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO) {
+		plog_info("Using dummy cpu topology\n");
+		snprintf(tmp, sizeof(tmp), "0x1");
+	} else {
+		prox_core_to_hex(tmp, sizeof(tmp), 0);
+		plog_info("\tWorker threads core mask is %s\n", tmp);
+		prox_core_to_hex(tmp, sizeof(tmp), 1);
+		plog_info("\tWith master core index %u, full core mask is %s\n", prox_cfg.master, tmp);
+	}
+
+	/* fake command line parameters for rte_eal_init() */
+	int argc = 0;
+	rte_argv[argc] = strdup(prog_name);
+	sprintf(rte_arg[++argc], "-c%s", tmp);
+	rte_argv[argc] = rte_arg[argc];
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+	if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO)
+		sprintf(rte_arg[++argc], "--master-lcore=%u", 0);
+	else
+		sprintf(rte_arg[++argc], "--master-lcore=%u", prox_cfg.master);
+	rte_argv[argc] = rte_arg[argc];
+#else
+	/* For old DPDK versions, the master core had to be the first
+	   core. */
+	uint32_t first_core = -1;
+
+	if (prox_core_next(&first_core, 1) == -1) {
+		plog_err("Can't core ID of first core in use\n");
+		return -1;
+	}
+	if (first_core != prox_cfg.master) {
+		plog_err("The master core needs to be the first core (master core = %u, first core = %u).\n", first_core, prox_cfg.master);
+		return -1;
+	}
+#endif
+
+	if (rte_cfg.memory) {
+		sprintf(rte_arg[++argc], "-m%u", rte_cfg.memory);
+		rte_argv[argc] = rte_arg[argc];
+	}
+
+	if (rte_cfg.force_nchannel) {
+		sprintf(rte_arg[++argc], "-n%u", rte_cfg.force_nchannel);
+		rte_argv[argc] = rte_arg[argc];
+	}
+
+	if (rte_cfg.force_nrank) {
+		sprintf(rte_arg[++argc], "-r%u", rte_cfg.force_nrank);
+		rte_argv[argc] = rte_arg[argc];
+	}
+
+	if (rte_cfg.no_hugetlbfs) {
+		strcpy(rte_arg[++argc], "--no-huge");
+		rte_argv[argc] = rte_arg[argc];
+	}
+
+	if (rte_cfg.no_pci) {
+		strcpy(rte_arg[++argc], "--no-pci");
+		rte_argv[argc] = rte_arg[argc];
+	}
+
+	if (rte_cfg.no_hpet) {
+		strcpy(rte_arg[++argc], "--no-hpet");
+		rte_argv[argc] = rte_arg[argc];
+	}
+
+	if (rte_cfg.no_shconf) {
+		strcpy(rte_arg[++argc], "--no-shconf");
+		rte_argv[argc] = rte_arg[argc];
+	}
+
+	if (rte_cfg.eal != NULL) {
+		char *ptr = rte_cfg.eal;
+		char *ptr2;
+		while (ptr != NULL) {
+			while (isspace(*ptr))
+				ptr++;
+			ptr2 = ptr;
+			ptr = strchr(ptr, ' ');
+			if (ptr) {
+				*ptr++ = '\0';
+			}
+			strcpy(rte_arg[++argc], ptr2);
+			rte_argv[argc] = rte_arg[argc];
+		}
+	}
+
+	if (rte_cfg.hugedir != NULL) {
+		strcpy(rte_arg[++argc], "--huge-dir");
+		rte_argv[argc] = rte_arg[argc];
+		rte_argv[++argc] = rte_cfg.hugedir;
+	}
+
+	if (rte_cfg.no_output) {
+		rte_set_log_level(0);
+	}
+	/* init EAL */
+	plog_info("\tEAL command line:");
+	if (argc >= MAX_RTE_ARGV) {
+		plog_err("too many arguments for EAL\n");
+		return -1;
+	}
+
+	for (int h = 0; h <= argc; ++h) {
+		plog_info(" %s", rte_argv[h]);
+	}
+	plog_info("\n");
+
+	rte_set_application_usage_hook(failed_rte_eal_init);
+	if (rte_eal_init(++argc, rte_argv) < 0) {
+		plog_err("\tError in rte_eal_init()\n");
+		return -1;
+	}
+	plog_info("\tEAL Initialized\n");
+
+	if (prox_cfg.flags & DSF_USE_DUMMY_CPU_TOPO)
+		return 0;
+
+	/* check if all active cores are in enabled in DPDK */
+	for (uint32_t lcore_id = 0; lcore_id < RTE_MAX_LCORE; ++lcore_id) {
+		if (lcore_id == prox_cfg.master) {
+			if (!rte_lcore_is_enabled(lcore_id))
+				return -1;
+		}
+		else if (rte_lcore_is_enabled(lcore_id) != prox_core_active(lcore_id, 0)) {
+			plog_err("\tFailed to enable lcore %u\n", lcore_id);
+			return -1;
+		}
+		else if (lcore_cfg_init[lcore_id].n_tasks_all != 0 && !rte_lcore_is_enabled(lcore_id)) {
+			plog_err("\tFailed to enable lcore %u\n", lcore_id);
+			return -1;
+		}
+	}
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/prox_args.h b/VNFs/DPPD-PROX/prox_args.h
new file mode 100644
index 00000000..1c900054
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_args.h
@@ -0,0 +1,41 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROX_ARGS_H_
+#define _PROX_ARGS_H_
+
+#include "lconf.h"
+
+struct rte_cfg {
+	/* DPDK standard options */
+	uint32_t memory;	 /* amount of asked memory */
+	uint32_t force_nchannel; /* force number of channels */
+	uint32_t force_nrank;	 /* force number of ranks */
+	uint32_t no_hugetlbfs;	 /* true to disable hugetlbfs */
+	uint32_t no_pci;	 /* true to disable PCI */
+	uint32_t no_hpet;	 /* true to disable HPET */
+	uint32_t no_shconf;	 /* true if there is no shared config */
+	char    *hugedir;	 /* dir where hugetlbfs is mounted */
+	char    *eal;            /* any additional eal option */
+	uint32_t no_output;	 /* disable EAL debug output */
+};
+
+int prox_parse_args(int argc, char **argv);
+int prox_read_config_file(void);
+int prox_setup_rte(const char *prog_name);
+const char *get_cfg_dir(void);
+
+#endif /* _PROX_ARGS_H_ */
diff --git a/VNFs/DPPD-PROX/prox_assert.h b/VNFs/DPPD-PROX/prox_assert.h
new file mode 100644
index 00000000..cc4f24e6
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_assert.h
@@ -0,0 +1,39 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROX_ASSERT_H_
+#define _PROX_ASSERT_H_
+
+#include <assert.h>
+#include "display.h"
+
+#if defined(__KLOCWORK__) || defined(ASSERT)
+
+#ifdef NDEBUG
+#error When enabling asserts, NDEBUG must be undefined
+#endif
+
+#define PROX_ASSERT(cond) do {			\
+		if (!(cond)) {			\
+			display_end();		\
+			assert(cond);		\
+		}				\
+	} while (0)
+#else
+#define PROX_ASSERT(cond) do {} while(0)
+#endif
+
+#endif /* _PROX_ASSERT_H_ */
diff --git a/VNFs/DPPD-PROX/prox_cfg.c b/VNFs/DPPD-PROX/prox_cfg.c
new file mode 100644
index 00000000..a2cf7953
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_cfg.c
@@ -0,0 +1,145 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+
+#include "prox_cfg.h"
+
+#define CM_N_BITS (sizeof(prox_cfg.core_mask[0]) * 8)
+#define CM_ALL_N_BITS (sizeof(prox_cfg.core_mask) * 8)
+
+struct prox_cfg prox_cfg = {
+	.update_interval_str = "1"
+};
+
+static int prox_cm_isset(const uint32_t lcore_id)
+{
+	uint64_t cm;
+	uint32_t cm_idx;
+
+	if (lcore_id > CM_ALL_N_BITS)
+		return -1;
+
+	cm = __UINT64_C(1) << (lcore_id % CM_N_BITS);
+	cm_idx = PROX_CM_DIM - 1 - lcore_id / CM_N_BITS;
+	return !!(prox_cfg.core_mask[cm_idx] & cm);
+}
+
+int prox_core_active(const uint32_t lcore_id, const int with_master)
+{
+	int ret;
+
+	ret = prox_cm_isset(lcore_id);
+	if (ret < 0)
+		return 0;
+
+	if (with_master)
+		return ret || lcore_id == prox_cfg.master;
+	else
+		return ret && lcore_id != prox_cfg.master;
+}
+
+int prox_core_next(uint32_t* lcore_id, const int with_master)
+{
+	for (uint32_t i = *lcore_id + 1; i < CM_ALL_N_BITS; ++i) {
+		if (prox_core_active(i, with_master)) {
+			*lcore_id = i;
+			return 0;
+		}
+	}
+	return -1;
+}
+
+int prox_core_to_hex(char *dst, const size_t size, const int with_master)
+{
+	uint64_t cm;
+	uint32_t cm_len;
+	uint32_t cm_first = 0;
+	uint32_t master = prox_cfg.master;
+
+	/* Minimum size of the string has to big enough to hold the
+	   bitmask in hex (including the prefix "0x"). */
+	if (size < PROX_CM_STR_LEN)
+		return 0;
+
+	snprintf(dst, size, "0x");
+	for (uint32_t i = 0; i < PROX_CM_DIM; ++i, cm_first = i) {
+		if ((with_master && ((CM_ALL_N_BITS - 1 - master) / CM_N_BITS == i * CM_N_BITS)) ||
+		    prox_cfg.core_mask[i]) {
+			break;
+		}
+	}
+
+	for (uint32_t i = cm_first; i < PROX_CM_DIM; ++i) {
+		cm = prox_cfg.core_mask[i];
+		if (with_master && ((CM_ALL_N_BITS - 1 - master) / CM_N_BITS == i)) {
+			cm |= (__UINT64_C(1) << (master % CM_N_BITS));
+		}
+
+		snprintf(dst + strlen(dst), size - strlen(dst), i == cm_first? "%lx" : "%016lx", cm);
+	}
+
+	return 0;
+}
+
+int prox_core_to_str(char *dst, const size_t size, const int with_master)
+{
+	uint32_t lcore_id = -1;
+	uint32_t first = 1;
+
+	*dst = 0;
+	lcore_id - 1;
+	while (prox_core_next(&lcore_id, with_master) == 0) {
+		/* Stop printing to string if there is not engough
+		   space left. Assume that adding 1 core to the string
+		   will take at most 5 + 1 bytes implying that
+		   lcore_id < 999. Check if ther is space for another
+		   6 bytes to add an elipsis */
+		if (12 + strlen(dst) > size) {
+			if (6 + strlen(dst) > size) {
+				snprintf(dst + strlen(dst), size - strlen(dst), ", ...");
+				return 0;
+			}
+			return -1;
+		}
+
+		snprintf(dst + strlen(dst), size - strlen(dst), first? "%u" : ", %u", lcore_id);
+		first = 0;
+	}
+
+	return 0;
+}
+
+void prox_core_clr(void)
+{
+	memset(prox_cfg.core_mask, 0, sizeof(prox_cfg.core_mask));
+}
+
+int prox_core_set_active(const uint32_t lcore_id)
+{
+	uint32_t cm_idx;
+	uint64_t cm;
+
+	if (lcore_id > CM_ALL_N_BITS)
+		return -1;
+
+	cm = __UINT64_C(1) << (lcore_id % CM_N_BITS);
+	cm_idx = PROX_CM_DIM - 1 - lcore_id / CM_N_BITS;
+	prox_cfg.core_mask[cm_idx] |= cm;
+
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/prox_cfg.h b/VNFs/DPPD-PROX/prox_cfg.h
new file mode 100644
index 00000000..a7d0e7ea
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_cfg.h
@@ -0,0 +1,87 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROX_CFG_H
+#define _PROX_CFG_H
+
+#include <inttypes.h>
+
+#include "prox_globals.h"
+
+#define PROX_CM_STR_LEN (2 + 2 * sizeof(prox_cfg.core_mask) + 1)
+#define PROX_CM_DIM     (RTE_MAX_LCORE/(sizeof(uint64_t) * 8))
+
+#define DSF_AUTOSTART             0x00000001      /* start all cores automatically */
+#define DSF_CHECK_INIT            0x00000002      /* check initialization sequence and exit */
+#define DSF_CHECK_SYNTAX          0x00000004      /* check configuration file syntax and exit */
+#define DSF_SHUFFLE               0x00000008      /* shuffle memory addresses within memory pool */
+#define DSF_WAIT_ON_QUIT          0x00000010      /* wait for all cores to stop before exiting */
+#define DSF_LISTEN_TCP            0x00000020      /* Listen on TCP port 8474 for input */
+#define DSF_LISTEN_UDS            0x00000040      /* Listen on /tmp/prox.sock for input */
+#define DSF_DAEMON                0x00000080      /* Run process as Daemon */
+#define UNIQUE_MEMPOOL_PER_SOCKET 0x00000100      /* Use Only one mempool per socket, shared between all cores on that socket */
+#define DSF_KEEP_SRC_MAC          0x00000200      /* In gen mode, do not overwrite src_mac by mac of physical port */
+#define DSF_MP_RINGS              0x00000400      /* Use Multi Producer rings when possible */
+#define DSF_USE_DUMMY_DEVICES     0x00000800      /* Instead of relying on real PCI devices, create null devices instead */
+#define DSF_USE_DUMMY_CPU_TOPO    0x00001000      /* Instead of relying on the cpu topology, load a cpu toplogy that will work with all cfgs. */
+#define DSF_DISABLE_CMT           0x00002000      /* CMT disabled */
+#define DSF_LIST_TASK_MODES       0x00004000      /* list supported task modes and exit */
+#define DSF_ENABLE_BYPASS         0x00008000      /* Use Multi Producer rings to enable ring bypass */
+
+#define MAX_PATH_LEN 1024
+
+enum prox_ui {
+	PROX_UI_CURSES,
+	PROX_UI_CLI,
+	PROX_UI_NONE,
+};
+
+struct prox_cfg {
+	enum prox_ui    ui;             /* By default, curses is used as a UI. */
+	char            update_interval_str[16];
+	int             use_stats_logger;
+	uint32_t	flags;		/* TGSF_* flags above */
+	uint32_t	master;		/* master core to run user interface on */
+	uint64_t        core_mask[PROX_CM_DIM]; /* Active cores without master core */
+	uint32_t	start_time;	/* if set (not 0), average pps will be calculated starting after start_time seconds */
+	uint32_t	duration_time;      /* if set (not 0), prox will exit duration_time seconds after start_time */
+	char            name[MAX_NAME_SIZE];
+	uint8_t         log_name_pid;
+	char            log_name[MAX_PATH_LEN];
+	int32_t         cpe_table_ports[PROX_MAX_PORTS];
+	uint32_t	logbuf_size;
+	uint32_t	logbuf_pos;
+	char		*logbuf;
+};
+
+extern struct prox_cfg prox_cfg;
+
+int prox_core_active(const uint32_t lcore_id, const int with_master);
+
+/* Returns non-zero if supplied lcore_id is the last active core. The
+   first core can be found by setting *lcore_id == -1. The function is
+   indented to be used as an interator. */
+int prox_core_next(uint32_t *lcore_id, const int with_master);
+
+int prox_core_to_hex(char *dst, const size_t size, const int with_master);
+
+int prox_core_to_str(char *dst, const size_t size, const int with_master);
+
+void prox_core_clr(void);
+
+int prox_core_set_active(const uint32_t lcore_id);
+
+#endif /* __PROX_CFG_H_ */
diff --git a/VNFs/DPPD-PROX/prox_cksum.c b/VNFs/DPPD-PROX/prox_cksum.c
new file mode 100644
index 00000000..b69c06f6
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_cksum.c
@@ -0,0 +1,148 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "prox_cksum.h"
+#include "prox_port_cfg.h"
+#include <rte_byteorder.h>
+#include "log.h"
+
+/* compute IP 16 bit checksum */
+void prox_ip_cksum_sw(struct ipv4_hdr *buf)
+{
+	const uint16_t size = sizeof(struct ipv4_hdr);
+	uint32_t cksum = 0;
+	uint32_t nb_dwords;
+	uint32_t tail, mask;
+	uint32_t *pdwd = (uint32_t *)buf;
+
+	/* compute 16 bit checksum using hi and low parts of 32 bit integers */
+	for (nb_dwords = (size >> 2); nb_dwords > 0; --nb_dwords) {
+		cksum += (*pdwd >> 16);
+		cksum += (*pdwd & 0xFFFF);
+		++pdwd;
+	}
+
+	/* deal with the odd byte length */
+	if (size & 0x03) {
+		tail = *pdwd;
+		/* calculate mask for valid parts */
+		mask = 0xFFFFFFFF << ((size & 0x03) << 3);
+		/* clear unused bits */
+		tail &= ~mask;
+
+		cksum += (tail >> 16) + (tail & 0xFFFF);
+	}
+
+	cksum = (cksum >> 16) + (cksum & 0xFFFF);
+	cksum = (cksum >> 16) + (cksum & 0xFFFF);
+
+	buf->hdr_checksum = ~((uint16_t)cksum);
+}
+
+static uint16_t calc_pseudo_checksum(uint8_t ipproto, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
+{
+	uint32_t csum = 0;
+
+	csum += (src_ip_addr >> 16) + (src_ip_addr & 0xFFFF);
+	csum += (dst_ip_addr >> 16) + (dst_ip_addr & 0xFFFF);
+	csum += rte_bswap16(ipproto) + rte_bswap16(len);
+	csum = (csum >> 16) + (csum & 0xFFFF);
+	return csum;
+}
+
+static void prox_write_udp_pseudo_hdr(struct udp_hdr *udp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
+{
+	/* Note that the csum is not complemented, while the pseaudo
+	   header checksum is calculated as "... the 16-bit one's
+	   complement of the one's complement sum of a pseudo header
+	   of information ...", the psuedoheader forms as a basis for
+	   the actual checksum calculated later either in software or
+	   hardware. */
+	udp->dgram_cksum = calc_pseudo_checksum(IPPROTO_UDP, len, src_ip_addr, dst_ip_addr);
+}
+
+static void prox_write_tcp_pseudo_hdr(struct tcp_hdr *tcp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
+{
+	tcp->cksum = calc_pseudo_checksum(IPPROTO_TCP, len, src_ip_addr, dst_ip_addr);
+}
+
+void prox_ip_udp_cksum(struct rte_mbuf *mbuf, struct ipv4_hdr *pip, uint16_t l2_len, uint16_t l3_len, int cksum_offload)
+{
+	prox_ip_cksum(mbuf, pip, l2_len, l3_len, cksum_offload & IPV4_CKSUM);
+
+#ifndef SOFT_CRC
+	if (cksum_offload & UDP_CKSUM)
+		mbuf->ol_flags |= PKT_TX_UDP_CKSUM;
+#endif
+
+	uint32_t l4_len = rte_bswap16(pip->total_length) - l3_len;
+	if (pip->next_proto_id == IPPROTO_UDP) {
+		struct udp_hdr *udp = (struct udp_hdr *)(((uint8_t*)pip) + l3_len);
+#ifndef SOFT_CRC
+		if (cksum_offload & UDP_CKSUM)
+			prox_write_udp_pseudo_hdr(udp, l4_len, pip->src_addr, pip->dst_addr);
+		else
+#endif
+		prox_udp_cksum_sw(udp, l4_len, pip->src_addr, pip->dst_addr);
+	} else if (pip->next_proto_id == IPPROTO_TCP) {
+		struct tcp_hdr *tcp = (struct tcp_hdr *)(((uint8_t*)pip) + l3_len);
+#ifndef SOFT_CRC
+		if (cksum_offload & UDP_CKSUM)
+			prox_write_tcp_pseudo_hdr(tcp, l4_len, pip->src_addr, pip->dst_addr);
+		else
+#endif
+		prox_tcp_cksum_sw(tcp, l4_len, pip->src_addr, pip->dst_addr);
+	}
+}
+
+static uint16_t checksum_byte_seq(uint16_t *buf, uint16_t len)
+{
+	uint32_t csum = 0;
+
+	while (len > 1) {
+		csum += *buf;
+		while (csum >> 16) {
+			csum &= 0xffff;
+			csum +=1;
+		}
+		buf++;
+		len -= 2;
+	}
+
+	if (len) {
+		csum += *(uint8_t*)buf;
+		while (csum >> 16) {
+			csum &= 0xffff;
+			csum +=1;
+		}
+	}
+	return ~csum;
+}
+
+void prox_udp_cksum_sw(struct udp_hdr *udp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
+{
+	prox_write_udp_pseudo_hdr(udp, len, src_ip_addr, dst_ip_addr);
+	uint16_t csum = checksum_byte_seq((uint16_t *)udp, len);
+	udp->dgram_cksum = csum;
+}
+
+void prox_tcp_cksum_sw(struct tcp_hdr *tcp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
+{
+	prox_write_tcp_pseudo_hdr(tcp, len, src_ip_addr, dst_ip_addr);
+
+	uint16_t csum = checksum_byte_seq((uint16_t *)tcp, len);
+	tcp->cksum = csum;
+}
diff --git a/VNFs/DPPD-PROX/prox_cksum.h b/VNFs/DPPD-PROX/prox_cksum.h
new file mode 100644
index 00000000..c11b17a5
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_cksum.h
@@ -0,0 +1,68 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROX_CKSUM_H_
+#define _PROX_CKSUM_H_
+
+#include <inttypes.h>
+#include <string.h>
+#include <stdio.h>
+#include <rte_version.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+#include <rte_tcp.h>
+#include <rte_mbuf.h>
+
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+#define CALC_TX_OL(l2_len, l3_len) ((uint64_t)(l2_len) | (uint64_t)(l3_len) << 7)
+#else
+#define CALC_TX_OL(l2_len, l3_len) (((uint64_t)(l2_len) << 9) | (uint64_t)(l3_len))
+#endif
+
+static void prox_ip_cksum_hw(struct rte_mbuf *mbuf, uint16_t l2_len, uint16_t l3_len)
+{
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+	mbuf->pkt.vlan_macip.data = CALC_TX_OL(l2_len, l3_len);
+#else
+	mbuf->tx_offload = CALC_TX_OL(l2_len, l3_len);
+#endif
+	mbuf->ol_flags |= PKT_TX_IP_CKSUM;
+}
+
+void prox_ip_cksum_sw(struct ipv4_hdr *buf);
+
+static inline void prox_ip_cksum(struct rte_mbuf *mbuf, struct ipv4_hdr *buf, uint16_t l2_len, uint16_t l3_len, int offload)
+{
+	buf->hdr_checksum = 0;
+#ifdef SOFT_CRC
+	prox_ip_cksum_sw(buf);
+#else
+	if (offload)
+		prox_ip_cksum_hw(mbuf, l2_len, l3_len);
+	else {
+		prox_ip_cksum_sw(buf);
+		/* TODO: calculate UDP checksum */
+	}
+#endif
+}
+
+void prox_ip_udp_cksum(struct rte_mbuf *mbuf, struct ipv4_hdr *buf, uint16_t l2_len, uint16_t l3_len, int cksum_offload);
+
+/* src_ip_addr/dst_ip_addr are in network byte order */
+void prox_udp_cksum_sw(struct udp_hdr *udp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr);
+void prox_tcp_cksum_sw(struct tcp_hdr *tcp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr);
+
+#endif /* _PROX_CKSUM_H_ */
diff --git a/VNFs/DPPD-PROX/prox_globals.h b/VNFs/DPPD-PROX/prox_globals.h
new file mode 100644
index 00000000..b09f3a52
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_globals.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#define PROX_MAX_PORTS          16
+#define MAX_TASKS_PER_CORE      8
+#define MAX_SOCKETS             64
+#define MAX_NAME_SIZE           64
+#define MAX_PROTOCOLS           3
+#define MAX_RINGS_PER_TASK      (MAX_WT_PER_LB*MAX_PROTOCOLS)
+#define MAX_WT_PER_LB           64
diff --git a/VNFs/DPPD-PROX/prox_lua.c b/VNFs/DPPD-PROX/prox_lua.c
new file mode 100644
index 00000000..b5c2fec9
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_lua.c
@@ -0,0 +1,411 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "prox_lua.h"
+#include "lua_compat.h"
+#include "parse_utils.h"
+
+static struct lua_State *lua_instance;
+
+static int l_mask(lua_State *L)
+{
+	uint32_t val, mask;
+
+	if (lua_gettop(L) != 2) {
+		return luaL_error(L, "Expecting 2 argument and got %d\n", lua_gettop(L));
+	}
+	if (!lua_isnumber(L, -1) || !lua_isnumber(L, -2)) {
+		return luaL_error(L, "Expecting (integer, integer) as arguments\n");
+	}
+	val = lua_tonumber(L, -1);
+	mask = lua_tonumber(L, -2);
+
+	lua_pushinteger(L, val & mask);
+
+	return 1;
+}
+
+static int l_server_content(lua_State *L)
+{
+	uint32_t beg, len;
+
+	if (lua_gettop(L) != 2) {
+		return luaL_error(L, "Expecting 2 argument and got %d\n", lua_gettop(L));
+	}
+	if (!lua_isnumber(L, -1) || !lua_isnumber(L, -2)) {
+		return luaL_error(L, "Expecting (integer, integer) as arguments\n");
+	}
+	len = lua_tonumber(L, -1);
+	beg = lua_tonumber(L, -2);
+
+	lua_createtable(L, 0, 3);
+
+	lua_pushinteger(L, beg);
+	lua_setfield(L, -2, "beg");
+	lua_pushinteger(L, len);
+	lua_setfield(L, -2, "len");
+	lua_pushinteger(L, 0);
+	lua_setfield(L, -2, "peer");
+
+	return 1;
+}
+
+static int l_client_content(lua_State *L)
+{
+	uint32_t beg, len;
+
+	if (lua_gettop(L) != 2) {
+		return luaL_error(L, "Expecting 2 argument and got %d\n", lua_gettop(L));
+	}
+	if (!lua_isnumber(L, -1) || !lua_isnumber(L, -2)) {
+		return luaL_error(L, "Expecting (integer, integer) as arguments\n");
+	}
+	len = lua_tonumber(L, -1);
+	beg = lua_tonumber(L, -2);
+
+	lua_createtable(L, 0, 3);
+
+	lua_pushinteger(L, beg);
+	lua_setfield(L, -2, "beg");
+	lua_pushinteger(L, len);
+	lua_setfield(L, -2, "len");
+	lua_pushinteger(L, 1);
+	lua_setfield(L, -2, "peer");
+
+	return 1;
+}
+
+static int l_bin_read(lua_State *L)
+{
+	const char *file_name = lua_tostring(L, -1);
+	int beg = lua_tonumber(L, -2);
+	int len = lua_gettop(L) == 3? lua_tonumber(L, -3) : -1;
+
+	if (lua_gettop(L) == 2) {
+		if (!lua_isnumber(L, -1) || !lua_isstring(L, -2)) {
+			return luaL_error(L, "Expecting (string, integer) as arguments\n");
+		}
+
+		file_name = lua_tostring(L, -2);
+		beg = lua_tonumber(L, -1);
+		len = -1;
+	}
+	else if (lua_gettop(L) == 3) {
+		if (!lua_isnumber(L, -1) || !lua_isnumber(L, -2) || !lua_isstring(L, 3)) {
+			return luaL_error(L, "Expecting (string, integer, integer) as arguments\n");
+		}
+
+		file_name = lua_tostring(L, -3);
+		beg = lua_tonumber(L, -2);
+		len = lua_tonumber(L, -1);
+	}
+	else
+		return luaL_error(L, "Expecting 2 or 3 arguments\n");
+
+	lua_createtable(L, 0, 3);
+
+	lua_pushstring(L, file_name);
+	lua_setfield(L, -2, "file_name");
+	lua_pushinteger(L, beg);
+	lua_setfield(L, -2, "beg");
+	lua_pushinteger(L, len);
+	lua_setfield(L, -2, "len");
+
+	return 1;
+}
+
+static int l_mac(lua_State *L)
+{
+	int mac[6];
+
+	if (lua_isstring(L, -1)) {
+		const char *arg = lua_tostring(L, -1);
+		char arg2[128];
+		strncpy(arg2, arg, sizeof(arg2));
+
+		char *p = arg2;
+		int count = 0;
+
+		while ((p = strchr(p, ':'))) {
+			count++;
+			p++;
+		}
+		p = arg2;
+		if (count != 5)
+			return luaL_error(L, "Invalid MAC format\n");
+
+		lua_createtable(L, 6, 0);
+		for (size_t i = 0; i < 6; ++i) {
+			char *n = strchr(p, ':');
+			if (n)
+				*n = 0;
+			if (strlen(p) != 2) {
+				return luaL_error(L, "Invalid MAC format\n");
+			}
+
+			lua_pushinteger(L, strtol(p, NULL, 16));
+			lua_rawseti(L, -2, i + 1);
+			p = n + 1;
+		}
+		return 1;
+	}
+
+	return luaL_error(L, "Invalid argument\n");
+}
+
+static int l_ip(lua_State *L)
+{
+	int ip[4];
+	if (lua_isnumber(L, -1)) {
+		uint32_t arg = lua_tointeger(L, -1);
+
+		ip[0] = arg >> 24 & 0xff;
+		ip[1] = arg >> 16 & 0xff;
+		ip[2] = arg >>  8 & 0xff;
+		ip[3] = arg >>  0 & 0xff;
+
+		lua_createtable(L, 4, 0);
+		for (size_t i = 0; i < 4; ++i) {
+			lua_pushinteger(L, ip[i]);
+			lua_rawseti(L, -2, i + 1);
+		}
+
+		return 1;
+	}
+	if (lua_isstring(L, -1)) {
+		const char *arg = lua_tostring(L, -1);
+
+		if (sscanf(arg, "%d.%d.%d.%d", &ip[0], &ip[1], &ip[2], &ip[3]) != 4) {
+			return luaL_error(L, "Invalid IP address format\n");
+		}
+
+		lua_createtable(L, 4, 0);
+		for (size_t i = 0; i < 4; ++i) {
+			lua_pushinteger(L, ip[i]);
+			lua_rawseti(L, -2, i + 1);
+		}
+
+		return 1;
+	}
+
+	return luaL_error(L, "Invalid argument\n");
+}
+
+static int l_ip6(lua_State *L)
+{
+	int ip[16];
+
+	if (!lua_isstring(L, -1)) {
+		return luaL_error(L, "Invalid argument type\n");
+	}
+
+	const char *arg = lua_tostring(L, -1);
+	char arg2[64];
+	char *addr_parts[8];
+	int n_parts = 0;
+	size_t str_len = strlen(arg);
+	int next_str = 1;
+	int ret;
+
+	strncpy(arg2, arg, sizeof(arg2));
+
+	for (size_t i = 0; i < str_len; ++i) {
+		if (next_str) {
+			if (n_parts == 8)
+				return luaL_error(L, "IPv6 address can't be longer than 16 bytes\n");
+			addr_parts[n_parts++] = &arg2[i];
+			next_str = 0;
+
+		}
+		if (arg2[i] == ':') {
+			arg2[i] = 0;
+			next_str = 1;
+		}
+	}
+
+	int omitted = 0;
+
+	for (int i = 0, j = 0; i < n_parts; ++i) {
+		if (*addr_parts[i] == 0) {
+			if (omitted == 0) {
+				return luaL_error(L, "Can omit zeros only once\n");
+			}
+			omitted = 1;
+			j += 8 - n_parts;
+		}
+		else {
+			uint16_t w = strtoll(addr_parts[i], NULL, 16);
+			ip[j++] = (w >> 8) & 0xff;
+			ip[j++] = w & 0xff;
+		}
+	}
+
+	lua_createtable(L, 16, 0);
+	for (size_t i = 0; i < 16; ++i) {
+		lua_pushinteger(L, ip[i]);
+		lua_rawseti(L, -2, i + 1);
+	}
+
+	return 1;
+}
+
+static int l_cidr(lua_State *L)
+{
+	const char *arg = lua_tostring(L, -1);
+
+	char tmp[128];
+	strncpy(tmp, arg, sizeof(tmp));
+
+	char *slash = strchr(tmp, '/');
+	*slash = 0;
+	slash++;
+
+	lua_createtable(L, 0, 2);
+	lua_pushstring(L, "ip");
+
+	lua_pushstring(L, tmp);
+	l_ip(L);
+	lua_remove(L, -2);
+
+	lua_settable(L, -3);
+
+	lua_pushstring(L, "depth");
+	lua_pushinteger(L, atoi(slash));
+	lua_settable(L, -3);
+	return 1;
+}
+
+static int l_cidr6(lua_State *L)
+{
+	const char *arg = lua_tostring(L, -1);
+
+	char tmp[128];
+	strncpy(tmp, arg, sizeof(tmp));
+
+	char *slash = strchr(tmp, '/');
+	*slash = 0;
+	slash++;
+
+	lua_createtable(L, 0, 2);
+	lua_pushstring(L, "ip6");
+
+	lua_pushstring(L, tmp);
+	l_ip6(L);
+	lua_remove(L, -2);
+
+	lua_settable(L, -3);
+
+	lua_pushstring(L, "depth");
+	lua_pushinteger(L, atoi(slash));
+	lua_settable(L, -3);
+	return 1;
+}
+
+static int l_val_mask(lua_State *L)
+{
+	if (!lua_isinteger(L, -2))
+		return luaL_error(L, "Argument 1 is not an integer\n");
+	if (!lua_isinteger(L, -1))
+		return luaL_error(L, "Argument 2 is not an integer\n");
+
+	uint32_t val = lua_tointeger(L, -2);
+	uint32_t mask = lua_tointeger(L, -1);
+
+	lua_createtable(L, 0, 2);
+	lua_pushstring(L, "val");
+	lua_pushinteger(L, val);
+	lua_settable(L, -3);
+
+	lua_pushstring(L, "mask");
+	lua_pushinteger(L, mask);
+	lua_settable(L, -3);
+
+	return 1;
+}
+
+static int l_val_range(lua_State *L)
+{
+	if (!lua_isinteger(L, -2))
+		return luaL_error(L, "Argument 1 is not an integer\n");
+	if (!lua_isinteger(L, -1))
+		return luaL_error(L, "Argument 2 is not an integer\n");
+
+	uint32_t beg = lua_tointeger(L, -2);
+	uint32_t end = lua_tointeger(L, -1);
+
+	lua_createtable(L, 0, 2);
+	lua_pushstring(L, "beg");
+	lua_pushinteger(L, beg);
+	lua_settable(L, -3);
+
+	lua_pushstring(L, "end");
+	lua_pushinteger(L, end);
+	lua_settable(L, -3);
+
+	return 1;
+}
+
+static int l_task_count(lua_State *L)
+{
+	struct core_task_set cts;
+	const char *str;
+
+	if (!lua_isstring(L, -1))
+		return luaL_error(L, "Argument 1 is not an string\n");
+	str = lua_tostring(L, -1);
+	if (parse_task_set(&cts, str))
+		return luaL_error(L, "Invalid core task set syntax\n");
+	lua_pushinteger(L, cts.n_elems);
+	return 1;
+}
+
+struct lua_State *prox_lua(void)
+{
+	if (!lua_instance) {
+		lua_instance = luaL_newstate();
+
+		luaL_openlibs(lua_instance);
+
+		lua_pushcfunction(lua_instance, l_ip);
+		lua_setglobal(lua_instance, "ip");
+		lua_pushcfunction(lua_instance, l_ip6);
+		lua_setglobal(lua_instance, "ip6");
+		lua_pushcfunction(lua_instance, l_cidr);
+		lua_setglobal(lua_instance, "cidr");
+		lua_pushcfunction(lua_instance, l_cidr6);
+		lua_setglobal(lua_instance, "cidr6");
+		lua_pushcfunction(lua_instance, l_mac);
+		lua_setglobal(lua_instance, "mac");
+		lua_pushcfunction(lua_instance, l_mask);
+		lua_setglobal(lua_instance, "mask");
+		lua_pushcfunction(lua_instance, l_val_mask);
+		lua_setglobal(lua_instance, "val_mask");
+		lua_pushcfunction(lua_instance, l_val_range);
+		lua_setglobal(lua_instance, "val_range");
+		lua_pushcfunction(lua_instance, l_bin_read);
+		lua_setglobal(lua_instance, "bin_read");
+		lua_pushcfunction(lua_instance, l_client_content);
+		lua_setglobal(lua_instance, "client_content");
+		lua_pushcfunction(lua_instance, l_server_content);
+		lua_setglobal(lua_instance, "server_content");
+		lua_pushcfunction(lua_instance, l_task_count);
+		lua_setglobal(lua_instance, "task_count");
+	}
+	return lua_instance;
+}
diff --git a/VNFs/DPPD-PROX/prox_lua.h b/VNFs/DPPD-PROX/prox_lua.h
new file mode 100644
index 00000000..8d29df69
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_lua.h
@@ -0,0 +1,27 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROX_LUA_H_
+#define _PROX_LUA_H_
+
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#include "lua_compat.h"
+
+struct lua_State *prox_lua(void);
+
+#endif /* _PROX_LUA_H_ */
diff --git a/VNFs/DPPD-PROX/prox_lua_types.c b/VNFs/DPPD-PROX/prox_lua_types.c
new file mode 100644
index 00000000..7a0b6e08
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_lua_types.c
@@ -0,0 +1,1156 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+
+#include <string.h>
+#include <rte_ether.h>
+#include <rte_lpm.h>
+#include <rte_lpm6.h>
+#include <rte_acl.h>
+#include <rte_version.h>
+#include <rte_hash_crc.h>
+
+#include "prox_malloc.h"
+#include "etypes.h"
+#include "prox_lua.h"
+#include "log.h"
+#include "quit.h"
+#include "defines.h"
+#include "prox_globals.h"
+#include "prox_lua_types.h"
+#include "ip_subnet.h"
+#include "hash_entry_types.h"
+#include "handle_qinq_encap4.h"
+#include "toeplitz.h"
+#include "handle_lb_5tuple.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#endif
+
+static char error_str[1024];
+static char *cur_pos;
+
+const char *get_lua_to_errors(void)
+{
+	return error_str;
+}
+
+static void null_terminate_error(void)
+{
+	size_t diff = cur_pos - error_str;
+
+	if (diff >= sizeof(error_str) &&
+	    error_str[sizeof(error_str) - 1] != 0)
+		error_str[sizeof(error_str) - 1] = 0;
+}
+
+__attribute__((format(printf, 1, 2))) static void set_err(const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+
+	cur_pos = error_str;
+	cur_pos += vsnprintf(cur_pos, sizeof(error_str) - (cur_pos - error_str), fmt, ap);
+	null_terminate_error();
+
+	va_end(ap);
+}
+
+__attribute__((format(printf, 1, 2))) static void concat_err(const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+
+	cur_pos += vsnprintf(cur_pos, sizeof(error_str) - (cur_pos - error_str), fmt, ap);
+	null_terminate_error();
+
+	va_end(ap);
+}
+
+/* Make sure that an element is on the top of the stack (zero on success) */
+int lua_getfrom(struct lua_State *L, enum lua_place from, const char *name)
+{
+	switch (from) {
+	case STACK:
+		return lua_gettop(L) > 0? 0 : -1;
+	case TABLE:
+		if (!lua_istable(L, -1)) {
+			set_err("Failed to get field '%s' from table (no table)\n", name);
+			return -1;
+		}
+
+		lua_pushstring(L, name);
+		lua_gettable(L, -2);
+		if (lua_isnil(L, -1)) {
+			set_err("Field '%s' is missing from table\n", name);
+			lua_pop(L, 1);
+			return -1;
+		}
+		return 1;
+	case GLOBAL:
+		lua_getglobal(L, name);
+		if (lua_isnil(L, -1)) {
+			set_err("Couldn't find global data '%s'\n", name);
+			lua_pop(L, 1);
+			return -1;
+		}
+		return 1;
+	}
+	return -1;
+}
+
+int lua_to_ip(struct lua_State *L, enum lua_place from, const char *name, uint32_t *ip)
+{
+	uint32_t n_entries;
+	uint32_t ip_array[4];
+	ptrdiff_t v;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	lua_len(L, -1);
+	n_entries = lua_tointeger(L, -1);
+	lua_pop(L, 1);
+
+	if (n_entries != 4) {
+		set_err("Invalid IPv4 format\n");
+		return -1;
+	}
+
+	*ip = 0;
+	for (int i = 0; i < 4; ++i) {
+		lua_pushinteger(L, i + 1);
+		lua_gettable(L, -2);
+		v = lua_tointeger(L, -1);
+		lua_pop(L, 1);
+		if (!(v >= 0 && v <= 255)) {
+			set_err("Invalid IPv4 format\n");
+			return -1;
+		}
+		*ip |= v << (24 - i*8);
+	}
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_ip6(struct lua_State *L, enum lua_place from, const char *name, uint8_t *ip)
+{
+	uint32_t n_entries;
+	ptrdiff_t v;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	lua_len(L, -1);
+	n_entries = lua_tointeger(L, -1);
+	lua_pop(L, 1);
+
+	if (n_entries != 16) {
+		set_err("Invalid IPv6 format\n");
+		return -1;
+	}
+
+	for (int i = 0; i < 16; ++i) {
+		lua_pushinteger(L, i + 1);
+		lua_gettable(L, -2);
+		v = lua_tointeger(L, -1);
+		lua_pop(L, 1);
+		ip[i] = v;
+	}
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_mac(struct lua_State *L, enum lua_place from, const char *name, struct ether_addr *mac)
+{
+	uint32_t n_entries;
+	uint32_t mac_array[4];
+	ptrdiff_t v;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	lua_len(L, -1);
+	n_entries = lua_tointeger(L, -1);
+	lua_pop(L, 1);
+
+	if (n_entries != 6) {
+		set_err("Invalid MAC format\n");
+		return -1;
+	}
+
+	for (int i = 0; i < 6; ++i) {
+		lua_pushinteger(L, i + 1);
+		lua_gettable(L, -2);
+		v = lua_tointeger(L, -1);
+		lua_pop(L, 1);
+		if (!(v >= 0 && v <= 255)) {
+			set_err("Invalid MAC format\n");
+			return -1;
+		}
+		mac->addr_bytes[i] = v;
+	}
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_cidr(struct lua_State *L, enum lua_place from, const char *name, struct ip4_subnet *cidr)
+{
+	uint32_t depth, ip;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("CIDR is not a table\n");
+		return -1;
+	}
+
+	if (lua_to_ip(L, TABLE, "ip", &ip) ||
+	    lua_to_int(L, TABLE, "depth", &depth)) {
+		return -1;
+	}
+	cidr->ip = ip;
+	cidr->prefix = depth;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_cidr6(struct lua_State *L, enum lua_place from, const char *name, struct ip6_subnet *cidr)
+{
+	uint32_t depth;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("CIDR6 is not a table\n");
+		return -1;
+	}
+
+	if (lua_to_ip6(L, TABLE, "ip6", cidr->ip) ||
+	    lua_to_int(L, TABLE, "depth", &depth)) {
+		return -1;
+	}
+	cidr->prefix = depth;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_val_mask(struct lua_State *L, enum lua_place from, const char *name, struct val_mask *val_mask)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("data entry is not a table\n");
+		return -1;
+	}
+
+	if (lua_to_int(L, TABLE, "val", &val_mask->val) ||
+	    lua_to_int(L, TABLE, "mask", &val_mask->mask))
+		return -1;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_val_range(struct lua_State *L, enum lua_place from, const char *name, struct val_range *val_range)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("data entry is not a table\n");
+		return -1;
+	}
+
+	if (lua_to_int(L, TABLE, "beg", &val_range->beg) ||
+	    lua_to_int(L, TABLE, "end", &val_range->end))
+		return -1;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_action(struct lua_State *L, enum lua_place from, const char *name, enum acl_action *action)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_isstring(L, -1)) {
+		set_err("data entry is not a table\n");
+		return -1;
+	}
+
+	const char *s = lua_tostring(L, -1);
+
+	if (!strcmp(s, "drop"))
+		*action = ACL_DROP;
+	else if (!strcmp(s, "allow"))
+		*action = ACL_ALLOW;
+	else if (!strcmp(s, "rate_limit"))
+		*action = ACL_RATE_LIMIT;
+	else
+		return -1;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_string(struct lua_State *L, enum lua_place from, const char *name, char *dst, size_t size)
+{
+	const char *str;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_isstring(L, -1)) {
+		plog_err("data is not an integer\n");
+		return -1;
+	}
+	str = lua_tostring(L, -1);
+
+	strncpy(dst, str, size);
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_port(struct lua_State *L, enum lua_place from, const char *name, uint16_t *port)
+{
+	double tmp = 0;
+	int ret;
+
+	ret = lua_to_double(L, from, name, &tmp);
+	if (ret == 0)
+		*port = tmp;
+	return ret;
+}
+
+int lua_to_int(struct lua_State *L, enum lua_place from, const char *name, uint32_t *val)
+{
+	double tmp = 0;
+	int ret;
+
+	ret = lua_to_double(L, from, name, &tmp);
+	if (ret == 0)
+		*val = tmp;
+	return ret;
+}
+
+int lua_to_double(struct lua_State *L, enum lua_place from, const char *name, double *val)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_isnumber(L, -1)) {
+		set_err("data is not a number\n");
+		return -1;
+	}
+	*val = lua_tonumber(L, -1);
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_routes4_entry(struct lua_State *L, enum lua_place from, const char *name, struct ip4_subnet *cidr, uint32_t *nh_idx)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("Can't read routes4 entry since data is not a table\n");
+		return -1;
+	}
+
+	if (lua_to_cidr(L, TABLE, "cidr", cidr) ||
+	    lua_to_int(L, TABLE, "next_hop_id", nh_idx)) {
+		return -1;
+	}
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_next_hop(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct next_hop **nh)
+{
+	struct next_hop *ret;
+	uint32_t next_hop_index;
+	uint32_t port_id;
+	uint32_t ip;
+	uint32_t mpls;
+	struct ether_addr mac;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("Can't read next hop since data is not a table\n");
+		return -1;
+	}
+
+	ret = prox_zmalloc(sizeof(*ret) * MAX_HOP_INDEX, socket);
+	PROX_PANIC(ret == NULL, "Could not allocate memory for next hop\n");
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_int(L, TABLE, "id", &next_hop_index) ||
+		    lua_to_int(L, TABLE, "port_id", &port_id) ||
+		    lua_to_ip(L, TABLE, "ip", &ip) ||
+		    lua_to_mac(L, TABLE, "mac", &mac) ||
+		    lua_to_int(L, TABLE, "mpls", &mpls))
+			return -1;
+
+		PROX_PANIC(port_id >= PROX_MAX_PORTS, "Port id too high (only supporting %d ports)\n", PROX_MAX_PORTS);
+		PROX_PANIC(next_hop_index >= MAX_HOP_INDEX, "Next-hop to high (only supporting %d next hops)\n", MAX_HOP_INDEX);
+
+		ret[next_hop_index].mac_port.out_idx = port_id;
+		ret[next_hop_index].ip_dst = ip;
+
+		ret[next_hop_index].mac_port.mac = mac;
+		ret[next_hop_index].mpls = mpls;
+
+		lua_pop(L, 1);
+	}
+
+	*nh = ret;
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_next_hop6(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct next_hop6 **nh)
+{
+	struct next_hop6 *ret;
+	uint32_t next_hop_index, port_id, mpls;
+	struct ether_addr mac;
+	uint8_t ip[16];
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("Data is not a table\n");
+		return -1;
+	}
+
+	ret = prox_zmalloc(sizeof(*ret) * MAX_HOP_INDEX, socket);
+	PROX_PANIC(ret == NULL, "Could not allocate memory for next hop\n");
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_int(L, TABLE, "id", &next_hop_index) ||
+		    lua_to_int(L, TABLE, "port_id", &port_id) ||
+		    lua_to_ip6(L, TABLE, "ip6", ip) ||
+		    lua_to_mac(L, TABLE, "mac", &mac) ||
+		    lua_to_int(L, TABLE, "mpls", &mpls))
+			return -1;
+
+		PROX_PANIC(port_id >= PROX_MAX_PORTS, "Port id too high (only supporting %d ports)\n", PROX_MAX_PORTS);
+		PROX_PANIC(next_hop_index >= MAX_HOP_INDEX, "Next-hop to high (only supporting %d next hops)\n", MAX_HOP_INDEX);
+
+		ret[next_hop_index].mac_port.out_idx = port_id;
+		memcpy(ret[next_hop_index].ip_dst,ip, 16);
+
+		ret[next_hop_index].mac_port.mac = mac;
+		ret[next_hop_index].mpls = mpls;
+
+		lua_pop(L, 1);
+	}
+
+	*nh = ret;
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_routes4(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct lpm4 *lpm)
+{
+	struct ip4_subnet dst;
+	uint32_t next_hop_index;
+	uint32_t n_loaded_rules;
+	uint32_t n_tot_rules;
+	struct rte_lpm *new_lpm;
+	char lpm_name[64];
+	int ret;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	snprintf(lpm_name, sizeof(lpm_name), "IPv4_lpm_s%u", socket);
+
+	if (!lua_istable(L, -1)) {
+		set_err("Data is not a table\n");
+		return -1;
+	}
+
+	lua_len(L, -1);
+	n_tot_rules = lua_tointeger(L, -1);
+	n_loaded_rules = 0;
+	lua_pop(L, 1);
+#if RTE_VERSION >= RTE_VERSION_NUM(16,4,0,1)
+	struct rte_lpm_config conf;
+	conf.max_rules = 2 * n_tot_rules;
+	conf.number_tbl8s = 256;
+	conf.flags = 0;
+	new_lpm = rte_lpm_create(lpm_name, socket, &conf);
+#else
+	new_lpm = rte_lpm_create(lpm_name, socket, 2 * n_tot_rules, 0);
+#endif
+	PROX_PANIC(NULL == new_lpm, "Failed to allocate lpm\n");
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_routes4_entry(L, STACK, NULL, &dst, &next_hop_index)) {
+			set_err("Failed to read entry while setting up lpm\n");
+			return -1;
+		}
+		ret = rte_lpm_add(new_lpm, dst.ip, dst.prefix, next_hop_index);
+
+		if (ret != 0) {
+			set_err("Failed to add (%d) index %u ip %x/%u to lpm\n",
+				 ret, next_hop_index, dst.ip, dst.prefix);
+		}
+		else if (++n_loaded_rules % 10000 == 0) {
+			plog_info("Route %d added\n", n_loaded_rules);
+		}
+
+		lua_pop(L, 1);
+	}
+
+	lpm->rte_lpm = new_lpm;
+	lpm->n_used_rules = n_loaded_rules;
+	lpm->n_free_rules = 2 * n_tot_rules - n_loaded_rules;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_lpm4(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct lpm4 **lpm)
+{
+	struct lpm4 *ret;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	ret = prox_zmalloc(sizeof(struct lpm4), socket);
+
+	if (!lua_istable(L, -1)) {
+		set_err("Can't read lpm4 since data is not a table\n");
+		return -1;
+	}
+
+	if (lua_to_routes4(L, TABLE, "routes", socket, ret) ||
+	    lua_to_next_hop(L, TABLE, "next_hops", socket, &ret->next_hops)) {
+		return -1;
+	}
+
+	if (ret->rte_lpm)
+		plog_info("Loaded %d routes\n", ret->n_used_rules);
+
+	*lpm = ret;
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_lpm6(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct lpm6 **lpm)
+{
+	struct lpm6 *ret;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("Lpm6 is not a table\n");
+		return -1;
+	}
+
+	ret = prox_zmalloc(sizeof(struct lpm6), socket);
+
+	if (lua_to_routes6(L, TABLE, "routes6", socket, ret) ||
+	    lua_to_next_hop6(L, TABLE, "next_hops6", socket, &ret->next_hops))
+		return -1;
+
+	if (ret->rte_lpm6)
+		plog_info("Loaded %d routes\n", ret->n_used_rules);
+
+	*lpm = ret;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+static int lua_to_lpm6_entry(struct lua_State *L, enum lua_place from, const char *name, struct ip6_subnet *cidr, uint32_t *nh_idx)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("lpm6 entry is not a table\n");
+		return -1;
+	}
+	if (lua_to_cidr6(L, TABLE, "cidr6", cidr) ||
+	    lua_to_int(L, TABLE, "next_hop_id", nh_idx)) {
+		return -1;
+	}
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_routes6(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct lpm6 *lpm)
+{
+	struct ip6_subnet dst;
+	uint32_t next_hop_index;
+	uint32_t n_loaded_rules;
+	struct rte_lpm6 *new_lpm;
+	struct rte_lpm6_config config;
+	uint32_t n_tot_rules;
+	char lpm_name[64];
+	int ret;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	snprintf(lpm_name, sizeof(lpm_name), "IPv6_lpm_s%u", socket);
+
+	if (!lua_istable(L, -1)) {
+		set_err("Data is not a table\n");
+		return -1;
+	}
+
+	lua_len(L, -1);
+	n_tot_rules = lua_tointeger(L, -1);
+	n_loaded_rules = 0;
+	lua_pop(L, 1);
+
+	config.max_rules = n_tot_rules;
+	config.number_tbl8s = (1 << 16);
+	config.flags = 0;
+
+	new_lpm = rte_lpm6_create(lpm_name, socket, &config);
+	PROX_PANIC(NULL == new_lpm, "Failed to allocate lpm\n");
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+
+		if (lua_to_lpm6_entry(L, STACK, NULL, &dst, &next_hop_index)) {
+			concat_err("Failed to read entry while setting up lpm\n");
+			return -1;
+		}
+
+		ret = rte_lpm6_add(new_lpm, dst.ip, dst.prefix, next_hop_index);
+
+		if (ret != 0) {
+			plog_warn("Failed to add (%d) index %u, %d\n",
+				  ret, next_hop_index, dst.prefix);
+		}
+		else if (++n_loaded_rules % 10000 == 0) {
+			plog_info("Route %d added\n", n_loaded_rules);
+		}
+
+		lua_pop(L, 1);
+	}
+
+	lpm->rte_lpm6 = new_lpm;
+	lpm->n_used_rules = n_loaded_rules;
+	lpm->n_free_rules = 2 * n_tot_rules - n_loaded_rules;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_dscp(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, uint8_t **dscp)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("DSCP is not a table\n");
+		return -1;
+	}
+
+	uint32_t dscp_bits, tc, queue;
+	int status;
+	*dscp = prox_zmalloc(64, socket);
+	PROX_PANIC(dscp == NULL, "Error creating dscp table");
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_int(L, TABLE, "dscp", &dscp_bits) ||
+		    lua_to_int(L, TABLE, "tc", &tc) ||
+		    lua_to_int(L, TABLE, "queue", &queue)) {
+			concat_err("Failed to read dscp config\n");
+			return -1;
+		}
+
+		lua_pop(L, 1);
+
+		(*dscp)[dscp_bits] = tc << 2 | queue;
+	}
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_qinq_gre_map(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct qinq_gre_map **qinq_gre_map)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		if (from != STACK)
+			set_err("QinQ to gre map is not a table\n");
+		else
+			set_err("QinQ to gre map %s is not a table\n", name);
+		return -1;
+	}
+
+	struct qinq_gre_map *ret;
+	uint32_t svlan, cvlan;
+	uint16_t be_svlan, be_cvlan;
+	uint32_t user;
+	uint32_t gre_id;
+
+	uint32_t n_entries;
+	uint32_t idx = 0;
+
+	lua_len(L, -1);
+	n_entries = lua_tointeger(L, -1);
+	lua_pop(L, 1);
+
+	size_t mem_size = 0;
+	mem_size += sizeof(struct qinq_gre_map);
+	mem_size += n_entries * sizeof(struct qinq_gre_entry);
+
+	ret = prox_zmalloc(mem_size, socket);
+	PROX_PANIC(ret == NULL, "Error creating gre_qinq map");
+
+	ret->count = n_entries;
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+
+		if (lua_to_int(L, TABLE, "svlan_id", &svlan) ||
+		    lua_to_int(L, TABLE, "cvlan_id", &cvlan) ||
+		    lua_to_int(L, TABLE, "gre_id", &gre_id) ||
+		    lua_to_int(L, TABLE, "user_id", &user)) {
+			concat_err("Failed to read user table config\n");
+			return -1;
+		}
+
+		be_svlan = rte_bswap16((uint16_t)svlan);
+		be_cvlan = rte_bswap16((uint16_t)cvlan);
+
+		ret->entries[idx].user = user;
+		ret->entries[idx].svlan = be_svlan;
+		ret->entries[idx].cvlan = be_cvlan;
+		ret->entries[idx].gre_id = gre_id;
+		ret->entries[idx].rss = toeplitz_hash((uint8_t *)&be_cvlan, 4);
+
+		plog_dbg("elem %u: be_svlan=%x, be_cvlan=%x, rss_input=%x, rss=%x, gre_id=%x\n",
+			 idx, be_svlan, be_cvlan, be_cvlan, ret->entries[idx].rss, gre_id);
+
+		idx++;
+		lua_pop(L, 1);
+	}
+
+	*qinq_gre_map = ret;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_user_table(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, uint16_t **user_table)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("Data is not a table\n");
+		return -1;
+	}
+
+	uint32_t svlan, cvlan;
+	uint16_t be_svlan, be_cvlan;
+	uint32_t user;
+
+	*user_table = prox_zmalloc(0x1000000 * sizeof(uint16_t), socket);
+	PROX_PANIC(*user_table == NULL, "Error creating user table");
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_int(L, TABLE, "svlan_id", &svlan) ||
+		    lua_to_int(L, TABLE, "cvlan_id", &cvlan) ||
+		    lua_to_int(L, TABLE, "user_id", &user)) {
+			concat_err("Failed to read user table config\n");
+			return -1;
+		}
+
+		be_svlan = rte_bswap16((uint16_t)svlan);
+		be_cvlan = rte_bswap16((uint16_t)cvlan);
+
+		(*user_table)[PKT_TO_LUTQINQ(be_svlan, be_cvlan)] = user;
+
+		lua_pop(L, 1);
+	}
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_ip6_tun_binding(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct ipv6_tun_binding_table **data)
+{
+	struct ipv6_tun_binding_table *ret;
+	uint32_t n_entries;
+	uint32_t idx = 0;
+	uint32_t port = 0;
+	size_t memsize = 0;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("Can't read IPv6 tunnel bindings entry since ret is not a table\n");
+		return -1;
+	}
+
+	lua_len(L, -1);
+	n_entries = lua_tointeger(L, -1);
+	lua_pop(L, 1);
+
+	memsize = sizeof(struct ipv6_tun_binding_table);
+	memsize += n_entries * sizeof(struct ipv6_tun_binding_entry);
+
+	ret = prox_zmalloc(memsize, socket);
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_ip6(L, TABLE, "ip6", ret->entry[idx].endpoint_addr.bytes) ||
+		    lua_to_mac(L, TABLE, "mac", &ret->entry[idx].next_hop_mac) ||
+		    lua_to_ip(L, TABLE, "ip", &ret->entry[idx].public_ipv4) ||
+		    lua_to_int(L, TABLE, "port", &port))
+			return -1;
+
+		ret->entry[idx].public_port = port;
+		idx++;
+		lua_pop(L, 1);
+	}
+	ret->num_binding_entries = idx;
+
+	plog_info("\tRead %d IPv6 Tunnel Binding entries\n", idx);
+
+	*data = ret;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+int lua_to_cpe_table_data(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct cpe_table_data **data)
+{
+	struct cpe_table_data *ret;
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("Can't read IPv6 tunnel bindings entry since ret is not a table\n");
+		return -1;
+	}
+
+	/* Each entry in the input table expands to multiple entries
+	   depending on the number of hosts within the subnet. For
+	   this reason, go through the whole table and find out how
+	   many entries will be added in total. */
+	struct ip4_subnet cidr;
+	uint32_t n_entries = 0;
+	uint32_t port_idx, gre_id, svlan, cvlan, user;
+	struct ether_addr mac;
+	uint32_t idx = 0;
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_cidr(L, TABLE, "cidr", &cidr))
+			return -1;
+		n_entries += ip4_subet_get_n_hosts(&cidr);
+		lua_pop(L, 1);
+	}
+
+	ret = prox_zmalloc(sizeof(*ret) + n_entries * sizeof(struct cpe_table_entry), 0);
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_to_int(L, TABLE, "dest_id", &port_idx) ||
+		    lua_to_int(L, TABLE, "gre_id", &gre_id) ||
+		    lua_to_int(L, TABLE, "svlan_id", &svlan) ||
+		    lua_to_int(L, TABLE, "cvlan_id", &cvlan) ||
+		    lua_to_cidr(L, TABLE, "cidr", &cidr) ||
+		    lua_to_mac(L, TABLE, "mac", &mac) ||
+		    lua_to_int(L, TABLE, "user_id", &user))
+			return -1;
+
+		uint32_t n_hosts = ip4_subet_get_n_hosts(&cidr);
+
+		for (uint32_t i = 0; i < n_hosts; ++i) {
+			ret->entries[idx].port_idx = port_idx;
+			ret->entries[idx].gre_id = gre_id;
+			ret->entries[idx].svlan = rte_bswap16(svlan);
+			ret->entries[idx].cvlan = rte_bswap16(cvlan);
+			ret->entries[idx].eth_addr = mac;
+			ret->entries[idx].user = user;
+
+			PROX_PANIC(ip4_subnet_to_host(&cidr, i, &ret->entries[idx].ip), "Invalid host in address\n");
+			ret->entries[idx].ip = rte_bswap32(ret->entries[idx].ip);
+			idx++;
+		}
+
+		lua_pop(L, 1);
+	}
+
+	ret->n_entries = n_entries;
+	*data = ret;
+
+	lua_pop(L, pop);
+	return 0;
+}
+
+struct acl4_rule {
+	struct rte_acl_rule_data data;
+	struct rte_acl_field fields[9];
+};
+
+int lua_to_rules(struct lua_State *L, enum lua_place from, const char *name, struct rte_acl_ctx *ctx, uint32_t* n_max_rules, int use_qinq, uint16_t qinq_tag)
+{
+	int pop;
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		set_err("Can't read rules since data is not a table\n");
+		return -1;
+	}
+
+	struct val_mask svlan, cvlan, ip_proto;
+	struct ip4_subnet src_cidr, dst_cidr;
+	struct val_range sport, dport;
+	enum acl_action action;
+	uint32_t n_rules = 0;
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (n_rules == *n_max_rules) {
+			set_err("Too many rules");
+			return -1;
+		}
+		if (use_qinq) {
+			if (lua_to_val_mask(L, TABLE, "svlan_id", &svlan) ||
+			    lua_to_val_mask(L, TABLE, "cvlan_id", &cvlan))
+				return -1;
+		}
+
+		if (lua_to_val_mask(L, TABLE, "ip_proto", &ip_proto) ||
+		    lua_to_cidr(L, TABLE, "src_cidr", &src_cidr) ||
+		    lua_to_cidr(L, TABLE, "dst_cidr", &dst_cidr) ||
+		    lua_to_val_range(L, TABLE, "sport", &sport) ||
+		    lua_to_val_range(L, TABLE, "dport", &dport) ||
+		    lua_to_action(L, TABLE, "action", &action))
+			return -1;
+
+		struct acl4_rule rule;
+
+		rule.data.userdata = action; /* allow, drop or rate_limit */
+		rule.data.category_mask = 1;
+		rule.data.priority = n_rules++;
+
+		/* Configuration for rules is done in little-endian so no bswap is needed here.. */
+
+		rule.fields[0].value.u8 = ip_proto.val;
+		rule.fields[0].mask_range.u8 = ip_proto.mask;
+		rule.fields[1].value.u32 = src_cidr.ip;
+		rule.fields[1].mask_range.u32 = src_cidr.prefix;
+
+		rule.fields[2].value.u32 = dst_cidr.ip;
+		rule.fields[2].mask_range.u32 = dst_cidr.prefix;
+
+		rule.fields[3].value.u16 = sport.beg;
+		rule.fields[3].mask_range.u16 = sport.end;
+
+		rule.fields[4].value.u16 = dport.beg;
+		rule.fields[4].mask_range.u16 = dport.end;
+
+		if (use_qinq) {
+			rule.fields[5].value.u16 = rte_bswap16(qinq_tag);
+			rule.fields[5].mask_range.u16 = 0xffff;
+
+			/* To mask out the TCI and only keep the VID, the mask should be 0x0fff */
+			rule.fields[6].value.u16 = svlan.val;
+			rule.fields[6].mask_range.u16 = svlan.mask;
+
+			rule.fields[7].value.u16 = rte_bswap16(ETYPE_VLAN);
+			rule.fields[7].mask_range.u16 = 0xffff;
+
+			rule.fields[8].value.u16 = cvlan.val;
+			rule.fields[8].mask_range.u16 = cvlan.mask;
+		}
+		else {
+			/* Reuse first ethertype from vlan to check if packet is IPv4 packet */
+			rule.fields[5].value.u16 =  rte_bswap16(ETYPE_IPv4);
+			rule.fields[5].mask_range.u16 = 0xffff;
+
+			/* Other fields are ignored */
+			rule.fields[6].value.u16 = 0;
+			rule.fields[6].mask_range.u16 = 0;
+			rule.fields[7].value.u16 = 0;
+			rule.fields[7].mask_range.u16 = 0;
+			rule.fields[8].value.u16 = 0;
+			rule.fields[8].mask_range.u16 = 0;
+		}
+
+		rte_acl_add_rules(ctx, (struct rte_acl_rule*) &rule, 1);
+		lua_pop(L, 1);
+	}
+
+	*n_max_rules -= n_rules;
+	lua_pop(L, pop);
+	return 0;
+}
+
+static inline uint32_t ipv4_hash_crc(const void *data, __rte_unused uint32_t data_len, uint32_t init_val)
+{
+	const union ipv4_5tuple_host *k;
+	uint32_t t;
+	const uint32_t *p;
+
+	k = data;
+	t = k->proto;
+	p = (const uint32_t *)&k->port_src;
+
+	init_val = rte_hash_crc_4byte(t, init_val);
+	init_val = rte_hash_crc_4byte(k->ip_src, init_val);
+	init_val = rte_hash_crc_4byte(k->ip_dst, init_val);
+	init_val = rte_hash_crc_4byte(*p, init_val);
+	return (init_val);
+}
+
+int lua_to_tuples(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct rte_hash **lookup_hash, uint8_t **out_if)
+{
+	int pop;
+	char s[64];
+
+	if ((pop = lua_getfrom(L, from, name)) < 0)
+		return -1;
+
+	if (!lua_istable(L, -1)) {
+		plog_err("Can't read rules since data is not a table\n");
+		return -1;
+	}
+
+	lua_len(L, -1);
+	uint32_t n_tot_tuples = lua_tointeger(L, -1);
+	lua_pop(L, 1);
+
+	struct rte_hash_parameters ipv4_l3fwd_hash_params = {
+		.name = NULL,
+		.entries = n_tot_tuples * 4,
+		.key_len = sizeof(union ipv4_5tuple_host),
+#if RTE_VERSION < RTE_VERSION_NUM(2, 1, 0, 0)
+		.bucket_entries = 4,
+#endif
+		.hash_func = ipv4_hash_crc,
+		.hash_func_init_val = 0,
+	};
+
+	/* create lb_5tuple hash - same hash is shared between cores on same socket */
+	snprintf(s, sizeof(s), "ipv4_l3fwd_hash_%d", socket);
+	if ((*lookup_hash = rte_hash_find_existing(s)) == NULL) {
+		ipv4_l3fwd_hash_params.name = s;
+		ipv4_l3fwd_hash_params.socket_id = socket;
+		*lookup_hash = rte_hash_create(&ipv4_l3fwd_hash_params);
+		PROX_PANIC(*lookup_hash == NULL, "Unable to create the lb_5tuple hash\n");
+	}
+
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		uint32_t if_out, ip_src, ip_dst, port_src, port_dst, proto;
+		union ipv4_5tuple_host newkey;
+
+		if (lua_to_int(L, TABLE, "if_out", &if_out) ||
+		    lua_to_int(L, TABLE, "ip_src", &ip_src) ||
+		    lua_to_int(L, TABLE, "ip_dst", &ip_dst) ||
+		    lua_to_int(L, TABLE, "port_src", &port_src) ||
+		    lua_to_int(L, TABLE, "port_dst", &port_dst) ||
+		    lua_to_int(L, TABLE, "proto", &proto)) {
+			plog_err("Failed to read user table config\n");
+			return -1;
+		}
+
+		newkey.ip_dst = rte_cpu_to_be_32(ip_dst);
+		newkey.ip_src = rte_cpu_to_be_32(ip_src);
+		newkey.port_dst = rte_cpu_to_be_16((uint16_t)port_dst);
+		newkey.port_src = rte_cpu_to_be_16((uint16_t)port_src);
+		newkey.proto = (uint8_t)proto;
+		newkey.pad0 = 0;
+		newkey.pad1 = 0;
+
+		int32_t ret = rte_hash_add_key(*lookup_hash, (void *) &newkey);
+		PROX_PANIC(ret < 0, "Unable to add entry (err code %d)\n", ret);
+		(*out_if)[ret] = (uint8_t) if_out;
+
+		lua_pop(L, 1);
+	}
+	lua_pop(L, pop);
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/prox_lua_types.h b/VNFs/DPPD-PROX/prox_lua_types.h
new file mode 100644
index 00000000..182c9055
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_lua_types.h
@@ -0,0 +1,142 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROX_LUA_TYPES_H_
+#define _PROX_LUA_TYPES_H_
+
+#include <inttypes.h>
+#include <rte_ether.h>
+#include <rte_hash.h>
+
+#include "ip6_addr.h"
+
+struct lua_State;
+struct ether_addr;
+struct ip4_subnet;
+struct ip6_subnet;
+struct next_hop;
+struct rte_lpm;
+struct rte_lpm6;
+struct next_hop6;
+struct rte_acl_ctx;
+struct qinq_gre_map;
+
+#define MAX_HOP_INDEX  128
+enum l4gen_peer {PEER_SERVER, PEER_CLIENT};
+
+static const char *l4gen_peer_to_str(enum l4gen_peer peer)
+{
+	return peer == PEER_SERVER? "server" : "client";
+}
+
+struct peer_data {
+	uint8_t *hdr;
+	uint32_t hdr_len;
+	uint8_t *content;
+};
+
+struct peer_action {
+	enum l4gen_peer   peer;
+	uint32_t          beg;
+	uint32_t          len;
+};
+
+struct lpm4 {
+	uint32_t n_free_rules;
+	uint32_t n_used_rules;
+	struct next_hop *next_hops;
+	struct rte_lpm *rte_lpm;
+};
+
+struct lpm6 {
+	struct rte_lpm6 *rte_lpm6;
+	struct next_hop6 *next_hops;
+	uint32_t n_free_rules;
+	uint32_t n_used_rules;
+};
+
+struct ipv6_tun_binding_entry {
+	struct ipv6_addr        endpoint_addr;  // IPv6 local addr
+	struct ether_addr       next_hop_mac;   // mac addr of next hop towards lwB4
+	uint32_t                public_ipv4;    // Public IPv4 address
+	uint16_t                public_port;    // Public base port (together with port mask, defines the Port Set)
+} __attribute__((__packed__));
+
+struct ipv6_tun_binding_table {
+	uint32_t                num_binding_entries;
+	struct ipv6_tun_binding_entry entry[0];
+};
+
+struct cpe_table_entry {
+	uint32_t port_idx;
+	uint32_t gre_id;
+	uint32_t svlan;
+	uint32_t cvlan;
+	uint32_t ip;
+	struct ether_addr eth_addr;
+	uint32_t user;
+};
+
+struct cpe_table_data {
+	uint32_t               n_entries;
+	struct cpe_table_entry entries[0];
+};
+
+struct val_mask {
+	uint32_t val;
+	uint32_t mask;
+};
+
+struct val_range {
+	uint32_t beg;
+	uint32_t end;
+};
+
+enum acl_action {ACL_NOT_SET, ACL_ALLOW, ACL_DROP, ACL_RATE_LIMIT};
+
+const char *get_lua_to_errors(void);
+
+enum lua_place {STACK, TABLE, GLOBAL};
+int lua_getfrom(struct lua_State *L, enum lua_place from, const char *name);
+
+int lua_to_port(struct lua_State *L, enum lua_place from, const char *name, uint16_t *port);
+int lua_to_ip(struct lua_State *L, enum lua_place from, const char *name, uint32_t *ip);
+int lua_to_ip6(struct lua_State *L, enum lua_place from, const char *name, uint8_t *ip);
+int lua_to_mac(struct lua_State *L, enum lua_place from, const char *name, struct ether_addr *mac);
+int lua_to_cidr(struct lua_State *L, enum lua_place from, const char *name, struct ip4_subnet *cidr);
+int lua_to_cidr6(struct lua_State *L, enum lua_place from, const char *name, struct ip6_subnet *cidr);
+int lua_to_int(struct lua_State *L, enum lua_place from, const char *name, uint32_t *val);
+int lua_to_double(struct lua_State *L, enum lua_place from, const char *name, double *val);
+int lua_to_string(struct lua_State *L, enum lua_place from, const char *name, char *dst, size_t size);
+int lua_to_val_mask(struct lua_State *L, enum lua_place from, const char *name, struct val_mask *val_mask);
+int lua_to_val_range(struct lua_State *L, enum lua_place from, const char *name, struct val_range *val_range);
+int lua_to_action(struct lua_State *L, enum lua_place from, const char *name, enum acl_action *action);
+int lua_to_dscp(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, uint8_t **dscp);
+int lua_to_user_table(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, uint16_t **user_table);
+int lua_to_lpm4(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct lpm4 **lpm);
+int lua_to_routes4(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct lpm4 *lpm);
+int lua_to_next_hop(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct next_hop **nh);
+int lua_to_lpm6(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct lpm6 **lpm);
+int lua_to_ip6_tun_binding(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct ipv6_tun_binding_table **data);
+int lua_to_qinq_gre_map(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct qinq_gre_map **qinq_gre_map);
+int lua_to_cpe_table_data(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct cpe_table_data **data);
+int lua_to_rules(struct lua_State *L, enum lua_place from, const char *name, struct rte_acl_ctx *ctx, uint32_t* n_max_rules, int use_qinq, uint16_t qinq_tag);
+int lua_to_routes4_entry(struct lua_State *L, enum lua_place from, const char *name, struct ip4_subnet *cidr, uint32_t *nh_idx);
+int lua_to_next_hop6(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct next_hop6 **nh);
+int lua_to_routes6(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct lpm6 *lpm);
+int lua_to_tuples(struct lua_State *L, enum lua_place from, const char *name, uint8_t socket, struct rte_hash **lookup_hash, uint8_t **out_if);
+
+#endif /* _PROX_LUA_TYPES_H_ */
diff --git a/VNFs/DPPD-PROX/prox_malloc.c b/VNFs/DPPD-PROX/prox_malloc.c
new file mode 100644
index 00000000..cec80f3e
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_malloc.c
@@ -0,0 +1,33 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_malloc.h>
+
+#include "prox_malloc.h"
+
+#ifndef RTE_CACHE_LINE_SIZE
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#endif
+
+void *prox_zmalloc(size_t size, int socket)
+{
+	return rte_zmalloc_socket(NULL, size, RTE_CACHE_LINE_SIZE, socket);
+}
+
+void prox_free(void *ptr)
+{
+	rte_free(ptr);
+}
diff --git a/VNFs/DPPD-PROX/prox_malloc.h b/VNFs/DPPD-PROX/prox_malloc.h
new file mode 100644
index 00000000..c75667de
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_malloc.h
@@ -0,0 +1,25 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROX_MALLOC_H_
+#define _PROX_MALLOC_H_
+
+#include <stddef.h>
+
+void *prox_zmalloc(size_t size, int socket);
+void prox_free(void *ptr);
+
+#endif /* _PROX_MALLOC_H_ */
diff --git a/VNFs/DPPD-PROX/prox_port_cfg.c b/VNFs/DPPD-PROX/prox_port_cfg.c
new file mode 100644
index 00000000..831a8ff9
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_port_cfg.c
@@ -0,0 +1,473 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <rte_version.h>
+#include <rte_eth_ring.h>
+#include <rte_mbuf.h>
+#if (RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)) && (RTE_VERSION <= RTE_VERSION_NUM(17,5,0,1))
+#include <rte_eth_null.h>
+#endif
+
+#include "prox_port_cfg.h"
+#include "prox_globals.h"
+#include "log.h"
+#include "quit.h"
+#include "defaults.h"
+#include "toeplitz.h"
+#include "defines.h"
+#include "prox_cksum.h"
+
+struct prox_port_cfg prox_port_cfg[PROX_MAX_PORTS];
+rte_atomic32_t lsc;
+
+int prox_nb_active_ports(void)
+{
+	int ret = 0;
+	for (uint32_t i = 0; i < PROX_MAX_PORTS; ++i) {
+		ret += prox_port_cfg[i].active;
+	}
+	return ret;
+}
+
+int prox_last_port_active(void)
+{
+	int ret = 0;
+	for (uint32_t i = 0; i < PROX_MAX_PORTS; ++i) {
+		if (prox_port_cfg[i].active) {
+			ret = i;
+		}
+	}
+	return ret;
+}
+
+static void lsc_cb(__attribute__((unused)) uint8_t port_id, enum rte_eth_event_type type, __attribute__((unused)) void *param)
+{
+	struct rte_eth_link link;
+
+	if (RTE_ETH_EVENT_INTR_LSC != type) {
+		return;
+	}
+
+	rte_atomic32_inc(&lsc);
+}
+
+struct prox_pktmbuf_reinit_args {
+	struct rte_mempool *mp;
+	struct lcore_cfg   *lconf;
+};
+
+/* standard mbuf initialization procedure */
+void prox_pktmbuf_init(struct rte_mempool *mp, void *opaque_arg, void *_m, unsigned i)
+{
+	struct rte_mbuf *mbuf = _m;
+
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+	mbuf->tx_offload = CALC_TX_OL(sizeof(struct ether_hdr), sizeof(struct ipv4_hdr));
+#else
+	mbuf->pkt.vlan_macip.f.l2_len = sizeof(struct ether_hdr);
+	mbuf->pkt.vlan_macip.f.l3_len = sizeof(struct ipv4_hdr);
+#endif
+
+	rte_pktmbuf_init(mp, opaque_arg, mbuf, i);
+}
+
+void prox_pktmbuf_reinit(void *arg, void *start, __attribute__((unused)) void *end, uint32_t idx)
+{
+	struct prox_pktmbuf_reinit_args *init_args = arg;
+	struct rte_mbuf *m;
+	char* obj = start;
+
+	obj += init_args->mp->header_size;
+	m = (struct rte_mbuf*)obj;
+
+	prox_pktmbuf_init(init_args->mp, init_args->lconf, obj, idx);
+}
+
+/* initialize rte devices and check the number of available ports */
+void init_rte_dev(int use_dummy_devices)
+{
+	uint8_t nb_ports, port_id_max, port_id_last;
+	struct rte_eth_dev_info dev_info;
+
+	nb_ports = rte_eth_dev_count();
+	/* get available ports configuration */
+	PROX_PANIC(use_dummy_devices && nb_ports, "Can't use dummy devices while there are also real ports\n");
+
+	if (use_dummy_devices) {
+#if (RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)) && (RTE_VERSION <= RTE_VERSION_NUM(17,5,0,1))
+		nb_ports = prox_last_port_active() + 1;
+		plog_info("Creating %u dummy devices\n", nb_ports);
+
+		char port_name[32] = "0dummy_dev";
+		for (uint32_t i = 0; i < nb_ports; ++i) {
+			eth_dev_null_create(port_name, 0, ETHER_MIN_LEN, 0);
+			port_name[0]++;
+		}
+#else
+	PROX_PANIC(use_dummy_devices, "Can't use dummy devices\n");
+#endif
+	}
+	else {
+		PROX_PANIC(nb_ports == 0, "\tError: DPDK could not find any port\n");
+		plog_info("\tDPDK has found %u ports\n", nb_ports);
+	}
+
+	if (nb_ports > PROX_MAX_PORTS) {
+		plog_warn("\tWarning: I can deal with at most %u ports."
+		        " Please update PROX_MAX_PORTS and recompile.\n", PROX_MAX_PORTS);
+
+		nb_ports = PROX_MAX_PORTS;
+	}
+	port_id_max = nb_ports - 1;
+	port_id_last = prox_last_port_active();
+	PROX_PANIC(port_id_last > port_id_max,
+		   "\tError: invalid port(s) specified, last port index active: %d (max index is %d)\n",
+		   port_id_last, port_id_max);
+
+	/* Assign ports to PROX interfaces & Read max RX/TX queues per port */
+	for (uint8_t port_id = 0; port_id < nb_ports; ++port_id) {
+		/* skip ports that are not enabled */
+		if (!prox_port_cfg[port_id].active) {
+			continue;
+		}
+		plog_info("\tGetting info for rte dev %u\n", port_id);
+		rte_eth_dev_info_get(port_id, &dev_info);
+		struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
+		port_cfg->socket = -1;
+
+		port_cfg->max_txq = dev_info.max_tx_queues;
+		port_cfg->max_rxq = dev_info.max_rx_queues;
+
+		if (!dev_info.pci_dev)
+			continue;
+
+		snprintf(port_cfg->pci_addr, sizeof(port_cfg->pci_addr),
+			 "%04x:%02x:%02x.%1x", dev_info.pci_dev->addr.domain, dev_info.pci_dev->addr.bus, dev_info.pci_dev->addr.devid, dev_info.pci_dev->addr.function);
+		strncpy(port_cfg->driver_name, dev_info.driver_name, sizeof(port_cfg->driver_name));
+		plog_info("\tPort %u : driver='%s' tx_queues=%d rx_queues=%d\n", port_id, !strcmp(port_cfg->driver_name, "")? "null" : port_cfg->driver_name, port_cfg->max_txq, port_cfg->max_rxq);
+
+		if (strncmp(port_cfg->driver_name, "rte_", 4) == 0) {
+			strncpy(port_cfg->short_name, prox_port_cfg[port_id].driver_name + 4, sizeof(port_cfg->short_name));
+		} else if (strncmp(port_cfg->driver_name, "net_", 4) == 0) {
+			strncpy(port_cfg->short_name, prox_port_cfg[port_id].driver_name + 4, sizeof(port_cfg->short_name));
+		} else {
+			strncpy(port_cfg->short_name, prox_port_cfg[port_id].driver_name, sizeof(port_cfg->short_name));
+		}
+		char *ptr;
+		if ((ptr = strstr(port_cfg->short_name, "_pmd")) != NULL) {
+			*ptr = '\x0';
+		}
+
+		/* Try to find the device's numa node */
+		char buf[1024];
+		snprintf(buf, sizeof(buf), "/sys/bus/pci/devices/%s/numa_node", port_cfg->pci_addr);
+		FILE* numa_node_fd = fopen(buf, "r");
+		if (numa_node_fd) {
+			if (fgets(buf, sizeof(buf), numa_node_fd) == NULL) {
+				plog_warn("Failed to read numa_node for device %s\n", port_cfg->pci_addr);
+			}
+			port_cfg->socket = strtol(buf, 0, 0);
+			if (port_cfg->socket == -1) {
+				plog_warn("System did not report numa_node for device %s\n", port_cfg->pci_addr);
+			}
+			fclose(numa_node_fd);
+		}
+
+		if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPV4_CKSUM) {
+			port_cfg->capabilities.tx_offload_cksum |= IPV4_CKSUM;
+		}
+		if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_UDP_CKSUM) {
+			port_cfg->capabilities.tx_offload_cksum |= UDP_CKSUM;
+		}
+	}
+}
+
+/* Create rte ring-backed devices */
+uint8_t init_rte_ring_dev(void)
+{
+	uint8_t nb_ring_dev = 0;
+
+	for (uint8_t port_id = 0; port_id < PROX_MAX_PORTS; ++port_id) {
+		/* skip ports that are not enabled */
+		if (!prox_port_cfg[port_id].active) {
+			continue;
+		}
+		struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
+		if (port_cfg->rx_ring[0] != '\0') {
+			plog_info("\tRing-backed port %u: rx='%s' tx='%s'\n", port_id, port_cfg->rx_ring, port_cfg->tx_ring);
+
+			struct rte_ring* rx_ring = rte_ring_lookup(port_cfg->rx_ring);
+			PROX_PANIC(rx_ring == NULL, "Ring %s not found for port %d!\n", port_cfg->rx_ring, port_id);
+			struct rte_ring* tx_ring = rte_ring_lookup(port_cfg->tx_ring);
+			PROX_PANIC(tx_ring == NULL, "Ring %s not found for port %d!\n", port_cfg->tx_ring, port_id);
+
+			int ret = rte_eth_from_rings(port_cfg->name, &rx_ring, 1, &tx_ring, 1, rte_socket_id());
+			PROX_PANIC(ret != 0, "Failed to create eth_dev from rings for port %d\n", port_id);
+
+			port_cfg->port_conf.intr_conf.lsc = 0; /* Link state interrupt not supported for ring-backed ports */
+
+			nb_ring_dev++;
+		}
+	}
+
+	return nb_ring_dev;
+}
+
+static void init_port(struct prox_port_cfg *port_cfg)
+{
+	static char dummy_pool_name[] = "0_dummy";
+	struct rte_eth_link link;
+	uint8_t port_id;
+	int ret;
+
+	port_id = port_cfg - prox_port_cfg;
+	plog_info("\t*** Initializing port %u ***\n", port_id);
+	plog_info("\t\tPort name is set to %s\n", port_cfg->name);
+	plog_info("\t\tPort max RX/TX queue is %u/%u\n", port_cfg->max_rxq, port_cfg->max_txq);
+	plog_info("\t\tPort driver is %s\n", port_cfg->driver_name);
+
+	PROX_PANIC(port_cfg->n_rxq == 0 && port_cfg->n_txq == 0,
+		   "\t\t port %u is enabled but no RX or TX queues have been configured", port_id);
+
+	if (port_cfg->n_rxq == 0) {
+		/* not receiving on this port */
+		plog_info("\t\tPort %u had no RX queues, setting to 1\n", port_id);
+		port_cfg->n_rxq = 1;
+		uint32_t mbuf_size = MBUF_SIZE;
+		if (strcmp(port_cfg->short_name, "vmxnet3") == 0) {
+			mbuf_size = MBUF_SIZE + RTE_PKTMBUF_HEADROOM;
+		}
+		plog_info("\t\tAllocating dummy memory pool on socket %u with %u elements of size %u\n",
+			  port_cfg->socket, port_cfg->n_rxd, mbuf_size);
+		port_cfg->pool[0] = rte_mempool_create(dummy_pool_name, port_cfg->n_rxd, mbuf_size,
+						       0,
+						       sizeof(struct rte_pktmbuf_pool_private),
+						       rte_pktmbuf_pool_init, NULL,
+						       prox_pktmbuf_init, 0,
+						       port_cfg->socket, 0);
+		PROX_PANIC(port_cfg->pool[0] == NULL, "Failed to allocate dummy memory pool on socket %u with %u elements\n",
+			   port_cfg->socket, port_cfg->n_rxd);
+		dummy_pool_name[0]++;
+	} else {
+		// Most pmd do not support setting mtu yet...
+		if (!strcmp(port_cfg->short_name, "ixgbe")) {
+			plog_info("\t\tSetting MTU size to %u for port %u ...\n", port_cfg->mtu, port_id);
+			ret = rte_eth_dev_set_mtu(port_id, port_cfg->mtu);
+			PROX_PANIC(ret < 0, "\n\t\t\trte_eth_dev_set_mtu() failed on port %u: error %d\n", port_id, ret);
+		}
+
+		if (port_cfg->n_txq == 0) {
+			/* not sending on this port */
+			plog_info("\t\tPort %u had no TX queues, setting to 1\n", port_id);
+			port_cfg->n_txq = 1;
+		}
+	}
+
+	if (port_cfg->n_rxq > 1)  {
+		// Enable RSS if multiple receive queues
+		port_cfg->port_conf.rxmode.mq_mode       		|= ETH_MQ_RX_RSS;
+		port_cfg->port_conf.rx_adv_conf.rss_conf.rss_key 	= toeplitz_init_key;
+		port_cfg->port_conf.rx_adv_conf.rss_conf.rss_key_len 	= TOEPLITZ_KEY_LEN;
+#if RTE_VERSION >= RTE_VERSION_NUM(2,0,0,0)
+		port_cfg->port_conf.rx_adv_conf.rss_conf.rss_hf 	= ETH_RSS_IPV4|ETH_RSS_NONFRAG_IPV4_UDP;
+#else
+		port_cfg->port_conf.rx_adv_conf.rss_conf.rss_hf 	= ETH_RSS_IPV4|ETH_RSS_NONF_IPV4_UDP;
+#endif
+	}
+
+	plog_info("\t\tConfiguring port %u... with %u RX queues and %u TX queues\n",
+		  port_id, port_cfg->n_rxq, port_cfg->n_txq);
+
+	PROX_PANIC(port_cfg->n_rxq > port_cfg->max_rxq, "\t\t\tToo many RX queues (configuring %u, max is %u)\n", port_cfg->n_rxq, port_cfg->max_rxq);
+	PROX_PANIC(port_cfg->n_txq > port_cfg->max_txq, "\t\t\tToo many TX queues (configuring %u, max is %u)\n", port_cfg->n_txq, port_cfg->max_txq);
+
+	if (!strcmp(port_cfg->short_name, "ixgbe_vf") ||
+	    !strcmp(port_cfg->short_name, "virtio") ||
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+	    !strcmp(port_cfg->short_name, "i40e") ||
+#endif
+	    !strcmp(port_cfg->short_name, "i40e_vf") ||
+	    !strcmp(port_cfg->driver_name, "") || /* NULL device */
+	    !strcmp(port_cfg->short_name, "vmxnet3")) {
+		port_cfg->port_conf.intr_conf.lsc = 0;
+		plog_info("\t\tDisabling link state interrupt for vmxnet3/VF/virtio (unsupported)\n");
+	}
+
+	if (port_cfg->lsc_set_explicitely) {
+		port_cfg->port_conf.intr_conf.lsc = port_cfg->lsc_val;
+		plog_info("\t\tOverriding link state interrupt configuration to '%s'\n", port_cfg->lsc_val? "enabled" : "disabled");
+	}
+	if (!strcmp(port_cfg->short_name, "vmxnet3")) {
+		if (port_cfg->n_txd < 512) {
+			// Vmxnet3 driver requires minimum 512 tx descriptors
+			plog_info("\t\tNumber of TX descriptors is set to 512 (minimum required for vmxnet3\n");
+			port_cfg->n_txd = 512;
+		}
+	}
+
+	ret = rte_eth_dev_configure(port_id, port_cfg->n_rxq,
+				    port_cfg->n_txq, &port_cfg->port_conf);
+	PROX_PANIC(ret < 0, "\t\t\trte_eth_dev_configure() failed on port %u: %s (%d)\n", port_id, strerror(-ret), ret);
+
+	if (port_cfg->port_conf.intr_conf.lsc) {
+		rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC, lsc_cb, NULL);
+	}
+
+	plog_info("\t\tMAC address set to "MAC_BYTES_FMT"\n", MAC_BYTES(port_cfg->eth_addr.addr_bytes));
+
+	/* initialize RX queues */
+	for (uint16_t queue_id = 0; queue_id < port_cfg->n_rxq; ++queue_id) {
+		plog_info("\t\tSetting up RX queue %u on port %u on socket %u with %u desc (pool 0x%p)\n",
+			  queue_id, port_id, port_cfg->socket,
+			  port_cfg->n_rxd, port_cfg->pool[queue_id]);
+
+		ret = rte_eth_rx_queue_setup(port_id, queue_id,
+					     port_cfg->n_rxd,
+					     port_cfg->socket, &port_cfg->rx_conf,
+					     port_cfg->pool[queue_id]);
+
+		PROX_PANIC(ret < 0, "\t\t\trte_eth_rx_queue_setup() failed on port %u: error %s (%d)\n", port_id, strerror(-ret), ret);
+	}
+	if (!strcmp(port_cfg->short_name, "virtio")) {
+		port_cfg->tx_conf.txq_flags |= ETH_TXQ_FLAGS_NOOFFLOADS;
+		plog_info("\t\tDisabling TX offloads (virtio does not support TX offloads)\n");
+	}
+
+	if (!strcmp(port_cfg->short_name, "vmxnet3")) {
+		port_cfg->tx_conf.txq_flags |= ETH_TXQ_FLAGS_NOOFFLOADS | ETH_TXQ_FLAGS_NOMULTSEGS;
+		plog_info("\t\tDisabling TX offloads and multsegs on port %d as vmxnet3 does not support them\n", port_id);
+	}
+	/* initialize one TX queue per logical core on each port */
+	for (uint16_t queue_id = 0; queue_id < port_cfg->n_txq; ++queue_id) {
+		plog_info("\t\tSetting up TX queue %u on socket %u with %u desc\n",
+			  queue_id, port_cfg->socket, port_cfg->n_txd);
+		ret = rte_eth_tx_queue_setup(port_id, queue_id, port_cfg->n_txd,
+					     port_cfg->socket, &port_cfg->tx_conf);
+		PROX_PANIC(ret < 0, "\t\t\trte_eth_tx_queue_setup() failed on port %u: error %d\n", port_id, ret);
+	}
+
+	plog_info("\t\tStarting up port %u ...", port_id);
+	ret = rte_eth_dev_start(port_id);
+
+	PROX_PANIC(ret < 0, "\n\t\t\trte_eth_dev_start() failed on port %u: error %d\n", port_id, ret);
+	plog_info(" done: ");
+
+	/* Getting link status can be done without waiting if Link
+	   State Interrupt is enabled since in that case, if the link
+	   is recognized as being down, an interrupt will notify that
+	   it has gone up. */
+	if (port_cfg->port_conf.intr_conf.lsc)
+		rte_eth_link_get_nowait(port_id, &link);
+	else
+		rte_eth_link_get(port_id, &link);
+
+	port_cfg->link_up = link.link_status;
+	port_cfg->link_speed = link.link_speed;
+	if (link.link_status) {
+		plog_info("Link Up - speed %'u Mbps - %s\n",
+			  link.link_speed,
+			  (link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
+			  "full-duplex" : "half-duplex");
+	}
+	else {
+		plog_info("Link Down\n");
+	}
+
+	if (port_cfg->promiscuous) {
+		rte_eth_promiscuous_enable(port_id);
+		plog_info("\t\tport %u in promiscuous mode\n", port_id);
+	}
+
+	if (strcmp(port_cfg->short_name, "ixgbe_vf") &&
+	    strcmp(port_cfg->short_name, "i40e") &&
+	    strcmp(port_cfg->short_name, "i40e_vf") &&
+	    strcmp(port_cfg->short_name, "vmxnet3")) {
+		for (uint8_t i = 0; i < 16; ++i) {
+			ret = rte_eth_dev_set_rx_queue_stats_mapping(port_id, i, i);
+			if (ret) {
+				plog_info("\t\trte_eth_dev_set_rx_queue_stats_mapping() failed: error %d\n", ret);
+			}
+			ret = rte_eth_dev_set_tx_queue_stats_mapping(port_id, i, i);
+			if (ret) {
+				plog_info("\t\trte_eth_dev_set_tx_queue_stats_mapping() failed: error %d\n", ret);
+			}
+		}
+	}
+}
+
+void init_port_all(void)
+{
+	uint8_t max_port_idx = prox_last_port_active() + 1;
+
+	for (uint8_t portid = 0; portid < max_port_idx; ++portid) {
+		if (!prox_port_cfg[portid].active) {
+			continue;
+		}
+		init_port(&prox_port_cfg[portid]);
+	}
+}
+
+void close_ports_atexit(void)
+{
+	uint8_t max_port_idx = prox_last_port_active() + 1;
+
+	for (uint8_t portid = 0; portid < max_port_idx; ++portid) {
+		if (!prox_port_cfg[portid].active) {
+			continue;
+		}
+		rte_eth_dev_close(portid);
+	}
+}
+
+void init_port_addr(void)
+{
+	struct prox_port_cfg *port_cfg;
+
+	for (uint8_t port_id = 0; port_id < PROX_MAX_PORTS; ++port_id) {
+		if (!prox_port_cfg[port_id].active) {
+			continue;
+		}
+		port_cfg = &prox_port_cfg[port_id];
+
+		switch (port_cfg->type) {
+		case PROX_PORT_MAC_HW:
+			rte_eth_macaddr_get(port_id, &port_cfg->eth_addr);
+			break;
+		case PROX_PORT_MAC_RAND:
+			eth_random_addr(port_cfg->eth_addr.addr_bytes);
+			break;
+		case PROX_PORT_MAC_SET:
+			break;
+		}
+	}
+}
+
+int port_is_active(uint8_t port_id)
+{
+	if (port_id > PROX_MAX_PORTS) {
+		plog_info("requested port is higher than highest supported port ID (%u)\n", PROX_MAX_PORTS);
+		return 0;
+	}
+
+	struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
+	if (!port_cfg->active) {
+		plog_info("Port %u is not active\n", port_id);
+		return 0;
+	}
+	return 1;
+}
diff --git a/VNFs/DPPD-PROX/prox_port_cfg.h b/VNFs/DPPD-PROX/prox_port_cfg.h
new file mode 100644
index 00000000..17616187
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_port_cfg.h
@@ -0,0 +1,83 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROX_PORT_CFG_H
+#define _PROX_PORT_CFG_H
+
+#include <rte_ether.h>
+#include <rte_ethdev.h>
+
+#include "prox_globals.h"
+
+enum addr_type {PROX_PORT_MAC_HW, PROX_PORT_MAC_SET, PROX_PORT_MAC_RAND};
+
+#define IPV4_CKSUM	1
+#define UDP_CKSUM	2
+
+struct prox_port_cfg {
+	struct rte_mempool *pool[32];  /* Rx/Tx mempool */
+	size_t pool_size[32];
+	uint8_t promiscuous;
+	uint8_t lsc_set_explicitely; /* Explicitly enable/disable lsc */
+	uint8_t lsc_val;
+	uint8_t active;
+	int socket;
+	uint16_t max_rxq;         /* max number of Tx queues */
+	uint16_t max_txq;         /* max number of Tx queues */
+	uint16_t n_rxq;           /* number of used Rx queues */
+	uint16_t n_txq;           /* number of used Tx queues */
+	uint32_t n_rxd;
+	uint32_t n_txd;
+	uint8_t  link_up;
+	uint32_t  link_speed;
+	uint32_t  mtu;
+	enum addr_type    type;
+	struct ether_addr eth_addr;    /* port MAC address */
+	char name[MAX_NAME_SIZE];
+	char short_name[MAX_NAME_SIZE];
+	char driver_name[MAX_NAME_SIZE];
+	char rx_ring[MAX_NAME_SIZE];
+	char tx_ring[MAX_NAME_SIZE];
+	char pci_addr[32];
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_eth_txconf tx_conf;
+	struct {
+		int tx_offload_cksum;
+	} capabilities;
+};
+
+extern rte_atomic32_t lsc;
+
+int prox_nb_active_ports(void);
+int prox_last_port_active(void);
+
+extern struct prox_port_cfg prox_port_cfg[];
+
+void init_rte_dev(int use_dummy_devices);
+uint8_t init_rte_ring_dev(void);
+void init_port_addr(void);
+void init_port_all(void);
+void close_ports_atexit(void);
+
+struct rte_mempool;
+
+void prox_pktmbuf_init(struct rte_mempool *mp, void *opaque_arg, void *_m, unsigned i);
+void prox_pktmbuf_reinit(void *arg, void *start, void *end, uint32_t idx);
+
+int port_is_active(uint8_t port_id);
+
+#endif /* __PROX_PORT_CFG_H_ */
diff --git a/VNFs/DPPD-PROX/prox_shared.c b/VNFs/DPPD-PROX/prox_shared.c
new file mode 100644
index 00000000..890d564b
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_shared.c
@@ -0,0 +1,174 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <stdio.h>
+#include <rte_hash.h>
+#include <rte_hash_crc.h>
+#include <rte_version.h>
+
+#include "quit.h"
+#include "log.h"
+#include "prox_shared.h"
+#include "prox_globals.h"
+
+#define INIT_HASH_TABLE_SIZE 8192
+
+struct prox_shared {
+	struct rte_hash *hash;
+	size_t          size;
+};
+
+struct prox_shared sh_system;
+struct prox_shared sh_socket[MAX_SOCKETS];
+struct prox_shared sh_core[RTE_MAX_LCORE];
+
+static char* get_sh_name(void)
+{
+	static char name[] = "prox_sh";
+
+	name[0]++;
+	return name;
+}
+
+struct rte_hash_parameters param = {
+	.key_len = 256,
+	.hash_func = rte_hash_crc,
+	.hash_func_init_val = 0,
+	.socket_id = 0,
+};
+
+static void prox_sh_create_hash(struct prox_shared *ps, size_t size)
+{
+	param.entries = size;
+	param.name = get_sh_name();
+	ps->hash = rte_hash_create(&param);
+	PROX_PANIC(ps->hash == NULL, "Failed to create hash table for shared data");
+	ps->size = size;
+	if (ps->size == INIT_HASH_TABLE_SIZE)
+		plog_info("Shared data tracking hash table created with size %zu\n", ps->size);
+	else
+		plog_info("Shared data tracking hash table grew to %zu\n", ps->size);
+}
+
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
+static int copy_hash(struct rte_hash *new_hash, struct rte_hash *old_hash)
+{
+	const void *next_key;
+	void *next_data;
+	uint32_t iter = 0;
+
+	while (rte_hash_iterate(old_hash, &next_key, &next_data, &iter) >= 0) {
+		if (rte_hash_add_key_data(new_hash, next_key, next_data) < 0)
+			return -1;
+	}
+
+	return 0;
+}
+#endif
+
+static int prox_sh_add(struct prox_shared *ps, const char *name, void *data)
+{
+	char key[256] = {0};
+	int ret;
+
+	strncpy(key, name, sizeof(key));
+	if (ps->size == 0) {
+		prox_sh_create_hash(ps, INIT_HASH_TABLE_SIZE);
+	}
+
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
+	do {
+		ret = rte_hash_add_key_data(ps->hash, key, data);
+		if (ret < 0) {
+			struct rte_hash *old = ps->hash;
+			int success;
+			do {
+				prox_sh_create_hash(ps, ps->size * 2);
+				success = !copy_hash(ps->hash, old);
+				if (success)
+					rte_hash_free(old);
+				else
+					rte_hash_free(ps->hash);
+			} while (!success);
+		}
+	} while (ret < 0);
+#else
+		PROX_PANIC(1, "DPDK < 2.1 not fully supported");
+#endif
+	return 0;
+}
+
+static void *prox_sh_find(struct prox_shared *sh, const char *name)
+{
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
+	char key[256] = {0};
+	int ret;
+	void *data;
+
+	if (!sh->hash)
+		return NULL;
+
+	strncpy(key, name, sizeof(key));
+	ret = rte_hash_lookup_data(sh->hash, key, &data);
+	if (ret >= 0)
+		return data;
+#else
+		PROX_PANIC(1, "DPDK < 2.1 not fully supported");
+#endif
+	return NULL;
+}
+
+int prox_sh_add_system(const char *name, void *data)
+{
+	return prox_sh_add(&sh_system, name, data);
+}
+
+int prox_sh_add_socket(const int socket_id, const char *name, void *data)
+{
+	if (socket_id >= MAX_SOCKETS)
+		return -1;
+
+	return prox_sh_add(&sh_socket[socket_id], name, data);
+}
+
+int prox_sh_add_core(const int core_id, const char *name, void *data)
+{
+	if (core_id >= RTE_MAX_LCORE)
+		return -1;
+
+	return prox_sh_add(&sh_core[core_id], name, data);
+}
+
+void *prox_sh_find_system(const char *name)
+{
+	return prox_sh_find(&sh_system, name);
+}
+
+void *prox_sh_find_socket(const int socket_id, const char *name)
+{
+	if (socket_id >= MAX_SOCKETS)
+		return NULL;
+
+	return prox_sh_find(&sh_socket[socket_id], name);
+}
+
+void *prox_sh_find_core(const int core_id, const char *name)
+{
+	if (core_id >= RTE_MAX_LCORE)
+		return NULL;
+
+	return prox_sh_find(&sh_core[core_id], name);
+}
diff --git a/VNFs/DPPD-PROX/prox_shared.h b/VNFs/DPPD-PROX/prox_shared.h
new file mode 100644
index 00000000..c98b1d64
--- /dev/null
+++ b/VNFs/DPPD-PROX/prox_shared.h
@@ -0,0 +1,32 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROX_SHARED_H_
+#define _PROX_SHARED_H_
+
+#include <rte_ether.h>
+
+/* Data can be shared at different levels. The levels are core wide,
+   socket wide and system wide. */
+int prox_sh_add_system(const char *name, void *data);
+int prox_sh_add_socket(const int socket_id, const char *name, void *data);
+int prox_sh_add_core(const int core_id, const char *name, void *data);
+
+void *prox_sh_find_system(const char *name);
+void *prox_sh_find_socket(const int socket_id, const char *name);
+void *prox_sh_find_core(const int core_id, const char *name);
+
+#endif /* _PROX_SHARED_H_ */
diff --git a/VNFs/DPPD-PROX/qinq.h b/VNFs/DPPD-PROX/qinq.h
new file mode 100644
index 00000000..14da9753
--- /dev/null
+++ b/VNFs/DPPD-PROX/qinq.h
@@ -0,0 +1,40 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _QINQ_H_
+#define _QINQ_H_
+
+#include <rte_ether.h>
+
+struct my_vlan_hdr {
+	uint16_t eth_proto;
+	uint16_t vlan_tci;
+} __attribute__((packed));
+
+struct vlans {
+	struct my_vlan_hdr svlan;
+	struct my_vlan_hdr cvlan;
+};
+
+struct qinq_hdr {
+	struct ether_addr  d_addr;
+	struct ether_addr  s_addr;
+	struct my_vlan_hdr svlan;
+	struct my_vlan_hdr cvlan;
+	uint16_t ether_type;
+} __attribute__((packed));
+
+#endif /* _QINQ_H_ */
diff --git a/VNFs/DPPD-PROX/quit.h b/VNFs/DPPD-PROX/quit.h
new file mode 100644
index 00000000..a01c0a02
--- /dev/null
+++ b/VNFs/DPPD-PROX/quit.h
@@ -0,0 +1,46 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _QUIT_H_
+#define _QUIT_H_
+
+#include <signal.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <rte_debug.h>
+
+#include "display.h"
+#include "prox_cfg.h"
+
+/* PROX_PANIC for checks that are possibly hit due to configuration or
+   when feature is not implemented. */
+/* Restore tty and abort if there is a problem */
+#define PROX_PANIC(cond, ...) do {					\
+		if (cond) {						\
+			plog_info(__VA_ARGS__);				\
+			display_end();					\
+ 			if (prox_cfg.flags & DSF_DAEMON) {		\
+                		pid_t ppid = getppid();			\
+				plog_info("sending SIGUSR2 to %d\n", ppid);\
+				kill(ppid, SIGUSR2);			\
+			}						\
+			rte_panic("PANIC at %s:%u, callstack:\n",	\
+				  __FILE__, __LINE__);			\
+		}							\
+	} while (0)
+
+#endif /* _QUIT_H_ */
diff --git a/VNFs/DPPD-PROX/random.h b/VNFs/DPPD-PROX/random.h
new file mode 100644
index 00000000..85508126
--- /dev/null
+++ b/VNFs/DPPD-PROX/random.h
@@ -0,0 +1,58 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+/*
+  This pseudorandom number generator is based on ref_xorshift128plus,
+  as implemented by reference_xorshift.h, which has been obtained
+  from https://sourceforge.net/projects/xorshift-cpp/
+
+  The licensing terms for reference_xorshift.h are reproduced below.
+
+  //  Written in 2014 by Ivo Doko (ivo.doko@gmail.com)
+  //  based on code written by Sebastiano Vigna (vigna@acm.org)
+  //  To the extent possible under law, the author has dedicated
+  //  all copyright and related and neighboring rights to this
+  //  software to the public domain worldwide. This software is
+  //  distributed without any warranty.
+  //  See <http://creativecommons.org/publicdomain/zero/1.0/>.
+*/
+
+#ifndef _RANDOM_H_
+#define _RANDOM_H_
+
+#include <rte_cycles.h>
+
+struct random {
+  uint64_t state[2];
+};
+
+static void random_init_seed(struct random *random)
+{
+  random->state[0] = rte_rdtsc();
+  random->state[1] = rte_rdtsc();
+}
+
+static uint64_t random_next(struct random *random)
+{
+  const uint64_t s0 = random->state[1];
+  const uint64_t s1 = random->state[0] ^ (random->state[0] << 23);
+
+  random->state[0] = random->state[1];
+  random->state[1] = (s1 ^ (s1 >> 18) ^ s0 ^ (s0 >> 5)) + s0;
+  return random->state[1];
+}
+
+#endif /* _RANDOM_H_ */
diff --git a/VNFs/DPPD-PROX/run.c b/VNFs/DPPD-PROX/run.c
new file mode 100644
index 00000000..971d7148
--- /dev/null
+++ b/VNFs/DPPD-PROX/run.c
@@ -0,0 +1,241 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <inttypes.h>
+#include <string.h>
+
+#include <rte_launch.h>
+#include <rte_cycles.h>
+#include <rte_atomic.h>
+
+#include "run.h"
+#include "prox_cfg.h"
+#include "prox_port_cfg.h"
+#include "quit.h"
+#include "commands.h"
+#include "main.h"
+#include "log.h"
+#include "display.h"
+#include "stats.h"
+#include "stats_cons.h"
+#include "stats_cons_log.h"
+#include "stats_cons_cli.h"
+
+#include "input.h"
+#include "input_curses.h"
+#include "input_conn.h"
+
+static int needs_refresh;
+static uint64_t update_interval;
+static int stop_prox = 0; /* set to 1 to stop prox */
+
+void set_update_interval(uint32_t msec)
+{
+	update_interval = msec_to_tsc(msec);
+}
+
+void req_refresh(void)
+{
+	needs_refresh = 1;
+}
+
+void quit(void)
+{
+	static rte_atomic32_t already_leaving = RTE_ATOMIC32_INIT(0);
+	if (!rte_atomic32_test_and_set(&already_leaving))
+		return;
+
+	plog_info("Leaving...\n");
+	if (lcore_cfg == NULL)
+		exit(EXIT_SUCCESS);
+	stop_core_all(-1);
+	stop_prox = 1;
+}
+
+static void update_link_states(void)
+{
+	struct prox_port_cfg *port_cfg;
+	struct rte_eth_link link;
+
+	for (uint8_t portid = 0; portid < PROX_MAX_PORTS; ++portid) {
+		if (!prox_port_cfg[portid].active) {
+			continue;
+		}
+
+		port_cfg  = &prox_port_cfg[portid];
+		rte_eth_link_get_nowait(portid, &link);
+		port_cfg->link_up = link.link_status;
+		port_cfg->link_speed = link.link_speed;
+	}
+}
+
+static struct stats_cons stats_cons[8];
+static size_t n_stats_cons = 0;
+static uint16_t stats_cons_flags = 0;
+
+static void stats_cons_add(struct stats_cons *sc)
+{
+	if (n_stats_cons == sizeof(stats_cons)/sizeof(stats_cons[0]))
+		return;
+
+	stats_cons[n_stats_cons++] = *sc;
+	sc->init();
+	stats_cons_flags |= sc->flags;
+}
+
+static void stats_cons_notify(void)
+{
+	for (size_t i = 0; i < n_stats_cons; ++i) {
+		stats_cons[i].notify();
+	}
+}
+
+static void stats_cons_refresh(void)
+{
+	for (size_t i = 0; i < n_stats_cons; ++i) {
+		if (stats_cons[i].refresh)
+			stats_cons[i].refresh();
+	}
+}
+
+static void stats_cons_finish(void)
+{
+	for (size_t i = 0; i < n_stats_cons; ++i) {
+		if (stats_cons[i].finish)
+			stats_cons[i].finish();
+	}
+}
+
+static void busy_wait_until(uint64_t deadline)
+{
+	while (rte_rdtsc() < deadline)
+		;
+}
+
+static void multiplexed_input_stats(uint64_t deadline)
+{
+	input_proc_until(deadline);
+
+	if (needs_refresh) {
+		needs_refresh = 0;
+		stats_cons_refresh();
+	}
+
+	if (rte_atomic32_read(&lsc)) {
+		rte_atomic32_dec(&lsc);
+		update_link_states();
+		stats_cons_refresh();
+	}
+}
+
+static void print_warnings(void)
+{
+	if (get_n_warnings() == -1) {
+		plog_info("Warnings disabled\n");
+	}
+	else if (get_n_warnings() > 0) {
+		int n_print = get_n_warnings() < 5? get_n_warnings(): 5;
+		plog_info("Started with %d warnings, last %d warnings: \n", get_n_warnings(), n_print);
+		for (int i = -n_print + 1; i <= 0; ++i) {
+			plog_info("%s", get_warning(i));
+		}
+	}
+	else {
+		plog_info("Started without warnings\n");
+	}
+}
+
+/* start main loop */
+void __attribute__((noreturn)) run(uint32_t flags)
+{
+	uint64_t cur_tsc;
+	uint64_t next_update;
+	uint64_t stop_tsc = 0;
+	const uint64_t update_interval_threshold = usec_to_tsc(1);
+
+	if (flags & DSF_LISTEN_TCP)
+		PROX_PANIC(reg_input_tcp(), "Failed to start listening on TCP port 8474: %s\n", strerror(errno));
+	if (flags & DSF_LISTEN_UDS)
+		PROX_PANIC(reg_input_uds(), "Failed to start listening on UDS /tmp/prox.sock: %s\n", strerror(errno));
+
+	if (prox_cfg.use_stats_logger)
+		stats_cons_add(stats_cons_log_get());
+
+	stats_init(prox_cfg.start_time, prox_cfg.duration_time);
+	stats_update(STATS_CONS_F_ALL);
+
+	switch (prox_cfg.ui) {
+	case PROX_UI_CURSES:
+		reg_input_curses();
+		stats_cons_add(&display);
+		break;
+	case PROX_UI_CLI:
+		stats_cons_add(stats_cons_cli_get());
+		break;
+	case PROX_UI_NONE:
+	default:
+		break;
+	}
+
+	if (flags & DSF_AUTOSTART)
+		start_core_all(-1);
+	else
+		stop_core_all(-1);
+
+	cur_tsc = rte_rdtsc();
+	if (prox_cfg.duration_time != 0) {
+		stop_tsc = cur_tsc + sec_to_tsc(prox_cfg.start_time + prox_cfg.duration_time);
+	}
+
+	stats_cons_notify();
+	stats_cons_refresh();
+
+	update_interval = str_to_tsc(prox_cfg.update_interval_str);
+	next_update = cur_tsc + update_interval;
+
+	cmd_rx_tx_info();
+	print_warnings();
+
+	while (stop_prox == 0) {
+
+		if (update_interval < update_interval_threshold)
+			busy_wait_until(next_update);
+		else
+			multiplexed_input_stats(next_update);
+
+		next_update += update_interval;
+
+		stats_update(stats_cons_flags);
+		stats_cons_notify();
+
+		if (stop_tsc && rte_rdtsc() >= stop_tsc) {
+			stop_prox = 1;
+		}
+	}
+
+	stats_cons_finish();
+
+	if (prox_cfg.flags & DSF_WAIT_ON_QUIT) {
+		stop_core_all(-1);
+	}
+
+	if (prox_cfg.logbuf) {
+		file_print(prox_cfg.logbuf);
+	}
+
+	display_end();
+	exit(EXIT_SUCCESS);
+}
diff --git a/VNFs/DPPD-PROX/run.h b/VNFs/DPPD-PROX/run.h
new file mode 100644
index 00000000..3c61aca6
--- /dev/null
+++ b/VNFs/DPPD-PROX/run.h
@@ -0,0 +1,25 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _RUN_H_
+#define _RUN_H_
+
+void run(uint32_t flags);
+void quit(void);
+void req_refresh(void);
+void set_update_interval(uint32_t msec);
+
+#endif /* _RUN_H_ */
diff --git a/VNFs/DPPD-PROX/rw_reg.c b/VNFs/DPPD-PROX/rw_reg.c
new file mode 100644
index 00000000..a0e59085
--- /dev/null
+++ b/VNFs/DPPD-PROX/rw_reg.c
@@ -0,0 +1,36 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ethdev.h>
+#include "rw_reg.h"
+
+int read_reg(uint8_t port_id, uint32_t addr, uint32_t *reg)
+{
+	struct rte_eth_dev *dev = &rte_eth_devices[port_id];
+	struct _dev_hw *hw = (struct _dev_hw *)dev->data->dev_private;
+
+	*reg = PROX_READ_REG(hw, addr);
+	return 0;
+}
+
+int write_reg(uint8_t port_id, uint32_t reg, uint32_t val)
+{
+	struct rte_eth_dev *dev = &rte_eth_devices[port_id];
+	struct _dev_hw *hw = (struct _dev_hw *)dev->data->dev_private;
+
+	PROX_WRITE_REG(hw, reg, val);
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/rw_reg.h b/VNFs/DPPD-PROX/rw_reg.h
new file mode 100644
index 00000000..1e38c7d0
--- /dev/null
+++ b/VNFs/DPPD-PROX/rw_reg.h
@@ -0,0 +1,43 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef __RW_REG_H__
+#define __RW_REG_H__
+
+/* Simplified, from DPDK 1.8 */
+struct _dev_hw {
+	uint8_t *hw_addr;
+};
+/* Registers access */
+
+#define PROX_PCI_REG_ADDR(hw, reg) \
+	((volatile uint32_t *)((char *)(hw)->hw_addr + (reg)))
+#define PROX_READ_REG(hw, reg) \
+	prox_read_addr(PROX_PCI_REG_ADDR((hw), (reg)))
+#define PROX_PCI_REG(reg) (*((volatile uint32_t *)(reg)))
+#define PROX_PCI_REG_WRITE(reg_addr, value) \
+	*((volatile uint32_t *) (reg_addr)) = (value)
+#define PROX_WRITE_REG(hw,reg,value) \
+	PROX_PCI_REG_WRITE(PROX_PCI_REG_ADDR((hw), (reg)), (value))
+
+static inline uint32_t prox_read_addr(volatile void* addr)
+{
+        return rte_le_to_cpu_32(PROX_PCI_REG(addr));
+}
+
+int read_reg(uint8_t portid, uint32_t addr, uint32_t *reg);
+int write_reg(uint8_t portid, uint32_t reg, uint32_t val);
+#endif
diff --git a/VNFs/DPPD-PROX/rx_pkt.c b/VNFs/DPPD-PROX/rx_pkt.c
new file mode 100644
index 00000000..a6c1fd10
--- /dev/null
+++ b/VNFs/DPPD-PROX/rx_pkt.c
@@ -0,0 +1,427 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+#include <rte_ethdev.h>
+#include <rte_version.h>
+
+#include "rx_pkt.h"
+#include "task_base.h"
+#include "clock.h"
+#include "stats.h"
+#include "log.h"
+#include "mbuf_utils.h"
+#include "input.h" /* Needed for callback on dump */
+
+/* _param version of the rx_pkt_hw functions are used to create two
+   instances of very similar variations of these functions. The
+   variations are specified by the "multi" parameter which significies
+   that the rte_eth_rx_burst function should be called multiple times.
+   The reason for this is that with the vector PMD, the maximum number
+   of packets being returned is 32. If packets have been split in
+   multiple mbufs then rte_eth_rx_burst might even receive less than
+   32 packets.
+   Some algorithms (like QoS) only work correctly if more than 32
+   packets are received if the dequeue step involves finding 32 packets.
+*/
+
+#define MIN_PMD_RX 32
+
+static uint16_t rx_pkt_hw_port_queue(struct port_queue *pq, struct rte_mbuf **mbufs, int multi)
+{
+	uint16_t nb_rx, n;
+
+	nb_rx = rte_eth_rx_burst(pq->port, pq->queue, mbufs, MAX_PKT_BURST);
+
+	if (multi) {
+		n = nb_rx;
+		while (n != 0 && MAX_PKT_BURST - nb_rx >= MIN_PMD_RX) {
+			n = rte_eth_rx_burst(pq->port, pq->queue, mbufs + nb_rx, MIN_PMD_RX);
+			nb_rx += n;
+			PROX_PANIC(nb_rx > 64, "Received %d packets while expecting maximum %d\n", n, MIN_PMD_RX);
+		}
+	}
+	return nb_rx;
+}
+
+static void next_port(struct rx_params_hw *rx_params_hw)
+{
+	++rx_params_hw->last_read_portid;
+	if (unlikely(rx_params_hw->last_read_portid == rx_params_hw->nb_rxports)) {
+		rx_params_hw->last_read_portid = 0;
+	}
+}
+
+static void next_port_pow2(struct rx_params_hw *rx_params_hw)
+{
+	rx_params_hw->last_read_portid = (rx_params_hw->last_read_portid + 1) & rx_params_hw->rxport_mask;
+}
+
+static uint16_t rx_pkt_hw_param(struct task_base *tbase, struct rte_mbuf ***mbufs, int multi,
+				void (*next)(struct rx_params_hw *rx_param_hw))
+{
+	uint8_t last_read_portid;
+	uint16_t nb_rx;
+
+	START_EMPTY_MEASSURE();
+	*mbufs = tbase->ws_mbuf->mbuf[0] +
+		(RTE_ALIGN_CEIL(tbase->ws_mbuf->idx[0].prod, 2) & WS_MBUF_MASK);
+
+	last_read_portid = tbase->rx_params_hw.last_read_portid;
+	struct port_queue *pq = &tbase->rx_params_hw.rx_pq[last_read_portid];
+
+	nb_rx = rx_pkt_hw_port_queue(pq, *mbufs, multi);
+	next(&tbase->rx_params_hw);
+
+	if (likely(nb_rx > 0)) {
+		TASK_STATS_ADD_RX(&tbase->aux->stats, nb_rx);
+		return nb_rx;
+	}
+	TASK_STATS_ADD_IDLE(&tbase->aux->stats, rte_rdtsc() - cur_tsc);
+	return 0;
+}
+
+static inline uint16_t rx_pkt_hw1_param(struct task_base *tbase, struct rte_mbuf ***mbufs, int multi)
+{
+	uint16_t nb_rx, n;
+
+	START_EMPTY_MEASSURE();
+	*mbufs = tbase->ws_mbuf->mbuf[0] +
+		(RTE_ALIGN_CEIL(tbase->ws_mbuf->idx[0].prod, 2) & WS_MBUF_MASK);
+
+	nb_rx = rte_eth_rx_burst(tbase->rx_params_hw1.rx_pq.port,
+				 tbase->rx_params_hw1.rx_pq.queue,
+				 *mbufs, MAX_PKT_BURST);
+
+	if (multi) {
+		n = nb_rx;
+		while ((n != 0) && (MAX_PKT_BURST - nb_rx >= MIN_PMD_RX)) {
+			n = rte_eth_rx_burst(tbase->rx_params_hw1.rx_pq.port,
+				 tbase->rx_params_hw1.rx_pq.queue,
+				 *mbufs + nb_rx, MIN_PMD_RX);
+			nb_rx += n;
+			PROX_PANIC(nb_rx > 64, "Received %d packets while expecting maximum %d\n", n, MIN_PMD_RX);
+		}
+	}
+
+	if (likely(nb_rx > 0)) {
+		TASK_STATS_ADD_RX(&tbase->aux->stats, nb_rx);
+		return nb_rx;
+	}
+	TASK_STATS_ADD_IDLE(&tbase->aux->stats, rte_rdtsc() - cur_tsc);
+	return 0;
+}
+
+uint16_t rx_pkt_hw(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	return rx_pkt_hw_param(tbase, mbufs, 0, next_port);
+}
+
+uint16_t rx_pkt_hw_pow2(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	return rx_pkt_hw_param(tbase, mbufs, 0, next_port_pow2);
+}
+
+uint16_t rx_pkt_hw1(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	return rx_pkt_hw1_param(tbase, mbufs, 0);
+}
+
+uint16_t rx_pkt_hw_multi(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	return rx_pkt_hw_param(tbase, mbufs, 1, next_port);
+}
+
+uint16_t rx_pkt_hw_pow2_multi(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	return rx_pkt_hw_param(tbase, mbufs, 1, next_port_pow2);
+}
+
+uint16_t rx_pkt_hw1_multi(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	return rx_pkt_hw1_param(tbase, mbufs, 1);
+}
+
+/* The following functions implement ring access */
+static uint16_t ring_deq(struct rte_ring *r, struct rte_mbuf **mbufs)
+{
+	void **v_mbufs = (void **)mbufs;
+#ifdef BRAS_RX_BULK
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+	return rte_ring_sc_dequeue_bulk(r, v_mbufs, MAX_RING_BURST) < 0? 0 : MAX_RING_BURST;
+#else
+	return rte_ring_sc_dequeue_bulk(r, v_mbufs, MAX_RING_BURST, NULL);
+#endif
+#else
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+	return rte_ring_sc_dequeue_burst(r, v_mbufs, MAX_RING_BURST);
+#else
+	return rte_ring_sc_dequeue_burst(r, v_mbufs, MAX_RING_BURST, NULL);
+#endif
+#endif
+}
+
+uint16_t rx_pkt_sw(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	START_EMPTY_MEASSURE();
+	*mbufs = tbase->ws_mbuf->mbuf[0] + (tbase->ws_mbuf->idx[0].prod & WS_MBUF_MASK);
+	uint8_t lr = tbase->rx_params_sw.last_read_ring;
+	uint16_t nb_rx;
+
+	do {
+		nb_rx = ring_deq(tbase->rx_params_sw.rx_rings[lr], *mbufs);
+		lr = lr + 1 == tbase->rx_params_sw.nb_rxrings? 0 : lr + 1;
+	} while(!nb_rx && lr != tbase->rx_params_sw.last_read_ring);
+
+	tbase->rx_params_sw.last_read_ring = lr;
+
+	if (nb_rx != 0) {
+		TASK_STATS_ADD_RX(&tbase->aux->stats, nb_rx);
+		return nb_rx;
+	}
+	else {
+		TASK_STATS_ADD_IDLE(&tbase->aux->stats, rte_rdtsc() - cur_tsc);
+		return 0;
+	}
+}
+
+/* Same as rx_pkt_sw expect with a mask for the number of receive
+   rings (can only be used if nb_rxring is a power of 2). */
+uint16_t rx_pkt_sw_pow2(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	START_EMPTY_MEASSURE();
+	*mbufs = tbase->ws_mbuf->mbuf[0] + (tbase->ws_mbuf->idx[0].prod & WS_MBUF_MASK);
+	uint8_t lr = tbase->rx_params_sw.last_read_ring;
+	uint16_t nb_rx;
+
+	do {
+		nb_rx = ring_deq(tbase->rx_params_sw.rx_rings[lr], *mbufs);
+		lr = (lr + 1) & tbase->rx_params_sw.rxrings_mask;
+	} while(!nb_rx && lr != tbase->rx_params_sw.last_read_ring);
+
+	tbase->rx_params_sw.last_read_ring = lr;
+
+	if (nb_rx != 0) {
+		TASK_STATS_ADD_RX(&tbase->aux->stats, nb_rx);
+		return nb_rx;
+	}
+	else {
+		TASK_STATS_ADD_IDLE(&tbase->aux->stats, rte_rdtsc() - cur_tsc);
+		return 0;
+	}
+}
+
+uint16_t rx_pkt_self(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	START_EMPTY_MEASSURE();
+	uint16_t nb_rx = tbase->ws_mbuf->idx[0].nb_rx;
+	if (nb_rx) {
+		tbase->ws_mbuf->idx[0].nb_rx = 0;
+		*mbufs = tbase->ws_mbuf->mbuf[0] + (tbase->ws_mbuf->idx[0].prod & WS_MBUF_MASK);
+		TASK_STATS_ADD_RX(&tbase->aux->stats, nb_rx);
+		return nb_rx;
+	}
+	else {
+		TASK_STATS_ADD_IDLE(&tbase->aux->stats, rte_rdtsc() - cur_tsc);
+		return 0;
+	}
+}
+
+/* Used for tasks that do not receive packets (i.e. Packet
+generation).  Always returns 1 but never returns packets and does not
+increment statistics. This function allows to use the same code path
+as for tasks that actually receive packets. */
+uint16_t rx_pkt_dummy(__attribute__((unused)) struct task_base *tbase,
+		      __attribute__((unused)) struct rte_mbuf ***mbufs)
+{
+	return 1;
+}
+
+/* After the system has been configured, it is known if there is only
+   one RX ring. If this is the case, a more specialized version of the
+   function above can be used to save cycles. */
+uint16_t rx_pkt_sw1(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	START_EMPTY_MEASSURE();
+	*mbufs = tbase->ws_mbuf->mbuf[0] + (tbase->ws_mbuf->idx[0].prod & WS_MBUF_MASK);
+	uint16_t nb_rx = ring_deq(tbase->rx_params_sw1.rx_ring, *mbufs);
+
+	if (nb_rx != 0) {
+		TASK_STATS_ADD_RX(&tbase->aux->stats, nb_rx);
+		return nb_rx;
+	}
+	else {
+		TASK_STATS_ADD_IDLE(&tbase->aux->stats, rte_rdtsc() - cur_tsc);
+		return 0;
+	}
+}
+
+static uint16_t call_prev_rx_pkt(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	uint16_t ret;
+
+	if (tbase->aux->rx_prev_idx + 1 == tbase->aux->rx_prev_count) {
+		ret = tbase->aux->rx_pkt_prev[tbase->aux->rx_prev_idx](tbase, mbufs);
+	} else {
+		tbase->aux->rx_prev_idx++;
+		ret = tbase->aux->rx_pkt_prev[tbase->aux->rx_prev_idx](tbase, mbufs);
+		tbase->aux->rx_prev_idx--;
+	}
+
+	return ret;
+}
+
+/* Only used when there are packets to be dumped. This function is
+   meant as a debugging tool and is therefore not optimized. When the
+   number of packets to dump falls back to 0, the original (optimized)
+   rx function is restored. This allows to support dumping packets
+   without any performance impact if the feature is not used. */
+uint16_t rx_pkt_dump(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	uint16_t ret = call_prev_rx_pkt(tbase, mbufs);
+
+	if (ret) {
+		uint32_t n_dump = tbase->aux->task_rt_dump.n_print_rx;
+		n_dump = ret < n_dump? ret : n_dump;
+
+		if (tbase->aux->task_rt_dump.input->reply == NULL) {
+			for (uint32_t i = 0; i < n_dump; ++i) {
+				plogd_info((*mbufs)[i], "RX: ");
+			}
+		}
+		else {
+			struct input *input = tbase->aux->task_rt_dump.input;
+
+			for (uint32_t i = 0; i < n_dump; ++i) {
+				/* TODO: Execute callback with full
+				   data in a single call. */
+				char tmp[128];
+				int strlen;
+
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+				int port_id = ((*mbufs)[i])->port;
+#else
+				int port_id = ((*mbufs)[i])->pkt.in_port;
+#endif
+				strlen = snprintf(tmp, sizeof(tmp), "pktdump,%d,%d\n", port_id,
+						      rte_pktmbuf_pkt_len((*mbufs)[i]));
+
+				input->reply(input, tmp, strlen);
+				input->reply(input, rte_pktmbuf_mtod((*mbufs)[i], char *), rte_pktmbuf_pkt_len((*mbufs)[i]));
+				input->reply(input, "\n", 1);
+			}
+		}
+
+		tbase->aux->task_rt_dump.n_print_rx -= n_dump;
+
+		if (0 == tbase->aux->task_rt_dump.n_print_rx) {
+			task_base_del_rx_pkt_function(tbase, rx_pkt_dump);
+		}
+	}
+	return ret;
+}
+
+uint16_t rx_pkt_trace(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	uint16_t ret = call_prev_rx_pkt(tbase, mbufs);
+
+	if (ret) {
+		uint32_t n_trace = tbase->aux->task_rt_dump.n_trace;
+		n_trace = ret < n_trace? ret : n_trace;
+		tbase->aux->task_rt_dump.cur_trace = n_trace;
+
+		for (uint32_t i = 0; i < n_trace; ++i) {
+			uint8_t *pkt = rte_pktmbuf_mtod((*mbufs)[i], uint8_t *);
+			rte_memcpy(tbase->aux->task_rt_dump.pkt_cpy[i], pkt, sizeof(tbase->aux->task_rt_dump.pkt_cpy[i]));
+			tbase->aux->task_rt_dump.pkt_cpy_len[i] = rte_pktmbuf_pkt_len((*mbufs)[i]);
+			tbase->aux->task_rt_dump.pkt_mbuf_addr[i] = (*mbufs)[i];
+		}
+
+		tbase->aux->task_rt_dump.n_trace -= n_trace;
+		/* Unset by TX when n_trace = 0 */
+	}
+	return ret;
+}
+
+/* Gather the distribution of the number of packets that have been
+   received from one RX call. Since the value is only modified by the
+   task that receives the packet, no atomic operation is needed. */
+uint16_t rx_pkt_distr(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	uint16_t ret = call_prev_rx_pkt(tbase, mbufs);
+
+	tbase->aux->rx_bucket[ret]++;
+	return ret;
+}
+
+uint16_t rx_pkt_bw(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	uint16_t ret = call_prev_rx_pkt(tbase, mbufs);
+	uint32_t tot_bytes = 0;
+
+	for (uint16_t i = 0; i < ret; ++i) {
+		tot_bytes += mbuf_wire_size((*mbufs)[i]);
+	}
+
+	TASK_STATS_ADD_RX_BYTES(&tbase->aux->stats, tot_bytes);
+
+	return ret;
+}
+
+uint16_t rx_pkt_tsc(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	uint64_t before = rte_rdtsc();
+	uint16_t ret = call_prev_rx_pkt(tbase, mbufs);
+	uint64_t after = rte_rdtsc();
+
+	tbase->aux->tsc_rx.before = before;
+	tbase->aux->tsc_rx.after = after;
+
+	return ret;
+}
+
+uint16_t rx_pkt_all(struct task_base *tbase, struct rte_mbuf ***mbufs)
+{
+	uint16_t tot = 0;
+	uint16_t ret = 0;
+	struct rte_mbuf **new_mbufs;
+	struct rte_mbuf **dst = tbase->aux->all_mbufs;
+
+	/* In case we receive less than MAX_PKT_BURST packets in one
+	   iteration, do no perform any copying of mbuf pointers. Use
+	   the buffer itself instead. */
+	ret = call_prev_rx_pkt(tbase, &new_mbufs);
+	if (ret < MAX_PKT_BURST/2) {
+		*mbufs = new_mbufs;
+		return ret;
+	}
+
+	memcpy(dst + tot, new_mbufs, ret * sizeof(*dst));
+	tot += ret;
+	*mbufs = dst;
+
+	do {
+		ret = call_prev_rx_pkt(tbase, &new_mbufs);
+		memcpy(dst + tot, new_mbufs, ret * sizeof(*dst));
+		tot += ret;
+	} while (ret == MAX_PKT_BURST/2 && tot < MAX_RX_PKT_ALL - MAX_PKT_BURST);
+
+	if (tot >= MAX_RX_PKT_ALL - MAX_PKT_BURST) {
+		plog_err("Could not receive all packets - buffer full\n");
+	}
+
+	return tot;
+}
diff --git a/VNFs/DPPD-PROX/rx_pkt.h b/VNFs/DPPD-PROX/rx_pkt.h
new file mode 100644
index 00000000..57b948e2
--- /dev/null
+++ b/VNFs/DPPD-PROX/rx_pkt.h
@@ -0,0 +1,49 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _RX_PKT_H_
+#define _RX_PKT_H_
+
+#include <inttypes.h>
+
+struct rte_mbuf;
+struct task_base;
+
+uint16_t rx_pkt_hw(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_hw_pow2(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_hw1(struct task_base *tbase, struct rte_mbuf ***mbufs);
+
+/* The _multi variation of the function is used to work-around the
+   problem with QoS, multi-seg mbufs and vector PMD. When vector
+   PMD returns more than 32 packets, the two variations of the
+   receive function can be merged back together. */
+uint16_t rx_pkt_hw_multi(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_hw_pow2_multi(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_hw1_multi(struct task_base *tbase, struct rte_mbuf ***mbufs);
+
+uint16_t rx_pkt_sw(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_sw_pow2(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_sw1(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_self(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_dummy(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_dump(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_trace(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_distr(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_bw(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_tsc(struct task_base *tbase, struct rte_mbuf ***mbufs);
+uint16_t rx_pkt_all(struct task_base *tbase, struct rte_mbuf ***mbufs);
+
+#endif /* _RX_PKT_H_ */
diff --git a/VNFs/DPPD-PROX/stats.c b/VNFs/DPPD-PROX/stats.c
new file mode 100644
index 00000000..2418826f
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats.c
@@ -0,0 +1,100 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+
+#include "prox_malloc.h"
+#include "prox_cfg.h"
+#include "stats.h"
+#include "stats_port.h"
+#include "stats_mempool.h"
+#include "stats_ring.h"
+#include "stats_l4gen.h"
+#include "stats_latency.h"
+#include "stats_global.h"
+#include "stats_core.h"
+#include "stats_task.h"
+#include "stats_prio_task.h"
+#include "stats_latency.h"
+
+/* Stores all readed values from the cores, displaying is done afterwards because
+   displaying introduces overhead. If displaying was done right after the values
+   are read, inaccuracy is introduced for later cores */
+int last_stat; /* 0 or 1 to track latest 2 measurements */
+
+void stats_reset(void)
+{
+	stats_task_reset();
+	stats_prio_task_reset();
+	stats_port_reset();
+	stats_latency_reset();
+	stats_global_reset();
+}
+
+void stats_init(unsigned avg_start, unsigned duration)
+{
+	stats_lcore_init();
+	stats_task_init();
+	stats_prio_task_init();
+	stats_port_init();
+	stats_mempool_init();
+	stats_latency_init();
+	stats_l4gen_init();
+	stats_ring_init();
+	stats_global_init(avg_start, duration);
+}
+
+void stats_update(uint16_t flag_cons)
+{
+	/* Keep track of last 2 measurements. */
+	last_stat = !last_stat;
+
+	if (flag_cons & STATS_CONS_F_TASKS)
+		stats_task_update();
+
+	if (flag_cons & STATS_CONS_F_PRIO_TASKS)
+		stats_prio_task_update();
+
+	if (flag_cons & STATS_CONS_F_LCORE)
+		stats_lcore_update();
+
+	if (flag_cons & STATS_CONS_F_PORTS)
+		stats_port_update();
+
+	if (flag_cons & STATS_CONS_F_MEMPOOLS)
+		stats_mempool_update();
+
+	if (flag_cons & STATS_CONS_F_LATENCY)
+		stats_latency_update();
+
+	if (flag_cons & STATS_CONS_F_L4GEN)
+		stats_l4gen_update();
+
+	if (flag_cons & STATS_CONS_F_RINGS)
+		stats_ring_update();
+
+	if (flag_cons & STATS_CONS_F_LCORE)
+		stats_lcore_post_proc();
+
+	if (flag_cons & STATS_CONS_F_TASKS)
+		stats_task_post_proc();
+
+	if (flag_cons & STATS_CONS_F_PRIO_TASKS)
+		stats_prio_task_post_proc();
+
+	if (flag_cons & STATS_CONS_F_GLOBAL)
+		stats_global_post_proc();
+}
diff --git a/VNFs/DPPD-PROX/stats.h b/VNFs/DPPD-PROX/stats.h
new file mode 100644
index 00000000..382fc4d0
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats.h
@@ -0,0 +1,31 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_H_
+#define _STATS_H_
+
+#include <rte_atomic.h>
+
+#include "stats_cons.h"
+#include "clock.h"
+#include "prox_globals.h"
+#include "genl4_bundle.h"
+
+void stats_reset(void);
+void stats_init(unsigned avg_start, unsigned duration);
+void stats_update(uint16_t flag_cons);
+
+#endif /* _STATS_H_ */
diff --git a/VNFs/DPPD-PROX/stats_cons.h b/VNFs/DPPD-PROX/stats_cons.h
new file mode 100644
index 00000000..ba51f49f
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_cons.h
@@ -0,0 +1,39 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_CONS_H_
+#define _STATS_CONS_H_
+
+#define STATS_CONS_F_TASKS      0x01
+#define STATS_CONS_F_LCORE      0x02
+#define STATS_CONS_F_PORTS      0x04
+#define STATS_CONS_F_MEMPOOLS   0x08
+#define STATS_CONS_F_RINGS      0x10
+#define STATS_CONS_F_LATENCY    0x20
+#define STATS_CONS_F_L4GEN      0x40
+#define STATS_CONS_F_GLOBAL     0x80
+#define STATS_CONS_F_PRIO_TASKS 0x100
+#define STATS_CONS_F_ALL        0x1ff
+
+struct stats_cons {
+	void (*init)(void);
+	void (*notify)(void);
+	void (*refresh)(void); /* Only called if not NULL, used to signal lsc or core stop/start */
+	void (*finish)(void);
+	uint16_t flags;
+};
+
+#endif /* _STATS_CONS_H_ */
diff --git a/VNFs/DPPD-PROX/stats_cons_cli.c b/VNFs/DPPD-PROX/stats_cons_cli.c
new file mode 100644
index 00000000..4f9235c6
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_cons_cli.c
@@ -0,0 +1,48 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+
+#include "stats.h"
+#include "stats_cons_cli.h"
+#include "prox_cfg.h"
+#include "prox_args.h"
+#include "prox_assert.h"
+#include "commands.h"
+
+static struct stats_cons stats_cons_cli = {
+	.init = stats_cons_cli_init,
+	.notify = stats_cons_cli_notify,
+	.finish = stats_cons_cli_finish,
+	.flags = STATS_CONS_F_ALL,
+};
+
+struct stats_cons *stats_cons_cli_get(void)
+{
+	return &stats_cons_cli;
+}
+
+void stats_cons_cli_init(void)
+{
+}
+
+void stats_cons_cli_notify(void)
+{
+}
+
+void stats_cons_cli_finish(void)
+{
+}
diff --git a/VNFs/DPPD-PROX/stats_cons_cli.h b/VNFs/DPPD-PROX/stats_cons_cli.h
new file mode 100644
index 00000000..b5856d6d
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_cons_cli.h
@@ -0,0 +1,28 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_CONS_CLI_H_
+#define _STATS_CONS_CLI_H_
+
+#include "stats_cons.h"
+
+void stats_cons_cli_init(void);
+void stats_cons_cli_notify(void);
+void stats_cons_cli_finish(void);
+
+struct stats_cons *stats_cons_cli_get(void);
+
+#endif /* _STATS_CONS_CLI_H_ */
diff --git a/VNFs/DPPD-PROX/stats_cons_log.c b/VNFs/DPPD-PROX/stats_cons_log.c
new file mode 100644
index 00000000..7e966533
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_cons_log.c
@@ -0,0 +1,269 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+
+#include "stats.h"
+#include "stats_l4gen.h"
+#include "stats_cons_log.h"
+#include "prox_cfg.h"
+#include "prox_args.h"
+#include "prox_assert.h"
+#include "commands.h"
+
+static struct stats_cons stats_cons_log = {
+	.init = stats_cons_log_init,
+	.notify = stats_cons_log_notify,
+	.finish = stats_cons_log_finish,
+#ifndef DPI_STATS
+	.flags = STATS_CONS_F_ALL,
+#else
+	.flags = STATS_CONS_F_PORTS|STATS_CONS_F_TASKS,
+#endif
+};
+
+struct header {
+	uint64_t hz;
+	uint64_t now;
+	uint64_t n_entries;
+	uint64_t n_entry_fields;
+	uint8_t  n_entry_field_size[64];
+};
+
+static void header_init(struct header *hdr, uint64_t hz, uint64_t now, uint64_t n_entries) {
+	memset(hdr, 0, sizeof(*hdr));
+	hdr->hz = hz;
+	hdr->now = now;
+	hdr->n_entries = n_entries;
+}
+
+static void header_add_field(struct header *hdr, uint8_t size) {
+	hdr->n_entry_field_size[hdr->n_entry_fields++] = size;
+}
+
+static void header_write(struct header *hdr, FILE *fp) {
+	size_t header_size_no_fields = sizeof(*hdr) - sizeof(hdr->n_entry_field_size);
+	size_t header_size_effective = header_size_no_fields + hdr->n_entry_fields;
+
+	fwrite(hdr, header_size_effective, 1, fp);
+}
+
+#define BUFFERED_RECORD_LEN 16384
+
+#define STATS_DUMP_FILE_NAME "stats_dump"
+static FILE *fp;
+
+struct entry {
+	uint32_t lcore_id;
+	uint32_t task_id;
+#ifndef DPI_STATS
+	uint32_t l4_stats_id;
+#endif
+};
+
+static struct entry entries[64];
+static uint64_t n_entries;
+
+#ifndef DPI_STATS
+struct record {
+	uint32_t lcore_id;
+	uint32_t task_id;
+	uint64_t active_connections;
+	uint64_t bundles_created;
+	uint64_t rx_bytes;
+	uint64_t tx_bytes;
+	uint64_t tsc;
+} __attribute__((packed));
+#else
+struct record {
+	uint32_t lcore_id;
+	uint32_t task_id;
+	uint64_t rx_bytes;
+	uint64_t tx_bytes;
+	uint64_t drop_bytes;
+	uint64_t tsc;
+} __attribute__((packed));
+#endif
+
+static struct record buf[BUFFERED_RECORD_LEN];
+static size_t buf_pos = 0;
+
+struct stats_cons *stats_cons_log_get(void)
+{
+	return &stats_cons_log;
+}
+
+#ifndef DPI_STATS
+void stats_cons_log_init(void)
+{
+	fp = fopen(STATS_DUMP_FILE_NAME, "w");
+	if (!fp)
+		return;
+
+	uint32_t lcore_id = -1;
+
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (lconf->n_tasks_all && (strcmp(lconf->targs[0].task_init->mode_str, "genl4") ||
+					   strcmp(lconf->targs[0].task_init->sub_mode_str, "")))
+			continue;
+
+		for (uint32_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			entries[n_entries].lcore_id = lcore_id;
+			entries[n_entries].task_id = task_id;
+			entries[n_entries].l4_stats_id = n_entries;
+			n_entries++;
+			if (n_entries == sizeof(entries)/sizeof(entries[0]))
+				break;
+		}
+		cmd_rx_bw_start(lcore_id);
+		cmd_tx_bw_start(lcore_id);
+		if (n_entries == sizeof(entries)/sizeof(entries[0]))
+			break;
+	}
+
+	struct header hdr;
+
+	header_init(&hdr, rte_get_tsc_hz(), rte_rdtsc(), n_entries);
+	header_add_field(&hdr, sizeof(((struct record *)0)->lcore_id));
+	header_add_field(&hdr, sizeof(((struct record *)0)->task_id));
+	header_add_field(&hdr, sizeof(((struct record *)0)->active_connections));
+	header_add_field(&hdr, sizeof(((struct record *)0)->bundles_created));
+	header_add_field(&hdr, sizeof(((struct record *)0)->rx_bytes));
+	header_add_field(&hdr, sizeof(((struct record *)0)->tx_bytes));
+	header_add_field(&hdr, sizeof(((struct record *)0)->tsc));
+
+	header_write(&hdr, fp);
+}
+
+void stats_cons_log_notify(void)
+{
+	const uint32_t n_l4gen = stats_get_n_l4gen();
+
+	if (buf_pos + n_entries > sizeof(buf)/sizeof(buf[0])) {
+		fwrite(buf, sizeof(buf[0]), buf_pos, fp);
+		buf_pos = 0;
+	}
+	PROX_ASSERT(buf_pos + n_entries <= sizeof(buf)/sizeof(buf[0]));
+
+	for (uint32_t i = 0; i < n_entries; ++i) {
+		uint32_t c = entries[i].lcore_id;
+		uint32_t t = entries[i].task_id;
+		uint32_t j = entries[i].l4_stats_id;
+		struct l4_stats_sample *clast = stats_get_l4_stats_sample(j, 1);
+		struct task_stats *l = stats_get_task_stats(c, t);
+		struct task_stats_sample *last = stats_get_task_stats_sample(c, t, 1);
+
+		buf[buf_pos].lcore_id = c;
+		buf[buf_pos].task_id  = t;
+
+		uint64_t tot_created = clast->stats.tcp_created + clast->stats.udp_created;
+		uint64_t tot_finished = clast->stats.tcp_finished_retransmit + clast->stats.tcp_finished_no_retransmit +
+			clast->stats.udp_finished + clast->stats.udp_expired + clast->stats.tcp_expired;
+
+		buf[buf_pos].active_connections = tot_created - tot_finished;
+		buf[buf_pos].bundles_created = clast->stats.bundles_created;
+		buf[buf_pos].rx_bytes = last->rx_bytes;
+		buf[buf_pos].tx_bytes = last->tx_bytes;
+		buf[buf_pos].tsc = clast->tsc;
+
+		buf_pos++;
+	}
+}
+
+#else
+void stats_cons_log_init(void)
+{
+	uint64_t el = rte_get_tsc_hz();
+	uint64_t now = rte_rdtsc();
+
+	fp = fopen(STATS_DUMP_FILE_NAME, "w");
+	if (!fp)
+		return;
+
+	uint32_t lcore_id = -1;
+
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+		if (!lconf->n_tasks_all)
+			continue;
+
+		for (uint32_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			if (strcmp(lconf->targs[task_id].task_init->mode_str, "lbpos"))
+				continue;
+
+			entries[n_entries].lcore_id = lcore_id;
+			entries[n_entries].task_id = task_id;
+			n_entries++;
+			if (n_entries == sizeof(entries)/sizeof(entries[0]))
+				break;
+		}
+		cmd_rx_bw_start(lcore_id);
+		cmd_tx_bw_start(lcore_id);
+		if (n_entries == sizeof(entries)/sizeof(entries[0]))
+			break;
+	}
+
+	struct header hdr;
+
+	header_init(&hdr, rte_get_tsc_hz(), rte_rdtsc(), n_entries);
+	header_add_field(&hdr, sizeof(((struct record *)0)->lcore_id));
+	header_add_field(&hdr, sizeof(((struct record *)0)->task_id));
+	header_add_field(&hdr, sizeof(((struct record *)0)->rx_bytes));
+	header_add_field(&hdr, sizeof(((struct record *)0)->tx_bytes));
+	header_add_field(&hdr, sizeof(((struct record *)0)->drop_bytes));
+	header_add_field(&hdr, sizeof(((struct record *)0)->tsc));
+	header_write(&hdr, fp);
+}
+
+void stats_cons_log_notify(void)
+{
+	for (uint32_t i = 0; i < n_entries; ++i) {
+		uint32_t c = entries[i].lcore_id;
+		uint32_t t = entries[i].task_id;
+		struct task_stats *l = stats_get_task_stats(c, t);
+		struct task_stats_sample *last = stats_get_task_stats_sample(c, t, 1);
+
+		buf[buf_pos].lcore_id = c;
+		buf[buf_pos].task_id  = t;
+		buf[buf_pos].tx_bytes = last->tx_bytes;
+		buf[buf_pos].rx_bytes = last->rx_bytes;
+		buf[buf_pos].drop_bytes = last->drop_bytes;
+		/* buf[buf_pos].drop_tx_fail = l->tot_drop_tx_fail; */
+		buf[buf_pos].tsc = last->tsc;
+
+		buf_pos++;
+
+		if (buf_pos == sizeof(buf)/sizeof(buf[0])) {
+			fwrite(buf, sizeof(buf), 1, fp);
+			buf_pos = 0;
+		}
+	}
+}
+#endif
+
+void stats_cons_log_finish(void)
+{
+	if (fp) {
+		if (buf_pos) {
+			fwrite(buf, sizeof(buf[0]), buf_pos, fp);
+			buf_pos = 0;
+		}
+		fclose(fp);
+	}
+}
diff --git a/VNFs/DPPD-PROX/stats_cons_log.h b/VNFs/DPPD-PROX/stats_cons_log.h
new file mode 100644
index 00000000..92597de2
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_cons_log.h
@@ -0,0 +1,28 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_CONS_LOG_H_
+#define _STATS_CONS_LOG_H_
+
+#include "stats_cons.h"
+
+void stats_cons_log_init(void);
+void stats_cons_log_notify(void);
+void stats_cons_log_finish(void);
+
+struct stats_cons *stats_cons_log_get(void);
+
+#endif /* _STATS_CONS_LOG_H_ */
diff --git a/VNFs/DPPD-PROX/stats_core.c b/VNFs/DPPD-PROX/stats_core.c
new file mode 100644
index 00000000..845399e3
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_core.c
@@ -0,0 +1,293 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_lcore.h>
+
+#include "prox_malloc.h"
+#include "stats_core.h"
+#include "cqm.h"
+#include "log.h"
+#include "msr.h"
+#include "parse_utils.h"
+#include "prox_cfg.h"
+#include "lconf.h"
+
+struct stats_core_manager {
+	struct rdt_features rdt_features;
+	int                msr_support;
+	int                max_core_id;
+	uint16_t           n_lcore_stats;
+	int cache_size[RTE_MAX_LCORE];
+	struct lcore_stats lcore_stats_set[0];
+};
+
+static struct stats_core_manager *scm;
+extern int last_stat;
+
+static int get_L3_size(void)
+{
+	char buf[1024]= "/proc/cpuinfo";
+	FILE* fd = fopen(buf, "r");
+	if (fd == NULL) {
+		plogx_err("Could not open %s", buf);
+		return -1;
+	}
+	int lcore = -1, val = 0, size = 0;
+	while (fgets(buf, sizeof(buf), fd) != NULL) {
+		if (sscanf(buf, "processor : %u", &val) == 1) {
+			lcore = val;
+			scm->max_core_id = lcore;
+		}
+		if (sscanf(buf, "cache size : %u", &val) == 1) {
+			size = val;
+			if ((lcore != -1) && (lcore < RTE_MAX_LCORE)) {
+				scm->cache_size[lcore] = size * 1024;
+			}
+		}
+	}
+	fclose(fd);
+	plog_info("\tMaximum core_id = %d\n", scm->max_core_id);
+	return 0;
+}
+
+int stats_get_n_lcore_stats(void)
+{
+	return scm->n_lcore_stats;
+}
+
+int stats_cpu_freq_enabled(void)
+{
+	return scm->msr_support;
+}
+
+int stats_cmt_enabled(void)
+{
+	return cmt_is_supported();
+}
+
+int stats_cat_enabled(void)
+{
+	return cat_is_supported();
+}
+
+int stats_mbm_enabled(void)
+{
+	return mbm_is_supported();
+}
+
+uint32_t stats_lcore_find_stat_id(uint32_t lcore_id)
+{
+	for (int i = 0; i < scm->n_lcore_stats; ++i)
+		if (scm->lcore_stats_set[i].lcore_id == lcore_id)
+			return i;
+	return 0;
+}
+
+struct lcore_stats_sample *stats_get_lcore_stats_sample(uint32_t stat_id, int l)
+{
+	return &scm->lcore_stats_set[stat_id].sample[l == last_stat];
+}
+
+struct lcore_stats *stats_get_lcore_stats(uint32_t stat_id)
+{
+	return &scm->lcore_stats_set[stat_id];
+}
+
+static struct stats_core_manager *alloc_stats_core_manager(void)
+{
+	const int socket_id = rte_lcore_to_socket_id(rte_lcore_id());
+	uint32_t n_lcore_stats = 0;
+	uint32_t lcore_id;
+	size_t mem_size;
+
+	lcore_id = -1;
+	while (prox_core_next(&lcore_id, 0) == 0)
+		n_lcore_stats++;
+	mem_size = sizeof(struct stats_core_manager) + sizeof(struct lcore_stats) * n_lcore_stats;
+	return prox_zmalloc(mem_size, socket_id);
+}
+
+void stats_lcore_init(void)
+{
+	struct lcore_cfg *lconf;
+	uint32_t lcore_id;
+	int j = 0;
+
+	scm = alloc_stats_core_manager();
+
+	if (is_virtualized()) {
+		plog_info("Not initializing msr as running in a VM\n");
+		scm->msr_support = 0;
+	} else if ((scm->msr_support = !msr_init()) == 0) {
+		plog_warn("Failed to open msr pseudo-file (missing msr kernel module?)\n");
+	}
+
+	scm->n_lcore_stats = 0;
+	lcore_id = -1;
+	get_L3_size();
+	while (prox_core_next(&lcore_id, 0) == 0) {
+		scm->lcore_stats_set[scm->n_lcore_stats++].lcore_id = lcore_id;
+	}
+	if (!rdt_is_supported())
+		return;
+
+	if (!scm->msr_support) {
+		plog_warn("CPU supports RDT but msr module not loaded. Disabling RDT stats.\n");
+		return;
+	}
+
+	if (0 != rdt_get_features(&scm->rdt_features)) {
+		plog_warn("Failed to get RDT features\n");
+		return;
+	}
+	else {
+		rdt_init_stat_core(rte_lcore_id());
+	}
+
+	/* Start using last rmid, to keep first rmid for technologies (like cat) where there are less rmid */
+	uint32_t last_rmid = scm->rdt_features.cmt_max_rmid;
+	for (uint32_t i = 0; i < scm->n_lcore_stats; ++i) {
+		scm->lcore_stats_set[i].rmid = last_rmid; // cmt_max_rmid is used by non-monitored cores
+		last_rmid--;
+	}
+
+	uint64_t cache_set;
+	for (uint32_t i = 0; i < scm->n_lcore_stats; ++i) {
+		plog_info("\tAssociating core %u to rmid %lu (associating each core used by prox to a different rmid)\n", scm->lcore_stats_set[i].lcore_id, scm->lcore_stats_set[i].rmid);
+		cqm_assoc(scm->lcore_stats_set[i].lcore_id, scm->lcore_stats_set[i].rmid);
+		uint32_t lcore_id = scm->lcore_stats_set[i].lcore_id;
+		lconf = &lcore_cfg[lcore_id];
+		cache_set = lconf->cache_set;
+		if ((cache_set) && (cache_set < PROX_MAX_CACHE_SET)) {
+			scm->lcore_stats_set[i].class = cache_set;
+			scm->lcore_stats_set[i].cat_mask = prox_cache_set_cfg[cache_set].mask;
+			if (prox_cache_set_cfg[cache_set].socket_id == -1) {
+				prox_cache_set_cfg[cache_set].socket_id = scm->lcore_stats_set[i].socket_id;
+				prox_cache_set_cfg[cache_set].lcore_id = lcore_id;
+			} else if (prox_cache_set_cfg[cache_set].socket_id != (int32_t)scm->lcore_stats_set[i].socket_id) {
+				plog_err("Unsupported config: Using same cache set on two different socket\n");
+			}
+		} else {
+			scm->lcore_stats_set[i].class = 0;
+			scm->lcore_stats_set[i].cat_mask = (1 << cat_get_num_ways()) -1;
+		}
+	}
+	cat_log_init(0);
+	last_rmid = scm->rdt_features.cat_max_rmid;
+	for (int i = 0; i < PROX_MAX_CACHE_SET; i++) {
+		if (prox_cache_set_cfg[i].mask) {
+			plog_info("\tSetting cache set %d to %x\n", i, prox_cache_set_cfg[i].mask);
+			cat_set_class_mask(prox_cache_set_cfg[i].lcore_id, i, prox_cache_set_cfg[i].mask);
+        	}
+       	}
+	for (uint32_t i = 0; i < scm->n_lcore_stats; ++i) {
+		uint32_t lcore_id = scm->lcore_stats_set[i].lcore_id;
+		lconf = &lcore_cfg[lcore_id];
+		cache_set = lconf->cache_set;
+		if (cache_set) {
+			if (prox_cache_set_cfg[cache_set].mask) {
+				scm->lcore_stats_set[i].rmid = (scm->lcore_stats_set[i].rmid) | (cache_set << 32);
+				plog_info("\tCache set = %ld for core %d\n", cache_set, lcore_id);
+				cqm_assoc(lcore_id, scm->lcore_stats_set[i].rmid);
+			} else {
+				plog_err("\tUndefined Cache set = %ld for core %d\n", cache_set, lcore_id);
+			}
+		} else {
+			if (prox_cache_set_cfg[cache_set].mask) {
+				scm->lcore_stats_set[i].rmid = (scm->lcore_stats_set[i].rmid);
+				plog_info("\tUsing default cache set for core %d\n", lcore_id);
+				cqm_assoc(lcore_id, scm->lcore_stats_set[i].rmid);
+			} else {
+				plog_info("\tNo default cache set for core %d\n", lcore_id);
+			}
+		}
+	}
+}
+
+static void stats_lcore_update_freq(void)
+{
+	for (uint8_t i = 0; i < scm->n_lcore_stats; ++i) {
+		struct lcore_stats *ls = &scm->lcore_stats_set[i];
+		struct lcore_stats_sample *lss = &ls->sample[last_stat];
+
+		msr_read(&lss->afreq, ls->lcore_id, 0xe8);
+		msr_read(&lss->mfreq, ls->lcore_id, 0xe7);
+	}
+}
+void stats_update_cache_mask(uint32_t lcore_id, uint32_t mask)
+{
+	for (uint8_t i = 0; i < scm->n_lcore_stats; ++i) {
+		struct lcore_stats *ls = &scm->lcore_stats_set[i];
+		if (ls->lcore_id == lcore_id) {
+			plog_info("Updating  core %d stats %d to mask %x\n", lcore_id, i, mask);
+			scm->lcore_stats_set[i].cat_mask = mask;
+		}
+	}
+}
+
+static void stats_lcore_update_rdt(void)
+{
+	for (uint8_t i = 0; i < scm->n_lcore_stats; ++i) {
+		struct lcore_stats *ls = &scm->lcore_stats_set[i];
+
+		if (ls->rmid) {
+			cmt_read_ctr(&ls->cmt_data, ls->rmid, ls->lcore_id);
+			mbm_read_tot_bdw(&ls->mbm_tot, ls->rmid, ls->lcore_id);
+			mbm_read_loc_bdw(&ls->mbm_loc, ls->rmid, ls->lcore_id);
+		}
+	}
+}
+
+void stats_lcore_post_proc(void)
+{
+	/* update CQM stats (calculate fraction and bytes reported) */
+	for (uint8_t i = 0; i < scm->n_lcore_stats; ++i) {
+		struct lcore_stats *ls = &scm->lcore_stats_set[i];
+		struct lcore_stats_sample *lss = &ls->sample[last_stat];
+
+		if (ls->rmid) {
+			ls->cmt_bytes = ls->cmt_data * scm->rdt_features.upscaling_factor;
+			lss->mbm_tot_bytes = ls->mbm_tot * scm->rdt_features.upscaling_factor;
+			lss->mbm_loc_bytes = ls->mbm_loc * scm->rdt_features.upscaling_factor;
+			plogx_dbg("cache[core %d] = %ld\n", ls->lcore_id, ls->cmt_bytes);
+		}
+	}
+	for (uint8_t i = 0; i < scm->n_lcore_stats; ++i) {
+		struct lcore_stats *ls = &scm->lcore_stats_set[i];
+
+		if (ls->rmid && scm->cache_size[ls->lcore_id])
+			ls->cmt_fraction = ls->cmt_bytes * 10000 / scm->cache_size[ls->lcore_id];
+		else
+			ls->cmt_fraction = 0;
+	}
+}
+
+void stats_lcore_update(void)
+{
+	if (scm->msr_support)
+		stats_lcore_update_freq();
+	if (rdt_is_supported())
+		stats_lcore_update_rdt();
+}
+
+void stats_lcore_assoc_rmid(void)
+{
+	for (uint32_t i = 0; i < scm->n_lcore_stats; ++i) {
+		uint32_t lcore_id = scm->lcore_stats_set[i].lcore_id;
+		scm->lcore_stats_set[i].rmid = scm->lcore_stats_set[i].rmid & 0xffffffff;
+		cqm_assoc(lcore_id, scm->lcore_stats_set[i].rmid);
+	}
+}
diff --git a/VNFs/DPPD-PROX/stats_core.h b/VNFs/DPPD-PROX/stats_core.h
new file mode 100644
index 00000000..f9939def
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_core.h
@@ -0,0 +1,59 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_CORE_H_
+#define _STATS_CORE_H_
+
+#include <inttypes.h>
+
+struct lcore_stats_sample {
+	uint64_t afreq;
+	uint64_t mfreq;
+	uint64_t mbm_tot_bytes;
+	uint64_t mbm_loc_bytes;
+};
+
+struct lcore_stats {
+	uint32_t lcore_id;
+	uint32_t socket_id;
+	uint64_t rmid;
+	uint64_t cmt_data;
+	uint64_t cmt_bytes;
+	uint64_t mbm_tot_bytes;
+	uint64_t mbm_loc_bytes;
+	uint64_t cmt_fraction;
+	uint32_t cat_mask;
+	uint64_t mbm_tot;
+	uint64_t mbm_loc;
+	uint32_t class;
+	struct lcore_stats_sample sample[2];
+};
+
+uint32_t stats_lcore_find_stat_id(uint32_t lcore_id);
+int stats_get_n_lcore_stats(void);
+struct lcore_stats *stats_get_lcore_stats(uint32_t stat_id);
+struct lcore_stats_sample *stats_get_lcore_stats_sample(uint32_t stat_id, int last);
+int stats_cpu_freq_enabled(void);
+int stats_cmt_enabled(void);
+int stats_cat_enabled(void);
+int stats_mbm_enabled(void);
+void stats_lcore_update(void);
+void stats_lcore_init(void);
+void stats_lcore_post_proc(void);
+void stats_update_cache_mask(uint32_t lcore_id, uint32_t mask);
+void stats_lcore_assoc_rmid(void);
+
+#endif /* _STATS_CORE_H_ */
diff --git a/VNFs/DPPD-PROX/stats_global.c b/VNFs/DPPD-PROX/stats_global.c
new file mode 100644
index 00000000..d7529d34
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_global.c
@@ -0,0 +1,110 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <rte_cycles.h>
+#include <inttypes.h>
+
+#include "stats_global.h"
+#include "stats_port.h"
+#include "stats_task.h"
+
+struct global_stats {
+	struct global_stats_sample sample[2];
+	struct global_stats_sample beg;
+	uint8_t  started_avg;
+	uint64_t start_tsc;
+	uint64_t end_tsc;
+};
+
+extern int last_stat;
+static struct global_stats global_stats;
+
+uint64_t stats_get_last_tsc(void)
+{
+	return global_stats.sample[last_stat].tsc;
+}
+
+uint64_t stats_global_start_tsc(void)
+{
+	return global_stats.start_tsc;
+}
+
+uint64_t stats_global_beg_tsc(void)
+{
+	return global_stats.beg.tsc;
+}
+
+uint64_t stats_global_end_tsc(void)
+{
+	return global_stats.end_tsc;
+}
+
+struct global_stats_sample *stats_get_global_stats(int last)
+{
+	return &global_stats.sample[last == last_stat];
+}
+
+struct global_stats_sample *stats_get_global_stats_beg(void)
+{
+	return (global_stats.beg.tsc < global_stats.sample[last_stat].tsc)? &global_stats.beg : NULL;
+}
+
+void stats_global_reset(void)
+{
+	uint64_t now = rte_rdtsc();
+	uint64_t last_tsc = global_stats.sample[last_stat].tsc;
+	uint64_t prev_tsc = global_stats.sample[!last_stat].tsc;
+	uint64_t end_tsc = global_stats.end_tsc;
+
+	memset(&global_stats, 0, sizeof(struct global_stats));
+	global_stats.sample[last_stat].tsc = last_tsc;
+	global_stats.sample[!last_stat].tsc = prev_tsc;
+	global_stats.start_tsc = now;
+	global_stats.beg.tsc = now;
+	global_stats.end_tsc = end_tsc;
+}
+
+void stats_global_init(unsigned avg_start, unsigned duration)
+{
+	uint64_t now = rte_rdtsc();
+
+	global_stats.start_tsc = now;
+	/* + 1 for rounding */
+	tsc_hz = rte_get_tsc_hz();
+	if (duration)
+		global_stats.end_tsc = global_stats.start_tsc + (avg_start + duration + 1) * tsc_hz;
+
+	global_stats.beg.tsc = global_stats.start_tsc + avg_start * tsc_hz;
+}
+
+void stats_global_post_proc(void)
+{
+	uint64_t *rx = &global_stats.sample[last_stat].host_rx_packets;
+	uint64_t *tx = &global_stats.sample[last_stat].host_tx_packets;
+	uint64_t *tsc = &global_stats.sample[last_stat].tsc;
+
+	stats_task_get_host_rx_tx_packets(rx, tx, tsc);
+	global_stats.sample[last_stat].nics_ierrors    = stats_port_get_ierrors();
+	global_stats.sample[last_stat].nics_imissed    = stats_port_get_imissed();
+	global_stats.sample[last_stat].nics_rx_packets = stats_port_get_rx_packets();
+	global_stats.sample[last_stat].nics_tx_packets = stats_port_get_tx_packets();
+
+	if (global_stats.sample[last_stat].tsc > global_stats.beg.tsc && !global_stats.started_avg) {
+		global_stats.started_avg = 1;
+		global_stats.beg = global_stats.sample[last_stat];
+	}
+}
diff --git a/VNFs/DPPD-PROX/stats_global.h b/VNFs/DPPD-PROX/stats_global.h
new file mode 100644
index 00000000..8f53ab5c
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_global.h
@@ -0,0 +1,42 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_GLOBAL_H_
+#define _STATS_GLOBAL_H_
+
+uint64_t stats_get_last_tsc(void);
+
+struct global_stats_sample {
+	uint64_t tsc;
+	uint64_t host_rx_packets;
+	uint64_t host_tx_packets;
+	uint64_t nics_rx_packets;
+	uint64_t nics_tx_packets;
+	uint64_t nics_ierrors;
+	uint64_t nics_imissed;
+};
+
+void stats_global_reset(void);
+void stats_global_init(unsigned avg_start, unsigned duration);
+void stats_global_post_proc(void);
+
+struct global_stats_sample *stats_get_global_stats(int last);
+struct global_stats_sample *stats_get_global_stats_beg(void);
+uint64_t stats_global_start_tsc(void);
+uint64_t stats_global_beg_tsc(void);
+uint64_t stats_global_end_tsc(void);
+
+#endif /* _STATS_GLOBAL_H_ */
diff --git a/VNFs/DPPD-PROX/stats_l4gen.c b/VNFs/DPPD-PROX/stats_l4gen.c
new file mode 100644
index 00000000..37af7ac4
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_l4gen.c
@@ -0,0 +1,110 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+
+#include "prox_malloc.h"
+#include "prox_cfg.h"
+#include "stats_l4gen.h"
+#include "task_init.h"
+
+struct task_l4gen_stats {
+	struct task_base base;
+	struct l4_stats l4_stats;
+};
+
+struct stats_l4gen_manager {
+	uint16_t n_l4gen;
+	struct task_l4_stats task_l4_stats[0];
+};
+
+extern int last_stat;
+static struct stats_l4gen_manager *sl4m;
+
+int stats_get_n_l4gen(void)
+{
+	return sl4m->n_l4gen;
+}
+
+struct task_l4_stats *stats_get_l4_stats(uint32_t i)
+{
+	return &sl4m->task_l4_stats[i];
+}
+
+struct l4_stats_sample *stats_get_l4_stats_sample(uint32_t i, int l)
+{
+	return &sl4m->task_l4_stats[i].sample[l == last_stat];
+}
+
+static struct stats_l4gen_manager *alloc_stats_l4gen_manager(void)
+{
+	struct lcore_cfg *lconf;
+	uint32_t lcore_id = -1;
+	size_t mem_size;
+	uint32_t n_l4gen = 0;
+	const int socket_id = rte_lcore_to_socket_id(rte_lcore_id());
+
+	lcore_id = -1;
+	while (prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			struct task_args *targ = &lconf->targs[task_id];
+
+			if (!strcmp(targ->task_init->mode_str, "genl4"))
+				n_l4gen++;
+		}
+	}
+
+	mem_size = sizeof(struct stats_l4gen_manager) + sizeof(struct task_l4_stats) * n_l4gen;
+	return prox_zmalloc(mem_size, socket_id);
+}
+
+void stats_l4gen_init(void)
+{
+	struct lcore_cfg *lconf;
+	uint32_t lcore_id = -1;
+
+	sl4m = alloc_stats_l4gen_manager();
+
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			struct task_args *targ = &lconf->targs[task_id];
+
+			if (!strcmp(targ->task_init->mode_str, "genl4")) {
+				sl4m->task_l4_stats[sl4m->n_l4gen].task = (struct task_l4gen_stats *)lconf->tasks_all[task_id];
+				sl4m->task_l4_stats[sl4m->n_l4gen].lcore_id = lcore_id;
+				sl4m->task_l4_stats[sl4m->n_l4gen].task_id = task_id;
+				sl4m->n_l4gen++;
+			}
+		}
+	}
+}
+
+void stats_l4gen_update(void)
+{
+	uint64_t before, after;
+
+	for (uint16_t i = 0; i < sl4m->n_l4gen; ++i) {
+		struct task_l4gen_stats *task_l4gen = sl4m->task_l4_stats[i].task;
+
+		before = rte_rdtsc();
+		sl4m->task_l4_stats[i].sample[last_stat].stats = task_l4gen->l4_stats;
+		after = rte_rdtsc();
+
+		sl4m->task_l4_stats[i].sample[last_stat].tsc = (before >> 1) + (after >> 1);
+	}
+}
diff --git a/VNFs/DPPD-PROX/stats_l4gen.h b/VNFs/DPPD-PROX/stats_l4gen.h
new file mode 100644
index 00000000..dfc4e111
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_l4gen.h
@@ -0,0 +1,44 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_L4GEN_H_
+#define _STATS_L4GEN_H_
+
+#include <inttypes.h>
+
+#include "genl4_bundle.h"
+
+struct task_l4gen_stats;
+
+struct l4_stats_sample {
+	uint64_t        tsc;
+	struct l4_stats stats;
+};
+
+struct task_l4_stats {
+	struct task_l4gen_stats *task;
+	struct l4_stats_sample sample[2];
+	uint8_t lcore_id;
+	uint8_t task_id;
+};
+
+void stats_l4gen_init(void);
+void stats_l4gen_update(void);
+int stats_get_n_l4gen(void);
+struct task_l4_stats *stats_get_l4_stats(uint32_t i);
+struct l4_stats_sample *stats_get_l4_stats_sample(uint32_t i, int l);
+
+#endif /* _STATS_L4GEN_H_ */
diff --git a/VNFs/DPPD-PROX/stats_latency.c b/VNFs/DPPD-PROX/stats_latency.c
new file mode 100644
index 00000000..52027892
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_latency.c
@@ -0,0 +1,225 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "prox_malloc.h"
+#include "stats_latency.h"
+#include "handle_lat.h"
+#include "prox_cfg.h"
+#include "prox_args.h"
+
+struct stats_latency_manager_entry {
+	struct task_lat        *task;
+	uint8_t                lcore_id;
+	uint8_t                task_id;
+	struct lat_test        lat_test;
+	struct lat_test        tot_lat_test;
+	struct stats_latency   stats;
+	struct stats_latency   tot;
+};
+
+struct stats_latency_manager {
+	uint16_t n_latency;
+	struct stats_latency_manager_entry entries[0]; /* copy of stats when running update stats. */
+};
+
+static struct stats_latency_manager *slm;
+
+void stats_latency_reset(void)
+{
+	for (uint16_t i = 0; i < slm->n_latency; ++i)
+		lat_test_reset(&slm->entries[i].tot_lat_test);
+}
+
+int stats_get_n_latency(void)
+{
+	return slm->n_latency;
+}
+
+uint32_t stats_latency_get_core_id(uint32_t i)
+{
+	return slm->entries[i].lcore_id;
+}
+
+uint32_t stats_latency_get_task_id(uint32_t i)
+{
+	return slm->entries[i].task_id;
+}
+
+struct stats_latency *stats_latency_get(uint32_t i)
+{
+	return &slm->entries[i].stats;
+}
+
+struct stats_latency *stats_latency_tot_get(uint32_t i)
+{
+	return &slm->entries[i].tot;
+}
+
+static struct stats_latency_manager_entry *stats_latency_entry_find(uint8_t lcore_id, uint8_t task_id)
+{
+	struct stats_latency_manager_entry *entry;
+
+	for (uint16_t i = 0; i < stats_get_n_latency(); ++i) {
+		entry = &slm->entries[i];
+
+		if (entry->lcore_id == lcore_id && entry->task_id == task_id) {
+			return entry;
+		}
+	}
+	return NULL;
+}
+
+struct stats_latency *stats_latency_tot_find(uint32_t lcore_id, uint32_t task_id)
+{
+	struct stats_latency_manager_entry *entry = stats_latency_entry_find(lcore_id, task_id);
+
+	if (!entry)
+		return NULL;
+	else
+		return &entry->tot;
+}
+
+struct stats_latency *stats_latency_find(uint32_t lcore_id, uint32_t task_id)
+{
+	struct stats_latency_manager_entry *entry = stats_latency_entry_find(lcore_id, task_id);
+
+	if (!entry)
+		return NULL;
+	else
+		return &entry->stats;
+}
+
+static int task_runs_observable_latency(struct task_args *targ)
+{
+	/* TODO: make this work with multiple ports and with
+	   rings. Currently, only showing lat tasks which have 1 RX
+	   port. */
+	return !strcmp(targ->task_init->mode_str, "lat") &&
+		(targ->nb_rxports == 1 || targ->nb_rxrings == 1);
+}
+
+static struct stats_latency_manager *alloc_stats_latency_manager(void)
+{
+	const uint32_t socket_id = rte_lcore_to_socket_id(rte_lcore_id());
+	struct stats_latency_manager *ret;
+	struct lcore_cfg *lconf;
+	uint32_t n_latency = 0;
+	uint32_t lcore_id;
+	size_t mem_size;
+
+	lcore_id = -1;
+	while (prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			struct task_args *targ = &lconf->targs[task_id];
+			if (task_runs_observable_latency(targ))
+				++n_latency;
+		}
+	}
+	mem_size = sizeof(*ret) + sizeof(ret->entries[0]) * n_latency;
+
+	ret = prox_zmalloc(mem_size, socket_id);
+	return ret;
+}
+
+static void stats_latency_add_task(struct lcore_cfg *lconf, struct task_args *targ)
+{
+	struct stats_latency_manager_entry *new_entry = &slm->entries[slm->n_latency];
+
+	new_entry->task = (struct task_lat *)targ->tbase;
+	new_entry->lcore_id = lconf->id;
+	new_entry->task_id = targ->id;
+	slm->n_latency++;
+}
+
+void stats_latency_init(void)
+{
+	struct lcore_cfg *lconf = NULL;
+	struct task_args *targ;
+
+	slm = alloc_stats_latency_manager();
+
+	while (core_targ_next(&lconf, &targ, 0) == 0) {
+		if (task_runs_observable_latency(targ))
+			stats_latency_add_task(lconf, targ);
+	}
+}
+
+#ifdef LATENCY_HISTOGRAM
+void stats_core_lat_histogram(uint8_t lcore_id, uint8_t task_id, uint64_t **buckets)
+{
+	struct stats_latency_manager_entry *lat_stats;
+	uint64_t tsc;
+
+	lat_stats = stats_latency_entry_find(lcore_id, task_id);
+
+	if (lat_stats)
+		*buckets = lat_stats->lat_test.buckets;
+	else
+		*buckets = NULL;
+}
+#endif
+
+static void stats_latency_fetch_entry(struct stats_latency_manager_entry *entry)
+{
+	struct stats_latency *cur = &entry->stats;
+	struct lat_test *lat_test_local = &entry->lat_test;
+	struct lat_test *lat_test_remote = task_lat_get_latency_meassurement(entry->task);
+
+	if (!lat_test_remote)
+		return;
+
+	if (lat_test_remote->tot_all_pkts) {
+		lat_test_copy(&entry->lat_test, lat_test_remote);
+		lat_test_reset(lat_test_remote);
+		lat_test_combine(&entry->tot_lat_test, &entry->lat_test);
+	}
+
+	task_lat_use_other_latency_meassurement(entry->task);
+}
+
+static void stats_latency_from_lat_test(struct stats_latency *dst, struct lat_test *src)
+{
+	/* In case packets were received, but measurements were too
+	   inaccurate */
+	if (src->tot_pkts) {
+		dst->max = lat_test_get_max(src);
+		dst->min = lat_test_get_min(src);
+		dst->avg = lat_test_get_avg(src);
+		dst->stddev = lat_test_get_stddev(src);
+	}
+	dst->accuracy_limit = lat_test_get_accuracy_limit(src);
+	dst->tot_packets = src->tot_pkts;
+	dst->tot_all_packets = src->tot_all_pkts;
+	dst->lost_packets = src->lost_packets;
+}
+
+static void stats_latency_update_entry(struct stats_latency_manager_entry *entry)
+{
+	if (!entry->lat_test.tot_all_pkts)
+		return;
+
+	stats_latency_from_lat_test(&entry->stats, &entry->lat_test);
+	stats_latency_from_lat_test(&entry->tot, &entry->tot_lat_test);
+}
+
+void stats_latency_update(void)
+{
+	for (uint16_t i = 0; i < slm->n_latency; ++i)
+		stats_latency_fetch_entry(&slm->entries[i]);
+	for (uint16_t i = 0; i < slm->n_latency; ++i)
+		stats_latency_update_entry(&slm->entries[i]);
+}
diff --git a/VNFs/DPPD-PROX/stats_latency.h b/VNFs/DPPD-PROX/stats_latency.h
new file mode 100644
index 00000000..83cd4a18
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_latency.h
@@ -0,0 +1,54 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_LATENCY_H_
+#define _STATS_LATENCY_H_
+
+#include <inttypes.h>
+
+#include "handle_lat.h"
+
+struct stats_latency {
+	struct time_unit_err avg;
+	struct time_unit_err min;
+	struct time_unit_err max;
+	struct time_unit_err stddev;
+
+	struct time_unit accuracy_limit;
+	uint64_t         lost_packets;
+	uint64_t         tot_packets;
+	uint64_t         tot_all_packets;
+};
+
+uint32_t stats_latency_get_core_id(uint32_t i);
+uint32_t stats_latency_get_task_id(uint32_t i);
+struct stats_latency *stats_latency_get(uint32_t i);
+struct stats_latency *stats_latency_find(uint32_t lcore_id, uint32_t task_id);
+
+struct stats_latency *stats_latency_tot_get(uint32_t i);
+struct stats_latency *stats_latency_tot_find(uint32_t lcore_id, uint32_t task_id);
+
+void stats_latency_init(void);
+void stats_latency_update(void);
+void stats_latency_reset(void);
+
+int stats_get_n_latency(void);
+
+#ifdef LATENCY_HISTOGRAM
+void stats_core_lat_histogram(uint8_t lcore_id, uint8_t task_id, uint64_t **buckets);
+#endif
+
+#endif /* _STATS_LATENCY_H_ */
diff --git a/VNFs/DPPD-PROX/stats_mempool.c b/VNFs/DPPD-PROX/stats_mempool.c
new file mode 100644
index 00000000..c5861eb5
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_mempool.c
@@ -0,0 +1,96 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_mempool.h>
+#include <rte_version.h>
+#include <inttypes.h>
+
+#include "prox_malloc.h"
+#include "prox_port_cfg.h"
+#include "stats_mempool.h"
+
+struct stats_mempool_manager {
+	uint32_t n_mempools;
+	struct mempool_stats mempool_stats[0];
+};
+
+static struct stats_mempool_manager *smm;
+
+struct mempool_stats *stats_get_mempool_stats(uint32_t i)
+{
+	return &smm->mempool_stats[i];
+}
+
+int stats_get_n_mempools(void)
+{
+	return smm->n_mempools;
+}
+
+static struct stats_mempool_manager *alloc_stats_mempool_manager(void)
+{
+	const uint32_t socket_id = rte_lcore_to_socket_id(rte_lcore_id());
+	uint32_t n_max_mempools = sizeof(prox_port_cfg[0].pool)/sizeof(prox_port_cfg[0].pool[0]);
+	uint32_t n_mempools = 0;
+	size_t mem_size = sizeof(struct stats_mempool_manager);
+
+	for (uint8_t i = 0; i < PROX_MAX_PORTS; ++i) {
+		if (!prox_port_cfg[i].active)
+			continue;
+
+		for (uint8_t j = 0; j < n_max_mempools; ++j) {
+			if (prox_port_cfg[i].pool[j] && prox_port_cfg[i].pool_size[j]) {
+				mem_size += sizeof(struct mempool_stats);
+			}
+		}
+	}
+
+	return prox_zmalloc(mem_size, socket_id);
+}
+
+void stats_mempool_init(void)
+{
+	uint32_t n_max_mempools = sizeof(prox_port_cfg[0].pool)/sizeof(prox_port_cfg[0].pool[0]);
+
+	smm = alloc_stats_mempool_manager();
+	for (uint8_t i = 0; i < PROX_MAX_PORTS; ++i) {
+		if (!prox_port_cfg[i].active)
+			continue;
+
+		for (uint8_t j = 0; j < n_max_mempools; ++j) {
+			if (prox_port_cfg[i].pool[j] && prox_port_cfg[i].pool_size[j]) {
+				struct mempool_stats *ms = &smm->mempool_stats[smm->n_mempools];
+
+				ms->pool = prox_port_cfg[i].pool[j];
+				ms->port = i;
+				ms->queue = j;
+				ms->size = prox_port_cfg[i].pool_size[j];
+				smm->n_mempools++;
+			}
+		}
+	}
+}
+
+void stats_mempool_update(void)
+{
+	for (uint8_t mp_id = 0; mp_id < smm->n_mempools; ++mp_id) {
+		/* Note: The function free_count returns the number of used entries. */
+#if RTE_VERSION >= RTE_VERSION_NUM(17,5,0,0)
+		smm->mempool_stats[mp_id].free = rte_mempool_avail_count(smm->mempool_stats[mp_id].pool);
+#else
+		smm->mempool_stats[mp_id].free = rte_mempool_count(smm->mempool_stats[mp_id].pool);
+#endif
+	}
+}
diff --git a/VNFs/DPPD-PROX/stats_mempool.h b/VNFs/DPPD-PROX/stats_mempool.h
new file mode 100644
index 00000000..b62e111f
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_mempool.h
@@ -0,0 +1,36 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_MEMPOOL_H_
+#define _STATS_MEMPOOL_H_
+
+#include <inttypes.h>
+#include <stddef.h>
+
+struct mempool_stats {
+	struct rte_mempool *pool;
+	uint16_t port;
+	uint16_t queue;
+	size_t free;
+	size_t size;
+};
+
+void stats_mempool_init(void);
+struct mempool_stats *stats_get_mempool_stats(uint32_t i);
+int stats_get_n_mempools(void);
+void stats_mempool_update(void);
+
+#endif /* _STATS_MEMPOOL_H_ */
diff --git a/VNFs/DPPD-PROX/stats_parser.c b/VNFs/DPPD-PROX/stats_parser.c
new file mode 100644
index 00000000..aa9d6741
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_parser.c
@@ -0,0 +1,897 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <stddef.h>
+
+#include "stats_parser.h"
+#include "log.h"
+#include "stats.h"
+#include "parse_utils.h"
+#include "handle_lat.h"
+#include "prox_port_cfg.h"
+#include "stats_port.h"
+#include "stats_mempool.h"
+#include "stats_ring.h"
+#include "stats_l4gen.h"
+#include "stats_latency.h"
+#include "stats_global.h"
+#include "stats_prio_task.h"
+
+struct stats_path_str {
+	const char *str;
+	uint64_t (*func)(int argc, const char *argv[]);
+};
+
+static int args_to_core_task(const char *core_str, const char *task_str, uint32_t *lcore_id, uint32_t *task_id)
+{
+	if (parse_list_set(lcore_id, core_str, 1) != 1)
+		return -1;
+	*task_id = atoi(task_str);
+
+	return 0;
+}
+
+static uint64_t sp_task_idle_cycles(int argc, const char *argv[])
+{
+	struct task_stats_sample *last;
+	uint32_t c, t;
+
+	if (args_to_core_task(argv[0], argv[1], &c, &t))
+		return -1;
+	return stats_get_task_stats_sample(c, t, 1)->tsc;
+}
+
+static uint64_t sp_task_rx_packets(int argc, const char *argv[])
+{
+	struct task_stats_sample *last;
+	uint32_t c, t;
+
+	if (args_to_core_task(argv[0], argv[1], &c, &t))
+		return -1;
+	return stats_get_task_stats_sample(c, t, 1)->rx_pkt_count;
+}
+
+static uint64_t sp_task_tx_packets(int argc, const char *argv[])
+{
+	struct task_stats_sample *last;
+	uint32_t c, t;
+
+	if (args_to_core_task(argv[0], argv[1], &c, &t))
+		return -1;
+	return stats_get_task_stats_sample(c, t, 1)->tx_pkt_count;
+}
+
+static uint64_t sp_task_drop_tx_fail(int argc, const char *argv[])
+{
+	struct task_stats_sample *last;
+	uint32_t c, t;
+
+	if (args_to_core_task(argv[0], argv[1], &c, &t))
+		return -1;
+	return stats_get_task_stats_sample(c, t, 1)->drop_tx_fail;
+}
+
+static uint64_t sp_task_drop_tx_fail_prio(int argc, const char *argv[])
+{
+	struct task_stats_sample *last;
+	uint32_t c, t;
+
+	if (args_to_core_task(argv[0], argv[1], &c, &t))
+		return -1;
+	if (stats_get_prio_task_stats_sample_by_core_task(c, t, 1))
+		return stats_get_prio_task_stats_sample_by_core_task(c, t, 1)->drop_tx_fail_prio[atoi(argv[2])];
+	else
+		return -1;
+}
+
+static uint64_t sp_task_rx_prio(int argc, const char *argv[])
+{
+	struct task_stats_sample *last;
+	uint32_t c, t;
+
+	if (args_to_core_task(argv[0], argv[1], &c, &t))
+		return -1;
+	return stats_get_prio_task_stats_sample_by_core_task(c, t, 1)->rx_prio[atoi(argv[2])];
+}
+
+static uint64_t sp_task_drop_discard(int argc, const char *argv[])
+{
+	struct task_stats_sample *last;
+	uint32_t c, t;
+
+	if (args_to_core_task(argv[0], argv[1], &c, &t))
+		return -1;
+	return stats_get_task_stats_sample(c, t, 1)->drop_discard;
+}
+
+static uint64_t sp_task_drop_handled(int argc, const char *argv[])
+{
+	struct task_stats_sample *last;
+	uint32_t c, t;
+
+	if (args_to_core_task(argv[0], argv[1], &c, &t))
+		return -1;
+	return stats_get_task_stats_sample(c, t, 1)->drop_handled;
+}
+
+static uint64_t sp_task_rx_bytes(int argc, const char *argv[])
+{
+	return -1;
+}
+
+static uint64_t sp_task_tx_bytes(int argc, const char *argv[])
+{
+	return -1;
+}
+
+static uint64_t sp_task_tsc(int argc, const char *argv[])
+{
+	struct task_stats_sample *last;
+	uint32_t c, t;
+
+	if (args_to_core_task(argv[0], argv[1], &c, &t))
+		return -1;
+	return stats_get_task_stats_sample(c, t, 1)->tsc;
+}
+
+static uint64_t sp_l4gen_created(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.tcp_created + clast->stats.udp_created;
+}
+
+static uint64_t sp_l4gen_finished(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.tcp_finished_retransmit + clast->stats.tcp_finished_no_retransmit +
+		clast->stats.udp_finished + clast->stats.udp_expired + clast->stats.tcp_expired;
+}
+
+static uint64_t sp_l4gen_expire_tcp(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return 	clast->stats.tcp_expired;
+}
+
+static uint64_t sp_l4gen_expire_udp(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.udp_expired;
+}
+
+static uint64_t sp_l4gen_retx(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.tcp_retransmits;
+}
+
+static uint64_t sp_l4gen_tsc(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->tsc;
+}
+
+static uint64_t sp_l4gen_torndown_no_retx(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.tcp_finished_no_retransmit;
+}
+
+static uint64_t sp_l4gen_torndown_retx(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.tcp_finished_retransmit;
+}
+
+static uint64_t sp_l4gen_torndown_udp(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.udp_finished;
+}
+
+static uint64_t sp_l4gen_created_tcp(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.tcp_created;
+
+}
+
+static uint64_t sp_l4gen_created_udp(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.udp_created;
+}
+
+static uint64_t sp_l4gen_created_all(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.tcp_created + clast->stats.udp_created;
+}
+
+static uint64_t sp_l4gen_created_bundles(int argc, const char *argv[])
+{
+	struct l4_stats_sample *clast = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_l4gen())
+		return -1;
+	clast = stats_get_l4_stats_sample(atoi(argv[0]), 1);
+	return clast->stats.bundles_created;
+}
+
+static uint64_t sp_latency_min(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_get(atoi(argv[0]));
+
+	if (!lat_test->tot_packets)
+		return -1;
+
+	struct time_unit tu = lat_test->min.time;
+	return time_unit_to_usec(&tu);
+}
+
+static uint64_t sp_mem_used(int argc, const char *argv[])
+{
+	struct mempool_stats *ms;
+
+	if (atoi(argv[0]) > stats_get_n_mempools())
+		return -1;
+	ms = stats_get_mempool_stats(atoi(argv[0]));
+	return ms->size - ms->free;
+}
+
+static uint64_t sp_mem_free(int argc, const char *argv[])
+{
+	struct mempool_stats *ms;
+
+	if (atoi(argv[0]) > stats_get_n_mempools())
+		return -1;
+	ms = stats_get_mempool_stats(atoi(argv[0]));
+	return ms->free;
+}
+
+static uint64_t sp_mem_size(int argc, const char *argv[])
+{
+	struct mempool_stats *ms;
+
+	if (atoi(argv[0]) > stats_get_n_mempools())
+		return -1;
+	ms = stats_get_mempool_stats(atoi(argv[0]));
+	return ms->size;
+}
+
+static uint64_t sp_port_no_mbufs(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->no_mbufs;
+}
+
+static uint64_t sp_port_ierrors(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->ierrors;
+}
+
+static uint64_t sp_port_imissed(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->imissed;
+}
+
+static uint64_t sp_port_oerrors(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->oerrors;
+}
+
+static uint64_t sp_port_rx_packets(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->rx_tot;
+}
+
+static uint64_t sp_port_tx_packets(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tx_tot;
+}
+
+static uint64_t sp_port_rx_bytes(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->rx_bytes;
+}
+
+static uint64_t sp_port_tx_bytes(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tx_bytes;
+}
+
+static uint64_t sp_port_tx_packets_64(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tx_pkt_size[PKT_SIZE_64];
+}
+
+static uint64_t sp_port_tx_packets_65_127(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tx_pkt_size[PKT_SIZE_65];
+}
+
+static uint64_t sp_port_tx_packets_128_255(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tx_pkt_size[PKT_SIZE_128];
+}
+
+static uint64_t sp_port_tx_packets_256_511(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tx_pkt_size[PKT_SIZE_256];
+}
+
+static uint64_t sp_port_tx_packets_512_1023(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tx_pkt_size[PKT_SIZE_512];
+}
+
+static uint64_t sp_port_tx_packets_1024_1522(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tx_pkt_size[PKT_SIZE_1024];
+}
+
+static uint64_t sp_port_tx_packets_1523_max(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tx_pkt_size[PKT_SIZE_1522];
+}
+
+static uint64_t sp_port_tsc(int argc, const char *argv[])
+{
+	uint32_t port_id = atoi(argv[0]);
+	struct port_stats_sample *ps;
+
+	if (port_id > PROX_MAX_PORTS || !prox_port_cfg[port_id].active)
+		return -1;
+	ps = stats_get_port_stats_sample(port_id, 1);
+	return ps->tsc;
+}
+
+static uint64_t sp_latency_max(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_get(atoi(argv[0]));
+
+	if (!lat_test->tot_packets)
+		return -1;
+
+	struct time_unit tu = lat_test->max.time;
+	return time_unit_to_usec(&tu);
+}
+
+static uint64_t sp_latency_avg(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_get(atoi(argv[0]));
+
+	if (!lat_test->tot_packets)
+		return -1;
+
+	struct time_unit tu = lat_test->avg.time;
+	return time_unit_to_usec(&tu);
+}
+
+static uint64_t sp_latency_lost(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_get(atoi(argv[0]));
+
+	if (!lat_test->tot_packets)
+		return -1;
+
+	return lat_test->lost_packets;
+}
+
+static uint64_t sp_latency_tot_lost(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_tot_get(atoi(argv[0]));
+
+	if (!lat_test->tot_packets)
+		return -1;
+
+	return lat_test->lost_packets;
+}
+
+static uint64_t sp_latency_total(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_get(atoi(argv[0]));
+
+	if (!lat_test->tot_all_packets)
+		return -1;
+
+	return lat_test->tot_all_packets;
+}
+
+static uint64_t sp_latency_used(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_get(atoi(argv[0]));
+
+	if (!lat_test->tot_all_packets)
+		return -1;
+
+	return lat_test->tot_packets;
+}
+
+static uint64_t sp_latency_tot_total(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_tot_get(atoi(argv[0]));
+
+	if (!lat_test->tot_all_packets)
+		return -1;
+
+	return lat_test->tot_all_packets;
+}
+
+static uint64_t sp_latency_tot_used(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_tot_get(atoi(argv[0]));
+
+	if (!lat_test->tot_all_packets)
+		return -1;
+
+	return lat_test->tot_packets;
+}
+
+static uint64_t sp_latency_tot_min(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_tot_get(atoi(argv[0]));
+
+	if (!lat_test->tot_packets)
+		return -1;
+
+	struct time_unit tu = lat_test->min.time;
+	return time_unit_to_usec(&tu);
+}
+
+static uint64_t sp_latency_tot_max(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_tot_get(atoi(argv[0]));
+
+	if (!lat_test->tot_packets)
+		return -1;
+
+	struct time_unit tu = lat_test->max.time;
+	return time_unit_to_usec(&tu);
+}
+
+static uint64_t sp_latency_tot_avg(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_tot_get(atoi(argv[0]));
+
+	if (!lat_test->tot_packets)
+		return -1;
+
+	struct time_unit tu = lat_test->avg.time;
+	return time_unit_to_usec(&tu);
+}
+
+static uint64_t sp_latency_stddev(int argc, const char *argv[])
+{
+	struct stats_latency *lat_test = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_latency())
+		return -1;
+	lat_test = stats_latency_get(atoi(argv[0]));
+
+	if (!lat_test->tot_packets)
+		return -1;
+
+	struct time_unit tu = lat_test->stddev.time;
+	return time_unit_to_usec(&tu);
+}
+
+static uint64_t sp_ring_used(int argc, const char *argv[])
+{
+	struct ring_stats *rs = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_rings())
+		return -1;
+	rs = stats_get_ring_stats(atoi(argv[0]));
+	return rs->size - rs->free;
+}
+
+static uint64_t sp_ring_free(int argc, const char *argv[])
+{
+	struct ring_stats *rs = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_rings())
+		return -1;
+	rs = stats_get_ring_stats(atoi(argv[0]));
+	return rs->free;
+}
+
+static uint64_t sp_ring_size(int argc, const char *argv[])
+{
+	struct ring_stats *rs = NULL;
+
+	if (atoi(argv[0]) >= stats_get_n_rings())
+		return -1;
+	rs = stats_get_ring_stats(atoi(argv[0]));
+	return rs->size;
+}
+
+static uint64_t sp_global_host_rx_packets(int argc, const char *argv[])
+{
+	return stats_get_global_stats(1)->host_rx_packets;
+}
+
+static uint64_t sp_global_host_tx_packets(int argc, const char *argv[])
+{
+	return stats_get_global_stats(1)->host_tx_packets;
+}
+
+static uint64_t sp_global_nics_rx_packets(int argc, const char *argv[])
+{
+	return stats_get_global_stats(1)->nics_rx_packets;
+}
+
+static uint64_t sp_global_nics_tx_packets(int argc, const char *argv[])
+{
+	return stats_get_global_stats(1)->nics_tx_packets;
+}
+
+static uint64_t sp_global_nics_ierrors(int argc, const char *argv[])
+{
+	return stats_get_global_stats(1)->nics_ierrors;
+}
+
+static uint64_t sp_global_nics_imissed(int argc, const char *argv[])
+{
+	return stats_get_global_stats(1)->nics_imissed;
+}
+
+static uint64_t sp_global_tsc(int argc, const char *argv[])
+{
+	return stats_get_global_stats(1)->tsc;
+}
+
+static uint64_t sp_hz(int argc, const char *argv[])
+{
+	return rte_get_tsc_hz();
+}
+
+struct stats_path_str stats_paths[] = {
+	{"hz", sp_hz},
+
+	{"global.host.rx.packets", sp_global_host_rx_packets},
+	{"global.host.tx.packets", sp_global_host_tx_packets},
+	{"global.nics.rx.packets", sp_global_nics_rx_packets},
+	{"global.nics.tx.packets", sp_global_nics_tx_packets},
+	{"global.nics.ierrrors", sp_global_nics_ierrors},
+	{"global.nics.imissed", sp_global_nics_imissed},
+	{"global.tsc", sp_global_tsc},
+
+	{"task.core(#).task(#).idle_cycles", sp_task_idle_cycles},
+	{"task.core(#).task(#).rx.packets", sp_task_rx_packets},
+	{"task.core(#).task(#).tx.packets", sp_task_tx_packets},
+	{"task.core(#).task(#).drop.tx_fail", sp_task_drop_tx_fail},
+	{"task.core(#).task(#).drop.discard", sp_task_drop_discard},
+	{"task.core(#).task(#).drop.handled", sp_task_drop_handled},
+	{"task.core(#).task(#).rx.bytes", sp_task_rx_bytes},
+	{"task.core(#).task(#).tx.bytes", sp_task_tx_bytes},
+	{"task.core(#).task(#).tsc", sp_task_tsc},
+	{"task.core(#).task(#).drop.tx_fail_prio(#)", sp_task_drop_tx_fail_prio},
+	{"task.core(#).task(#).rx_prio(#)", sp_task_rx_prio},
+
+	{"port(#).no_mbufs", sp_port_no_mbufs},
+	{"port(#).ierrors", sp_port_ierrors},
+	{"port(#).imissed", sp_port_imissed},
+	{"port(#).oerrors", sp_port_oerrors},
+	{"port(#).rx.packets", sp_port_rx_packets},
+	{"port(#).tx.packets", sp_port_tx_packets},
+	{"port(#).rx.bytes", sp_port_rx_bytes},
+	{"port(#).tx.bytes", sp_port_tx_bytes},
+	{"port(#).tx.packets_64", sp_port_tx_packets_64},
+	{"port(#).tx.packets_65_127", sp_port_tx_packets_65_127},
+	{"port(#).tx.packets_128_255", sp_port_tx_packets_128_255},
+	{"port(#).tx.packets_256_511", sp_port_tx_packets_256_511},
+	{"port(#).tx.packets_512_1023", sp_port_tx_packets_512_1023},
+	{"port(#).tx.packets_1024_1522", sp_port_tx_packets_1024_1522},
+	{"port(#).tx.packets_1523_max", sp_port_tx_packets_1523_max},
+	{"port(#).tsc", sp_port_tsc},
+
+	{"mem(#).used", sp_mem_used},
+	{"mem(#).free", sp_mem_free},
+	{"mem(#).size", sp_mem_size},
+
+	{"latency(#).min", sp_latency_min},
+	{"latency(#).max", sp_latency_max},
+	{"latency(#).avg", sp_latency_avg},
+	{"latency(#).lost", sp_latency_lost},
+	{"latency(#).used", sp_latency_used},
+	{"latency(#).total", sp_latency_total},
+	{"latency(#).tot.min", sp_latency_tot_min},
+	{"latency(#).tot.max", sp_latency_tot_max},
+	{"latency(#).tot.avg", sp_latency_tot_avg},
+	{"latency(#).tot.lost", sp_latency_tot_lost},
+	{"latency(#).tot.used", sp_latency_tot_used},
+	{"latency(#).tot.total", sp_latency_tot_total},
+	{"latency(#).stddev", sp_latency_stddev},
+
+	{"ring(#).used", sp_ring_used},
+	{"ring(#).free", sp_ring_free},
+	{"ring(#).size", sp_ring_size},
+
+	{"l4gen(#).created.tcp", sp_l4gen_created_tcp},
+	{"l4gen(#).created.udp", sp_l4gen_created_udp},
+	{"l4gen(#).created.all", sp_l4gen_created_all},
+	{"l4gen(#).created.bundles", sp_l4gen_created_bundles},
+	{"l4gen(#).torndown.no_retx", sp_l4gen_torndown_no_retx},
+	{"l4gen(#).torndown.retx", sp_l4gen_torndown_retx},
+	{"l4gen(#).torndown.udp", sp_l4gen_torndown_udp},
+	{"l4gen(#).expired.tcp", sp_l4gen_expire_tcp},
+	{"l4gen(#).expired.udp", sp_l4gen_expire_udp},
+	{"l4gen(#).created", sp_l4gen_created},
+	{"l4gen(#).finished", sp_l4gen_finished},
+	{"l4gen(#).retx", sp_l4gen_retx},
+	{"l4gen(#).tsc", sp_l4gen_tsc},
+};
+
+static int stats_parser_extract_args(char *stats_path, size_t *argc, char **argv)
+{
+	size_t len = strlen(stats_path);
+	size_t j = 0;
+	size_t k = 0;
+	int state = 0;
+
+	for (size_t i = 0; i < len; ++i) {
+		switch (state) {
+		case 0:
+			if (stats_path[i] == '(') {
+				state = 1;
+				k = 0;
+			}
+			else if (stats_path[i] == ')')
+				return -1;
+			stats_path[j] = stats_path[i];
+			j++;
+			break;
+		case 1:
+			if (stats_path[i] == ')') {
+				state = 0;
+				stats_path[j] = '#';
+				j++;
+				stats_path[j] = ')';
+				j++;
+				(*argc)++;
+			}
+			else {
+				argv[*argc][k++] = stats_path[i];
+			}
+			break;
+		}
+	}
+	if (state == 1)
+		return -1;
+	stats_path[j] = 0;
+	return 0;
+}
+
+uint64_t stats_parser_get(const char *stats_path)
+{
+	size_t stats_path_len;
+
+	char stats_path_cpy[128];
+
+	strncpy(stats_path_cpy, stats_path, sizeof(stats_path_cpy));
+	stats_path_len = strlen(stats_path);
+
+	size_t max_argc = 16;
+	size_t argc = 0;
+	char argv_data[16][16] = {{0}};
+	char *argv[16];
+	const char *argv_c[16];
+
+	for (size_t i = 0; i < 16; ++i) {
+		argv[i] = argv_data[i];
+		argv_c[i] = argv_data[i];
+	}
+
+	if (stats_parser_extract_args(stats_path_cpy, &argc, argv))
+		return -1;
+
+	for (size_t i = 0; i < sizeof(stats_paths)/sizeof(stats_paths[0]); ++i) {
+		if (strcmp(stats_paths[i].str, stats_path_cpy) == 0) {
+			if (stats_paths[i].func == NULL)
+				return -1;
+			return stats_paths[i].func(argc, argv_c);
+		}
+	}
+
+	return -1;
+}
diff --git a/VNFs/DPPD-PROX/stats_parser.h b/VNFs/DPPD-PROX/stats_parser.h
new file mode 100644
index 00000000..0812dbfc
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_parser.h
@@ -0,0 +1,24 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_PARSER_H_
+#define _STATS_PARSER_H_
+
+#include <inttypes.h>
+
+uint64_t stats_parser_get(const char *stats_path);
+
+#endif /* _STATS_PARSER_H_ */
diff --git a/VNFs/DPPD-PROX/stats_port.c b/VNFs/DPPD-PROX/stats_port.c
new file mode 100644
index 00000000..b5e70dcc
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_port.c
@@ -0,0 +1,407 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+
+#include <rte_version.h>
+#include <rte_ethdev.h>
+#include <rte_cycles.h>
+#include <rte_byteorder.h>
+
+#include "prox_malloc.h"
+#include "log.h"
+#include "quit.h"
+#include "stats_port.h"
+#include "prox_port_cfg.h"
+#include "rw_reg.h"
+
+#if defined(PROX_STATS) && defined(PROX_HW_DIRECT_STATS)
+
+/* Directly access hardware counters instead of going through DPDK. This allows getting
+ * specific counters that DPDK does not report or aggregates with other ones.
+ */
+
+/* Definitions for IXGBE (taken from PMD) */
+#define PROX_IXGBE_MPC(_i)           (0x03FA0 + ((_i) * 4)) /* 8 of these 3FA0-3FBC*/
+#define PROX_IXGBE_QBRC_L(_i)        (0x01034 + ((_i) * 0x40)) /* 16 of these */
+#define PROX_IXGBE_QBRC_H(_i)        (0x01038 + ((_i) * 0x40)) /* 16 of these */
+#define PROX_IXGBE_QPRC(_i)          (0x01030 + ((_i) * 0x40)) /* 16 of these */
+#define PROX_IXGBE_GPTC              0x04080
+#define PROX_IXGBE_TPR               0x040D0
+#define PROX_IXGBE_TORL              0x040C0
+#define PROX_IXGBE_TORH              0x040C4
+#define PROX_IXGBE_GOTCL             0x04090
+#define PROX_IXGBE_GOTCH             0x04094
+
+#define IXGBE_QUEUE_STAT_COUNTERS 16
+
+static void ixgbe_read_stats(uint8_t port_id, struct port_stats_sample* stats, struct port_stats_sample *prev, int last_stat)
+{
+	uint64_t before, after;
+	unsigned i;
+
+	struct rte_eth_dev* dev = &rte_eth_devices[port_id];
+
+	/* WARNING: Assumes hardware address is first field of structure! This may change! */
+	struct _dev_hw* hw = (struct _dev_hw *)(dev->data->dev_private);
+
+	stats->no_mbufs = dev->data->rx_mbuf_alloc_failed;
+
+	/* Since we only read deltas from the NIC, we have to add to previous values
+	 * even though we actually substract again later to find out the rates!
+	 */
+	stats->ierrors = prev->ierrors;
+	stats->imissed = prev->imissed;
+	stats->rx_bytes = prev->rx_bytes;
+	stats->rx_tot = prev->rx_tot;
+	stats->tx_bytes = prev->tx_bytes;
+	stats->tx_tot = prev->tx_tot;
+
+	/* WARNING: In this implementation, we count as imiised only the "no descriptor"
+	 * missed packets cases and not the actual receive errors.
+	 */
+	before = rte_rdtsc();
+	for (i = 0; i < 8; i++) {
+		stats->imissed += PROX_READ_REG(hw, PROX_IXGBE_MPC(i));
+	}
+
+	/* RX stats */
+#if 0
+	/* This version is equivalent to what ixgbe PMD does. It only accounts for packets
+	 * actually received on the host.
+	 */
+	for (i = 0; i < IXGBE_QUEUE_STAT_COUNTERS; i++) {
+		/* ipackets: */
+		stats->rx_tot += PROX_READ_REG(hw, PROX_IXGBE_QPRC(i));
+		/* ibytes: */
+		stats->rx_bytes += PROX_READ_REG(hw, PROX_IXGBE_QBRC_L(i));
+		stats->rx_bytes += ((uint64_t)PROX_READ_REG(hw, PROX_IXGBE_QBRC_H(i)) << 32);
+	}
+#else
+	/* This version reports the packets received by the NIC, regardless of whether they
+	 * reached the host or not, etc. (no need to add ierrors or imissedto this packet count)
+	 */
+	stats->rx_tot += PROX_READ_REG(hw, PROX_IXGBE_TPR);
+	stats->rx_bytes += PROX_READ_REG(hw, PROX_IXGBE_TORL);
+	stats->rx_bytes += ((uint64_t)PROX_READ_REG(hw, PROX_IXGBE_TORH) << 32);
+#endif
+
+	/* TX stats */
+	/* opackets: */
+	stats->tx_tot += PROX_READ_REG(hw, PROX_IXGBE_GPTC);
+	/* obytes: */
+	stats->tx_bytes += PROX_READ_REG(hw, PROX_IXGBE_GOTCL);
+	stats->tx_bytes += ((uint64_t)PROX_READ_REG(hw, PROX_IXGBE_GOTCH) << 32);
+	after = rte_rdtsc();
+	stats->tsc = (before >> 1) + (after >> 1);
+}
+
+#endif
+
+extern int last_stat;
+static struct port_stats   port_stats[PROX_MAX_PORTS];
+static uint8_t nb_interface;
+static uint8_t n_ports;
+static int num_xstats[PROX_MAX_PORTS] = {0};
+static int num_ixgbe_xstats = 0;
+
+#if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,1)
+#define XSTATS_SUPPORT 1
+#else
+#define XSTATS_SUPPORT 0
+#endif
+
+#if XSTATS_SUPPORT
+#if RTE_VERSION >= RTE_VERSION_NUM(16,7,0,0)
+static struct rte_eth_xstat *eth_xstats[PROX_MAX_PORTS] = {0};
+static struct rte_eth_xstat_name *eth_xstat_names[PROX_MAX_PORTS] = {0};
+#else
+static struct rte_eth_xstats *eth_xstats[PROX_MAX_PORTS] = {0};
+static struct rte_eth_xstats *eth_xstat_names[PROX_MAX_PORTS] = {0};
+#endif
+static int xstat_tpr_offset[PROX_MAX_PORTS] ={0}, xstat_tor_offset[PROX_MAX_PORTS] = {0};
+static int tx_pkt_size_offset[PROX_MAX_PORTS][PKT_SIZE_COUNT];
+#endif
+
+#if RTE_VERSION >= RTE_VERSION_NUM(16,7,0,0)
+static int find_xstats_str(struct rte_eth_xstat_name *xstats, int n, const char *name)
+#else
+static int find_xstats_str(struct rte_eth_xstats *xstats, int n, const char *name)
+#endif
+{
+	for (int i = 0; i < n; i++) {
+		if (strcmp(xstats[i].name, name) == 0)
+			return i;
+	}
+
+	return -1;
+}
+
+void stats_port_init(void)
+{
+	int potential_ixgbe_warn = 0;
+	for (int i = 0; i < PROX_MAX_PORTS; i++) {
+		xstat_tpr_offset[i] = -1;
+		xstat_tor_offset[i] = -1;
+		for (int j = 0; j < PKT_SIZE_COUNT; j++) {
+			tx_pkt_size_offset[i][j] = -1;
+		}
+	}
+#if XSTATS_SUPPORT
+	nb_interface = prox_last_port_active() + 1;
+	n_ports = prox_nb_active_ports();
+
+	for (uint8_t port_id = 0; port_id < nb_interface; ++port_id) {
+		if (prox_port_cfg[port_id].active) {
+#if RTE_VERSION >= RTE_VERSION_NUM(16,7,0,0)
+			num_xstats[port_id] = rte_eth_xstats_get_names(port_id, NULL, 0);
+			eth_xstat_names[port_id] = prox_zmalloc(num_xstats[port_id] * sizeof(struct rte_eth_xstat_name), prox_port_cfg[port_id].socket);
+			PROX_PANIC(eth_xstat_names[port_id] == NULL, "Error allocating memory for xstats");
+			num_xstats[port_id] = rte_eth_xstats_get_names(port_id, eth_xstat_names[port_id], num_xstats[port_id]);
+			eth_xstats[port_id] = prox_zmalloc(num_xstats[port_id] * sizeof(struct rte_eth_xstat), prox_port_cfg[port_id].socket);
+			PROX_PANIC(eth_xstats[port_id] == NULL, "Error allocating memory for xstats");
+#else
+			num_xstats[port_id] = rte_eth_xstats_get(port_id, NULL, 0);
+			eth_xstats[port_id] = prox_zmalloc(num_xstats[port_id] * sizeof(struct rte_eth_xstats), prox_port_cfg[port_id].socket);
+			PROX_PANIC(eth_xstats[port_id] == NULL, "Error allocating memory for xstats");
+			eth_xstat_names[port_id] = eth_xstats[port_id];
+			num_xstats[port_id] = rte_eth_xstats_get(port_id, eth_xstats[port_id], num_xstats[port_id]);
+#endif
+			if (!strcmp(prox_port_cfg[port_id].short_name, "ixgbe")) {
+				potential_ixgbe_warn = 1;
+				xstat_tor_offset[port_id] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "rx_total_bytes");
+				xstat_tpr_offset[port_id] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "rx_total_packets");
+			}
+			tx_pkt_size_offset[port_id][PKT_SIZE_64] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "tx_size_64_packets");
+			tx_pkt_size_offset[port_id][PKT_SIZE_65] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "tx_size_65_to_127_packets");
+			tx_pkt_size_offset[port_id][PKT_SIZE_128] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "tx_size_128_to_255_packets");
+			tx_pkt_size_offset[port_id][PKT_SIZE_256] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "tx_size_256_to_511_packets");
+			tx_pkt_size_offset[port_id][PKT_SIZE_512] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "tx_size_512_to_1023_packets");
+			if (0 == strcmp(prox_port_cfg[port_id].short_name, "ixgbe")) {
+				tx_pkt_size_offset[port_id][PKT_SIZE_1024] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "tx_size_1024_to_max_packets");
+			} else {
+				tx_pkt_size_offset[port_id][PKT_SIZE_1024] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "tx_size_1024_to_1522_packets");
+				tx_pkt_size_offset[port_id][PKT_SIZE_1522] = find_xstats_str(eth_xstat_names[port_id], num_xstats[port_id], "tx_size_1523_to_max_packets");
+			}
+			plog_info("offset = %d, %d, %d, %d, %d, %d %d\n", tx_pkt_size_offset[port_id][PKT_SIZE_64], tx_pkt_size_offset[port_id][PKT_SIZE_65], tx_pkt_size_offset[port_id][PKT_SIZE_128], tx_pkt_size_offset[port_id][PKT_SIZE_256], tx_pkt_size_offset[port_id][PKT_SIZE_512], tx_pkt_size_offset[port_id][PKT_SIZE_1024], tx_pkt_size_offset[port_id][PKT_SIZE_1522]);
+#if RTE_VERSION >= RTE_VERSION_NUM(16,7,0,0)
+			prox_free(eth_xstat_names[port_id]);
+#endif
+			if (num_xstats[port_id] == 0 || eth_xstats[port_id] == NULL) {
+				plog_warn("Failed to initialize xstat for port %d, running without xstats\n", port_id);
+				num_xstats[port_id] = 0;
+			}
+		}
+	}
+	for (uint8_t port_id = 0; port_id < nb_interface; ++port_id) {
+		if ((xstat_tor_offset[port_id] != -1) && (xstat_tpr_offset[port_id] != -1)) {
+			num_ixgbe_xstats = 2;	// ixgbe PMD supports tor and tpr xstats
+			break;
+		}
+	}
+	if ((num_ixgbe_xstats == 0) && (potential_ixgbe_warn))
+		plog_warn("Failed to initialize ixgbe xstat, running without ixgbe xstats\n");
+#endif
+}
+
+static void nic_read_stats(uint8_t port_id)
+{
+	unsigned is_ixgbe = (0 == strcmp(prox_port_cfg[port_id].short_name, "ixgbe"));
+
+	struct port_stats_sample *stats = &port_stats[port_id].sample[last_stat];
+
+#if defined(PROX_STATS) && defined(PROX_HW_DIRECT_STATS)
+	if (is_ixgbe) {
+		struct port_stats_sample *prev = &port_stats[port_id].sample[!last_stat];
+		ixgbe_read_stats(port_id, stats, prev, last_stat);
+		return;
+	}
+#endif
+	uint64_t before, after;
+
+	struct rte_eth_stats eth_stat;
+
+	before = rte_rdtsc();
+	rte_eth_stats_get(port_id, &eth_stat);
+	after = rte_rdtsc();
+
+	stats->tsc = (before >> 1) + (after >> 1);
+	stats->no_mbufs = eth_stat.rx_nombuf;
+	stats->ierrors = eth_stat.ierrors;
+	stats->imissed = eth_stat.imissed;
+	stats->oerrors = eth_stat.oerrors;
+	stats->rx_bytes = eth_stat.ibytes;
+
+	/* The goal would be to get the total number of bytes received
+	   by the NIC (including overhead). Without the patch
+	   (i.e. num_ixgbe_xstats == 0) we can't do this directly with
+	   DPDK 2.1 API. So, we report the number of bytes (including
+	   overhead) received by the host. */
+
+#if XSTATS_SUPPORT
+	if (num_xstats[port_id]) {
+		rte_eth_xstats_get(port_id, eth_xstats[port_id], num_xstats[port_id]);
+		for (size_t i = 0; i < sizeof(tx_pkt_size_offset[0])/sizeof(tx_pkt_size_offset[0][0]); ++i) {
+			if (tx_pkt_size_offset[port_id][i] != -1)
+				stats->tx_pkt_size[i] = (eth_xstats[port_id][tx_pkt_size_offset[port_id][i]]).value;
+			else
+				stats->tx_pkt_size[i] = -1;
+		}
+	} else {
+		for (size_t i = 0; i < sizeof(tx_pkt_size_offset[0])/sizeof(tx_pkt_size_offset[0][0]); ++i) {
+			stats->tx_pkt_size[i] = -1;
+		}
+	}
+#endif
+	if (is_ixgbe) {
+#if XSTATS_SUPPORT
+		if (num_ixgbe_xstats) {
+			stats->rx_tot = eth_xstats[port_id][xstat_tpr_offset[port_id]].value;
+			stats->rx_bytes = eth_xstats[port_id][xstat_tor_offset[port_id]].value;
+		} else
+#endif
+		{
+			stats->rx_tot = eth_stat.ipackets + eth_stat.ierrors + eth_stat.imissed;
+			/* On ixgbe, the rx_bytes counts bytes
+			   received by Host without overhead. The
+			   rx_tot counts the number of packets
+			   received by the NIC. If we only add 20 *
+			   rx_tot to rx_bytes, the result will also
+			   take into account 20 * "number of packets
+			   dropped by the nic". Note that in case CRC
+			   is stripped on ixgbe, the CRC bytes are not
+			   counted. */
+			if (prox_port_cfg[port_id].port_conf.rxmode.hw_strip_crc == 1)
+				stats->rx_bytes = eth_stat.ibytes +
+					(24 * eth_stat.ipackets - 20 * (eth_stat.ierrors + eth_stat.imissed));
+			else
+				stats->rx_bytes = eth_stat.ibytes +
+					(20 * eth_stat.ipackets - 20 * (eth_stat.ierrors + eth_stat.imissed));
+		}
+	} else if (strcmp(prox_port_cfg[port_id].short_name, "i40e_vf") == 0) {
+		// For I40E VF, imissed already part of received packets
+		stats->rx_tot = eth_stat.ipackets;
+	} else {
+		stats->rx_tot = eth_stat.ipackets + eth_stat.imissed;
+	}
+	stats->tx_tot = eth_stat.opackets;
+	stats->tx_bytes = eth_stat.obytes;
+}
+
+void stats_port_reset(void)
+{
+	for (uint8_t port_id = 0; port_id < nb_interface; ++port_id) {
+		if (prox_port_cfg[port_id].active) {
+			rte_eth_stats_reset(port_id);
+			memset(&port_stats[port_id], 0, sizeof(struct port_stats));
+		}
+	}
+}
+
+void stats_port_update(void)
+{
+	for (uint8_t port_id = 0; port_id < nb_interface; ++port_id) {
+		if (prox_port_cfg[port_id].active) {
+			nic_read_stats(port_id);
+		}
+	}
+}
+
+uint64_t stats_port_get_ierrors(void)
+{
+	uint64_t ret = 0;
+
+	for (uint8_t port_id = 0; port_id < nb_interface; ++port_id) {
+		if (prox_port_cfg[port_id].active)
+			ret += port_stats[port_id].sample[last_stat].ierrors;
+	}
+	return ret;
+}
+
+uint64_t stats_port_get_imissed(void)
+{
+	uint64_t ret = 0;
+
+	for (uint8_t port_id = 0; port_id < nb_interface; ++port_id) {
+		if (prox_port_cfg[port_id].active)
+			ret += port_stats[port_id].sample[last_stat].imissed;
+	}
+	return ret;
+}
+
+uint64_t stats_port_get_rx_packets(void)
+{
+	uint64_t ret = 0;
+
+	for (uint8_t port_id = 0; port_id < nb_interface; ++port_id) {
+		if (prox_port_cfg[port_id].active)
+			ret += port_stats[port_id].sample[last_stat].rx_tot;
+	}
+	return ret;
+}
+
+uint64_t stats_port_get_tx_packets(void)
+{
+	uint64_t ret = 0;
+
+	for (uint8_t port_id = 0; port_id < nb_interface; ++port_id) {
+		if (prox_port_cfg[port_id].active)
+			ret += port_stats[port_id].sample[last_stat].tx_tot;
+	}
+	return ret;
+}
+
+int stats_get_n_ports(void)
+{
+	return n_ports;
+}
+
+struct port_stats_sample *stats_get_port_stats_sample(uint32_t port_id, int l)
+{
+	return &port_stats[port_id].sample[l == last_stat];
+}
+
+int stats_port(uint8_t port_id, struct get_port_stats *gps)
+{
+	if (!prox_port_cfg[port_id].active)
+		return -1;
+
+	struct port_stats_sample *last = &port_stats[port_id].sample[last_stat];
+	struct port_stats_sample *prev = &port_stats[port_id].sample[!last_stat];
+
+	gps->no_mbufs_diff = last->no_mbufs - prev->no_mbufs;
+	gps->ierrors_diff = last->ierrors - prev->ierrors;
+	gps->imissed_diff = last->imissed - prev->imissed;
+	gps->rx_bytes_diff = last->rx_bytes - prev->rx_bytes;
+	gps->tx_bytes_diff = last->tx_bytes - prev->tx_bytes;
+	gps->rx_pkts_diff = last->rx_tot - prev->rx_tot;
+	if (unlikely(prev->rx_tot > last->rx_tot))
+		gps->rx_pkts_diff = 0;
+	gps->tx_pkts_diff = last->tx_tot - prev->tx_tot;
+	if (unlikely(prev->tx_tot > last->tx_tot))
+		gps->rx_pkts_diff = 0;
+	gps->rx_tot = last->rx_tot;
+	gps->tx_tot = last->tx_tot;
+	gps->no_mbufs_tot = last->no_mbufs;
+	gps->ierrors_tot = last->ierrors;
+	gps->imissed_tot = last->imissed;
+
+	gps->last_tsc = last->tsc;
+	gps->prev_tsc = prev->tsc;
+
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/stats_port.h b/VNFs/DPPD-PROX/stats_port.h
new file mode 100644
index 00000000..4e166e1b
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_port.h
@@ -0,0 +1,79 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_PORT_H_
+#define _STATS_PORT_H_
+
+#include <inttypes.h>
+
+enum PKT_SIZE_BIN {
+	PKT_SIZE_64,
+	PKT_SIZE_65,
+	PKT_SIZE_128,
+	PKT_SIZE_256,
+	PKT_SIZE_512,
+	PKT_SIZE_1024,
+	PKT_SIZE_1522,
+	PKT_SIZE_COUNT,
+};
+
+struct port_stats_sample {
+	uint64_t tsc;
+	uint64_t no_mbufs;
+	uint64_t ierrors;
+	uint64_t imissed;
+	uint64_t oerrors;
+	uint64_t rx_tot;
+	uint64_t tx_tot;
+	uint64_t rx_bytes;
+	uint64_t tx_bytes;
+	uint64_t tx_pkt_size[PKT_SIZE_COUNT];
+};
+
+struct port_stats {
+	struct port_stats_sample sample[2];
+};
+
+struct get_port_stats {
+	uint64_t no_mbufs_diff;
+	uint64_t ierrors_diff;
+	uint64_t imissed_diff;
+	uint64_t rx_bytes_diff;
+	uint64_t tx_bytes_diff;
+	uint64_t rx_pkts_diff;
+	uint64_t tx_pkts_diff;
+	uint64_t rx_tot;
+	uint64_t tx_tot;
+	uint64_t no_mbufs_tot;
+	uint64_t ierrors_tot;
+	uint64_t imissed_tot;
+	uint64_t last_tsc;
+	uint64_t prev_tsc;
+};
+
+int stats_port(uint8_t port_id, struct get_port_stats *ps);
+void stats_port_init(void);
+void stats_port_reset(void);
+void stats_port_update(void);
+uint64_t stats_port_get_ierrors(void);
+uint64_t stats_port_get_imissed(void);
+uint64_t stats_port_get_rx_packets(void);
+uint64_t stats_port_get_tx_packets(void);
+
+int stats_get_n_ports(void);
+struct port_stats_sample *stats_get_port_stats_sample(uint32_t port_id, int l);
+
+#endif /* _STATS_PORT_H_ */
diff --git a/VNFs/DPPD-PROX/stats_prio.c b/VNFs/DPPD-PROX/stats_prio.c
new file mode 100644
index 00000000..3d39d580
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_prio.c
@@ -0,0 +1,131 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <stddef.h>
+
+#include "handle_aggregator.h"
+#include "stats_prio_task.h"
+#include "prox_cfg.h"
+#include "prox_globals.h"
+#include "lconf.h"
+
+struct lcore_task_stats {
+	struct task_stats task_stats[MAX_TASKS_PER_CORE];
+};
+
+struct lcore_prio_task_stats {
+	struct prio_task_stats prio_task_stats[MAX_TASKS_PER_CORE];
+};
+
+extern int last_stat;
+static struct prio_task_stats   prio_task_stats_set[RTE_MAX_LCORE * MAX_TASKS_PER_CORE];
+static uint8_t nb_prio_tasks_tot;
+
+int stats_get_n_prio_tasks_tot(void)
+{
+        return nb_prio_tasks_tot;
+}
+
+struct prio_task_stats_sample *stats_get_prio_task_stats_sample(uint32_t prio_task_id, int l)
+{
+	return &prio_task_stats_set[prio_task_id].sample[l == last_stat];
+}
+
+struct prio_task_stats_sample *stats_get_prio_task_stats_sample_by_core_task(uint32_t lcore_id, uint32_t prio_task_id, int l)
+{
+	for (uint8_t task_id = 0; task_id < nb_prio_tasks_tot; ++task_id) {
+		if ((prio_task_stats_set[task_id].lcore_id == lcore_id) && (prio_task_stats_set[task_id].task_id == task_id))
+			return &prio_task_stats_set[prio_task_id].sample[l == last_stat];
+	}
+	return NULL;
+}
+
+void stats_prio_task_reset(void)
+{
+	struct prio_task_stats *cur_task_stats;
+
+	for (uint8_t task_id = 0; task_id < nb_prio_tasks_tot; ++task_id) {
+		cur_task_stats = &prio_task_stats_set[task_id];
+		for (int i = 0; i < 8; i++) {
+			cur_task_stats->tot_drop_tx_fail_prio[i] = 0;
+			cur_task_stats->tot_rx_prio[i] = 0;
+		}
+	}
+}
+
+uint64_t stats_core_task_tot_drop_tx_fail_prio(uint8_t prio_task_id, uint8_t prio)
+{
+	return prio_task_stats_set[prio_task_id].tot_drop_tx_fail_prio[prio];
+}
+
+uint64_t stats_core_task_tot_rx_prio(uint8_t prio_task_id, uint8_t prio)
+{
+	return prio_task_stats_set[prio_task_id].tot_rx_prio[prio];
+}
+
+void stats_prio_task_post_proc(void)
+{
+	for (uint8_t task_id = 0; task_id < nb_prio_tasks_tot; ++task_id) {
+		struct prio_task_stats *cur_task_stats = &prio_task_stats_set[task_id];
+		const struct prio_task_stats_sample *last = &cur_task_stats->sample[last_stat];
+		const struct prio_task_stats_sample *prev = &cur_task_stats->sample[!last_stat];
+
+		for (int i=0; i<8; i++) {
+			cur_task_stats->tot_rx_prio[i] += last->rx_prio[i] - prev->rx_prio[i];
+			cur_task_stats->tot_drop_tx_fail_prio[i] += last->drop_tx_fail_prio[i] - prev->drop_tx_fail_prio[i];
+		}
+	}
+}
+
+void stats_prio_task_update(void)
+{
+	uint64_t before, after;
+
+	for (uint8_t task_id = 0; task_id < nb_prio_tasks_tot; ++task_id) {
+		struct prio_task_stats *cur_task_stats = &prio_task_stats_set[task_id];
+		struct prio_task_rt_stats *stats = cur_task_stats->stats;
+		struct prio_task_stats_sample *last = &cur_task_stats->sample[last_stat];
+
+		before = rte_rdtsc();
+		for (int i=0; i<8; i++) {
+			last->drop_tx_fail_prio[i] = stats->drop_tx_fail_prio[i];
+			last->rx_prio[i] = stats->rx_prio[i];
+		}
+		after = rte_rdtsc();
+		last->tsc = (before >> 1) + (after >> 1);
+	}
+}
+
+void stats_prio_task_init(void)
+{
+	struct lcore_cfg *lconf;
+	uint32_t lcore_id;
+
+	/* add cores that are receiving from and sending to physical ports first */
+	lcore_id = -1;
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			struct task_args *targ = &lconf->targs[task_id];
+			if (strcmp(targ->task_init->mode_str, "aggreg") == 0) {
+				struct prio_task_rt_stats *stats = &((struct task_aggregator *)(lconf->tasks_all[task_id]))->stats;
+				prio_task_stats_set[nb_prio_tasks_tot].stats = stats;
+				prio_task_stats_set[nb_prio_tasks_tot].lcore_id = lcore_id;
+				prio_task_stats_set[nb_prio_tasks_tot++].task_id = task_id;
+			}
+		}
+	}
+}
diff --git a/VNFs/DPPD-PROX/stats_prio_task.h b/VNFs/DPPD-PROX/stats_prio_task.h
new file mode 100644
index 00000000..ce150591
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_prio_task.h
@@ -0,0 +1,55 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_PRIO_TASK_H_
+#define _STATS_PRIO_TASK_H_
+
+#include <inttypes.h>
+
+#include "clock.h"
+
+struct prio_task_stats_sample {
+	uint64_t tsc;
+	uint64_t drop_tx_fail_prio[8];
+	uint64_t rx_prio[8];
+};
+
+struct prio_task_rt_stats {
+	uint64_t drop_tx_fail_prio[8];
+	uint64_t rx_prio[8];
+};
+
+struct prio_task_stats {
+	uint64_t tot_drop_tx_fail_prio[8];
+	uint64_t tot_rx_prio[8];
+	uint8_t lcore_id;
+	uint8_t task_id;
+	struct prio_task_stats_sample sample[2];
+	struct prio_task_rt_stats *stats;
+};
+
+int stats_get_n_prio_tasks_tot(void);
+void stats_prio_task_reset(void);
+void stats_prio_task_post_proc(void);
+void stats_prio_task_update(void);
+void stats_prio_task_init(void);
+
+struct prio_task_stats_sample *stats_get_prio_task_stats_sample(uint32_t task_id, int last);
+struct prio_task_stats_sample *stats_get_prio_task_stats_sample_by_core_task(uint32_t lcore_id, uint32_t task_id, int last);
+uint64_t stats_core_task_tot_drop_tx_fail_prio(uint8_t task_id, uint8_t prio);
+uint64_t stats_core_task_tot_rx_prio(uint8_t task_id, uint8_t prio);
+
+#endif /* _STATS_PRIO_TASK_H_ */
diff --git a/VNFs/DPPD-PROX/stats_ring.c b/VNFs/DPPD-PROX/stats_ring.c
new file mode 100644
index 00000000..d0792ac1
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_ring.c
@@ -0,0 +1,160 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <inttypes.h>
+#include <rte_ring.h>
+#include <rte_version.h>
+
+#include "prox_malloc.h"
+#include "stats_ring.h"
+#include "prox_port_cfg.h"
+#include "prox_cfg.h"
+#include "lconf.h"
+#include "log.h"
+#include "quit.h"
+
+struct stats_ring_manager {
+	uint16_t n_rings;
+	struct ring_stats ring_stats[0];
+};
+
+static struct stats_ring_manager *rsm;
+
+int stats_get_n_rings(void)
+{
+	return rsm->n_rings;
+}
+
+struct ring_stats *stats_get_ring_stats(uint32_t i)
+{
+	return &rsm->ring_stats[i];
+}
+
+void stats_ring_update(void)
+{
+	for (uint16_t r_id = 0; r_id < rsm->n_rings; ++r_id) {
+		rsm->ring_stats[r_id].free = rte_ring_free_count(rsm->ring_stats[r_id].ring);
+	}
+}
+
+static struct ring_stats *init_rings_add(struct stats_ring_manager *rsm, struct rte_ring *ring)
+{
+	for (uint16_t i = 0; i < rsm->n_rings; ++i) {
+		if (strcmp(ring->name, rsm->ring_stats[i].ring->name) == 0)
+			return &rsm->ring_stats[i];
+	}
+	rsm->ring_stats[rsm->n_rings++].ring = ring;
+	return &rsm->ring_stats[rsm->n_rings - 1];
+}
+
+static struct stats_ring_manager *alloc_stats_ring_manager(void)
+{
+	const uint32_t socket_id = rte_lcore_to_socket_id(rte_lcore_id());
+	struct lcore_cfg *lconf;
+	uint32_t lcore_id = -1;
+	uint32_t n_rings = 0;
+	struct task_args *targ;
+
+	/* n_rings could be more than total number of rings since
+	   rings could be referenced by multiple cores. */
+	while(prox_core_next(&lcore_id, 1) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+
+		for(uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			targ = &lconf->targs[task_id];
+
+			for(uint32_t rxring_id = 0; rxring_id < targ->nb_rxrings; ++rxring_id) {
+				if (!targ->tx_opt_ring_task)
+					n_rings++;
+			}
+			for (uint32_t txring_id = 0; txring_id < targ->nb_txrings; ++txring_id) {
+				if (!targ->tx_opt_ring)
+					n_rings++;
+			}
+		}
+	}
+
+	for (uint8_t port_id = 0; port_id < PROX_MAX_PORTS; ++port_id) {
+		if (!prox_port_cfg[port_id].active) {
+			continue;
+		}
+
+		if (prox_port_cfg[port_id].rx_ring[0] != '\0')
+			n_rings++;
+
+		if (prox_port_cfg[port_id].tx_ring[0] != '\0')
+			n_rings++;
+	}
+
+	size_t mem_size = sizeof(struct stats_ring_manager) +
+		n_rings * sizeof(struct ring_stats);
+
+	return prox_zmalloc(mem_size, socket_id);
+}
+
+void stats_ring_init(void)
+{
+	uint32_t lcore_id = -1;
+	struct lcore_cfg *lconf;
+	struct task_args *targ;
+
+	rsm = alloc_stats_ring_manager();
+	while(prox_core_next(&lcore_id, 1) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+
+		for(uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			targ = &lconf->targs[task_id];
+
+			for(uint32_t rxring_id = 0; rxring_id < targ->nb_rxrings; ++rxring_id) {
+				if (!targ->tx_opt_ring_task)
+					init_rings_add(rsm, targ->rx_rings[rxring_id]);
+			}
+
+			for (uint32_t txring_id = 0; txring_id < targ->nb_txrings; ++txring_id) {
+				if (!targ->tx_opt_ring)
+					init_rings_add(rsm, targ->tx_rings[txring_id]);
+			}
+		}
+	}
+
+	struct ring_stats *stats = NULL;
+
+	for (uint8_t port_id = 0; port_id < PROX_MAX_PORTS; ++port_id) {
+		if (!prox_port_cfg[port_id].active) {
+			continue;
+		}
+
+		if (prox_port_cfg[port_id].rx_ring[0] != '\0') {
+			stats = init_rings_add(rsm, rte_ring_lookup(prox_port_cfg[port_id].rx_ring));
+			stats->port[stats->nb_ports++] = &prox_port_cfg[port_id];
+		}
+
+		if (prox_port_cfg[port_id].tx_ring[0] != '\0') {
+			stats = init_rings_add(rsm, rte_ring_lookup(prox_port_cfg[port_id].tx_ring));
+			stats->port[stats->nb_ports++] = &prox_port_cfg[port_id];
+		}
+	}
+
+	/* The actual usable space for a ring is size - 1. There is at
+	   most one free entry in the ring to distinguish between
+	   full/empty. */
+	for (uint16_t ring_id = 0; ring_id < rsm->n_rings; ++ring_id)
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+		rsm->ring_stats[ring_id].size = rsm->ring_stats[ring_id].ring->prod.size - 1;
+#else
+		rsm->ring_stats[ring_id].size = rsm->ring_stats[ring_id].ring->size - 1;
+#endif
+}
diff --git a/VNFs/DPPD-PROX/stats_ring.h b/VNFs/DPPD-PROX/stats_ring.h
new file mode 100644
index 00000000..d9d4d63f
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_ring.h
@@ -0,0 +1,34 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "prox_globals.h"
+
+struct rte_ring;
+struct prox_port_cfg;
+
+struct ring_stats {
+	struct rte_ring	*ring;
+	uint32_t	 nb_ports;
+	struct prox_port_cfg *port[PROX_MAX_PORTS];
+	uint32_t	 free;
+	uint32_t	 size;
+};
+
+void stats_ring_update(void);
+void stats_ring_init(void);
+
+int stats_get_n_rings(void);
+struct ring_stats *stats_get_ring_stats(uint32_t i);
diff --git a/VNFs/DPPD-PROX/stats_task.c b/VNFs/DPPD-PROX/stats_task.c
new file mode 100644
index 00000000..6b4dc2dd
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_task.c
@@ -0,0 +1,227 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <stddef.h>
+
+#include "stats_task.h"
+#include "prox_cfg.h"
+#include "prox_globals.h"
+#include "lconf.h"
+
+struct lcore_task_stats {
+	struct task_stats task_stats[MAX_TASKS_PER_CORE];
+};
+
+#define TASK_STATS_RX 0x01
+#define TASK_STATS_TX 0x02
+
+extern int last_stat;
+static struct lcore_task_stats  lcore_task_stats_all[RTE_MAX_LCORE];
+static struct task_stats   *task_stats_set[RTE_MAX_LCORE * MAX_TASKS_PER_CORE];
+static uint8_t nb_tasks_tot;
+int stats_get_n_tasks_tot(void)
+{
+	return nb_tasks_tot;
+}
+
+struct task_stats *stats_get_task_stats(uint32_t lcore_id, uint32_t task_id)
+{
+	return &lcore_task_stats_all[lcore_id].task_stats[task_id];
+}
+
+struct task_stats_sample *stats_get_task_stats_sample(uint32_t lcore_id, uint32_t task_id, int l)
+{
+	return &lcore_task_stats_all[lcore_id].task_stats[task_id].sample[l == last_stat];
+}
+
+void stats_task_reset(void)
+{
+	struct task_stats *cur_task_stats;
+
+	for (uint8_t task_id = 0; task_id < nb_tasks_tot; ++task_id) {
+		cur_task_stats = task_stats_set[task_id];
+		cur_task_stats->tot_rx_pkt_count = 0;
+		cur_task_stats->tot_tx_pkt_count = 0;
+		cur_task_stats->tot_drop_tx_fail = 0;
+		cur_task_stats->tot_drop_discard = 0;
+		cur_task_stats->tot_drop_handled = 0;
+	}
+}
+
+uint64_t stats_core_task_tot_rx(uint8_t lcore_id, uint8_t task_id)
+{
+	return lcore_task_stats_all[lcore_id].task_stats[task_id].tot_rx_pkt_count;
+}
+
+uint64_t stats_core_task_tot_tx(uint8_t lcore_id, uint8_t task_id)
+{
+	return lcore_task_stats_all[lcore_id].task_stats[task_id].tot_tx_pkt_count;
+}
+
+uint64_t stats_core_task_tot_drop(uint8_t lcore_id, uint8_t task_id)
+{
+	return lcore_task_stats_all[lcore_id].task_stats[task_id].tot_drop_tx_fail +
+		lcore_task_stats_all[lcore_id].task_stats[task_id].tot_drop_discard +
+		lcore_task_stats_all[lcore_id].task_stats[task_id].tot_drop_handled;
+}
+
+uint64_t stats_core_task_last_tsc(uint8_t lcore_id, uint8_t task_id)
+{
+	return lcore_task_stats_all[lcore_id].task_stats[task_id].sample[last_stat].tsc;
+}
+
+static void init_core_port(struct task_stats *ts, struct task_rt_stats *stats, uint8_t flags)
+{
+	ts->stats = stats;
+	ts->flags |= flags;
+}
+
+void stats_task_post_proc(void)
+{
+	for (uint8_t task_id = 0; task_id < nb_tasks_tot; ++task_id) {
+		struct task_stats *cur_task_stats = task_stats_set[task_id];
+		const struct task_stats_sample *last = &cur_task_stats->sample[last_stat];
+		const struct task_stats_sample *prev = &cur_task_stats->sample[!last_stat];
+
+		/* no total stats for empty loops */
+		cur_task_stats->tot_rx_pkt_count += last->rx_pkt_count - prev->rx_pkt_count;
+		cur_task_stats->tot_tx_pkt_count += last->tx_pkt_count - prev->tx_pkt_count;
+		cur_task_stats->tot_drop_tx_fail += last->drop_tx_fail - prev->drop_tx_fail;
+		cur_task_stats->tot_drop_discard += last->drop_discard - prev->drop_discard;
+		cur_task_stats->tot_drop_handled += last->drop_handled - prev->drop_handled;
+	}
+}
+
+void stats_task_update(void)
+{
+	uint64_t before, after;
+
+	for (uint8_t task_id = 0; task_id < nb_tasks_tot; ++task_id) {
+		struct task_stats *cur_task_stats = task_stats_set[task_id];
+		struct task_rt_stats *stats = cur_task_stats->stats;
+		struct task_stats_sample *last = &cur_task_stats->sample[last_stat];
+
+		/* Read TX first and RX second, in order to prevent displaying
+		   a negative packet loss. Depending on the configuration
+		   (when forwarding, for example), TX might be bigger than RX. */
+		before = rte_rdtsc();
+		last->tx_pkt_count = stats->tx_pkt_count;
+		last->drop_tx_fail = stats->drop_tx_fail;
+		last->drop_discard = stats->drop_discard;
+		last->drop_handled = stats->drop_handled;
+		last->rx_pkt_count = stats->rx_pkt_count;
+		last->empty_cycles = stats->idle_cycles;
+		last->tx_bytes     = stats->tx_bytes;
+		last->rx_bytes     = stats->rx_bytes;
+		last->drop_bytes   = stats->drop_bytes;
+		after = rte_rdtsc();
+		last->tsc = (before >> 1) + (after >> 1);
+	}
+}
+
+void stats_task_get_host_rx_tx_packets(uint64_t *rx, uint64_t *tx, uint64_t *tsc)
+{
+	const struct task_stats *t;
+
+	*rx = 0;
+	*tx = 0;
+
+	for (uint8_t task_id = 0; task_id < nb_tasks_tot; ++task_id) {
+		t = task_stats_set[task_id];
+
+		if (t->flags & TASK_STATS_RX)
+			*rx += t->tot_rx_pkt_count;
+
+		if (t->flags & TASK_STATS_TX)
+			*tx += t->tot_tx_pkt_count;
+	}
+	if (nb_tasks_tot)
+		*tsc = task_stats_set[nb_tasks_tot - 1]->sample[last_stat].tsc;
+}
+
+/* Populate active_stats_set for stats reporting, the order of the
+   cores is important for gathering the most accurate statistics. TX
+   cores should be updated before RX cores (to prevent negative Loss
+   stats). The total number of tasks are saved in nb_tasks_tot. */
+void stats_task_init(void)
+{
+	struct lcore_cfg *lconf;
+	uint32_t lcore_id;
+
+	/* add cores that are receiving from and sending to physical ports first */
+	lcore_id = -1;
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			struct task_args *targ = &lconf->targs[task_id];
+			struct task_rt_stats *stats = &lconf->tasks_all[task_id]->aux->stats;
+			if (targ->nb_rxrings == 0 && targ->nb_txrings == 0) {
+				struct task_stats *ts = &lcore_task_stats_all[lcore_id].task_stats[task_id];
+
+				init_core_port(ts, stats, TASK_STATS_RX | TASK_STATS_TX);
+				task_stats_set[nb_tasks_tot++] = ts;
+			}
+		}
+	}
+
+	/* add cores that are sending to physical ports second */
+	lcore_id = -1;
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			struct task_args *targ = &lconf->targs[task_id];
+			struct task_rt_stats *stats = &lconf->tasks_all[task_id]->aux->stats;
+			if (targ->nb_rxrings != 0 && targ->nb_txrings == 0) {
+				struct task_stats *ts = &lcore_task_stats_all[lcore_id].task_stats[task_id];
+
+				init_core_port(ts, stats, TASK_STATS_TX);
+				task_stats_set[nb_tasks_tot++] = ts;
+			}
+		}
+	}
+
+	/* add cores that are receiving from physical ports third */
+	lcore_id = -1;
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			struct task_args *targ = &lconf->targs[task_id];
+			struct task_rt_stats *stats = &lconf->tasks_all[task_id]->aux->stats;
+			if (targ->nb_rxrings == 0 && targ->nb_txrings != 0) {
+				struct task_stats *ts = &lcore_task_stats_all[lcore_id].task_stats[task_id];
+
+				init_core_port(ts, stats, TASK_STATS_RX);
+				task_stats_set[nb_tasks_tot++] = ts;
+			}
+		}
+	}
+
+	/* add cores that are working internally (no physical ports attached) */
+	lcore_id = -1;
+	while(prox_core_next(&lcore_id, 0) == 0) {
+		lconf = &lcore_cfg[lcore_id];
+		for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+			struct task_args *targ = &lconf->targs[task_id];
+			struct task_rt_stats *stats = &lconf->tasks_all[task_id]->aux->stats;
+			if (targ->nb_rxrings != 0 && targ->nb_txrings != 0) {
+				struct task_stats *ts = &lcore_task_stats_all[lcore_id].task_stats[task_id];
+
+				init_core_port(ts, stats, 0);
+				task_stats_set[nb_tasks_tot++] = ts;
+			}
+		}
+	}
+}
diff --git a/VNFs/DPPD-PROX/stats_task.h b/VNFs/DPPD-PROX/stats_task.h
new file mode 100644
index 00000000..156eb326
--- /dev/null
+++ b/VNFs/DPPD-PROX/stats_task.h
@@ -0,0 +1,145 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STATS_TASK_H_
+#define _STATS_TASK_H_
+
+#include <inttypes.h>
+
+#include "clock.h"
+
+/* The struct task_stats is read/write from the task itself and
+   read-only from the core that collects the stats. Since only the
+   task executing the actual work ever modifies the stats, no locking
+   is required. Both a read and a write are atomic (assuming the
+   correct alignment). From this, it followed that the statistics can
+   be incremented directly by the task itself. In cases where these
+   assumptions do not hold, a possible solution (although slightly
+   less accurate) would be to keep accumulate statistics temporarily
+   in a separate structure and periodically copying the statistics to
+   the statistics core through atomic primitives, for example through
+   rte_atomic32_set(). The accuracy would be determined by the
+   frequency at which the statistics are transferred to the statistics
+   core. */
+
+struct task_rt_stats {
+	uint32_t	rx_pkt_count;
+	uint32_t	tx_pkt_count;
+	uint32_t	drop_tx_fail;
+	uint32_t	drop_discard;
+	uint32_t        drop_handled;
+	uint32_t	idle_cycles;
+	uint64_t        rx_bytes;
+	uint64_t        tx_bytes;
+	uint64_t        drop_bytes;
+} __attribute__((packed)) __rte_cache_aligned;
+
+#ifdef PROX_STATS
+#define TASK_STATS_ADD_IDLE(stats, cycles) do {				\
+		(stats)->idle_cycles += (cycles) + rdtsc_overhead_stats; \
+	} while(0)							\
+
+#define TASK_STATS_ADD_TX(stats, ntx) do {	\
+		(stats)->tx_pkt_count += ntx;	\
+	} while(0)				\
+
+#define TASK_STATS_ADD_DROP_TX_FAIL(stats, ntx) do {	\
+		(stats)->drop_tx_fail += ntx;		\
+	} while(0)					\
+
+#define TASK_STATS_ADD_DROP_HANDLED(stats, ntx) do {	\
+		(stats)->drop_handled += ntx;		\
+	} while(0)					\
+
+#define TASK_STATS_ADD_DROP_DISCARD(stats, ntx) do {	\
+		(stats)->drop_discard += ntx;		\
+	} while(0)					\
+
+#define TASK_STATS_ADD_RX(stats, ntx) do {	\
+		(stats)->rx_pkt_count += ntx;	\
+	} while (0)				\
+
+#define TASK_STATS_ADD_RX_BYTES(stats, bytes) do {	\
+		(stats)->rx_bytes += bytes;		\
+	} while (0)					\
+
+#define TASK_STATS_ADD_TX_BYTES(stats, bytes) do {	\
+		(stats)->tx_bytes += bytes;		\
+	} while (0)					\
+
+#define TASK_STATS_ADD_DROP_BYTES(stats, bytes) do {	\
+		(stats)->drop_bytes += bytes;		\
+	} while (0)					\
+
+#define START_EMPTY_MEASSURE() uint64_t cur_tsc = rte_rdtsc();
+#else
+#define TASK_STATS_ADD_IDLE(stats, cycles) do {} while(0)
+#define TASK_STATS_ADD_TX(stats, ntx)  do {} while(0)
+#define TASK_STATS_ADD_DROP_TX_FAIL(stats, ntx)  do {} while(0)
+#define TASK_STATS_ADD_DROP_HANDLED(stats, ntx)  do {} while(0)
+#define TASK_STATS_ADD_DROP_DISCARD(stats, ntx)  do {} while(0)
+#define TASK_STATS_ADD_RX(stats, ntx)  do {} while(0)
+#define TASK_STATS_ADD_RX_BYTES(stats, bytes)  do {} while(0)
+#define TASK_STATS_ADD_TX_BYTES(stats, bytes)  do {} while(0)
+#define TASK_STATS_ADD_DROP_BYTES(stats, bytes) do {} while(0)
+#define START_EMPTY_MEASSURE()  do {} while(0)
+#endif
+
+struct task_stats_sample {
+	uint64_t tsc;
+	uint32_t tx_pkt_count;
+	uint32_t drop_tx_fail;
+	uint32_t drop_discard;
+	uint32_t drop_handled;
+	uint32_t rx_pkt_count;
+	uint32_t empty_cycles;
+	uint64_t rx_bytes;
+	uint64_t tx_bytes;
+	uint64_t drop_bytes;
+};
+
+struct task_stats {
+	uint64_t tot_tx_pkt_count;
+	uint64_t tot_drop_tx_fail;
+	uint64_t tot_drop_discard;
+	uint64_t tot_drop_handled;
+	uint64_t tot_rx_pkt_count;
+
+	struct task_stats_sample sample[2];
+
+	struct task_rt_stats *stats;
+	/* flags set if total RX/TX values need to be reported set at
+	   initialization time, only need to access stats values in port */
+	uint8_t flags;
+};
+
+void stats_task_reset(void);
+void stats_task_post_proc(void);
+void stats_task_update(void);
+void stats_task_init(void);
+
+int stats_get_n_tasks_tot(void);
+
+struct task_stats *stats_get_task_stats(uint32_t lcore_id, uint32_t task_id);
+struct task_stats_sample *stats_get_task_stats_sample(uint32_t lcore_id, uint32_t task_id, int last);
+void stats_task_get_host_rx_tx_packets(uint64_t *rx, uint64_t *tx, uint64_t *tsc);
+
+uint64_t stats_core_task_tot_rx(uint8_t lcore_id, uint8_t task_id);
+uint64_t stats_core_task_tot_tx(uint8_t lcore_id, uint8_t task_id);
+uint64_t stats_core_task_tot_drop(uint8_t lcore_id, uint8_t task_id);
+uint64_t stats_core_task_last_tsc(uint8_t lcore_id, uint8_t task_id);
+
+#endif /* _STATS_TASK_H_ */
diff --git a/VNFs/DPPD-PROX/task_base.h b/VNFs/DPPD-PROX/task_base.h
new file mode 100644
index 00000000..b2fab2fc
--- /dev/null
+++ b/VNFs/DPPD-PROX/task_base.h
@@ -0,0 +1,247 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _TASK_BASE_H_
+#define _TASK_BASE_H_
+
+#include <rte_common.h>
+#ifndef __rte_cache_aligned
+#include <rte_memory.h>
+#endif
+
+#include "defaults.h"
+#include "prox_globals.h"
+#include "stats_task.h"
+
+// runtime_flags 8 bits only
+#define TASK_MPLS_TAGGING              0x0001
+#define TASK_ROUTING                   0x0002
+#define TASK_CLASSIFY                  0x0004
+#define TASK_CTRL_HANDLE_ARP           0x0008
+#define TASK_MARK                      0x0020
+#define TASK_FP_HANDLE_ARP             0x0040
+#define TASK_TX_CRC                    0x0080
+
+// flag_features 64 bits
+#define TASK_FEATURE_ROUTING           0x0001
+#define TASK_FEATURE_CLASSIFY          0x0002
+#define TASK_FEATURE_MULTI_RX                  0x0004
+#define TASK_FEATURE_NEVER_DISCARDS            0x0008
+#define TASK_FEATURE_NO_RX                     0x0010
+#define TASK_FEATURE_TXQ_FLAGS_NOOFFLOADS      0x0020
+#define TASK_FEATURE_TXQ_FLAGS_NOMULTSEGS      0x0040
+#define TASK_FEATURE_ZERO_RX                   0x0080
+#define TASK_FEATURE_TXQ_FLAGS_REFCOUNT        0x0100
+#define TASK_FEATURE_TSC_RX                    0x0200
+#define TASK_FEATURE_THROUGHPUT_OPT            0x0400
+#define TASK_FEATURE_GRE_ID                    0x1000
+#define TASK_FEATURE_LUT_QINQ_RSS              0x2000
+#define TASK_FEATURE_LUT_QINQ_HASH             0x4000
+#define TASK_FEATURE_RX_ALL                    0x8000
+#define TASK_MULTIPLE_MAC                      0x10000
+
+#define FLAG_TX_FLUSH                  0x01
+#define FLAG_NEVER_FLUSH               0x02
+// Task specific flags
+#define BASE_FLAG_LUT_QINQ_HASH       	0x08
+#define BASE_FLAG_LUT_QINQ_RSS       	0x10
+
+#define OUT_DISCARD 0xFF
+#define OUT_HANDLED 0xFE
+
+#define WS_MBUF_MASK (2 * MAX_PKT_BURST - 1)
+
+/* struct ws_mbuf stores the working set of mbufs. It starts with a
+   prod/cons index to keep track of the number of elemenets. */
+struct ws_mbuf {
+	struct {
+		uint16_t        prod;
+		uint16_t        cons;
+	        uint16_t        nb_rx;
+		uint16_t        pad; /* reserved */
+	} idx[MAX_RINGS_PER_TASK];
+	struct rte_mbuf *mbuf[][MAX_RING_BURST * 3]  __rte_cache_aligned;
+};
+
+struct port_queue {
+	uint8_t port;
+	uint8_t queue;
+} __attribute__((packed));
+
+struct rx_params_hw {
+	union {
+		uint8_t           nb_rxports;
+		uint8_t           rxport_mask;
+	};
+	uint8_t           last_read_portid;
+	struct port_queue *rx_pq;
+} __attribute__((packed));
+
+struct rx_params_hw1 {
+	struct port_queue rx_pq;
+} __attribute__((packed));
+
+struct rx_params_sw {
+	union {
+		uint8_t         nb_rxrings;
+		uint8_t         rxrings_mask; /* Used if rte_is_power_of_2(nb_rxrings)*/
+	};
+	uint8_t         last_read_ring;
+	struct rte_ring **rx_rings;
+} __attribute__((packed));
+
+/* If there is only one input ring, the pointer to it can be stored
+   directly into the task_base instead of having to use a pointer to a
+   set of rings which would require two dereferences. */
+struct rx_params_sw1 {
+	struct rte_ring *rx_ring;
+} __attribute__((packed));
+
+struct tx_params_hw {
+	uint16_t          nb_txports;
+	struct port_queue *tx_port_queue;
+} __attribute__((packed));
+
+struct tx_params_sw {
+	uint16_t         nb_txrings;
+	struct rte_ring **tx_rings;
+} __attribute__((packed));
+
+struct tx_params_hw_sw {	/* Only one port supported in this mode */
+	uint16_t         nb_txrings;
+	struct rte_ring **tx_rings;
+	struct port_queue tx_port_queue;
+} __attribute__((packed));
+
+struct task_rt_dump {
+	uint32_t n_print_rx;
+	uint32_t n_print_tx;
+	struct input *input;
+	uint32_t n_trace;
+	uint32_t cur_trace;
+	void     *pkt_mbuf_addr[MAX_RING_BURST]; /* To track reordering */
+	uint8_t  pkt_cpy[MAX_RING_BURST][128];
+	uint16_t pkt_cpy_len[MAX_RING_BURST];
+};
+
+struct task_base;
+
+#define MAX_RX_PKT_ALL 16384
+
+#define MAX_STACKED_RX_FUCTIONS 16
+
+typedef uint16_t (*rx_pkt_func) (struct task_base *tbase, struct rte_mbuf ***mbufs);
+
+struct task_base_aux {
+	/* Not used when PROX_STATS is not defined */
+	struct task_rt_stats stats;
+	struct task_rt_dump task_rt_dump;
+
+	/* Used if TASK_TSC_RX is enabled*/
+	struct {
+		uint64_t before;
+		uint64_t after;
+	} tsc_rx;
+
+	struct  rte_mbuf **all_mbufs;
+
+	int      rx_prev_count;
+	int      rx_prev_idx;
+	uint16_t (*rx_pkt_prev[MAX_STACKED_RX_FUCTIONS])(struct task_base *tbase, struct rte_mbuf ***mbufs);
+
+	uint32_t rx_bucket[MAX_RING_BURST + 1];
+	uint32_t tx_bucket[MAX_RING_BURST + 1];
+	int (*tx_pkt_orig)(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+	int (*tx_pkt_hw)(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+	uint16_t (*tx_pkt_try)(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts);
+	void (*stop)(struct task_base *tbase);
+	void (*start)(struct task_base *tbase);
+	void (*stop_last)(struct task_base *tbase);
+	void (*start_first)(struct task_base *tbase);
+};
+
+/* The task_base is accessed for _all_ task types. In case
+   no debugging is needed, it has been optimized to fit
+   into a single cache line to minimize cache pollution */
+struct task_base {
+	int (*handle_bulk)(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts);
+	int (*tx_pkt)(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+	uint16_t (*rx_pkt)(struct task_base *tbase, struct rte_mbuf ***mbufs);
+
+	struct task_base_aux* aux;
+	/* The working set of mbufs contains mbufs that are currently
+	   being handled. */
+	struct ws_mbuf *ws_mbuf;
+
+	uint16_t flags;
+
+	union {
+		struct rx_params_hw rx_params_hw;
+		struct rx_params_hw1 rx_params_hw1;
+		struct rx_params_sw rx_params_sw;
+		struct rx_params_sw1 rx_params_sw1;
+	};
+
+	union {
+		struct tx_params_hw tx_params_hw;
+		struct tx_params_sw tx_params_sw;
+		struct tx_params_hw_sw tx_params_hw_sw;
+	};
+} __attribute__((packed)) __rte_cache_aligned;
+
+static void task_base_add_rx_pkt_function(struct task_base *tbase, rx_pkt_func to_add)
+{
+	if (tbase->aux->rx_prev_count == MAX_STACKED_RX_FUCTIONS) {
+		return;
+	}
+
+	for (int16_t i = tbase->aux->rx_prev_count; i >= 0; --i) {
+		tbase->aux->rx_pkt_prev[i + 1] = tbase->aux->rx_pkt_prev[i];
+	}
+	tbase->aux->rx_pkt_prev[0] = tbase->rx_pkt;
+	tbase->rx_pkt = to_add;
+	tbase->aux->rx_prev_count++;
+}
+
+static void task_base_del_rx_pkt_function(struct task_base *tbase, rx_pkt_func to_del)
+{
+	int cur = 0;
+	int found = 0;
+
+	if (tbase->aux->rx_prev_count == 1) {
+		tbase->rx_pkt = tbase->aux->rx_pkt_prev[0];
+		found = 1;
+	} else {
+		for (int16_t i = 0; i < tbase->aux->rx_prev_count; ++i) {
+			if (found || tbase->aux->rx_pkt_prev[i] != to_del)
+				tbase->aux->rx_pkt_prev[cur++] = tbase->aux->rx_pkt_prev[i];
+			else
+				found = 1;
+		}
+	}
+	if (found)
+		tbase->aux->rx_prev_count--;
+}
+
+static rx_pkt_func task_base_get_original_rx_pkt_function(struct task_base *tbase)
+{
+	if (tbase->aux->rx_prev_count == 0)
+		return tbase->rx_pkt;
+	else
+		return tbase->aux->rx_pkt_prev[tbase->aux->rx_prev_count - 1];
+}
+
+#endif /* _TASK_BASE_H_ */
diff --git a/VNFs/DPPD-PROX/task_init.c b/VNFs/DPPD-PROX/task_init.c
new file mode 100644
index 00000000..6d9c7b3d
--- /dev/null
+++ b/VNFs/DPPD-PROX/task_init.c
@@ -0,0 +1,401 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <rte_version.h>
+
+#include "prox_port_cfg.h"
+#include "prox_malloc.h"
+#include "task_init.h"
+#include "rx_pkt.h"
+#include "tx_pkt.h"
+#include "log.h"
+#include "quit.h"
+#include "lconf.h"
+#include "thread_generic.h"
+#include "prox_assert.h"
+
+#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
+#define RTE_CACHE_LINE_SIZE CACHE_LINE_SIZE
+#endif
+
+static unsigned first_task = 1;
+LIST_HEAD(,task_init) head;
+
+void reg_task(struct task_init* t)
+{
+	PROX_PANIC(t->handle == NULL, "No handle function specified for task with name %d\n", t->mode);
+
+	if (t->thread_x == NULL)
+		t->thread_x = thread_generic;
+
+	if (first_task) {
+		first_task = 0;
+		LIST_INIT(&head);
+	}
+
+	LIST_INSERT_HEAD(&head, t, entries);
+}
+
+struct task_init *to_task_init(const char *mode_str, const char *sub_mode_str)
+{
+	struct task_init *cur_t;
+
+	LIST_FOREACH(cur_t, &head, entries) {
+		if (!strcmp(mode_str, cur_t->mode_str) &&
+		    !strcmp(sub_mode_str, cur_t->sub_mode_str)) {
+			return cur_t;
+		}
+	}
+
+	return NULL;
+}
+
+static int compare_strcmp(const void *a, const void *b)
+{
+	return strcmp(*(const char * const *)a, *(const char * const *)b);
+}
+
+void tasks_list(void)
+{
+	struct task_init *cur_t;
+	char buf[sizeof(cur_t->mode_str) + sizeof(cur_t->sub_mode_str) + 4];
+
+	int nb_modes = 1; /* master */
+	LIST_FOREACH(cur_t, &head, entries) {
+		++nb_modes;
+	}
+
+	char **modes = calloc(nb_modes, sizeof(*modes));
+	char **cur_m = modes;
+	*cur_m++ = strdup("master");
+	LIST_FOREACH(cur_t, &head, entries) {
+		snprintf(buf, sizeof(buf), "%s%s%s",
+			cur_t->mode_str,
+			(cur_t->sub_mode_str[0] == 0) ? "" : " / ",
+			cur_t->sub_mode_str);
+		*cur_m++ = strdup(buf);
+	}
+	qsort(modes, nb_modes, sizeof(*modes), compare_strcmp);
+
+	plog_info("=== List of supported task modes / sub modes ===\n");
+	for (cur_m = modes; nb_modes; ++cur_m, --nb_modes) {
+		plog_info("\t%s\n", *cur_m);
+		free(*cur_m);
+	}
+	free(modes);
+}
+
+static size_t calc_memsize(struct task_args *targ, size_t task_size)
+{
+	size_t memsize = task_size;
+
+	memsize += sizeof(struct task_base_aux);
+
+	if (targ->nb_rxports != 0) {
+		memsize += 2 * sizeof(uint8_t)*targ->nb_rxports;
+	}
+	if (targ->nb_rxrings != 0 || targ->tx_opt_ring_task) {
+		memsize += sizeof(struct rte_ring *)*targ->nb_rxrings;
+	}
+	if (targ->nb_txrings != 0) {
+		memsize += sizeof(struct rte_ring *) * targ->nb_txrings;
+		memsize = RTE_ALIGN_CEIL(memsize, RTE_CACHE_LINE_SIZE);
+		memsize += sizeof(struct ws_mbuf) + sizeof(((struct ws_mbuf*)0)->mbuf[0]) * targ->nb_txrings;
+	}
+	else if (targ->nb_txports != 0) {
+		memsize += sizeof(struct port_queue) * targ->nb_txports;
+		memsize = RTE_ALIGN_CEIL(memsize, RTE_CACHE_LINE_SIZE);
+		memsize += sizeof(struct ws_mbuf) + sizeof(((struct ws_mbuf*)0)->mbuf[0]) * targ->nb_txports;
+	}
+	else {
+		memsize = RTE_ALIGN_CEIL(memsize, RTE_CACHE_LINE_SIZE);
+		memsize += sizeof(struct ws_mbuf) + sizeof(((struct ws_mbuf*)0)->mbuf[0]);
+	}
+
+	return memsize;
+}
+
+static void *flush_function(struct task_args *targ)
+{
+	if (targ->flags & TASK_ARG_DROP) {
+		return targ->nb_txrings ? flush_queues_sw : flush_queues_hw;
+	}
+	else {
+		return targ->nb_txrings ? flush_queues_no_drop_sw : flush_queues_no_drop_hw;
+	}
+}
+
+static size_t init_rx_tx_rings_ports(struct task_args *targ, struct task_base *tbase, size_t offset)
+{
+	if (targ->tx_opt_ring_task) {
+		tbase->rx_pkt = rx_pkt_self;
+	}
+	else if (targ->nb_rxrings != 0) {
+
+		if (targ->nb_rxrings == 1) {
+			tbase->rx_pkt = rx_pkt_sw1;
+			tbase->rx_params_sw1.rx_ring = targ->rx_rings[0];
+		}
+		else {
+			tbase->rx_pkt = rx_pkt_sw;
+			tbase->rx_params_sw.nb_rxrings = targ->nb_rxrings;
+			tbase->rx_params_sw.rx_rings = (struct rte_ring **)(((uint8_t *)tbase) + offset);
+			offset += sizeof(struct rte_ring *)*tbase->rx_params_sw.nb_rxrings;
+
+			for (uint8_t i = 0; i < tbase->rx_params_sw.nb_rxrings; ++i) {
+				tbase->rx_params_sw.rx_rings[i] = targ->rx_rings[i];
+			}
+
+			if (rte_is_power_of_2(targ->nb_rxrings)) {
+				tbase->rx_pkt = rx_pkt_sw_pow2;
+				tbase->rx_params_sw.rxrings_mask = targ->nb_rxrings - 1;
+			}
+		}
+	}
+	else {
+		if (targ->nb_rxports == 1) {
+			tbase->rx_pkt = (targ->task_init->flag_features & TASK_FEATURE_MULTI_RX)? rx_pkt_hw1_multi : rx_pkt_hw1;
+			tbase->rx_params_hw1.rx_pq.port =  targ->rx_port_queue[0].port;
+			tbase->rx_params_hw1.rx_pq.queue = targ->rx_port_queue[0].queue;
+		}
+		else {
+			PROX_ASSERT((targ->nb_rxports != 0) || (targ->task_init->flag_features & TASK_FEATURE_NO_RX));
+			tbase->rx_pkt = (targ->task_init->flag_features & TASK_FEATURE_MULTI_RX)? rx_pkt_hw_multi : rx_pkt_hw;
+			tbase->rx_params_hw.nb_rxports = targ->nb_rxports;
+			tbase->rx_params_hw.rx_pq = (struct port_queue *)(((uint8_t *)tbase) + offset);
+			offset += sizeof(struct port_queue) * tbase->rx_params_hw.nb_rxports;
+			for (int i = 0; i< targ->nb_rxports; i++) {
+				tbase->rx_params_hw.rx_pq[i].port = targ->rx_port_queue[i].port;
+				tbase->rx_params_hw.rx_pq[i].queue = targ->rx_port_queue[i].queue;
+			}
+
+			if (rte_is_power_of_2(targ->nb_rxports)) {
+				tbase->rx_pkt = (targ->task_init->flag_features & TASK_FEATURE_MULTI_RX)? rx_pkt_hw_pow2_multi : rx_pkt_hw_pow2;
+				tbase->rx_params_hw.rxport_mask = targ->nb_rxports - 1;
+			}
+		}
+	}
+
+	if ((targ->nb_txrings != 0) && (!targ->tx_opt_ring) && (!(targ->flags & TASK_ARG_DROP))) {
+		// Transmitting to a ring in NO DROP. We need to make sure the receiving task in not running on the same core.
+		// Otherwise we might end up in a dead lock: trying in a loop to transmit to a task which cannot receive anymore
+		// (as npt being scheduled).
+		struct core_task ct;
+		struct task_args *dtarg;
+		for (unsigned int j = 0; j < targ->nb_txrings; j++) {
+			ct = targ->core_task_set[0].core_task[j];
+			PROX_PANIC(ct.core == targ->lconf->id, "Core %d, task %d: NO_DROP task transmitting to another task (core %d, task %d) running on on same core => potential deadlock\n", targ->lconf->id, targ->id, ct.core, ct.task);
+			//plog_info("Core %d, task %d: NO_DROP task transmitting to another task (core %d, task %d) running on on same core => potential deadlock\n", targ->lconf->id, targ->id, ct.core, ct.task);
+		}
+	}
+	if ((targ->nb_txrings != 0) && (targ->nb_txports == 1)) {
+		/* Transmitting to multiple rings and one port */
+		plog_info("Initializing with 1 port %d queue %d nb_rings=%d\n", targ->tx_port_queue[0].port, targ->tx_port_queue[0].queue, targ->nb_txrings);
+		tbase->tx_params_hw_sw.tx_port_queue.port =  targ->tx_port_queue[0].port;
+		tbase->tx_params_hw_sw.tx_port_queue.queue =  targ->tx_port_queue[0].queue;
+		if (!targ->tx_opt_ring) {
+			tbase->tx_params_hw_sw.nb_txrings = targ->nb_txrings;
+			tbase->tx_params_hw_sw.tx_rings = (struct rte_ring **)(((uint8_t *)tbase) + offset);
+			offset += sizeof(struct rte_ring *)*tbase->tx_params_hw_sw.nb_txrings;
+
+			for (uint8_t i = 0; i < tbase->tx_params_hw_sw.nb_txrings; ++i) {
+				tbase->tx_params_hw_sw.tx_rings[i] = targ->tx_rings[i];
+			}
+
+			offset = RTE_ALIGN_CEIL(offset, RTE_CACHE_LINE_SIZE);
+			tbase->ws_mbuf = (struct ws_mbuf *)(((uint8_t *)tbase) + offset);
+			offset += sizeof(struct ws_mbuf) + sizeof(((struct ws_mbuf*)0)->mbuf[0]) * tbase->tx_params_hw_sw.nb_txrings;
+		}
+	}
+	else if (!targ->tx_opt_ring) {
+		if (targ->nb_txrings != 0) {
+			tbase->tx_params_sw.nb_txrings = targ->nb_txrings;
+			tbase->tx_params_sw.tx_rings = (struct rte_ring **)(((uint8_t *)tbase) + offset);
+			offset += sizeof(struct rte_ring *)*tbase->tx_params_sw.nb_txrings;
+
+			for (uint8_t i = 0; i < tbase->tx_params_sw.nb_txrings; ++i) {
+				tbase->tx_params_sw.tx_rings[i] = targ->tx_rings[i];
+			}
+
+			offset = RTE_ALIGN_CEIL(offset, RTE_CACHE_LINE_SIZE);
+			tbase->ws_mbuf = (struct ws_mbuf *)(((uint8_t *)tbase) + offset);
+			offset += sizeof(struct ws_mbuf) + sizeof(((struct ws_mbuf*)0)->mbuf[0]) * tbase->tx_params_sw.nb_txrings;
+		}
+		else if (targ->nb_txports != 0) {
+			tbase->tx_params_hw.nb_txports = targ->nb_txports;
+			tbase->tx_params_hw.tx_port_queue = (struct port_queue *)(((uint8_t *)tbase) + offset);
+			offset += sizeof(struct port_queue) * tbase->tx_params_hw.nb_txports;
+			for (uint8_t i = 0; i < tbase->tx_params_hw.nb_txports; ++i) {
+				tbase->tx_params_hw.tx_port_queue[i].port = targ->tx_port_queue[i].port;
+				tbase->tx_params_hw.tx_port_queue[i].queue = targ->tx_port_queue[i].queue;
+			}
+
+			offset = RTE_ALIGN_CEIL(offset, RTE_CACHE_LINE_SIZE);
+			tbase->ws_mbuf = (struct ws_mbuf *)(((uint8_t *)tbase) + offset);
+			offset += sizeof(struct ws_mbuf) + sizeof(((struct ws_mbuf*)0)->mbuf[0]) * tbase->tx_params_hw.nb_txports;
+		}
+		else {
+			offset = RTE_ALIGN_CEIL(offset, RTE_CACHE_LINE_SIZE);
+			tbase->ws_mbuf = (struct ws_mbuf *)(((uint8_t *)tbase) + offset);
+			offset += sizeof(struct ws_mbuf) + sizeof(((struct ws_mbuf*)0)->mbuf[0]);
+		}
+
+		struct ws_mbuf* w = tbase->ws_mbuf;
+		struct task_args *prev = targ->tx_opt_ring_task;
+
+		while (prev) {
+			prev->tbase->ws_mbuf = w;
+			prev = prev->tx_opt_ring_task;
+		}
+	}
+	if (targ->nb_txrings == 1 || targ->nb_txports == 1 || targ->tx_opt_ring) {
+		if (targ->task_init->flag_features & TASK_FEATURE_NEVER_DISCARDS) {
+			if (targ->tx_opt_ring) {
+				tbase->tx_pkt = tx_pkt_never_discard_self;
+			}
+			else if (targ->flags & TASK_ARG_DROP) {
+				if (targ->task_init->flag_features & TASK_FEATURE_THROUGHPUT_OPT)
+					tbase->tx_pkt = targ->nb_txrings ? tx_pkt_never_discard_sw1 : tx_pkt_never_discard_hw1_thrpt_opt;
+				else
+					tbase->tx_pkt = targ->nb_txrings ? tx_pkt_never_discard_sw1 : tx_pkt_never_discard_hw1_lat_opt;
+			}
+			else {
+				if (targ->task_init->flag_features & TASK_FEATURE_THROUGHPUT_OPT)
+					tbase->tx_pkt = targ->nb_txrings ? tx_pkt_no_drop_never_discard_sw1 : tx_pkt_no_drop_never_discard_hw1_thrpt_opt;
+				else
+					tbase->tx_pkt = targ->nb_txrings ? tx_pkt_no_drop_never_discard_sw1 : tx_pkt_no_drop_never_discard_hw1_lat_opt;
+			}
+			if ((targ->nb_txrings) || ((targ->task_init->flag_features & TASK_FEATURE_THROUGHPUT_OPT) == 0))
+	        		tbase->flags |= FLAG_NEVER_FLUSH;
+			else
+				targ->lconf->flush_queues[targ->task] = flush_function(targ);
+		}
+		else {
+			if (targ->tx_opt_ring) {
+				tbase->tx_pkt = tx_pkt_self;
+			}
+			else if (targ->flags & TASK_ARG_DROP) {
+				tbase->tx_pkt = targ->nb_txrings ? tx_pkt_sw1 : tx_pkt_hw1;
+			}
+			else {
+				tbase->tx_pkt = targ->nb_txrings ? tx_pkt_no_drop_sw1 : tx_pkt_no_drop_hw1;
+			}
+	        	tbase->flags |= FLAG_NEVER_FLUSH;
+		}
+	}
+	else {
+		if (targ->flags & TASK_ARG_DROP) {
+			tbase->tx_pkt = targ->nb_txrings ? tx_pkt_sw : tx_pkt_hw;
+		}
+		else {
+			tbase->tx_pkt = targ->nb_txrings ? tx_pkt_no_drop_sw : tx_pkt_no_drop_hw;
+		}
+
+		targ->lconf->flush_queues[targ->task] = flush_function(targ);
+	}
+
+	if (targ->task_init->flag_features & TASK_FEATURE_NO_RX) {
+		tbase->rx_pkt = rx_pkt_dummy;
+	}
+
+	if (targ->nb_txrings == 0 && targ->nb_txports == 0) {
+		tbase->tx_pkt = tx_pkt_drop_all;
+	}
+
+	return offset;
+}
+
+struct task_base *init_task_struct(struct task_args *targ)
+{
+	struct task_init* t = targ->task_init;
+	size_t offset = 0;
+	size_t memsize = calc_memsize(targ, t->size);
+	uint8_t task_socket = rte_lcore_to_socket_id(targ->lconf->id);
+	struct task_base *tbase = prox_zmalloc(memsize, task_socket);
+	PROX_PANIC(tbase == NULL, "Failed to allocate memory for task (%zu bytes)", memsize);
+	offset += t->size;
+
+	if (targ->nb_txrings == 0 && targ->nb_txports == 0)
+		tbase->flags |= FLAG_NEVER_FLUSH;
+
+	offset = init_rx_tx_rings_ports(targ, tbase, offset);
+	tbase->aux = (struct task_base_aux *)(((uint8_t *)tbase) + offset);
+
+	if (targ->task_init->flag_features & TASK_FEATURE_RX_ALL) {
+		task_base_add_rx_pkt_function(tbase, rx_pkt_all);
+		tbase->aux->all_mbufs = prox_zmalloc(MAX_RX_PKT_ALL * sizeof(* tbase->aux->all_mbufs), task_socket);
+	}
+	if (targ->task_init->flag_features & TASK_FEATURE_TSC_RX) {
+		task_base_add_rx_pkt_function(tbase, rx_pkt_tsc);
+	}
+
+	offset += sizeof(struct task_base_aux);
+
+	tbase->handle_bulk = t->handle;
+
+	targ->tbase = tbase;
+	if (t->init) {
+		t->init(tbase, targ);
+	}
+	tbase->aux->start = t->start;
+	tbase->aux->stop = t->stop;
+	tbase->aux->start_first = t->start_first;
+	tbase->aux->stop_last = t->stop_last;
+	if ((targ->nb_txrings != 0) && (targ->nb_txports == 1)) {
+		tbase->aux->tx_pkt_hw = tx_pkt_no_drop_never_discard_hw1_no_pointer;
+	}
+	if (targ->tx_opt_ring) {
+		tbase->aux->tx_pkt_try = tx_try_self;
+	} else if (targ->nb_txrings == 1) {
+		tbase->aux->tx_pkt_try = tx_try_sw1;
+	} else if (targ->nb_txports) {
+		tbase->aux->tx_pkt_try = tx_try_hw1;
+	}
+
+	return tbase;
+}
+
+struct task_args *find_reachable_task_sending_to_port(struct task_args *from)
+{
+	if (!from->nb_txrings)
+		return from;
+
+	struct core_task ct;
+	struct task_args *dtarg, *ret;
+
+	for (uint32_t i = 0; i < from->nb_txrings; ++i) {
+		ct = from->core_task_set[0].core_task[i];
+		dtarg = core_targ_get(ct.core, ct.task);
+		ret = find_reachable_task_sending_to_port(dtarg);
+		if (ret)
+			return ret;
+	}
+	return NULL;
+}
+
+struct prox_port_cfg *find_reachable_port(struct task_args *from)
+{
+	struct task_args *dst = find_reachable_task_sending_to_port(from);
+
+	if (dst) {
+		int port_id = dst->tx_port_queue[0].port;
+
+		return &prox_port_cfg[port_id];
+	}
+	return NULL;
+}
diff --git a/VNFs/DPPD-PROX/task_init.h b/VNFs/DPPD-PROX/task_init.h
new file mode 100644
index 00000000..beb4de02
--- /dev/null
+++ b/VNFs/DPPD-PROX/task_init.h
@@ -0,0 +1,239 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _TASK_INIT_H_
+#define _TASK_INIT_H_
+
+#include <sys/queue.h>
+
+#include <rte_common.h>
+#include <rte_sched.h>
+#include <rte_ether.h>
+#include "task_base.h"
+#include "prox_globals.h"
+#include "ip6_addr.h"
+#include "flow_iter.h"
+#include "parse_utils.h"
+
+struct rte_mbuf;
+struct lcore_cfg;
+
+#if MAX_RINGS_PER_TASK < PROX_MAX_PORTS
+#error MAX_RINGS_PER_TASK < PROX_MAX_PORTS
+#endif
+
+#define TASK_ARG_DROP           0x01
+#define TASK_ARG_RX_RING        0x02
+#define TASK_ARG_RTE_TABLE      0x08
+#define TASK_ARG_LOCAL_LPM      0x10
+#define TASK_ARG_QINQ_ACL       0x20
+#define TASK_ARG_CTRL_RINGS_P   0x40
+#define TASK_ARG_DST_MAC_SET	0x80
+#define TASK_ARG_SRC_MAC_SET	0x100
+#define	TASK_ARG_DO_NOT_SET_SRC_MAC 0x200
+#define	TASK_ARG_DO_NOT_SET_DST_MAC 0x400
+#define	TASK_ARG_HW_SRC_MAC 	0x800
+
+enum protocols {IPV4, ARP, IPV6};
+
+struct qos_cfg {
+	struct rte_sched_port_params port_params;
+	struct rte_sched_subport_params subport_params[1];
+	struct rte_sched_pipe_params pipe_params[1];
+};
+
+enum task_mode {NOT_SET, MASTER, QINQ_DECAP4, QINQ_DECAP6,
+		QINQ_ENCAP4, QINQ_ENCAP6, GRE_DECAP, GRE_ENCAP,CGNAT,
+};
+
+struct task_args;
+
+struct task_init {
+	enum task_mode mode;
+	char mode_str[32];
+	char sub_mode_str[32];
+	void (*early_init)(struct task_args *targ);
+	void (*init)(struct task_base *tbase, struct task_args *targ);
+	int (*handle)(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts);
+	void (*start)(struct task_base *tbase);
+	void (*stop)(struct task_base *tbase);
+	void (*start_first)(struct task_base *tbase);
+	void (*stop_last)(struct task_base *tbase);
+	int (*thread_x)(struct lcore_cfg* lconf);
+	struct flow_iter flow_iter;
+	size_t size;
+	uint16_t     flag_req_data; /* flags from prox_shared.h */
+	uint64_t     flag_features;
+	uint32_t mbuf_size;
+	LIST_ENTRY(task_init) entries;
+};
+
+static int task_init_flag_set(struct task_init *task_init, uint64_t flag)
+{
+	return !!(task_init->flag_features & flag);
+}
+
+enum police_action {
+        ACT_GREEN = e_RTE_METER_GREEN,
+        ACT_YELLOW = e_RTE_METER_YELLOW,
+        ACT_RED = e_RTE_METER_RED,
+        ACT_DROP = 3,
+	ACT_INVALID = 4
+};
+
+/* Configuration for task that is only used during startup. */
+struct task_args {
+	struct task_base       *tbase;
+	struct task_init*       task_init;
+	struct rte_mempool     *pool;
+	char		       pool_name[MAX_NAME_SIZE];
+	struct lcore_cfg       *lconf;
+	uint32_t               nb_mbuf;
+	uint32_t               mbuf_size;
+	uint8_t    	       mbuf_size_set_explicitely;
+	uint32_t               nb_cache_mbuf;
+	uint8_t                nb_slave_threads;
+	uint8_t		       nb_worker_threads;
+	uint8_t		       worker_thread_id;
+	uint8_t		       task;
+	uint32_t               id;
+	struct core_task_set   core_task_set[MAX_PROTOCOLS];
+	struct task_args       *prev_tasks[MAX_RINGS_PER_TASK];
+	uint32_t               n_prev_tasks;
+	uint32_t               ring_size; /* default is RX_RING_SIZE */
+	struct qos_cfg         qos_conf;
+	uint32_t               flags;
+	uint32_t               runtime_flags;
+	uint8_t                nb_txports;
+	uint8_t                nb_txrings;
+	uint8_t                nb_rxrings;
+	uint8_t                tot_rxrings;
+	uint8_t                nb_rxports;
+	uint32_t               byte_offset;
+	uint32_t               gateway_ipv4;
+	uint32_t               number_gen_ip;
+	uint32_t               local_ipv4;
+	struct ipv6_addr       local_ipv6;    /* For IPv6 Tunnel, it's the local tunnel endpoint address */
+	struct rte_ring        *rx_rings[MAX_RINGS_PER_TASK];
+	struct rte_ring        *tx_rings[MAX_RINGS_PER_TASK];
+	uint32_t               tot_n_txrings_inited;
+	struct ether_addr      edaddr;
+	struct ether_addr      esaddr;
+	struct port_queue      tx_port_queue[PROX_MAX_PORTS];
+	struct port_queue      rx_port_queue[PROX_MAX_PORTS];
+	/* Used to set up actual task at initialization time. */
+	enum task_mode         mode;
+	/* Destination output position in hw or sw when using mac learned dest port. */
+	uint8_t                mapping[PROX_MAX_PORTS];
+	struct rte_table_hash  *cpe_table;
+	struct rte_table_hash  *qinq_gre_table;
+	struct rte_hash        *cpe_gre_hash;
+	struct rte_hash        *qinq_gre_hash;
+	struct cpe_data        *cpe_data;
+	struct cpe_gre_data    *cpe_gre_data;
+	struct qinq_gre_data   *qinq_gre_data;
+	uint8_t                tx_opt_ring;
+	struct task_args       *tx_opt_ring_task;
+	uint32_t               qinq_tag;
+
+#ifdef ENABLE_EXTRA_USER_STATISTICS
+	uint32_t               n_users;	// Number of users in user table.
+#endif
+	uint32_t               n_flows;	// Number of flows used in policing
+	uint32_t               cir;
+	uint32_t               cbs;
+	uint32_t               ebs;
+	uint32_t               pir;
+	uint32_t               pbs;
+	uint32_t               overhead;
+	enum police_action     police_act[3][3];
+	uint32_t               marking[4];
+	uint32_t               n_max_rules;
+	uint32_t               random_delay_us;
+	uint32_t               delay_us;
+	uint32_t               cpe_table_timeout_ms;
+	uint32_t               etype;
+#ifdef GRE_TP
+	uint32_t tb_rate;                /**< Pipe token bucket rate (measured in bytes per second) */
+	uint32_t tb_size;                /**< Pipe token bucket size (measured in credits) */
+#endif
+	uint8_t                tunnel_hop_limit;  /* IPv6 Tunnel - Hop limit */
+        uint16_t               lookup_port_mask;  /* Ipv6 Tunnel - Mask applied to UDP/TCP port before lookup */
+	uint32_t               ctrl_freq;
+	uint8_t                lb_friend_core;
+	uint8_t                lb_friend_task;
+	/* gen related*/
+	uint64_t               rate_bps;
+	uint32_t               n_rand_str;
+	char                   rand_str[64][64];
+	uint32_t               rand_offset[64];
+	char                   pcap_file[256];
+	uint32_t               accur_pos;
+	uint32_t               sig_pos;
+	uint32_t               sig;
+	uint32_t               lat_pos;
+	uint32_t               packet_id_pos;
+	uint32_t               latency_buffer_size;
+	uint32_t               bucket_size;
+	uint32_t               lat_enabled;
+	uint32_t               pkt_size;
+	uint8_t                pkt_inline[ETHER_MAX_LEN];
+	uint32_t               probability;
+	char                   nat_table[256];
+	uint32_t               use_src;
+	char                   route_table[256];
+	char                   rules[256];
+	char                   dscp[256];
+	char                   tun_bindings[256];
+	char                   cpe_table_name[256];
+	char                   user_table[256];
+	uint32_t               n_concur_conn;
+	char                   streams[256];
+	uint32_t               min_bulk_size;
+	uint32_t               max_bulk_size;
+	uint32_t               max_setup_rate;
+	uint32_t               n_pkts;
+	uint32_t               loop;
+	uint32_t               flow_table_size;
+	char                   dpi_engine_path[256];
+	char                   dpi_engine_args[16][256];
+	uint32_t               n_dpi_engine_args;
+	uint32_t               generator_id;
+	uint32_t               accuracy_limit_nsec;
+	/* cgnat related */
+	uint32_t                     public_ip_count;
+	struct public_ip_config_info *public_ip_config_info;
+	struct public_entry          *public_entries;
+	struct private_flow_entry    *private_flow_entries;
+	struct rte_hash              *public_ip_port_hash;
+	struct rte_hash              *private_ip_port_hash;
+	struct rte_hash              *private_ip_hash;
+	struct private_ip_info       *private_ip_info;
+};
+
+/* Return the first port that is reachable through the task. If the
+   task itself does not send directly to a port, the function will
+   search reachable tasks through each outgoing ring */
+struct task_args *find_reachable_task_sending_to_port(struct task_args *from);
+struct prox_port_cfg *find_reachable_port(struct task_args *from);
+
+struct task_base *init_task_struct(struct task_args *targ);
+struct task_init *to_task_init(const char *mode_str, const char *sub_mode_str);
+void tasks_list(void);
+
+void reg_task(struct task_init* t);
+
+#endif /* _TASK_INIT_H_ */
diff --git a/VNFs/DPPD-PROX/thread_generic.c b/VNFs/DPPD-PROX/thread_generic.c
new file mode 100644
index 00000000..f596bf25
--- /dev/null
+++ b/VNFs/DPPD-PROX/thread_generic.c
@@ -0,0 +1,196 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+#include <rte_table_hash.h>
+
+#include "log.h"
+#include "thread_generic.h"
+#include "stats.h"
+#include "tx_pkt.h"
+#include "lconf.h"
+#include "hash_entry_types.h"
+#include "defines.h"
+#include "hash_utils.h"
+
+struct tsc_task {
+	uint64_t tsc;
+	uint64_t (* tsc_task)(struct lcore_cfg *lconf);
+};
+
+static uint64_t tsc_drain(struct lcore_cfg *lconf)
+{
+	lconf_flush_all_queues(lconf);
+	return DRAIN_TIMEOUT;
+}
+
+static uint64_t tsc_term(struct lcore_cfg *lconf)
+{
+	if (lconf_is_req(lconf) && lconf_do_flags(lconf)) {
+		lconf_flush_all_queues(lconf);
+		return -2;
+	}
+	return TERM_TIMEOUT;
+}
+
+static uint64_t tsc_period(struct lcore_cfg *lconf)
+{
+	lconf->period_func(lconf->period_data);
+	return lconf->period_timeout;
+}
+
+static uint64_t tsc_ctrl(struct lcore_cfg *lconf)
+{
+	const uint8_t n_tasks_all = lconf->n_tasks_all;
+	void *msgs[MAX_RING_BURST];
+	uint16_t n_msgs;
+
+	for (uint8_t task_id = 0; task_id < n_tasks_all; ++task_id) {
+		if (lconf->ctrl_rings_m[task_id] && lconf->ctrl_func_m[task_id]) {
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+			n_msgs = rte_ring_sc_dequeue_burst(lconf->ctrl_rings_m[task_id], msgs, MAX_RING_BURST);
+#else
+			n_msgs = rte_ring_sc_dequeue_burst(lconf->ctrl_rings_m[task_id], msgs, MAX_RING_BURST, NULL);
+#endif
+			if (n_msgs) {
+				lconf->ctrl_func_m[task_id](lconf->tasks_all[task_id], msgs, n_msgs);
+			}
+		}
+		if (lconf->ctrl_rings_p[task_id] && lconf->ctrl_func_p[task_id]) {
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+			n_msgs = rte_ring_sc_dequeue_burst(lconf->ctrl_rings_p[task_id], msgs, MAX_RING_BURST);
+#else
+			n_msgs = rte_ring_sc_dequeue_burst(lconf->ctrl_rings_p[task_id], msgs, MAX_RING_BURST, NULL);
+#endif
+			if (n_msgs) {
+				lconf->ctrl_func_p[task_id](lconf->tasks_all[task_id], (struct rte_mbuf **)msgs, n_msgs);
+			}
+		}
+	}
+	return lconf->ctrl_timeout;
+}
+
+int thread_generic(struct lcore_cfg *lconf)
+{
+	struct task_base *tasks[MAX_TASKS_PER_CORE];
+	int next[MAX_TASKS_PER_CORE] = {0};
+	struct rte_mbuf **mbufs;
+	uint64_t cur_tsc = rte_rdtsc();
+	uint8_t zero_rx[MAX_TASKS_PER_CORE] = {0};
+	struct tsc_task tsc_tasks[] = {
+		{.tsc = cur_tsc, .tsc_task = tsc_term},
+		{.tsc = cur_tsc + DRAIN_TIMEOUT, .tsc_task = tsc_drain},
+		{.tsc = -1},
+		{.tsc = -1},
+		{.tsc = -1},
+	};
+	uint8_t n_tasks_run = lconf->n_tasks_run;
+
+	if (lconf->period_func) {
+		tsc_tasks[2].tsc = cur_tsc + lconf->period_timeout;
+		tsc_tasks[2].tsc_task = tsc_period;
+	}
+
+	for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+		if (lconf->ctrl_func_m[task_id]) {
+			tsc_tasks[3].tsc = cur_tsc + lconf->ctrl_timeout;
+			tsc_tasks[3].tsc_task = tsc_ctrl;
+			break;
+		}
+		if (lconf->ctrl_func_p[task_id]) {
+			tsc_tasks[3].tsc = cur_tsc + lconf->ctrl_timeout;
+			tsc_tasks[3].tsc_task = tsc_ctrl;
+			break;
+		}
+	}
+
+	/* sort tsc tasks */
+	for (size_t i = 0; i < sizeof(tsc_tasks)/sizeof(tsc_tasks[0]); ++i) {
+		for (size_t j = i + 1; j < sizeof(tsc_tasks)/sizeof(tsc_tasks[0]); ++j) {
+			if (tsc_tasks[i].tsc > tsc_tasks[j].tsc) {
+				struct tsc_task tmp = tsc_tasks[i];
+				tsc_tasks[i] = tsc_tasks[j];
+				tsc_tasks[j] = tmp;
+			}
+		}
+	}
+	struct tsc_task next_tsc = tsc_tasks[0];
+
+	for (;;) {
+		cur_tsc = rte_rdtsc();
+		/* Sort scheduled tsc_tasks starting from earliest
+		   first. A linear search is performed moving
+		   tsc_tasks that are scheduled earlier to the front
+		   of the list. There is a high frequency tsc_task in
+		   most cases. As a consequence, the currently
+		   scheduled tsc_task will be rescheduled to be
+		   executed as the first again. If many tsc_tasks are
+		   to be used, the algorithm should be replaced with a
+		   priority-queue (heap). */
+		if (unlikely(cur_tsc >= next_tsc.tsc)) {
+			uint64_t resched_diff = tsc_tasks[0].tsc_task(lconf);
+
+			if (resched_diff == (uint64_t)-2) {
+				n_tasks_run = lconf->n_tasks_run;
+				if (!n_tasks_run)
+					return 0;
+				for (int i = 0; i < lconf->n_tasks_run; ++i) {
+					tasks[i] = lconf->tasks_run[i];
+
+					uint8_t task_id = lconf_get_task_id(lconf, tasks[i]);
+					if (lconf->targs[task_id].task_init->flag_features & TASK_FEATURE_ZERO_RX)
+						zero_rx[i] = 1;
+				}
+			}
+
+			uint64_t new_tsc = tsc_tasks[0].tsc + resched_diff;
+			tsc_tasks[0].tsc = new_tsc;
+			next_tsc.tsc = new_tsc;
+
+			for (size_t i = 1; i < sizeof(tsc_tasks)/sizeof(tsc_tasks[0]); ++i) {
+				if (new_tsc < tsc_tasks[i].tsc) {
+					if (i > 1) {
+						tsc_tasks[i - 1] = next_tsc;
+						next_tsc = tsc_tasks[0];
+					}
+					break;
+				}
+				else
+					tsc_tasks[i - 1] = tsc_tasks[i];
+			}
+		}
+
+		uint16_t nb_rx;
+		for (uint8_t task_id = 0; task_id < n_tasks_run; ++task_id) {
+			struct task_base *t = tasks[task_id];
+			struct task_args *targ = &lconf->targs[task_id];
+			// Do not skip a task receiving packets from an optimized ring
+			// as the transmitting task expects such a receiving task to always run and consume
+			// the transmitted packets.
+			if (unlikely(next[task_id] && (targ->tx_opt_ring_task == NULL))) {
+				// plogx_info("task %d is too busy\n", task_id);
+				next[task_id] = 0;
+			} else {
+				nb_rx = t->rx_pkt(t, &mbufs);
+				if (likely(nb_rx || zero_rx[task_id])) {
+					next[task_id] = t->handle_bulk(t, mbufs, nb_rx);
+				}
+			}
+
+		}
+	}
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/thread_generic.h b/VNFs/DPPD-PROX/thread_generic.h
new file mode 100644
index 00000000..a5b45a18
--- /dev/null
+++ b/VNFs/DPPD-PROX/thread_generic.h
@@ -0,0 +1,30 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _THREAD_GENERIC_H_
+#define _THREAD_GENERIC_H_
+
+struct lcore_cfg;
+
+/* The generic thread can do everything needed for each of the tasks.
+   It is not optimized for any specific case and suggested use is only
+   for testing purpose and for tasks that require to run a function
+   periodically (i.e. ARP management). More specific "thread_XXX"
+   functions should be used to only do the steps only necessary for
+   the task. */
+int thread_generic(struct lcore_cfg *lconf);
+
+#endif /* _THREAD_GENERIC_H_ */
diff --git a/VNFs/DPPD-PROX/thread_nop.c b/VNFs/DPPD-PROX/thread_nop.c
new file mode 100644
index 00000000..ba30dc61
--- /dev/null
+++ b/VNFs/DPPD-PROX/thread_nop.c
@@ -0,0 +1,66 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+
+#include "log.h"
+#include "lconf.h"
+#include "thread_nop.h"
+#include "handle_nop.h"
+#include "stats.h"
+#include "lconf.h"
+#include "defines.h"
+
+int thread_nop(struct lcore_cfg *lconf)
+{
+	struct task_base *tasks[MAX_TASKS_PER_CORE];
+	struct rte_mbuf **mbufs;
+	uint64_t cur_tsc = rte_rdtsc();
+	uint64_t term_tsc = cur_tsc;
+	uint64_t drain_tsc = cur_tsc;
+	uint8_t n_tasks_run = 0;
+
+	for (;;) {
+		cur_tsc = rte_rdtsc();
+		if (cur_tsc > term_tsc) {
+			term_tsc = cur_tsc + TERM_TIMEOUT;
+			if (lconf_is_req(lconf) && lconf_do_flags(lconf)) {
+				n_tasks_run = lconf->n_tasks_run;
+
+				if (!n_tasks_run)
+					return 0;
+				for (int i = 0; i < lconf->n_tasks_run; ++i) {
+					tasks[i] = lconf->tasks_run[i];
+				}
+			}
+		}
+		if (cur_tsc > drain_tsc) {
+			drain_tsc = cur_tsc + DRAIN_TIMEOUT;
+			lconf_flush_all_queues(lconf);
+		}
+
+		for (uint8_t task_id = 0; task_id < n_tasks_run; ++task_id) {
+			struct task_base *t = tasks[task_id];
+			uint16_t nb_rx = t->rx_pkt(t, &mbufs);
+
+			if (likely(nb_rx)) {
+				handle_nop_bulk(t, mbufs, nb_rx);
+			}
+		}
+	}
+
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/thread_nop.h b/VNFs/DPPD-PROX/thread_nop.h
new file mode 100644
index 00000000..6bc4465a
--- /dev/null
+++ b/VNFs/DPPD-PROX/thread_nop.h
@@ -0,0 +1,28 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _THREAD_NOP_H_
+#define _THREAD_NOP_H_
+
+struct lcore_cfg;
+
+/* A separate threading function specifically with minimal features is
+   supplied to allow testing with minimal overhead. This thread
+   function is only used when all tasks on the core use have the
+   .thread_x field set to thread_nop. */
+int thread_nop(struct lcore_cfg *lconf);
+
+#endif /* _THREAD_NOP_H_ */
diff --git a/VNFs/DPPD-PROX/thread_pipeline.c b/VNFs/DPPD-PROX/thread_pipeline.c
new file mode 100644
index 00000000..242b137b
--- /dev/null
+++ b/VNFs/DPPD-PROX/thread_pipeline.c
@@ -0,0 +1,295 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_cycles.h>
+#include <rte_port_ethdev.h>
+#include <rte_port_ring.h>
+#include <rte_version.h>
+
+#include "log.h"
+#include "quit.h"
+#include "thread_pipeline.h"
+#include "lconf.h"
+#include "defines.h"
+
+/* Helper function: create pipeline, input ports and output ports */
+void init_pipe_create_in_out(struct task_pipe *tpipe, struct task_args *targ)
+{
+	struct task_base *tbase = (struct task_base *)tpipe;
+	const char *name = targ->lconf->name;
+	const char *mode = targ->task_init->mode_str;
+	uint8_t lcore_id = targ->lconf->id;
+	uint8_t task_id = targ->task;
+	int err;
+
+	/* create pipeline */
+	struct rte_pipeline_params pipeline_params = {
+		.name = name,
+		.socket_id = rte_lcore_to_socket_id(lcore_id),
+	};
+	tpipe->p = rte_pipeline_create(&pipeline_params);
+	PROX_PANIC(tpipe->p == NULL,
+			"Failed to create %s pipeline on core %u task %u\n",
+			mode, lcore_id, task_id);
+
+	/* create pipeline input ports */
+	if (targ->nb_rxrings != 0) {
+		for (uint8_t i = 0; i < tbase->rx_params_sw.nb_rxrings; ++i) {
+			struct rte_port_ring_reader_params port_ring_params = {
+				.ring = tbase->rx_params_sw.rx_rings[i],
+			};
+			struct rte_pipeline_port_in_params port_params = {
+				.ops = &rte_port_ring_reader_ops,
+				.arg_create = &port_ring_params,
+				.f_action = NULL, //TODO: fill metadata
+				.arg_ah = NULL,
+				.burst_size = MAX_RING_BURST,
+			};
+			err = rte_pipeline_port_in_create(tpipe->p,
+					&port_params, &tpipe->port_in_id[i]);
+			PROX_PANIC(err != 0, "Failed to create SW input port %u "
+					"for %s pipeline on core %u task %u: "
+					"err = %d\n",
+					i, mode, lcore_id, task_id, err);
+		}
+		tpipe->n_ports_in = tbase->rx_params_sw.nb_rxrings;
+	}
+	else {
+		for (uint8_t i = 0; i < tbase->rx_params_hw.nb_rxports; ++i) {
+			struct rte_port_ethdev_reader_params port_ethdev_params = {
+				.port_id = tbase->rx_params_hw.rx_pq[i].port,
+				.queue_id = tbase->rx_params_hw.rx_pq[i].queue,
+			};
+			struct rte_pipeline_port_in_params port_params = {
+				.ops = &rte_port_ethdev_reader_ops,
+				.arg_create = &port_ethdev_params,
+				.f_action = NULL, //TODO: fill metadata
+				.arg_ah = NULL,
+				.burst_size = MAX_PKT_BURST,
+			};
+			err = rte_pipeline_port_in_create(tpipe->p,
+					&port_params, &tpipe->port_in_id[0]);
+			PROX_PANIC(err != 0, "Failed to create HW input port "
+					"for %s pipeline on core %u task %u: "
+					"err = %d\n",
+					mode, lcore_id, task_id, err);
+		}
+		tpipe->n_ports_in = tbase->rx_params_hw.nb_rxports;
+	}
+	PROX_PANIC(tpipe->n_ports_in < 1, "No input port created "
+			"for %s pipeline on core %u task %u\n",
+			mode, lcore_id, task_id);
+
+	/* create pipeline output ports */
+	if (targ->nb_txrings != 0) {
+		for (uint8_t i = 0; i < tbase->tx_params_sw.nb_txrings; ++i) {
+			struct rte_port_ring_writer_params port_ring_params = {
+				.ring = tbase->tx_params_sw.tx_rings[i],
+				.tx_burst_sz = MAX_RING_BURST,
+			};
+			struct rte_pipeline_port_out_params port_params = {
+				.ops = &rte_port_ring_writer_ops,
+				.arg_create = &port_ring_params,
+				.f_action = NULL,	//TODO
+#if RTE_VERSION < RTE_VERSION_NUM(16,4,0,0)
+				.f_action_bulk = NULL,	//TODO
+#endif
+				.arg_ah = NULL,
+			};
+			err = rte_pipeline_port_out_create(tpipe->p,
+					&port_params, &tpipe->port_out_id[i]);
+			PROX_PANIC(err != 0, "Failed to create SW output port %u "
+					"for %s pipeline on core %u task %u: "
+					"err = %d\n",
+					i, mode, lcore_id, task_id, err);
+		}
+		tpipe->n_ports_out = tbase->tx_params_sw.nb_txrings;
+	}
+	else {
+		for (uint8_t i = 0; i < tbase->tx_params_hw.nb_txports; ++i) {
+			struct rte_port_ethdev_writer_params port_ethdev_params = {
+				.port_id = tbase->tx_params_hw.tx_port_queue[i].port,
+				.queue_id = tbase->tx_params_hw.tx_port_queue[i].queue,
+				.tx_burst_sz = MAX_PKT_BURST,
+			};
+			struct rte_pipeline_port_out_params port_params = {
+				.ops = &rte_port_ethdev_writer_ops,
+				.arg_create = &port_ethdev_params,
+				.f_action = NULL,	//TODO
+#if RTE_VERSION < RTE_VERSION_NUM(16,4,0,0)
+				.f_action_bulk = NULL,	//TODO
+#endif
+				.arg_ah = NULL,
+			};
+			err = rte_pipeline_port_out_create(tpipe->p,
+					&port_params, &tpipe->port_out_id[i]);
+			PROX_PANIC(err != 0, "Failed to create HW output port %u "
+					"for %s pipeline on core %u task %u: "
+					"err = %d\n",
+					i, mode, lcore_id, task_id, err);
+		}
+		tpipe->n_ports_out = tbase->tx_params_hw.nb_txports;
+	}
+	PROX_PANIC(tpipe->n_ports_out < 1, "No output port created "
+			"for %s pipeline on core %u task %u\n",
+			mode, lcore_id, task_id);
+}
+
+/* Helper function: connect pipeline input ports to one pipeline table */
+void init_pipe_connect_one(struct task_pipe *tpipe, struct task_args *targ,
+		uint32_t table_id)
+{
+	const char *mode = targ->task_init->mode_str;
+	uint8_t lcore_id = targ->lconf->id;
+	uint8_t task_id = targ->task;
+	int err;
+
+	for (uint8_t i = 0; i < tpipe->n_ports_in; ++i) {
+		err = rte_pipeline_port_in_connect_to_table(tpipe->p,
+				tpipe->port_in_id[i], table_id);
+		PROX_PANIC(err != 0, "Failed to connect input port %u to table id %u "
+				"for %s pipeline on core %u task %u: "
+				"err = %d\n",
+				i, table_id, mode, lcore_id, task_id, err);
+	}
+}
+
+/* Helper function: connect pipeline input ports to all pipeline tables */
+void init_pipe_connect_all(struct task_pipe *tpipe, struct task_args *targ)
+{
+	const char *mode = targ->task_init->mode_str;
+	uint8_t lcore_id = targ->lconf->id;
+	uint8_t task_id = targ->task;
+	int err;
+
+	PROX_PANIC(tpipe->n_tables < tpipe->n_ports_in,
+			"Not enough tables (%u) to connect %u input ports "
+			"for %s pipeline on core %u task %u\n",
+			tpipe->n_tables, tpipe->n_ports_in,
+			mode, lcore_id, task_id);
+
+	for (uint8_t i = 0; i < tpipe->n_ports_in; ++i) {
+		err = rte_pipeline_port_in_connect_to_table(tpipe->p,
+				tpipe->port_in_id[i], tpipe->table_id[i]);
+		PROX_PANIC(err != 0, "Failed to connect input port %u to table id %u "
+				"for %s pipeline on core %u task %u: "
+				"err = %d\n",
+				i, tpipe->table_id[i], mode, lcore_id, task_id, err);
+	}
+}
+
+/* Helper function: enable pipeline input ports */
+void init_pipe_enable(struct task_pipe *tpipe, struct task_args *targ)
+{
+	const char *mode = targ->task_init->mode_str;
+	uint8_t lcore_id = targ->lconf->id;
+	uint8_t task_id = targ->task;
+	int err;
+
+	for (uint8_t i = 0; i < tpipe->n_ports_in; ++i) {
+		err = rte_pipeline_port_in_enable(tpipe->p, tpipe->port_in_id[i]);
+		PROX_PANIC(err != 0, "Failed to enable input port %u "
+				"for %s pipeline on core %u task %u: "
+				"err = %d\n",
+				i, mode, lcore_id, task_id, err);
+	}
+}
+
+/* Helper function: check pipeline consistency */
+void init_pipe_check(struct task_pipe *tpipe, struct task_args *targ)
+{
+	const char *mode = targ->task_init->mode_str;
+	uint8_t lcore_id = targ->lconf->id;
+	uint8_t task_id = targ->task;
+	int err;
+
+	err = rte_pipeline_check(tpipe->p);
+	PROX_PANIC(err != 0, "Failed consistency check "
+			"for %s pipeline on core %u task %u: "
+			"err = %d\n",
+			mode, lcore_id, task_id, err);
+}
+
+/* This function will panic on purpose: tasks based on Packet Framework
+   pipelines should not be invoked via the usual task_base.handle_bulk method */
+int handle_pipe(struct task_base *tbase,
+		__attribute__((unused)) struct rte_mbuf **mbufs,
+		__attribute__((unused)) uint16_t n_pkts)
+{
+	uint32_t lcore_id = rte_lcore_id();
+	struct lcore_cfg *lconf = &lcore_cfg[lcore_id];
+
+	for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+		struct task_args *targ = &lconf->targs[task_id];
+		if (lconf->tasks_all[task_id] == tbase) {
+			PROX_PANIC(1, "Error on core %u task %u: cannot run "
+					"%s pipeline and other non-PF tasks\n",
+					lcore_id, task_id, targ->task_init->mode_str);
+		}
+	}
+	PROX_PANIC(1, "Error: cannot find task on core %u\n", lcore_id);
+	return 0;
+}
+
+int thread_pipeline(struct lcore_cfg *lconf)
+{
+	struct task_pipe *pipes[MAX_TASKS_PER_CORE];
+	uint64_t cur_tsc = rte_rdtsc();
+	uint64_t term_tsc = cur_tsc + TERM_TIMEOUT;
+	uint64_t drain_tsc = cur_tsc + DRAIN_TIMEOUT;
+	const uint8_t nb_tasks = lconf->n_tasks_all;
+
+	for (uint8_t task_id = 0; task_id < lconf->n_tasks_all; ++task_id) {
+		//TODO: solve other mutually exclusive thread/tasks
+		struct task_args *targ = &lconf->targs[task_id];
+		PROX_PANIC(targ->task_init->thread_x != thread_pipeline,
+				"Invalid task %u '%s' on core %u: %s() can only "
+				"run tasks based on Packet Framework pipelines\n",
+				targ->task, targ->task_init->mode_str,
+				targ->lconf->id, __func__);
+
+		pipes[task_id] = (struct task_pipe *)lconf->tasks_all[task_id];
+	}
+
+	lconf->flags |= LCONF_FLAG_RUNNING;
+	for (;;) {
+		cur_tsc = rte_rdtsc();
+		if (cur_tsc > drain_tsc) {
+			drain_tsc = cur_tsc + DRAIN_TIMEOUT;
+
+			if (cur_tsc > term_tsc) {
+				term_tsc = cur_tsc + TERM_TIMEOUT;
+				if (lconf->msg.req && lconf->msg.type == LCONF_MSG_STOP) {
+					lconf->flags &= ~LCONF_FLAG_RUNNING;
+					break;
+				}
+				if (!lconf_is_req(lconf)) {
+					lconf_unset_req(lconf);
+					plog_warn("Command ignored (lconf functions not supported in Packet Framework pipelines)\n");
+				}
+			}
+
+			for (uint8_t task_id = 0; task_id < nb_tasks; ++task_id) {
+				rte_pipeline_flush(pipes[task_id]->p);
+			}
+		}
+
+		for (uint8_t task_id = 0; task_id < nb_tasks; ++task_id) {
+			rte_pipeline_run(pipes[task_id]->p);
+		}
+	}
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/thread_pipeline.h b/VNFs/DPPD-PROX/thread_pipeline.h
new file mode 100644
index 00000000..35cb64c7
--- /dev/null
+++ b/VNFs/DPPD-PROX/thread_pipeline.h
@@ -0,0 +1,60 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _THREAD_PIPELINE_H_
+#define _THREAD_PIPELINE_H_
+
+#include <rte_pipeline.h>
+
+#include "lconf.h"
+#include "task_base.h"
+
+/* Tasks based on Packet Framework pipelines */
+struct task_pipe {
+	struct task_base base;
+
+	struct rte_pipeline *p;
+	uint32_t port_in_id[MAX_RINGS_PER_TASK];
+	uint32_t port_out_id[MAX_RINGS_PER_TASK];
+	uint32_t table_id[MAX_RINGS_PER_TASK];
+	uint8_t n_ports_in;
+	uint8_t n_ports_out;
+	uint8_t n_tables;
+};
+
+/* Helper function: create pipeline, input ports and output ports */
+void init_pipe_create_in_out(struct task_pipe *tpipe, struct task_args *targ);
+
+/* Helper function: connect pipeline input ports to one pipeline table */
+void init_pipe_connect_one(struct task_pipe *tpipe, struct task_args *targ, uint32_t table_id);
+
+/* Helper function: connect pipeline input ports to all pipeline tables */
+void init_pipe_connect_all(struct task_pipe *tpipe, struct task_args *targ);
+
+/* Helper function: enable pipeline input ports */
+void init_pipe_enable(struct task_pipe *tpipe, struct task_args *targ);
+
+/* Helper function: check pipeline consistency */
+void init_pipe_check(struct task_pipe *tpipe, struct task_args *targ);
+
+/* This function will panic on purpose: tasks based on Packet Framework
+   pipelines should not be invoked via the usual task_base.handle_bulk method */
+int handle_pipe(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+
+/* The pipeline thread can only run tasks based on Packet Framework pipelines */
+int thread_pipeline(struct lcore_cfg *lconf);
+
+#endif /* _THREAD_PIPELINE_H_ */
diff --git a/VNFs/DPPD-PROX/toeplitz.c b/VNFs/DPPD-PROX/toeplitz.c
new file mode 100644
index 00000000..62424579
--- /dev/null
+++ b/VNFs/DPPD-PROX/toeplitz.c
@@ -0,0 +1,60 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdint.h>
+#include "toeplitz.h"
+
+/* From XL710 Datasheet, 7.1.10 */
+
+uint8_t toeplitz_init_key[TOEPLITZ_KEY_LEN] =
+	{0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x8f, 0xb0,
+	 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
+	 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
+	 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
+	 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00
+};
+
+uint32_t toeplitz_hash(uint8_t *buf_p, int buflen)
+{
+	uint32_t result = 0;
+	uint8_t *key_p = toeplitz_init_key;
+	uint8_t byte, *byte4_p = key_p+4;
+	int i, pos = 0;
+	int bit = 0;
+	uint32_t key_word = __builtin_bswap32(*(uint32_t *)key_p);
+
+	for (i = 0; i < buflen; ++i) {
+		byte = buf_p[i];
+		for (bit = 0; bit <= 7; ++bit) {
+			if (byte & (1 << (7 - bit))) {
+				result ^= key_word;
+			}
+			key_word = (key_word << 1) | ((*byte4_p >> (7 - bit)) & 1);
+		}
+		if (pos >= TOEPLITZ_KEY_LEN - 4) {
+			pos = 0;
+			byte4_p = key_p;
+		}
+		else {
+			pos++;
+			byte4_p++;
+		}
+	}
+	return result;
+}
diff --git a/VNFs/DPPD-PROX/toeplitz.h b/VNFs/DPPD-PROX/toeplitz.h
new file mode 100644
index 00000000..f24ae766
--- /dev/null
+++ b/VNFs/DPPD-PROX/toeplitz.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _TOEPLITZ_H_
+#define _TOEPLITZ_H_
+
+#define TOEPLITZ_KEY_LEN	52
+extern uint8_t toeplitz_init_key[TOEPLITZ_KEY_LEN];
+uint32_t toeplitz_hash(uint8_t *buf_p, int buflen);
+#endif
diff --git a/VNFs/DPPD-PROX/token_time.h b/VNFs/DPPD-PROX/token_time.h
new file mode 100644
index 00000000..e59647ad
--- /dev/null
+++ b/VNFs/DPPD-PROX/token_time.h
@@ -0,0 +1,165 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _TOKEN_TIME_H_
+#define _TOKEN_TIME_H_
+
+#include <rte_cycles.h>
+#include <math.h>
+
+#include "prox_assert.h"
+
+struct token_time_cfg {
+	uint64_t bpp;
+	uint64_t period;
+	uint64_t bytes_max;
+};
+
+struct token_time {
+	uint64_t tsc_last;
+	uint64_t tsc_last_bytes;
+	uint64_t bytes_now;
+	struct token_time_cfg cfg;
+};
+
+/* Convert a given fractional bytes per period into bpp with as
+   minimal loss of accuracy. */
+static struct token_time_cfg token_time_cfg_create(double frac, uint64_t period, uint64_t bytes_max)
+{
+	struct token_time_cfg ret;
+
+	/* Since period is expressed in units of cycles and it is in
+	   most cases set to 1 second (which means its value is <=
+	   3*10^9) and 2^64/10^9 > 6148914691 > 2^32). This means that
+	   at most, period and frac will be doubled 32 times by the
+	   following algorithm. Hence, the total error introduced by
+	   the chosen values for bpp and period will be between 0 and
+	   1/2^33. Note that since there are more operations that
+	   can't overflow, the actual accuracy will probably be
+	   lower. */
+
+	/* The reason to limit period by UINT64_MAX/(uint64_t)frac is
+	   that at run-time, the token_time_update function will
+	   multiply a number that is <= period with bpp. In addition,
+	   the token_time_tsc_until function will multiply at most
+	   bytes_max with period so make sure that can't overflow. */
+
+	while (period < UINT64_MAX/2 && frac != floor(frac) &&
+	       (frac < 2.0f || period < UINT64_MAX/4/(uint64_t)frac) &&
+	       (bytes_max == UINT64_MAX || period < UINT64_MAX/2/bytes_max)) {
+		period *= 2;
+		frac *= 2;
+	}
+
+	ret.bpp = floor(frac + 0.5);
+	ret.period = period;
+	ret.bytes_max = bytes_max;
+
+	return ret;
+}
+
+static void token_time_update(struct token_time *tt, uint64_t tsc)
+{
+	uint64_t new_bytes;
+	uint64_t t_diff = tsc - tt->tsc_last;
+
+	/* Since the rate is expressed in tt->bpp, i.e. bytes per
+	   period, counters can only be incremented/decremented
+	   accurately every period cycles. */
+
+	/* If the last update was more than a period ago, the update
+	   can be performed accurately. */
+	if (t_diff > tt->cfg.period) {
+		/* First add remaining tokens in the last period that
+		   was added partially. */
+		new_bytes = tt->cfg.bpp - tt->tsc_last_bytes;
+		tt->tsc_last_bytes = 0;
+		tt->bytes_now += new_bytes;
+		t_diff -= tt->cfg.period;
+		tt->tsc_last += tt->cfg.period;
+
+		/* If now it turns out that more periods have elapsed,
+		   add the bytes for those periods directly. */
+		if (t_diff > tt->cfg.period) {
+			uint64_t periods = t_diff/tt->cfg.period;
+
+			tt->bytes_now += periods * tt->cfg.bpp;
+			t_diff -= tt->cfg.period * periods;
+			tt->tsc_last += tt->cfg.period * periods;
+		}
+	}
+
+	/* At this point, t_diff will be guaranteed to be less
+	   than tt->cfg.period. */
+	new_bytes = t_diff * tt->cfg.bpp/tt->cfg.period - tt->tsc_last_bytes;
+	tt->tsc_last_bytes += new_bytes;
+	tt->bytes_now += new_bytes;
+	if (tt->bytes_now > tt->cfg.bytes_max)
+		tt->bytes_now = tt->cfg.bytes_max;
+}
+
+static void token_time_set_bpp(struct token_time *tt, uint64_t bpp)
+{
+	tt->cfg.bpp = bpp;
+}
+
+static void token_time_init(struct token_time *tt, const struct token_time_cfg *cfg)
+{
+	tt->cfg = *cfg;
+}
+
+static void token_time_reset(struct token_time *tt, uint64_t tsc, uint64_t bytes_now)
+{
+	tt->tsc_last = tsc;
+	tt->bytes_now = bytes_now;
+	tt->tsc_last_bytes = 0;
+}
+
+static void token_time_reset_full(struct token_time *tt, uint64_t tsc)
+{
+	token_time_reset(tt, tsc, tt->cfg.bytes_max);
+}
+
+static int token_time_take(struct token_time *tt, uint64_t bytes)
+{
+	if (bytes > tt->bytes_now)
+		return -1;
+	tt->bytes_now -= bytes;
+	return 0;
+}
+
+static void token_time_take_clamp(struct token_time *tt, uint64_t bytes)
+{
+	if (bytes > tt->bytes_now)
+		tt->bytes_now = 0;
+	else
+		tt->bytes_now -= bytes;
+}
+
+static uint64_t token_time_tsc_until(const struct token_time *tt, uint64_t bytes)
+{
+	if (tt->bytes_now >= bytes)
+		return 0;
+
+	return (bytes - tt->bytes_now) * tt->cfg.period / tt->cfg.bpp;
+}
+
+static uint64_t token_time_tsc_until_full(const struct token_time *tt)
+{
+	return token_time_tsc_until(tt, tt->cfg.bytes_max);
+}
+
+#endif /* _TOKEN_TIME_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/Makefile b/VNFs/DPPD-PROX/tools/flow_extract/Makefile
new file mode 100644
index 00000000..a772b8c5
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/Makefile
@@ -0,0 +1,59 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+SOURCES = main.cpp
+SOURCES += streamextract.cpp
+SOURCES += pcapreader.cpp
+SOURCES += pcapwriter.cpp
+SOURCES += timestamp.cpp
+SOURCES += pcappkt.cpp
+SOURCES += netsocket.cpp
+SOURCES += stream3.cpp
+SOURCES += stream2.cpp
+SOURCES += stream.cpp
+SOURCES += path.cpp
+SOURCES += allocator.cpp
+SOURCES += halfstream.cpp
+SOURCES += bundle.cpp
+SOURCES += progress.cpp
+SOURCES += mappedfile.cpp
+SOURCES += streamsorter.cpp
+SOURCES += memreader.cpp
+SOURCES += programconfig.cpp
+
+BUILD_DIR = build
+OBJECTS = $(SOURCES:%.cpp=$(BUILD_DIR)/%.o)
+PROG = flowextract
+
+CXXFLAGS += -D__STDC_LIMIT_MACROS -g -O2 -Wall -ansi -pedantic -Wno-unused -msse4.2
+LDFLAGS = -lpcap
+
+$(BUILD_DIR)/$(PROG): $(OBJECTS)
+	@echo -e "LD\t$<"
+	@$(CXX) $(CXXFLAGS) $(LDFLAGS) $(OBJECTS) -o $@
+
+-include $(SOURCES:%.cpp=$(BUILD_DIR)/%.d)
+
+$(BUILD_DIR)/%.o: %.cpp
+	@mkdir -p $(BUILD_DIR)
+	@echo -e "CXX\t $<"
+	@$(CXX) -c $(CXXFLAGS) $*.cpp -o $@
+	@$(CXX) -MM $(CXXFLAGS) $*.cpp -MT $(BUILD_DIR)/$*.o > $(BUILD_DIR)/$*.d
+	@cp -f $(BUILD_DIR)/$*.d $(BUILD_DIR)/$*.d.tmp
+	@sed -e 's/.*://' -e 's/\\$$//' < $(BUILD_DIR)/$*.d.tmp | fmt -1 | sed -e 's/^ *//' -e 's/$$/:/' >> $(BUILD_DIR)/$*.d
+	@rm -f $(BUILD_DIR)/$*.d.tmp
+clean:
+	@rm -f $(BUILD_DIR)/$(PROG) $(BUILD_DIR)/*.o $(BUILD_DIR)/*.d
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/README b/VNFs/DPPD-PROX/tools/flow_extract/README
new file mode 100644
index 00000000..fb8754b3
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/README
@@ -0,0 +1,20 @@
+##
+## Copyright (c) 2010-2017 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+The flow extract tool is meant a to be run as a first pass on a pcap
+file. The output is a lua config file describing the relations between
+flows together with a binary file that contains all the packet headers
+and payload.
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/allocator.cpp b/VNFs/DPPD-PROX/tools/flow_extract/allocator.cpp
new file mode 100644
index 00000000..c861ebfe
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/allocator.cpp
@@ -0,0 +1,84 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <iostream>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#define USEHP
+
+using namespace std;
+
+#include "allocator.hpp"
+
+Allocator::Allocator(size_t size, size_t threshold)
+	: m_size(size), m_threshold(threshold), m_alloc_offset(0)
+{
+#ifdef USEHP
+	int fd = open("/mnt/huge/hp", O_CREAT | O_RDWR, 0755);
+	if (fd < 0) {
+		cerr << "Allocator failed to open huge page file descriptor: " << strerror(errno) << endl;
+		exit(EXIT_FAILURE);
+	}
+	m_mem = (uint8_t *)mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+	if (m_mem == MAP_FAILED) {
+		perror("mmap");
+		unlink("/mnt/huge");
+		cerr << "Allocator mmap failed: " << strerror(errno) << endl;
+		exit (EXIT_FAILURE);
+	}
+#else
+	m_mem = new uint8_t[size];
+#endif
+}
+
+Allocator::~Allocator()
+{
+#ifdef USEHP
+	munmap((void *)m_mem, m_size);
+#else
+	delete[] m_mem;
+#endif
+}
+
+void *Allocator::alloc(size_t size)
+{
+	void *ret = &m_mem[m_alloc_offset];
+
+	m_alloc_offset += size;
+	return ret;
+}
+
+void Allocator::reset()
+{
+	m_alloc_offset = 0;
+}
+
+size_t Allocator::getFreeSize() const
+{
+	return m_size - m_alloc_offset;
+}
+
+bool Allocator::lowThresholdReached() const
+{
+	return (m_size - m_alloc_offset) < m_threshold;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/allocator.hpp b/VNFs/DPPD-PROX/tools/flow_extract/allocator.hpp
new file mode 100644
index 00000000..d3f1537e
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/allocator.hpp
@@ -0,0 +1,38 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _ALLOCATOR_H_
+#define _ALLOCATOR_H_
+
+#include <cstddef>
+#include <inttypes.h>
+
+class Allocator {
+public:
+	Allocator(size_t size, size_t lowThreshold);
+	~Allocator();
+	bool lowThresholdReached() const;
+	void *alloc(size_t size);
+	void reset();
+	size_t getFreeSize() const;
+private:
+	size_t  m_size;
+	size_t  m_threshold;
+	size_t  m_alloc_offset;
+	uint8_t *m_mem;
+};
+
+#endif /* _ALLOCATOR_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/bundle.cpp b/VNFs/DPPD-PROX/tools/flow_extract/bundle.cpp
new file mode 100644
index 00000000..abeaf14e
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/bundle.cpp
@@ -0,0 +1,28 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "bundle.hpp"
+
+void Bundle::toLua(ofstream *f, const string& streamTableName, uint32_t idx) const
+{
+	(*f) << "bundles[" << idx << "] = {";
+
+	for(vector<uint32_t>::const_iterator i = streams.begin(); i != streams.end(); ++i) {
+		(*f) << streamTableName << "[" << (*i) << "]," ;
+	}
+
+	(*f) << "}" << endl;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/bundle.hpp b/VNFs/DPPD-PROX/tools/flow_extract/bundle.hpp
new file mode 100644
index 00000000..cb5d81b6
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/bundle.hpp
@@ -0,0 +1,38 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _BUNDLE_H_
+#define _BUNDLE_H_
+
+#include <vector>
+#include <inttypes.h>
+#include <fstream>
+
+using namespace std;
+
+class Bundle
+{
+public:
+	void addStream(uint32_t streamId, uint32_t port) {streams.push_back(streamId); ports.push_back(port);}
+	const vector<uint32_t>& getStream() const {return streams;}
+	const vector<uint32_t>& getPorts() const {return ports;}
+	void toLua(ofstream *f, const string& streamTableName, uint32_t idx) const;
+private:
+	vector<uint32_t> streams;
+	vector<uint32_t> ports;
+};
+
+#endif /* _BUNDLE_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/crc.hpp b/VNFs/DPPD-PROX/tools/flow_extract/crc.hpp
new file mode 100644
index 00000000..713b4abd
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/crc.hpp
@@ -0,0 +1,51 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _CRC_H_
+#define _CRC_H_
+
+static uint32_t crc32(const uint8_t *buf, size_t len, int init)
+{
+	uint32_t ret = init;
+
+	while (len/8) {
+		ret = __builtin_ia32_crc32di(ret, *((uint64_t*)buf));
+		len -= 8;
+		buf += 8;
+	}
+
+	while (len/4) {
+		ret = __builtin_ia32_crc32si(ret, *((uint32_t*)buf));
+		len -= 4;
+		buf += 4;
+	}
+
+	while (len/2) {
+		ret = __builtin_ia32_crc32hi(ret, *((uint16_t*)buf));
+		len -= 2;
+		buf += 2;
+	}
+
+	while (len) {
+		ret = __builtin_ia32_crc32qi(ret, *((uint8_t*)buf));
+		len -= 1;
+		buf += 1;
+	}
+
+	return ret;
+}
+
+#endif /* _CRC_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/csvfilereader.cpp b/VNFs/DPPD-PROX/tools/flow_extract/csvfilereader.cpp
new file mode 100644
index 00000000..909fc94d
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/csvfilereader.cpp
@@ -0,0 +1,67 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+#include <stdint.h>
+
+#include "csvfilereader.hpp"
+
+int CsvFileReader::open(const string& str)
+{
+	char *resolved_path = new char[1024];
+
+	memset(resolved_path, 0, 1024);
+	realpath(str.c_str(), resolved_path);
+	file.open(resolved_path);
+
+	delete []resolved_path;
+	return file.is_open();
+}
+
+vector<string> CsvFileReader::read()
+{
+	vector<string> ret;
+	size_t prev = 0, cur = 0;
+	string line;
+
+	if (file.eof())
+		return vector<string>();
+
+   	std::getline(file, line);
+	if (line.empty())
+		return vector<string>();
+
+	while (true) {
+		cur = line.find_first_of(',', prev);
+
+		if (cur != SIZE_MAX) {
+			ret.push_back(line.substr(prev, cur - prev));
+			prev = cur + 1;
+		}
+		else {
+			ret.push_back(line.substr(prev, line.size() - prev));
+			break;
+		}
+	}
+	return ret;
+}
+
+void CsvFileReader::close()
+{
+	file.close();
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/csvfilereader.hpp b/VNFs/DPPD-PROX/tools/flow_extract/csvfilereader.hpp
new file mode 100644
index 00000000..21f397a7
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/csvfilereader.hpp
@@ -0,0 +1,35 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _CSVFILE_H_
+#define _CSVFILE_H_
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+class CsvFileReader {
+public:
+	int open(const string& str);
+	vector<string> read();
+	void close();
+private:
+	ifstream file;
+};
+
+#endif /* _CSVFILE_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/flowtable.hpp b/VNFs/DPPD-PROX/tools/flow_extract/flowtable.hpp
new file mode 100644
index 00000000..ebb4d927
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/flowtable.hpp
@@ -0,0 +1,174 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _FLOWTABLE_H_
+#define _FLOWTABLE_H_
+
+#include <inttypes.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <cstring>
+
+#include <vector>
+#include <list>
+#include <cstddef>
+#include <utility>
+
+#include "crc.hpp"
+#include "timestamp.hpp"
+
+using namespace std;
+
+template <typename K, typename T>
+class FlowTable {
+public:
+	struct entry {
+		entry(K key, T value, const struct timeval& tv, list<struct entry> *parent) :
+			key(key), value(value), tv(tv), parent(parent) {}
+		bool expired(const Timestamp &now, const Timestamp &maxDiff) const
+		{
+			return now - Timestamp(tv) > maxDiff;
+		}
+		K key;
+		T value;
+		struct timeval tv; /* List time entry has been hit */
+		list<struct entry> *parent;
+	};
+	class Iterator {
+		friend class FlowTable;
+	public:
+		bool operator!=(const Iterator& other) {
+			return m_v != other.m_v ||
+				m_vec_pos != other.m_vec_pos ||
+				m_a != other.m_a;
+
+		}
+		Iterator& operator++() {
+			m_a++;
+			while (m_vec_pos != m_v->size() - 1 && m_a == (*m_v)[m_vec_pos].end()) {
+				m_vec_pos++;
+				m_a = (*m_v)[m_vec_pos].begin();
+			}
+
+			return *this;
+		}
+		struct entry &operator*() {
+			return *m_a;
+		}
+	private:
+		Iterator(uint32_t vec_pos, vector<list<struct entry> > *v)
+			: m_vec_pos(vec_pos), m_v(v)
+		{
+			m_a = (*m_v)[vec_pos].begin();
+			while (m_vec_pos != m_v->size() - 1 && m_a == (*m_v)[m_vec_pos].end()) {
+				m_vec_pos++;
+				m_a = (*m_v)[m_vec_pos].begin();
+			}
+		}
+		Iterator(uint32_t vec_pos, vector<list<struct entry> > *v, const typename list< struct entry>::iterator& a)
+			: m_vec_pos(vec_pos), m_v(v), m_a(a)
+		{ }
+		uint32_t m_vec_pos;
+		vector<list<struct entry> > *m_v;
+		typename list<struct entry>::iterator m_a;
+	};
+	uint32_t getEntryCount() const {return m_entryCount;}
+	FlowTable(uint32_t size);
+	void expire(const struct timeval& tv);
+	struct entry* lookup(const K& key);
+	void  remove(struct FlowTable<K,T>::entry* entry);
+	struct entry* insert(const K& key, const T& value, const struct timeval& tv);
+	Iterator begin() {return Iterator(0, &m_elems);}
+	Iterator end() {return Iterator(m_elems.size() - 1, &m_elems, m_elems.back().end());}
+	void clear();
+private:
+	void clearBucket(list<struct entry> *l);
+	vector<list<struct entry> > m_elems;
+	uint32_t m_entryCount;
+};
+
+template <typename K, typename T>
+FlowTable<K, T>::FlowTable(uint32_t size)
+	: m_elems(), m_entryCount(0)
+
+{
+	m_elems.resize(size);
+}
+
+template <typename K, typename T>
+struct FlowTable<K, T>::entry* FlowTable<K, T>::lookup(const K& key)
+{
+	uint32_t ret = crc32((uint8_t*)&key, sizeof(K), 0);
+
+	list<struct entry> &l = m_elems[ret % m_elems.size()];
+
+	if (l.empty())
+		return NULL;
+
+	for (typename list<struct entry>::iterator it = l.begin(); it != l.end(); ++it) {
+		if (memcmp(&((*it).key), &key, sizeof(key)) == 0)
+			return &(*it);
+	}
+	return NULL;
+}
+
+template <typename K, typename T>
+struct FlowTable<K, T>::entry *FlowTable<K, T>::insert(const K& key, const T& value, const struct timeval& tv)
+{
+	uint32_t ret = crc32((uint8_t*)&key, sizeof(K), 0);
+	list<struct entry> &l = m_elems[ret % m_elems.size()];
+
+	l.push_back(entry(key, value, tv, &l));
+
+	struct entry &n = l.back();
+	m_entryCount++;
+	n.key = key;
+	n.value = value;
+	return &n;
+}
+
+template <typename K, typename T>
+void FlowTable<K, T>::remove(struct FlowTable<K,T>::entry* entry)
+{
+	list<struct entry> &l = *entry->parent;
+
+	for (typename list<struct entry>::iterator it = l.begin(); it != l.end(); ++it) {
+		if (memcmp(&((*it).key), &entry->key, sizeof(entry->key)) == 0) {
+			l.erase(it);
+			m_entryCount--;
+			return ;
+		}
+	}
+}
+
+template <typename K, typename T>
+void FlowTable<K, T>::clearBucket(list<struct entry> *l)
+{
+	while (!l->empty()) {
+		m_entryCount--;
+		l->erase(l->begin());
+	}
+}
+
+template <typename K, typename T>
+void FlowTable<K, T>::clear()
+{
+	for (size_t i = 0; i < m_elems.size(); ++i) {
+		clearBucket(&m_elems[i]);
+	}
+}
+
+#endif /* _FLOWTABLE_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/halfstream.cpp b/VNFs/DPPD-PROX/tools/flow_extract/halfstream.cpp
new file mode 100644
index 00000000..7d8f1fe2
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/halfstream.cpp
@@ -0,0 +1,101 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <fstream>
+#include <arpa/inet.h>
+
+#include "halfstream.hpp"
+
+HalfStream::Action::Part HalfStream::addPkt(const PcapPkt &pkt)
+{
+	const uint32_t pktId = pkts.size();
+	const uint8_t *l5;
+	uint32_t l5Len;
+	uint16_t tmpHdrLen;
+
+	const struct PcapPkt::tcp_hdr *tcp;
+
+	struct pkt_tuple pt = pkt.parsePkt((const uint8_t **)&tcp, &tmpHdrLen, &l5, &l5Len);
+
+	if (pt.proto_id == IPPROTO_TCP) {
+		if (tcp->tcp_flags & 0x02)
+			tcpOpen = true;
+		if (tcp->tcp_flags & 0x01)
+			tcpClose = true;
+	}
+
+	if (pkts.empty()) {
+		first = pkt.ts();
+		hdrLen = tmpHdrLen;
+		memcpy(hdr, pkt.payload(), hdrLen);
+	}
+	last = pkt.ts();
+	totLen += pkt.len();
+	contentLen += l5Len;
+
+	pkts.push_back(pkt);
+
+	return Action::Part(pktId, l5 - pkt.payload(), l5Len);
+}
+
+double HalfStream::getRate() const
+{
+	if (pkts.empty())
+		return 0;
+	if (first == last)
+		return 1250000000;
+
+	return totLen / (last - first);
+}
+
+HalfStream::Action::Action(HalfStream* stream, const Part &p, bool isClient)
+	: halfStream(stream), m_isClient(isClient)
+{
+	addPart(p);
+}
+
+void HalfStream::Action::addPart(const Part &p)
+{
+	parts.push_back(p);
+}
+
+uint32_t HalfStream::Action::totLen() const
+{
+	uint32_t ret = 0;
+
+	for (list<Part>::const_iterator i = parts.begin(); i != parts.end(); ++i) {
+		ret += (*i).len;
+	}
+
+	return ret;
+}
+
+void HalfStream::Action::toFile(ofstream *f) const
+{
+	for (list<Part>::const_iterator i = parts.begin(); i != parts.end(); ++i) {
+		const PcapPkt &pkt = halfStream->pkts[i->pktId];
+		const uint8_t *payload = &pkt.payload()[i->offset];
+		const uint16_t len = i->len;
+
+		f->write((const char *)payload, len);
+	}
+}
+
+HalfStream::HalfStream()
+	: first(0, 0), last(0, 0), totLen(0), hdrLen(0), contentLen(0), tcpOpen(false), tcpClose(false)
+{
+
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/halfstream.hpp b/VNFs/DPPD-PROX/tools/flow_extract/halfstream.hpp
new file mode 100644
index 00000000..6216979d
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/halfstream.hpp
@@ -0,0 +1,63 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <inttypes.h>
+#include <list>
+#include <vector>
+
+#include "timestamp.hpp"
+#include "pcappkt.hpp"
+
+struct HalfStream {
+	struct Action {
+	public:
+		struct Part {
+			Part(uint32_t pktId, uint32_t offset, uint32_t len)
+				: pktId(pktId), offset(offset), len(len) {}
+			uint32_t pktId;
+			uint32_t offset;
+			uint32_t len;
+		};
+
+		Action(HalfStream* stream, const Part &p, bool isClient);
+		void addPart(const Part& p);
+		bool isClient() const {return m_isClient;}
+		/* An action can consist of multiple
+		   packets. The data is not stored in the
+		   action. Instead, a packet id together with
+		   an offset into the packet and a length is
+		   kept to save space */
+		void toFile(ofstream* f) const;
+		uint32_t totLen() const;
+	private:
+		HalfStream *halfStream;
+		bool       m_isClient;
+		list<Part> parts;
+	};
+
+	HalfStream();
+	Timestamp first;
+	Timestamp last;
+	uint64_t totLen;
+	uint64_t hdrLen;
+	uint8_t hdr[64];
+	vector<PcapPkt> pkts;
+	uint64_t contentLen;
+	bool tcpOpen;
+	bool tcpClose;
+	Action::Part addPkt(const PcapPkt &pkt);
+	double getRate() const;
+};
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/main.cpp b/VNFs/DPPD-PROX/tools/flow_extract/main.cpp
new file mode 100644
index 00000000..d1476c5f
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/main.cpp
@@ -0,0 +1,37 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <inttypes.h>
+#include <cstdlib>
+
+#include "streamextract.hpp"
+
+using namespace std;
+
+int main(int argc, char *argv[])
+{
+	ProgramConfig programConfig;
+
+	if (programConfig.parseOptions(argc, argv)) {
+		cerr << programConfig.getError() << endl;
+		cerr << programConfig.getUsage() << endl;
+		return EXIT_FAILURE;
+	}
+
+	StreamExtract se(programConfig);
+
+	return se.run();
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/mappedfile.cpp b/VNFs/DPPD-PROX/tools/flow_extract/mappedfile.cpp
new file mode 100644
index 00000000..b2d1a9da
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/mappedfile.cpp
@@ -0,0 +1,109 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <cstdlib>
+#include <cstdio>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <iostream>
+#include <cerrno>
+#include <sys/mman.h>
+#include <cstring>
+
+#include "mappedfile.hpp"
+
+static void zeroOutFile(int fd, size_t size)
+{
+	void *empty = calloc(1, 4096);
+
+	while (size > 4096) {
+		write(fd, empty, 4096);
+		size -= 4096;
+	}
+	write(fd, empty, size);
+	free(empty);
+}
+
+int MappedFile::open(const string& filePath, size_t size)
+{
+	mappedFileSize = size;
+
+	fd = ::open(filePath.c_str(), O_RDWR | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR);
+	if (fd < 0) {
+		cerr << "Failed to open file " << filePath << ":" << strerror(errno) << endl;
+		return -1;
+	}
+
+	zeroOutFile(fd, size);
+	data = mmap(NULL, mappedFileSize, PROT_WRITE | PROT_READ, MAP_SHARED, fd, 0);
+
+	if (data == MAP_FAILED) {
+		cerr << "Failed to map file: " << strerror(errno) << endl;
+		return -1;
+	}
+	return 0;
+}
+
+static size_t getFileSize(const string& filePath)
+{
+	struct stat s;
+	if (stat(filePath.c_str(), &s))
+		return -1;
+
+	return s.st_size;
+}
+
+int MappedFile::open(const string& filePath)
+{
+	mappedFileSize = getFileSize(filePath);
+
+	fd = ::open(filePath.c_str(), O_RDONLY);
+	if (fd < 0) {
+		cerr << "Failed to open file " << filePath << ":" << strerror(errno) << endl;
+		return -1;
+	}
+
+	data = mmap(NULL, mappedFileSize, PROT_READ, MAP_SHARED, fd, 0);
+
+	if (data == MAP_FAILED) {
+		cerr << "Failed to map file: " << strerror(errno) << endl;
+		return -1;
+	}
+	return 0;
+}
+
+int MappedFile::sync()
+{
+	if (msync(data, mappedFileSize, MS_SYNC) == -1) {
+		cerr << "Failed to sync: " << strerror(errno) << endl;
+		return -1;
+	}
+	return 0;
+}
+
+
+void MappedFile::close()
+{
+	sync();
+	munmap(data, mappedFileSize);
+	::close(fd);
+}
+
+size_t MappedFile::size() const
+{
+	return mappedFileSize;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/mappedfile.hpp b/VNFs/DPPD-PROX/tools/flow_extract/mappedfile.hpp
new file mode 100644
index 00000000..7bf79df5
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/mappedfile.hpp
@@ -0,0 +1,40 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _MAPPEDFILE_H_
+#define _MAPPEDFILE_H_
+
+#include <inttypes.h>
+#include <string>
+
+using namespace std;
+
+class MappedFile {
+public:
+	int open(const string& filePath, size_t size);
+	int open(const string& filePath);
+	void close();
+	int sync();
+	uint8_t* getMapBeg() {return (uint8_t *)data;}
+	uint8_t* getMapEnd() {return (uint8_t *)data + mappedFileSize;}
+	size_t size() const;
+private:
+	int fd;
+	size_t mappedFileSize;
+	void *data;
+};
+
+#endif /* _MAPPEDFILE_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/memreader.cpp b/VNFs/DPPD-PROX/tools/flow_extract/memreader.cpp
new file mode 100644
index 00000000..df77631c
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/memreader.cpp
@@ -0,0 +1,106 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <cstdlib>
+
+#include "memreader.hpp"
+#include "mappedfile.hpp"
+#include "stream3.hpp"
+
+MemReader::MemReader(MappedFile *file, const vector<size_t> &offsets)
+{
+	initRanges(file->getMapBeg(), file->getMapEnd(), offsets);
+}
+
+bool MemReader::read(Stream3 *stream)
+{
+	if (ranges.empty())
+		return false;
+
+	readStream(stream, getLowestID());
+	removeEmptyRanges();
+	return true;
+}
+
+uint32_t MemReader::getLowestID() const
+{
+	uint32_t lowestID = UINT32_MAX;
+	uint32_t rangeID;
+
+	for (size_t i = 0; i < ranges.size(); ++i) {
+		rangeID = Stream3::getIDFromMem(ranges[i].first);
+		if (rangeID < lowestID)
+			lowestID = rangeID;
+	}
+	return lowestID;
+}
+
+void MemReader::readStream(Stream3 *stream, uint32_t id)
+{
+	stream->removeAllPackets();
+	stream->setID(id);
+	
+	size_t len = 0;
+	for (size_t i = 0; i < ranges.size(); ++i) {
+		if (Stream3::getIDFromMem(ranges[i].first) == id) {
+			stream->addFromMemory(ranges[i].first, &len);
+			ranges[i].first += len;
+		}
+	}
+}
+
+void MemReader::removeEmptyRanges()
+{
+	vector<pair <uint8_t *, uint8_t *> > original = ranges;
+	size_t destinationIdx = 0;
+
+	for (size_t i = 0; i < original.size(); ++i) {
+		if (original[i].first < original[i].second)
+			ranges[destinationIdx++] = original[i];
+	}
+	ranges.resize(destinationIdx);
+}
+
+void MemReader::initRanges(uint8_t *begin, uint8_t *end, const vector<size_t> &offsets)
+{
+	ranges.resize(offsets.size());
+
+	totalLength = 0;
+	for (size_t i = 0; i < offsets.size(); ++i) {
+		ranges[i].first = begin + offsets[i];
+		if (i != offsets.size() - 1)
+			ranges[i].second = begin + offsets[i + 1];
+		else
+			ranges[i].second = end;
+		totalLength += ranges[i].second - ranges[i].first;
+	}
+	removeEmptyRanges();
+}
+
+size_t MemReader::getRangeLengths() const
+{
+	size_t total = 0;
+
+	for (size_t i = 0; i < ranges.size(); ++i) {
+		total += ranges[i].second - ranges[i].first;
+	}
+	return total;
+}
+
+size_t MemReader::consumed() const
+{
+	return totalLength - getRangeLengths();
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/memreader.hpp b/VNFs/DPPD-PROX/tools/flow_extract/memreader.hpp
new file mode 100644
index 00000000..31be4c31
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/memreader.hpp
@@ -0,0 +1,45 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _MEMREADER_H_
+#define _MEMREADER_H_
+
+#include <vector>
+#include <inttypes.h>
+
+using namespace std;
+
+class Stream3;
+class MappedFile;
+
+class MemReader {
+public:
+	MemReader(MappedFile *file, const vector<size_t> &offsets);
+        bool read(Stream3 *stream);
+	size_t getTotalLength() const {return totalLength;}
+	size_t consumed() const;
+private:
+	size_t getRangeLengths() const;
+        uint32_t getLowestID() const;
+	void removeEmptyRanges();
+	void readStream(Stream3 *stream, uint32_t id);
+	void initRanges(uint8_t *begin, uint8_t *end, const vector<size_t> &offsets);
+
+	size_t totalLength;
+	vector<pair <uint8_t *, uint8_t *> > ranges;
+};
+
+#endif /* _MEMREADER_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/netsocket.cpp b/VNFs/DPPD-PROX/tools/flow_extract/netsocket.cpp
new file mode 100644
index 00000000..8c61ba7d
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/netsocket.cpp
@@ -0,0 +1,33 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "netsocket.hpp"
+
+NetSocket::NetSocket(uint32_t host, uint16_t port)
+	: host(host), port(port)
+{
+
+}
+
+bool NetSocket::operator>(const NetSocket& other) const
+{
+	return host > other.host || (host == other.host && port > other.port);
+}
+
+bool NetSocket::operator<(const NetSocket& other) const
+{
+	return host < other.host || (host == other.host && port < other.port);
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/netsocket.hpp b/VNFs/DPPD-PROX/tools/flow_extract/netsocket.hpp
new file mode 100644
index 00000000..bfd6bec9
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/netsocket.hpp
@@ -0,0 +1,31 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _NETSOCKET_H_
+#define _NETSOCKET_H_
+
+#include <inttypes.h>
+
+struct NetSocket {
+	NetSocket() {}
+	NetSocket(uint32_t host, uint16_t port);
+	bool operator>(const NetSocket& other) const;
+	bool operator<(const NetSocket& other) const;
+	uint32_t host;
+	uint16_t port;
+};
+
+#endif /* _NETSOCKET_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/path.cpp b/VNFs/DPPD-PROX/tools/flow_extract/path.cpp
new file mode 100644
index 00000000..7d94aae6
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/path.cpp
@@ -0,0 +1,97 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <iostream>
+#include <iomanip>
+#include <sys/stat.h>
+#include <sstream>
+#include <fstream>
+
+#include "path.hpp"
+
+bool Path::isDir() const
+{
+	struct stat s = { 0 };
+
+	if (stat(path.c_str(), &s)) {
+		return false;
+	}
+
+	return s.st_mode & S_IFDIR;
+}
+
+bool Path::isFile() const
+{
+	struct stat s = { 0 };
+
+	if (stat(path.c_str(), &s)) {
+		return false;
+	}
+
+	return s.st_mode & S_IFREG;
+}
+
+Path Path::add(const string& str) const
+{
+	stringstream ss;
+
+	ss << path << str;
+
+        return Path(ss.str());
+}
+
+Path Path::add(int number) const
+{
+	stringstream ss;
+
+	ss << path << number;
+
+	return Path(ss.str());
+}
+
+Path &Path::concat(const string &add)
+{
+	stringstream ss;
+
+	ss << path << add;
+	path = ss.str();
+
+        return *this;
+}
+
+int Path::mkdir() const
+{
+	if (!isDir())
+		return ::mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+	return 0;
+}
+
+std::ostream& operator<<(std::ofstream &stream, const Path &p)
+{
+	stream << p.path.c_str();
+
+	return stream;
+}
+
+string Path::getFileName() const
+{
+	for (size_t i = path.size() - 1; i >= 0; --i) {
+		if (path[i] == '/') {
+			return path.substr(i + 1);
+		}
+	}
+	return path;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/path.hpp b/VNFs/DPPD-PROX/tools/flow_extract/path.hpp
new file mode 100644
index 00000000..e56c9050
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/path.hpp
@@ -0,0 +1,42 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PATH_H_
+#define _PATH_H_
+
+#include <string>
+
+using namespace std;
+
+class Path {
+public:
+	Path();
+	Path(const Path& other) : path(other.path) {}
+	Path(const string& str) : path(str) {}
+	Path add(const string& str) const;
+	Path add(int number) const;
+	Path &concat(const string &str);
+	const string& str() const {return path;}
+	bool isDir() const;
+	bool isFile() const;
+	string getFileName() const;
+	int mkdir() const;
+	friend std::ostream& operator<<(std::ofstream &stream, const Path &path);
+private:
+	string path;
+};
+
+#endif /* _PATH_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/pcappkt.cpp b/VNFs/DPPD-PROX/tools/flow_extract/pcappkt.cpp
new file mode 100644
index 00000000..91708bb1
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/pcappkt.cpp
@@ -0,0 +1,266 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <pcap.h>
+#include <inttypes.h>
+#include <cstring>
+#include <arpa/inet.h>
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include "allocator.hpp"
+#include "pcappkt.hpp"
+
+Allocator *PcapPkt::allocator = NULL;
+
+void* PcapPkt::operator new(size_t size)
+{
+	if (allocator)
+		return allocator->alloc(size);
+	else
+		return ::operator new(size);
+}
+
+void PcapPkt::operator delete(void *pointer)
+{
+	if (!allocator)
+		:: operator delete(pointer);
+}
+
+PcapPkt::PcapPkt(uint8_t *mem)
+{
+	header = *(struct pcap_pkthdr *)mem;
+	mem += sizeof(header);
+	buf = new uint8_t[header.len];
+	memcpy(buf, mem, header.len);
+}
+
+PcapPkt::PcapPkt()
+{
+	buf = new uint8_t[1514];
+	memset(&header, 0, sizeof(header));
+}
+
+PcapPkt::PcapPkt(const PcapPkt& other)
+{
+	if (!allocator) {
+		buf = new uint8_t[other.len()];
+	}
+	else {
+		buf = (uint8_t *)allocator->alloc(other.len());
+	}
+
+	memcpy(buf, other.buf, other.len());
+	header = other.header;
+}
+
+PcapPkt::~PcapPkt()
+{
+	if (!allocator)
+		delete[] buf;
+}
+
+#define ETYPE_IPv4	0x0008	/* IPv4 in little endian */
+#define ETYPE_IPv6	0xDD86	/* IPv6 in little endian */
+#define ETYPE_ARP	0x0608	/* ARP in little endian */
+#define ETYPE_VLAN	0x0081	/* 802-1aq - VLAN */
+#define ETYPE_MPLSU	0x4788	/* MPLS unicast */
+#define ETYPE_MPLSM	0x4888	/* MPLS multicast */
+#define ETYPE_8021ad	0xA888	/* Q-in-Q */
+#define ETYPE_LLDP	0xCC88	/* Link Layer Discovery Protocol (LLDP) */
+#define ETYPE_EoGRE	0x5865	/* EoGRE in little endian */
+
+struct ipv4_hdr {
+	uint8_t  version_ihl;		/**< version and header length */
+	uint8_t  type_of_service;	/**< type of service */
+	uint16_t total_length;		/**< length of packet */
+	uint16_t packet_id;		/**< packet ID */
+	uint16_t fragment_offset;	/**< fragmentation offset */
+	uint8_t  time_to_live;		/**< time to live */
+	uint8_t  next_proto_id;		/**< protocol ID */
+	uint16_t hdr_checksum;		/**< header checksum */
+	uint32_t src_addr;		/**< source address */
+	uint32_t dst_addr;		/**< destination address */
+} __attribute__((__packed__));
+
+struct ether_addr {
+	uint8_t addr_bytes[6]; /**< Address bytes in transmission order */
+} __attribute__((__packed__));
+
+struct ether_hdr {
+	struct ether_addr d_addr; /**< Destination address. */
+	struct ether_addr s_addr; /**< Source address. */
+	uint16_t ether_type;      /**< Frame type. */
+} __attribute__((__packed__));
+
+struct vlan_hdr {
+	uint16_t vlan_tci; /**< Priority (3) + CFI (1) + Identifier Code (12) */
+	uint16_t eth_proto;/**< Ethernet type of encapsulated frame. */
+} __attribute__((__packed__));
+
+struct udp_hdr {
+	uint16_t src_port;    /**< UDP source port. */
+	uint16_t dst_port;    /**< UDP destination port. */
+	uint16_t dgram_len;   /**< UDP datagram length */
+	uint16_t dgram_cksum; /**< UDP datagram checksum */
+} __attribute__((__packed__));
+
+struct pkt_tuple PcapPkt::parsePkt(const uint8_t **l4_hdr, uint16_t *hdr_len, const uint8_t **l5, uint32_t *l5_len) const
+{
+	struct pkt_tuple pt = {0};
+
+	const struct ether_hdr *peth = (struct ether_hdr *)buf;
+	int l2_types_count = 0;
+	const struct ipv4_hdr* pip = 0;
+
+	switch (peth->ether_type) {
+	case ETYPE_IPv4:
+			pip = (const struct ipv4_hdr *)(peth + 1);
+		break;
+	case ETYPE_VLAN: {
+		const struct vlan_hdr *vlan = (const struct vlan_hdr *)(peth + 1);
+		if (vlan->eth_proto == ETYPE_IPv4) {
+			pip = (const struct ipv4_hdr *)(peth + 1);
+		}
+		else if (vlan->eth_proto == ETYPE_VLAN) {
+			const struct vlan_hdr *vlan = (const struct vlan_hdr *)(peth + 1);
+			if (vlan->eth_proto == ETYPE_IPv4) {
+				pip = (const struct ipv4_hdr *)(peth + 1);
+			}
+			else if (vlan->eth_proto == ETYPE_IPv6) {
+				throw 0;
+			}
+			else {
+				/* TODO: handle BAD PACKET */
+				throw 0;
+			}
+		}
+	}
+		break;
+	case ETYPE_8021ad: {
+		const struct vlan_hdr *vlan = (const struct vlan_hdr *)(peth + 1);
+		if (vlan->eth_proto == ETYPE_VLAN) {
+			const struct vlan_hdr *vlan = (const struct vlan_hdr *)(peth + 1);
+			if (vlan->eth_proto == ETYPE_IPv4) {
+				pip = (const struct ipv4_hdr *)(peth + 1);
+			}
+			else {
+				throw 0;
+			}
+		}
+		else {
+			throw 0;
+		}
+	}
+		break;
+	case ETYPE_MPLSU:
+		break;
+	default:
+		break;
+	}
+
+	/* L3 */
+	if ((pip->version_ihl >> 4) == 4) {
+
+		if ((pip->version_ihl & 0x0f) != 0x05) {
+			/* TODO: optional fields */
+			throw 0;
+		}
+
+		pt.proto_id = pip->next_proto_id;
+		pt.src_addr = pip->src_addr;
+		pt.dst_addr = pip->dst_addr;
+	}
+	else {
+		/* TODO: IPv6 and bad packets */
+		throw 0;
+	}
+
+	/* L4 parser */
+	if (pt.proto_id == IPPROTO_UDP) {
+		const struct udp_hdr *udp = (const struct udp_hdr*)(pip + 1);
+		if (l4_hdr)
+			*l4_hdr = (const uint8_t*)udp;
+		if (hdr_len)
+			*hdr_len = (const uint8_t*)udp - buf;
+		pt.src_port = udp->src_port;
+		pt.dst_port = udp->dst_port;
+		if (l5)
+			*l5 = ((const uint8_t*)udp) + sizeof(struct udp_hdr);
+		if (l5_len)
+			*l5_len = ntohs(udp->dgram_len) - sizeof(struct udp_hdr);
+	}
+	else if (pt.proto_id == IPPROTO_TCP) {
+		const struct tcp_hdr *tcp = (const struct tcp_hdr *)(pip + 1);
+		if (l4_hdr)
+			*l4_hdr = (const uint8_t*)tcp;
+		if (hdr_len)
+			*hdr_len = (const uint8_t*)tcp - buf;
+		pt.src_port = tcp->src_port;
+		pt.dst_port = tcp->dst_port;
+
+		if (l5)
+			*l5 = ((const uint8_t*)tcp) + ((tcp->data_off >> 4)*4);
+		if (l5_len)
+			*l5_len = ntohs(pip->total_length) - sizeof(struct ipv4_hdr) - ((tcp->data_off >> 4)*4);
+	}
+	else {
+		fprintf(stderr, "unsupported protocol %d\n", pt.proto_id);
+		throw 0;
+	}
+
+	return pt;
+}
+
+void PcapPkt::toMem(uint8_t *mem) const
+{
+	memcpy(mem, &header, sizeof(header));
+	mem += sizeof(header);
+	memcpy(mem, buf, header.len);
+}
+
+void PcapPkt::fromMem(uint8_t *mem)
+{
+	memcpy(&header, mem, sizeof(header));
+	mem += sizeof(header);
+	memcpy(buf, mem, header.len);
+}
+
+void PcapPkt::toFile(ofstream *file) const
+{
+	file->write(reinterpret_cast<const char *>(&header), sizeof(header));
+	file->write(reinterpret_cast<const char *>(buf), header.len);
+}
+size_t PcapPkt::memSize() const
+{
+	return sizeof(header) + header.len;
+}
+
+PcapPkt::L4Proto PcapPkt::getProto() const
+{
+	struct pkt_tuple pt = parsePkt();
+	return pt.proto_id == IPPROTO_TCP? PROTO_TCP : PROTO_UDP;
+}
+
+ostream& operator<<(ostream& stream, const pkt_tuple &other)
+{
+       	stream << other.src_addr << ","
+	       << other.dst_addr << ","
+	       << (int)other.proto_id << ","
+	       << other.src_port << ","
+	       << other.dst_port;
+	return stream;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/pcappkt.hpp b/VNFs/DPPD-PROX/tools/flow_extract/pcappkt.hpp
new file mode 100644
index 00000000..e437c790
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/pcappkt.hpp
@@ -0,0 +1,104 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PCAPPKT_H_
+#define _PCAPPKT_H_
+
+#include <inttypes.h>
+#include <pcap.h>
+#include <string>
+#include <cstring>
+
+using namespace std;
+
+struct pkt_tuple {
+	uint32_t src_addr;
+	uint32_t dst_addr;
+	uint8_t proto_id;
+	uint16_t src_port;
+	uint16_t dst_port;
+	bool operator!=(const pkt_tuple& other) const
+	{
+		return src_addr != other.src_addr ||
+			dst_addr != other.dst_addr ||
+			proto_id != other.proto_id ||
+			src_port != other.src_port ||
+			dst_port != other.dst_port;
+	}
+	bool operator==(const pkt_tuple& other) const
+	{
+		return src_addr == other.src_addr &&
+			dst_addr == other.dst_addr &&
+			proto_id == other.proto_id &&
+			src_port == other.src_port &&
+			dst_port == other.dst_port;
+	}
+	friend ostream& operator<<(ostream& stream, const pkt_tuple &other);
+	struct pkt_tuple flip() const
+	{
+		struct pkt_tuple ret;
+
+		ret = *this;
+		ret.src_addr = dst_addr;
+		ret.src_port = dst_port;
+		ret.dst_addr = src_addr;
+		ret.dst_port = src_port;
+		return ret;
+	}
+
+} __attribute__((packed));
+
+class Allocator;
+
+class PcapPkt {
+	friend class PcapReader;
+public:
+	struct tcp_hdr {
+		uint16_t src_port;  /**< TCP source port. */
+		uint16_t dst_port;  /**< TCP destination port. */
+		uint32_t sent_seq;  /**< TX data sequence number. */
+		uint32_t recv_ack;  /**< RX data acknowledgement sequence number. */
+		uint8_t  data_off;  /**< Data offset. */
+		uint8_t  tcp_flags; /**< TCP flags */
+		uint16_t rx_win;    /**< RX flow control window. */
+		uint16_t cksum;     /**< TCP checksum. */
+		uint16_t tcp_urp;   /**< TCP urgent pointer, if any. */
+	} __attribute__((__packed__));
+
+	static Allocator *allocator;
+	enum L4Proto {PROTO_TCP, PROTO_UDP};
+	PcapPkt();
+	void* operator new(size_t size);
+	static void operator delete(void *pointer);
+	PcapPkt(const PcapPkt& other);
+	PcapPkt(uint8_t *mem);
+	void toMem(uint8_t *mem) const;
+	void fromMem(uint8_t *mem);
+	void toFile(ofstream *file) const;
+	size_t memSize() const;
+	const struct timeval &ts() const {return header.ts;}
+	const uint16_t len() const {return header.len;}
+	pkt_tuple parsePkt(const uint8_t **l4_hdr = NULL, uint16_t *hdr_len = NULL, const uint8_t **l5 = NULL, uint32_t *l5_len = NULL) const;
+	const struct pcap_pkthdr &hdr() const {return header;}
+	const uint8_t *payload() const {return buf;}
+	enum L4Proto getProto() const;
+	~PcapPkt();
+private:
+	struct pcap_pkthdr header;
+	uint8_t *buf;
+};
+
+#endif /* _PCAPPKT_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/pcappktref.cpp b/VNFs/DPPD-PROX/tools/flow_extract/pcappktref.cpp
new file mode 100644
index 00000000..2a0f2f05
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/pcappktref.cpp
@@ -0,0 +1,32 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "pcappktref.hpp"
+
+PcapPktRef::PcapPktRef(const PcapPktRef &other)
+	: pos(other.pos), pr(other.pr)
+{
+}
+
+PcapPkt PcapPktRef::getPcapPkt()
+{
+	PcapPkt ret;
+
+	if (!pr->readOnce(&ret, pos)) {
+		cerr << "failed to read pcap from pcap pkt ref" << endl;
+	}
+	return ret;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/pcappktref.hpp b/VNFs/DPPD-PROX/tools/flow_extract/pcappktref.hpp
new file mode 100644
index 00000000..1afaf2a5
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/pcappktref.hpp
@@ -0,0 +1,40 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PCAPPKTREF_H_
+#define _PCAPPKTREF_H_
+
+#include <iostream>
+
+#include "pcapreader.hpp"
+#include "pcappkt.hpp"
+
+using namespace std;
+
+class PcapPktRef
+{
+public:
+	PcapPktRef(uint64_t pos, PcapReader *pr) : pos(pos), pr(pr) {}
+	PcapPktRef(const PcapPktRef &other);
+	PcapPktRef() : pos(0), pr(0) {}
+	bool isValid() const {return pos != 0;}
+	PcapPkt getPcapPkt();
+private:
+	uint64_t pos;
+	PcapReader *pr;
+};
+
+#endif /* _PCAPPKTREF_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/pcapreader.cpp b/VNFs/DPPD-PROX/tools/flow_extract/pcapreader.cpp
new file mode 100644
index 00000000..6b5a6734
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/pcapreader.cpp
@@ -0,0 +1,76 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <pcap.h>
+#include <cstring>
+#include <linux/in.h>
+
+#include "pcapreader.hpp"
+
+int PcapReader::open(const string& file_path)
+{
+	char err_str[PCAP_ERRBUF_SIZE];
+
+	if (m_handle) {
+		m_error = "Pcap file already open";
+		return -1;
+	}
+
+	m_handle = pcap_open_offline_with_tstamp_precision(file_path.c_str(),
+							   PCAP_TSTAMP_PRECISION_NANO,
+							   err_str);
+
+	if (!m_handle) {
+		m_error = "Failed to open pcap file";
+		return -1;
+	}
+
+	m_file_beg = ftell(pcap_file(m_handle));
+	fseek(pcap_file(m_handle), 0, SEEK_END);
+	m_file_end = ftell(pcap_file(m_handle));
+	fseek(pcap_file(m_handle), m_file_beg, SEEK_SET);
+
+	return 0;
+}
+
+int PcapReader::readOnce(PcapPkt *pkt, uint64_t pos)
+{
+	return -1;
+}
+
+int PcapReader::read(PcapPkt *pkt)
+{
+	if (!m_handle) {
+		m_error = "No pcap file opened";
+	}
+
+	const uint8_t *buf = pcap_next(m_handle, &pkt->header);
+
+	if (buf) {
+		memcpy(pkt->buf, buf, pkt->header.len);
+		pktReadCount++;
+	}
+
+	return !!buf;
+}
+
+void PcapReader::close()
+{
+	if (m_handle)
+		pcap_close(m_handle);
+
+	m_handle = NULL;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/pcapreader.hpp b/VNFs/DPPD-PROX/tools/flow_extract/pcapreader.hpp
new file mode 100644
index 00000000..3766c67b
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/pcapreader.hpp
@@ -0,0 +1,48 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PCAPREADER_H_
+#define _PCAPREADER_H_
+
+#include <inttypes.h>
+#include <string>
+
+#include <pcap.h>
+
+#include "pcappkt.hpp"
+
+using namespace std;
+
+class PcapReader {
+public:
+        PcapReader() : m_handle(NULL), pktReadCount(0) {}
+	int open(const string& file_path);
+	size_t pos() {return ftell(pcap_file(m_handle)) - m_file_beg;}
+	size_t end() {return m_file_end;}
+	int read(PcapPkt *pkt);
+	int readOnce(PcapPkt *pkt, uint64_t pos);
+	size_t getPktReadCount() const {return pktReadCount;}
+	void close();
+	const string &getError() const {return m_error;}
+private:
+	pcap_t *m_handle;
+	size_t m_file_beg;
+	size_t m_file_end;
+	size_t pktReadCount;
+	string m_error;
+};
+
+#endif /* _PCAPREADER_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/pcapwriter.cpp b/VNFs/DPPD-PROX/tools/flow_extract/pcapwriter.cpp
new file mode 100644
index 00000000..4c7c4cea
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/pcapwriter.cpp
@@ -0,0 +1,46 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "pcapwriter.hpp"
+
+int PcapWriter::open(const string& file_path)
+{
+	m_handle = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, 65536, PCAP_TSTAMP_PRECISION_NANO);
+	if (m_handle == NULL)
+		return -1;
+
+	m_pcap_dumper = pcap_dump_open(m_handle, file_path.c_str());
+	if (m_pcap_dumper == NULL) {
+		pcap_close(m_handle);
+		return -1;
+	}
+
+	return 0;
+}
+
+int PcapWriter::write(const PcapPkt& pkt)
+{
+	pcap_dump((unsigned char *)m_pcap_dumper, &pkt.hdr(), pkt.payload());
+	return 0;
+}
+
+void PcapWriter::close()
+{
+	if (m_pcap_dumper)
+		pcap_dump_close(m_pcap_dumper);
+	if (m_handle)
+		pcap_close(m_handle);
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/pcapwriter.hpp b/VNFs/DPPD-PROX/tools/flow_extract/pcapwriter.hpp
new file mode 100644
index 00000000..32f79369
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/pcapwriter.hpp
@@ -0,0 +1,33 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PCAPWRITER_H_
+#define _PCAPWRITER_H_
+
+#include "pcappkt.hpp"
+
+class PcapWriter {
+public:
+	PcapWriter() {}
+	int open(const string& file_path);
+	int write(const PcapPkt& pkt);
+	void close();
+private:
+	pcap_t *m_handle;
+	pcap_dumper_t *m_pcap_dumper;
+};
+
+#endif /* _PCAPWRITER_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/programconfig.cpp b/VNFs/DPPD-PROX/tools/flow_extract/programconfig.cpp
new file mode 100644
index 00000000..7b1e18e1
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/programconfig.cpp
@@ -0,0 +1,119 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <sstream>
+#include <getopt.h>
+#include <iostream>
+#include <cstdlib>
+#include "programconfig.hpp"
+
+ProgramConfig::ProgramConfig()
+	: path_file_in_pcap(""), path_dir_out("output"),
+	  path_file_dest_lua("lua"), max_pkts(UINT32_MAX),
+	  max_streams(UINT32_MAX), sampleCount(20000), flowTableSize(8*1024*1024),
+	  run_first_step(true), write_pcaps(false)
+{
+}
+
+string ProgramConfig::getUsage() const
+{
+	stringstream ret;
+
+	ret << "Usage example: "<< m_programName << " -i in.pcap\n\n"
+	    << "Flow Extract 2.0 analyzes and extracts a traffic profile\n"
+	    << "configuration from a pcap file. The output is a lua\n"
+	    << "configuration file and a binary file containing all the\n"
+	    << "headers and payloads for each stream.\n\n"
+
+	    << "The program supports analyzing large pcap file (> 300 GB).\n"
+	    << "For this, it uses a multi-pass approach. The output of \n"
+	    << "intermediary steps is stored in the working directory. The\n"
+	    << "algorithm can be described by the following steps:\n\n"
+	    << "   1. The pcap file in read chunks of 16 GB. The packets in\n"
+	    << "      each chunk are associated with streams. The streams are\n"
+	    << "      ordered through a global ID. Each stream is stored as a"
+	    << "      sequence of packets that belong to that stream. The\n"
+	    << "      resulting file at 'DIR/tmp' where DIR is specified\n"
+	    << "      through -o options as shown below.\n"
+	    << "      Each chunk in tmp is merged and the result is written\n"
+	    << "      to file1. Reading the stream with a given ID from all chunks\n"
+	    << "      gets all the packets for the stream from the whole pcap in\n"
+	    << "      memory. This first step forms is implemented by an\n"
+	    << "      external sorting algorithm.\n"
+	    << "   2. File2 is read and the source IP for each stream is used to\n"
+	    << "      associate each stream with a bundle. SAMPLE_COUNT samples\n"
+	    << "      are taken from the set of bundles. The set of streams that\n"
+	    << "      are still referenced by the sampled bundles extracted from\n"
+	    << "      file2 and written to the final binary file. This binary file\n"
+	    << "      is referenced from the lua configuration. The lua config file\n"
+	    << "      is written out as part of this step.\n"
+	    << "Arguments:\n"
+	    << "-i FILE         Input pcap to process\n"
+	    << "-o DIR          output directory and working directory\n"
+	    << "-s SAMPLE_COUNT Number of samples to take (default is 20K)\n"
+	    << "-k              Skip the first step as described above. Useful to\n"
+	    << "                adjust the number of samples without having to\n"
+	    << "                repeat the whole process\n";
+
+
+	return ret.str();
+}
+
+int ProgramConfig::checkConfig()
+{
+	if (path_file_in_pcap.empty()) {
+		m_error = "Missing input pcap file\n";
+		return -1;
+	}
+	return 0;
+}
+
+int ProgramConfig::parseOptions(int argc, char *argv[])
+{
+	char c;
+
+	m_programName = argv[0];
+	while ((c = getopt(argc, argv, "hki:o:s:p")) != -1) {
+		switch (c) {
+		case 'h':
+			return -1;
+			break;
+		case 'k':
+			run_first_step = false;
+			break;
+		case 'i':
+			path_file_in_pcap = optarg;
+			break;
+		case 'o':
+			path_dir_out = optarg;
+			break;
+		case 's':
+			sampleCount = atoi(optarg);
+			break;
+		case 'p':
+			write_pcaps = true;
+			break;
+		case '?':
+			cerr << getUsage() << endl;
+			return 0;
+		default:
+			m_error = "Invalid parameter\n";
+			return -1;
+		}
+	}
+
+	return checkConfig();
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/programconfig.hpp b/VNFs/DPPD-PROX/tools/flow_extract/programconfig.hpp
new file mode 100644
index 00000000..59b7104d
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/programconfig.hpp
@@ -0,0 +1,47 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROGRAMCONFIG_H_
+#define _PROGRAMCONFIG_H_
+
+#include <string>
+#include <inttypes.h>
+
+using namespace std;
+
+class ProgramConfig {
+public:
+	ProgramConfig();
+	string getUsage() const;
+	int parseOptions(int argc, char *argv[]);
+	const string& getError() const {return m_error;}
+
+	string path_file_in_pcap;
+	string path_dir_out;
+	string path_file_dest_lua;
+	uint32_t max_pkts;
+	uint32_t max_streams;
+	uint32_t sampleCount;
+	uint32_t flowTableSize;
+	bool run_first_step;
+	bool write_pcaps;
+private:
+	int checkConfig();
+	string m_error;
+	string m_programName;
+};
+
+#endif /* _PROGRAMCONFIG_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/progress.cpp b/VNFs/DPPD-PROX/tools/flow_extract/progress.cpp
new file mode 100644
index 00000000..2c65960f
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/progress.cpp
@@ -0,0 +1,96 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <sys/time.h>
+#include <iostream>
+#include <cstdio>
+#include <sstream>
+
+#include "progress.hpp"
+
+static uint64_t getSec()
+{
+	struct timeval tv;
+
+	gettimeofday(&tv, NULL);
+	return tv.tv_sec;
+}
+
+Progress::Progress(size_t maxProgress, bool inPlace, bool showElapsedTime)
+	: maxProgress(maxProgress), curProgress(0), inPlace(inPlace), showElapsedTime(showElapsedTime), prevLength(0), title("Progress")
+{
+	lastRefresh = -1;
+	firstRefresh = getSec();
+}
+
+void Progress::setProgress(size_t curProgress)
+{
+	this->curProgress = curProgress;
+}
+
+void Progress::setProgress()
+{
+	this->curProgress = maxProgress;
+}
+
+uint32_t Progress::addDetail(const string& detail)
+{
+	details.push_back(make_pair(detail, 0));
+	return details.size() - 1;
+}
+
+void Progress::setDetail(uint32_t idx, uint32_t val)
+{
+	details[idx].second = val;
+}
+
+bool Progress::couldRefresh()
+{
+	uint32_t cur = getSec();
+
+	return (lastRefresh != cur);
+}
+
+void Progress::refresh(bool withNewLine)
+{
+	lastRefresh = getSec();
+	uint64_t elapsed = lastRefresh - firstRefresh;
+	size_t progress = curProgress * 100 / maxProgress;
+	size_t remainingTime = curProgress? (elapsed * maxProgress - elapsed * curProgress) / curProgress : 0;
+
+	stringstream ss;
+
+	if (inPlace)
+		ss << "\r";
+	ss << title << ": " << progress << "%";
+	ss << ", remaining: " << remainingTime;
+	if (showElapsedTime)
+		ss << ", elapsed: " << elapsed;
+	for (size_t i = 0; i < details.size(); ++i)
+		ss << ", " << details[i].first << ": " << details[i].second;
+
+	size_t prevLength2 = ss.str().size();
+
+	while (ss.str().size() < prevLength)
+		ss << " ";
+	prevLength = prevLength2;
+
+	if (!inPlace || withNewLine)
+		ss << "\n";
+
+	cout << ss.str();
+	cout.flush();
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/progress.hpp b/VNFs/DPPD-PROX/tools/flow_extract/progress.hpp
new file mode 100644
index 00000000..7f55cf98
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/progress.hpp
@@ -0,0 +1,50 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _PROGRESS_H_
+#define _PROGRESS_H_
+
+#include <inttypes.h>
+#include <vector>
+#include <utility>
+#include <string>
+
+using namespace std;
+
+class Progress {
+public:
+	Progress(size_t maxProgress, bool inPlace = true, bool showElapsedTime = true);
+	void setTitle(const string &prefix) {this->title = title;}
+	void setProgress(size_t curProgress);
+	void setProgress();
+	uint32_t addDetail(const string& detail);
+	void clearDetails() {details.clear();}
+	void setDetail(uint32_t idx, uint32_t val);
+	bool couldRefresh();
+	void refresh(bool withNewLine = false);
+private:
+	uint64_t firstRefresh;
+	uint64_t lastRefresh;
+	size_t maxProgress;
+	size_t curProgress;
+	bool inPlace;
+	bool showElapsedTime;
+	size_t prevLength;
+	string title;
+	vector<pair<string, uint32_t> > details;
+};
+
+#endif /* _PROGRESS_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/stream.cpp b/VNFs/DPPD-PROX/tools/flow_extract/stream.cpp
new file mode 100644
index 00000000..b8056852
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/stream.cpp
@@ -0,0 +1,171 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <iostream>
+#include <iomanip>
+#include <arpa/inet.h>
+
+#include "pcapwriter.hpp"
+#include "stream.hpp"
+
+Stream::Stream(uint32_t id, uint32_t sizeHint)
+	: m_id(id), m_prevPktIsClient(false)
+{
+	m_client.pkts.reserve(sizeHint / 2);
+	m_server.pkts.reserve(sizeHint / 2);
+	m_pkts.reserve(sizeHint);
+}
+
+bool Stream::isClient(const PcapPkt &pkt) const
+{
+	return m_pt == pkt.parsePkt();
+}
+
+size_t Stream::pktCount() const
+{
+	return m_client.pkts.size() + m_server.pkts.size();
+}
+
+void Stream::setTupleFromPkt(const PcapPkt &pkt)
+{
+	m_pt = pkt.parsePkt();
+}
+
+void Stream::addPkt(const PcapPkt &pkt)
+{
+	if (!pktCount())
+		setTupleFromPkt(pkt);
+
+	bool isClientPkt = isClient(pkt);
+	HalfStream *half;
+
+	if (isClientPkt)
+		half = &m_client;
+	else
+		half = &m_server;
+
+	HalfStream::Action::Part p = half->addPkt(pkt);
+
+	if (p.len) {
+		addAction(half, p, isClientPkt);
+	}
+
+	m_pkts.push_back(pkt);
+}
+
+void Stream::addAction(HalfStream *half, HalfStream::Action::Part p, bool isClientPkt)
+{
+	if (m_actions.empty() || m_prevPktIsClient != isClientPkt || m_pt.proto_id == IPPROTO_UDP)
+		m_actions.push_back(HalfStream::Action(half, p, isClientPkt));
+	else
+		m_actions.back().addPart(p);
+	m_prevPktIsClient = isClientPkt;
+}
+
+Stream::Header Stream::getHeader() const
+{
+	Header h;
+
+	h.streamId = m_id;
+	h.clientHdrLen = m_client.hdrLen;
+	h.clientContentLen = m_client.contentLen;
+	h.serverHdrLen = m_server.hdrLen;
+	h.serverContentLen = m_server.contentLen;
+	h.actionCount = m_actions.size();
+	h.clientIP = m_pt.src_addr;
+	h.clientPort = m_pt.src_port;
+	h.serverIP = m_pt.dst_addr;
+	h.serverPort = m_pt.dst_port;
+	h.upRate = m_client.getRate();
+	h.dnRate = m_server.getRate();
+	h.protocol = m_pt.proto_id;
+	h.completedTCP = (m_client.tcpOpen && m_client.tcpClose && m_server.tcpOpen && m_server.tcpClose) ||
+		(!m_client.tcpOpen && !m_client.tcpClose && !m_server.tcpOpen && !m_server.tcpClose);
+
+	return h;
+}
+
+void Stream::Header::toFile(ofstream *f) const
+{
+	f->write((const char *)this, sizeof(*this));
+}
+
+int Stream::Header::fromFile(ifstream *f)
+{
+	const size_t readSize = sizeof(*this);
+
+	f->read((char *)this, readSize);
+	return 	f->gcount() == readSize? 0 : -1;
+}
+
+size_t Stream::Header::getStreamLen() const
+{
+	return 	actionCount * sizeof(ActionEntry)
+		+ clientHdrLen + clientContentLen
+		+ serverHdrLen + serverContentLen;
+}
+
+void Stream::actionsToFile(ofstream *f) const
+{
+	ActionEntry actionEntry;
+	uint32_t runningTotalLen[2] = {0};
+
+	for (size_t i = 0; i < m_actions.size(); ++i) {
+		actionEntry.peer = m_actions[i].isClient()? 0 : 1;
+		actionEntry.beg = runningTotalLen[actionEntry.peer];
+		actionEntry.len = m_actions[i].totLen();
+
+		runningTotalLen[actionEntry.peer] += actionEntry.len;
+		f->write((const char *)&actionEntry, sizeof(actionEntry));
+	}
+}
+
+void Stream::clientHdrToFile(ofstream *f) const
+{
+	f->write((const char *)m_client.hdr, m_client.hdrLen);
+}
+
+void Stream::serverHdrToFile(ofstream *f) const
+{
+	f->write((const char *)m_server.hdr, m_server.hdrLen);
+}
+
+void Stream::contentsToFile(ofstream *f, bool isClient) const
+{
+	for (size_t i = 0; i < m_actions.size(); ++i)
+		if (m_actions[i].isClient() == isClient)
+			m_actions[i].toFile(f);
+}
+
+void Stream::toFile(ofstream *f)
+{
+	getHeader().toFile(f);
+	actionsToFile(f);
+	clientHdrToFile(f);
+	serverHdrToFile(f);
+	contentsToFile(f, true);
+	contentsToFile(f, false);
+}
+
+void Stream::toPcap(const string& outFile)
+{
+	PcapWriter pw;
+
+	pw.open(outFile);
+	for (size_t i = 0; i < m_pkts.size(); ++i)
+		pw.write(m_pkts[i]);
+	pw.close();
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/stream.hpp b/VNFs/DPPD-PROX/tools/flow_extract/stream.hpp
new file mode 100644
index 00000000..28547d18
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/stream.hpp
@@ -0,0 +1,94 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STREAM_H_
+#define _STREAM_H_
+
+#include <list>
+#include <string>
+#include <fstream>
+#include <cstring>
+#include <vector>
+#include <cstdlib>
+#include <sys/time.h>
+
+#include "pcappktref.hpp"
+#include "pcappkt.hpp"
+#include "netsocket.hpp"
+#include "timestamp.hpp"
+#include "halfstream.hpp"
+
+using namespace std;
+
+class PcapReader;
+
+class Stream {
+public:
+	struct Header {
+		uint32_t streamId;
+		uint16_t clientHdrLen;
+		uint32_t clientContentLen;
+		uint16_t serverHdrLen;
+		uint32_t serverContentLen;
+		uint32_t actionCount;
+		uint32_t clientIP;
+		uint16_t clientPort;
+		uint32_t serverIP;
+		uint16_t serverPort;
+		double   upRate;
+		double   dnRate;
+		uint8_t  protocol;
+		uint8_t  completedTCP;
+ 		void     toFile(ofstream *f) const;
+		int      fromFile(ifstream *f);
+		size_t   getStreamLen() const;
+	};
+	struct ActionEntry {
+		uint8_t peer;
+		uint32_t beg;
+		uint32_t len;
+	} __attribute__((packed));
+
+	Stream(uint32_t id = -1, uint32_t sizeHint = 0);
+	void addPkt(const PcapPkt &pkt);
+	void toFile(ofstream *f);
+	void toPcap(const string& outFile);
+	double getRate() const;
+	size_t actionCount() const {return m_actions.size();}
+
+private:
+	Header getHeader() const;
+	void actionsToFile(ofstream *f) const;
+	void clientHdrToFile(ofstream *f) const;
+	void serverHdrToFile(ofstream *f) const;
+	void contentsToFile(ofstream *f, bool isClient) const;
+	bool isClient(const PcapPkt &pkt) const;
+	size_t pktCount() const;
+	struct pkt_tuple m_pt;
+	void setTupleFromPkt(const PcapPkt &pkt);
+	void addToClient(const PcapPkt &pkt);
+	void addToServer(const PcapPkt &pkt);
+	void addAction(HalfStream *half, HalfStream::Action::Part p, bool isClientPkt);
+
+	int m_id;
+	vector<PcapPkt> m_pkts;
+	vector<HalfStream::Action> m_actions;
+	HalfStream m_client;
+	HalfStream m_server;
+	bool m_prevPktIsClient;
+};
+
+#endif /* _STREAM_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/stream2.cpp b/VNFs/DPPD-PROX/tools/flow_extract/stream2.cpp
new file mode 100644
index 00000000..51057e7d
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/stream2.cpp
@@ -0,0 +1,151 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <iomanip>
+#include <arpa/inet.h>
+#include <sstream>
+
+#include "stream.hpp"
+#include "stream2.hpp"
+
+int Stream2::fromFile(ifstream *f)
+{
+	m_actions.clear();
+	if (streamHdr.fromFile(f))
+		return -1;
+	if (actionsFromFile(f, streamHdr.actionCount))
+		return -1;
+	if (setReferences(f))
+		return -1;
+
+	return 0;
+}
+
+int Stream2::actionsFromFile(ifstream *f, size_t actionCount)
+{
+	m_actions.resize(actionCount);
+	for (size_t i = 0; i < actionCount; ++i)
+		f->read((char *)&m_actions[i], sizeof(Stream::ActionEntry));
+
+	return 0;
+}
+
+int Stream2::setReferences(ifstream *f)
+{
+	size_t toRead = streamHdr.clientHdrLen +
+		streamHdr.serverHdrLen +
+		streamHdr.clientContentLen +
+		streamHdr.serverContentLen;
+
+	delete [] clientServerHdrContent;
+	clientServerHdrContent = new uint8_t[toRead];
+	f->read((char *)clientServerHdrContent, toRead);
+	return 0;
+}
+
+void Stream2::calcOffsets(ofstream *out)
+{
+	size_t curPos = out->tellp();
+
+	clientHdrBeg = curPos;
+	serverHdrBeg = clientHdrBeg + streamHdr.clientHdrLen;
+	clientContentBeg = serverHdrBeg + streamHdr.serverHdrLen;
+	serverContentBeg = clientContentBeg + streamHdr.clientContentLen;
+}
+
+void Stream2::toFile(ofstream *out) const
+{
+	size_t len = streamHdr.clientHdrLen +
+		streamHdr.serverHdrLen +
+		streamHdr.clientContentLen +
+		streamHdr.serverContentLen;
+
+	out->write((const char *)clientServerHdrContent, len);
+}
+
+static string ipToString(const uint32_t ip)
+{
+	uint32_t ip_ne = htonl(ip);
+	stringstream ss;
+
+	ss << ((ip_ne >> 24) & 0xff) << "."
+	   << ((ip_ne >> 16) & 0xff) << "."
+	   << ((ip_ne >> 8) & 0xff) << "."
+	   << (ip_ne & 0xff);
+
+	return ss.str();
+}
+
+static string spaces(uint32_t count)
+{
+	stringstream ss;
+
+	while (count--)
+		ss << " ";
+	return ss.str();
+}
+
+NetSocket Stream2::getServerNetSocket() const
+{
+	return NetSocket(streamHdr.serverIP, ntohs(streamHdr.serverPort));
+}
+
+NetSocket Stream2::getClientNetSocket() const
+{
+	return NetSocket(streamHdr.clientIP, ntohs(streamHdr.clientPort));
+}
+void Stream2::setServerNetSocket(const NetSocket& netSocket)
+{
+	streamHdr.serverPort = htons(netSocket.port);
+	streamHdr.serverIP = netSocket.host;
+}
+
+void Stream2::setClientNetSocket(const NetSocket& netSocket)
+{
+	streamHdr.clientPort = htons(netSocket.port);
+	streamHdr.clientIP = netSocket.host;
+}
+void Stream2::toLua(ofstream *f, const string& binFileName, const string& streamTableName) const
+
+{
+	(*f) << std::fixed;
+
+	(*f) << streamTableName << "[" << streamHdr.streamId << "] = {" << endl
+	     << spaces(3) << "client_data = {" << endl
+	     << spaces(6) << "header = bin_read(" << binFileName << "," << clientHdrBeg << "," << streamHdr.clientHdrLen << "), " << endl
+	     << spaces(6) << "content = bin_read(" << binFileName << "," << clientContentBeg << "," << streamHdr.clientContentLen << "), " << endl
+	     << spaces(3) << "}," << endl
+	     << spaces(3) << "server_data = {" << endl
+	     << spaces(6) << "header = bin_read(" << binFileName << "," << serverHdrBeg << "," << streamHdr.serverHdrLen << "), " << endl
+	     << spaces(6) << "content = bin_read(" << binFileName << "," << serverContentBeg << "," << streamHdr.serverContentLen << "), " << endl
+	     << spaces(3) << "}," << endl
+	     << spaces(3) << "actions = {" << endl;
+
+	for (size_t i = 0; i < m_actions.size(); ++i) {
+		const char *peer_str = m_actions[i].peer == 0? "client" : "server";
+
+		(*f) << spaces(6) <<  peer_str << "_content(" << m_actions[i].beg << "," << m_actions[i].len << ")," << endl;
+	}
+
+	(*f) << spaces(3) << "}," << endl
+	     << spaces(3) << "clients = {ip = ip(\"" << ipToString(streamHdr.clientIP) << "\"), port = " << ntohs(streamHdr.clientPort) << "}," << endl
+	     << spaces(3) << "servers = {ip = ip(\"" << ipToString(streamHdr.serverIP) << "\"), port = " << ntohs(streamHdr.serverPort) << "}," << endl
+	     << spaces(3) << "l4_proto = \"" << (streamHdr.protocol == 0x06? "tcp" : "udp") << "\"," << endl
+	     << spaces(3) << "up_bps = " << setprecision(4) << streamHdr.upRate << "," << endl
+	     << spaces(3) << "dn_bps = " << setprecision(4) << streamHdr.dnRate << "," << endl;
+
+	(*f) << "}" << endl;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/stream2.hpp b/VNFs/DPPD-PROX/tools/flow_extract/stream2.hpp
new file mode 100644
index 00000000..fd9d9c8c
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/stream2.hpp
@@ -0,0 +1,54 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STREAM2_H_
+#define _STREAM2_H_
+
+#include <inttypes.h>
+#include <fstream>
+
+#include "netsocket.hpp"
+
+using namespace std;
+
+class Stream2 {
+public:
+	Stream2() : clientServerHdrContent(NULL) {}
+	~Stream2() {delete [] clientServerHdrContent;}
+	int fromFile(ifstream *f);
+	void calcOffsets(ofstream *out);
+	void toFile(ofstream *out) const;
+	void toLua(ofstream *f, const string& binFileName, const string& streamTableName) const;
+	NetSocket getServerNetSocket() const;
+	NetSocket getClientNetSocket() const;
+	void setServerNetSocket(const NetSocket& netSocket);
+	void setClientNetSocket(const NetSocket& netSocket);
+	Stream::Header      streamHdr;
+private:
+	int actionsFromFile(ifstream *f, size_t actionCount);
+	int setReferences(ifstream *f);
+
+	uint8_t *clientServerHdrContent;
+
+	uint32_t clientHdrBeg;
+	uint32_t serverHdrBeg;
+	uint32_t clientContentBeg;
+	uint32_t serverContentBeg;
+
+	vector<Stream::ActionEntry> m_actions;
+};
+
+#endif /* _STREAM2_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/stream3.cpp b/VNFs/DPPD-PROX/tools/flow_extract/stream3.cpp
new file mode 100644
index 00000000..30c166ae
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/stream3.cpp
@@ -0,0 +1,95 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+#include "stream3.hpp"
+
+Stream3::Stream3(uint32_t id, PcapPkt::L4Proto proto)
+	: m_id(id), m_proto(proto), m_pktCount(0), m_flushCount(0)
+{
+}
+
+void Stream3::writeHeader(ofstream *outputFile) const
+{
+	outputFile->write(reinterpret_cast<const char *>(&m_id), sizeof(m_id));
+	outputFile->write(reinterpret_cast<const char *>(&m_flushCount), sizeof(m_flushCount));
+}
+
+void Stream3::writePackets(ofstream *outputFile) const
+{
+	for (size_t i  = 0; i < m_pkts.size(); ++i)
+		m_pkts[i]->toFile(outputFile);
+}
+
+void Stream3::clearPackets()
+{
+	for (size_t i = 0; i < m_pkts.size(); ++i)
+		delete m_pkts[i];
+	m_pkts.clear();
+	m_flushCount = 0;
+}
+
+void Stream3::flush(ofstream *outputFile)
+{
+	writeHeader(outputFile);
+	writePackets(outputFile);
+	clearPackets();
+}
+
+void Stream3::addPkt(const PcapPkt& pkt)
+{
+	m_pkts.push_back(new PcapPkt(pkt));
+	m_pktCount++;
+	m_flushCount++;
+}
+
+Timestamp Stream3::getTimeout() const
+{
+	uint32_t timeoutMinutes = m_proto == PcapPkt::PROTO_UDP? 10 : 5;
+
+	return Timestamp(timeoutMinutes * 60, 0);
+}
+
+uint32_t Stream3::getIDFromMem(uint8_t *mem)
+{
+	return *reinterpret_cast<uint32_t *>(mem);
+}
+
+void Stream3::addFromMemory(uint8_t *mem, size_t *len)
+{
+	uint32_t n_pkts;
+
+	mem += sizeof(m_id);
+	n_pkts = *reinterpret_cast<uint32_t *>(mem);
+	mem += sizeof(n_pkts);
+
+	*len = sizeof(m_id) + sizeof(n_pkts);
+	for (uint32_t i = 0; i < n_pkts; ++i) {
+	        addPkt(PcapPkt(mem));
+		mem += m_pkts.back()->memSize();
+		*len += m_pkts.back()->memSize();
+	}
+}
+
+void Stream3::removeAllPackets()
+{
+	clearPackets();
+	m_pktCount = 0;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/stream3.hpp b/VNFs/DPPD-PROX/tools/flow_extract/stream3.hpp
new file mode 100644
index 00000000..7e94814e
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/stream3.hpp
@@ -0,0 +1,55 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STREAM3_H_
+#define _STREAM3_H_
+
+#include <inttypes.h>
+#include <vector>
+
+#include "pcappkt.hpp"
+#include "timestamp.hpp"
+
+using namespace std;
+class Allocator;
+
+class Stream3 {
+public:
+	PcapPkt::L4Proto getProto(void) const {return m_proto;}
+	Stream3(uint32_t id, PcapPkt::L4Proto proto);
+	Stream3() : m_id(UINT32_MAX), m_proto(PcapPkt::PROTO_UDP), m_pktCount(0), m_flushCount(0) {}
+	void addPkt(const PcapPkt& pkt);
+	void flush(ofstream *outputFile);
+	void addFromMemory(uint8_t *mem, size_t *len);
+	static uint32_t getIDFromMem(uint8_t *mem);
+	bool hasFlushablePackets() const {return !!m_flushCount;}
+	Timestamp getTimeout() const;
+	uint32_t getID() const {return m_id;}
+	void removeAllPackets();
+	void setID(const uint32_t id) {m_id = id;}
+private:
+	void writeHeader(ofstream *outputFile) const;
+	void writePackets(ofstream *outputFile) const;
+	void clearPackets();
+
+	uint32_t m_id;
+	PcapPkt::L4Proto m_proto;
+	vector<PcapPkt *> m_pkts;
+	uint32_t m_pktCount;
+	uint32_t m_flushCount;
+};
+
+#endif /* _STREAM3_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/streamextract.cpp b/VNFs/DPPD-PROX/tools/flow_extract/streamextract.cpp
new file mode 100644
index 00000000..e493ef3f
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/streamextract.cpp
@@ -0,0 +1,406 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <inttypes.h>
+#include <string>
+#include <cstdio>
+#include <iostream>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sstream>
+#include <set>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <cerrno>
+#include <cstdlib>
+#include <map>
+
+#include "path.hpp"
+#include "bundle.hpp"
+#include "stream.hpp"
+#include "stream2.hpp"
+#include "allocator.hpp"
+#include "timestamp.hpp"
+#include "streamextract.hpp"
+#include "pcapreader.hpp"
+#include "pcapwriter.hpp"
+#include "flowtable.hpp"
+#include "stream3.hpp"
+#include "netsocket.hpp"
+#include "pcappktref.hpp"
+#include "progress.hpp"
+#include "mappedfile.hpp"
+#include "streamsorter.hpp"
+
+using namespace std;
+
+static bool is_dir(const string& path_dir_out)
+{
+	struct stat s = { 0 };
+
+	if (stat(path_dir_out.c_str(), &s)) {
+		return false;
+	}
+
+	return s.st_mode & S_IFDIR;
+}
+
+StreamExtract::StreamExtract(const ProgramConfig &cfg)
+	: ft2(cfg.flowTableSize),
+	  streamSorter(cfg.flowTableSize, cfg.path_dir_out, 1024UL*1024*1024*8),
+	  cfg(cfg)
+{
+}
+
+vector<Bundle> StreamExtract::createBundles(const string& streamPath)
+{
+	map<uint32_t, Bundle>::iterator iterBundle;
+	map<uint32_t, Bundle> bundles;
+	set<uint32_t> servers;
+
+	Stream2 s;
+	ifstream binIn;
+
+	binIn.open(streamPath.c_str());
+	binIn.seekg(0, binIn.end);
+	Progress progress(binIn.tellg());
+	binIn.seekg(0, binIn.beg);
+
+	while (!s.fromFile(&binIn)) {
+		if (progress.couldRefresh()) {
+			progress.setProgress(binIn.tellg());
+			progress.refresh();
+		}
+		if (!s.streamHdr.completedTCP)
+			continue;
+		if (!s.streamHdr.serverHdrLen)
+			continue;
+		/* The current implementation does not support clients
+		   that are also servers. */
+		servers.insert(s.streamHdr.serverIP);
+		if (servers.find(s.streamHdr.clientIP) != servers.end())
+			continue;
+
+		/* Since each application is represented as a path
+		   graph (there is only one reply for a given request
+		   and only one request after a given reply), each
+		   application must run on a unique server. For this
+		   reason, check if the socket on the server already
+		   is occupied and if so, keep incrementing the socket
+		   until the collision is resolved. */
+		iterBundle = bundles.find(s.streamHdr.clientIP);
+
+		if (iterBundle == bundles.end()) {
+			bundles.insert(make_pair(s.streamHdr.clientIP, Bundle()));
+			iterBundle = bundles.find(s.streamHdr.clientIP);
+		}
+
+		(*iterBundle).second.addStream(s.streamHdr.streamId, s.getServerNetSocket().port);
+	}
+
+	progress.setProgress();
+	progress.refresh(true);
+
+	binIn.close();
+
+	vector<Bundle> ret;
+
+	ret.reserve(bundles.size());
+
+	for (map<uint32_t, Bundle>::const_iterator i = bundles.begin(); i != bundles.end(); ++i)
+		ret.push_back(i->second);
+
+	return ret;
+}
+
+set<uint32_t> StreamExtract::getBundleStreamIDs(const vector<Bundle*>& bundleSamples)
+{
+	set<uint32_t> streamIDs;
+
+	for (size_t i = 0; i < bundleSamples.size(); ++i) {
+		const vector<uint32_t> &bundleStreamIDs = bundleSamples[i]->getStream();
+
+		for (vector<uint32_t>::const_iterator j = bundleStreamIDs.begin(); j != bundleStreamIDs.end(); ++j) {
+			streamIDs.insert(*j);
+		}
+	}
+
+	return streamIDs;
+}
+
+static size_t getRandom(size_t limit)
+{
+	size_t r = rand();
+	size_t rand_limit = (RAND_MAX/limit)*limit;
+
+	while (r > rand_limit)
+		r = rand();
+
+	return r % limit;
+}
+
+static void removeFill(vector<Bundle*> *from, size_t idx)
+{
+	Bundle *last = from->back();
+	from->pop_back();
+
+	if (idx != from->size())
+		(*from)[idx] = last;
+}
+
+static vector<Bundle*> takeSamples(vector<Bundle>& bundles, size_t sampleCount)
+{
+	vector<Bundle*> bundleSamples;
+
+	bundleSamples.reserve(bundles.size());
+
+	cout << "Sampling " << sampleCount << " bundles out of " << bundles.size() << endl;
+	for (size_t i = 0; i < bundles.size(); ++i)
+		bundleSamples.push_back(&bundles[i]);
+
+	srand(1000);
+	while (bundleSamples.size() > sampleCount) {
+		size_t r = getRandom(bundleSamples.size());
+		removeFill(&bundleSamples, r);
+	}
+	return bundleSamples;
+}
+
+static size_t replaceWithRunningTotals(vector<size_t> *streamLength)
+{
+	size_t runningTotal = 0;
+	for (size_t i = 0; i < streamLength->size(); ++i) {
+		size_t len = (*streamLength)[i] + sizeof(uint32_t);
+		(*streamLength)[i] = runningTotal;
+		runningTotal += len;
+	}
+	return runningTotal;
+}
+
+static void printPorts(const vector<Bundle> &bundles)
+{
+	set<uint32_t> streamIDs;
+
+	for (size_t i = 0; i < bundles.size(); ++i) {
+		const vector<uint32_t> &ports = bundles[i].getPorts();
+
+		for (size_t j = 0; j < ports.size(); ++j) {
+			if (j + 1 == ports.size())
+				cout << ports[j] << ",END" << endl;
+			else
+				cout << ports[j] << "," << ports[j +1] << endl;
+		}
+	}
+}
+
+string StreamExtract::createStreamPcapFileName(int id)
+{
+	stringstream ss;
+
+	ss << cfg.path_dir_out << "/s" << id << ".pcap";
+
+	return ss.str();
+}
+
+int StreamExtract::writeToPcaps(const string &sourceFilePath, const set<uint32_t> &streamIDs)
+{
+	set<uint32_t>::const_iterator i = streamIDs.begin();
+
+	MappedFile mappedFile;
+	if (mappedFile.open(sourceFilePath)) {
+		cerr << "Failed to open file " << sourceFilePath << ":" << strerror(errno) << endl;
+		return -1;
+	}
+
+	PcapPkt::allocator = NULL;
+
+	Progress progress((uint64_t)mappedFile.getMapEnd() - (uint64_t)mappedFile.getMapBeg());
+	cout << "Writing  " << streamIDs.size() << " streams to pcaps" << endl;
+	uint8_t *data2 = mappedFile.getMapBeg();
+	while (data2 < mappedFile.getMapEnd()) {
+		uint32_t id = *reinterpret_cast<uint32_t *>(data2);
+
+		data2 += sizeof(id);
+		uint32_t pktCount = *reinterpret_cast<uint32_t *>(data2);
+		data2 += sizeof(pktCount);
+		Stream s(id, pktCount);
+		while (pktCount--) {
+			PcapPkt p(data2);
+
+			data2 += p.memSize();
+			s.addPkt(p);
+		}
+
+		while (i != streamIDs.end() && (*i) < id)
+			i++;
+		if (i == streamIDs.end())
+			break;
+		if (*i > id)
+			continue;
+
+		const string pcapPath = createStreamPcapFileName(id);
+
+		s.toPcap(pcapPath);
+		if (progress.couldRefresh()) {
+			progress.setProgress((uint64_t)data2 - (uint64_t)mappedFile.getMapBeg());
+			progress.refresh();
+			mappedFile.sync();
+		}
+	}
+
+	progress.setProgress(data2 - mappedFile.getMapBeg());
+	progress.refresh(true);
+
+	mappedFile.close();
+	return 0;
+}
+
+int StreamExtract::writeToLua(const string& binFilePath, const Path &smallFinalBin, const string& luaFilePath, const string &orderedTemp)
+{
+	vector<Bundle> bundles = createBundles(binFilePath);
+	vector<Bundle*> bundleSamples = takeSamples(bundles, cfg.sampleCount);
+	set<uint32_t> streamIDs = getBundleStreamIDs(bundleSamples);
+
+	if (cfg.write_pcaps)
+		writeToPcaps(orderedTemp, streamIDs);
+
+	ofstream outLua;
+	ofstream outSmallBin;
+	outLua.open(luaFilePath.c_str());
+	outLua << "bf = \""<< smallFinalBin.getFileName() << "\"" << endl;
+	outLua << "s = {}\n";
+	set<uint32_t>::iterator i = streamIDs.begin();
+
+	set<NetSocket> serverSockets;
+	ifstream binIn;
+	Stream2 s;
+
+	outSmallBin.open(smallFinalBin.str().c_str());
+	binIn.open(binFilePath.c_str());
+	while (!s.fromFile(&binIn)) {
+		while (i != streamIDs.end() && (*i) < s.streamHdr.streamId)
+			i++;
+		if (i == streamIDs.end())
+			break;
+		if (*i > s.streamHdr.streamId)
+			continue;
+		s.calcOffsets(&outSmallBin);
+		s.toFile(&outSmallBin);
+		while (serverSockets.find(s.getServerNetSocket()) != serverSockets.end()) {
+			NetSocket ns = s.getServerNetSocket();
+
+			ns.port++;
+			s.setServerNetSocket(ns);
+		}
+		serverSockets.insert(s.getServerNetSocket());
+
+		s.toLua(&outLua, "bf", "s");
+	}
+	binIn.close();
+
+	uint32_t bundleCount = 0;
+
+	outLua << "bundles = {}" << endl;
+	for (size_t i = 0; i < bundleSamples.size(); ++i) {
+		bundleSamples[i]->toLua(&outLua, "s", ++bundleCount);
+	}
+	outLua << "return bundles" << endl;
+	outLua.close();
+	return 0;
+}
+
+int StreamExtract::writeFinalBin(const string& sourceFilePath, const string& destFilePath)
+{
+	MappedFile mappedFile;
+	if (mappedFile.open(sourceFilePath)) {
+		cerr << "Failed to open file " << sourceFilePath << ":" << strerror(errno) << endl;
+		return -1;
+	}
+	ofstream binOut;
+
+	binOut.open(destFilePath.c_str());
+	PcapPkt::allocator = NULL;
+
+	Progress progress((uint64_t)mappedFile.getMapEnd() - (uint64_t)mappedFile.getMapBeg());
+
+	int streamCount = 0;
+	uint8_t *data2 = mappedFile.getMapBeg();
+	while (data2 < mappedFile.getMapEnd()) {
+	        uint32_t id = *reinterpret_cast<uint32_t *>(data2);
+
+		data2 += sizeof(id);
+		uint32_t pktCount = *reinterpret_cast<uint32_t *>(data2);
+		data2 += sizeof(pktCount);
+		Stream s(id, pktCount);
+		while (pktCount--) {
+        		PcapPkt p(data2);
+
+			data2 += p.memSize();
+			s.addPkt(p);
+		}
+		s.toFile(&binOut);
+		streamCount++;
+		if (progress.couldRefresh()) {
+			progress.setProgress((uint64_t)data2 - (uint64_t)mappedFile.getMapBeg());
+			progress.refresh();
+			mappedFile.sync();
+		}
+	}
+
+	progress.setProgress(data2 - mappedFile.getMapBeg());
+	progress.refresh(true);
+
+	binOut.close();
+	mappedFile.close();
+	return 0;
+}
+
+int StreamExtract::run()
+{
+	Path p(cfg.path_dir_out);
+	p.mkdir();
+
+	string orderedTemp = p.add("/a").str();
+
+	string finalBin = p.add("/b").str();
+	Path smallfinalBin = p.add("/data.bin").str();
+	string luaFile = p.add("/cfg.lua").str();
+
+	cout << "Writing to directory '" << p.str() << "'" << endl;
+	cout << "Ordered streams '" << orderedTemp << "'" << endl;
+	cout << "Final binary output '" << finalBin << "'" << endl;
+	cout << "lua file '" << luaFile << "' will contain " << cfg.sampleCount << " bundles" << endl;
+
+	if (cfg.run_first_step) {
+		cout << "starting sorting" << endl;
+		streamSorter.sort(cfg.path_file_in_pcap, orderedTemp);
+		cout << "writing final binary file (converting format)" << endl;
+		if (writeFinalBin(orderedTemp, finalBin))
+			return -1;
+	} else {
+		cout << "Skipping first step" << endl;
+		if (!Path(finalBin).isFile()) {
+			cerr << "File is missing:" << finalBin << endl;
+			return -1;
+		}
+	}
+	cout << "writing Lua '" << luaFile << "'" << endl;
+	if (writeToLua(finalBin, smallfinalBin, luaFile, orderedTemp))
+		return -1;
+	return 0;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/streamextract.hpp b/VNFs/DPPD-PROX/tools/flow_extract/streamextract.hpp
new file mode 100644
index 00000000..d5dbdb05
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/streamextract.hpp
@@ -0,0 +1,55 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STREAMEXTRACT_H_
+#define _STREAMEXTRACT_H_
+
+#include <string>
+#include <list>
+#include <map>
+#include <set>
+
+#include "programconfig.hpp"
+#include "bundle.hpp"
+#include "pcapreader.hpp"
+#include "flowtable.hpp"
+#include "pcappkt.hpp"
+#include "stream3.hpp"
+#include "streamsorter.hpp"
+#include "path.hpp"
+
+using namespace std;
+
+class StreamExtract {
+public:
+	/* The size of the flow table determines the number of flows
+	   that can be active at a given time. When a flow expires, it
+	   is written out to a file and the memory is freed. */
+	StreamExtract(const ProgramConfig &cfg);
+	int run();
+private:
+	int writeToPcaps(const string &sourceFilePath, const set<uint32_t> &streamIDs);
+	int writeToLua(const string& binFilePath, const Path &smallFinalBin, const string& luaFilePath, const string& orderedTemp);
+	int writeFinalBin(const string& sourceFilePath, const string& destFilePath);
+	string createStreamPcapFileName(int id);
+	vector<Bundle> createBundles(const string& streamPath);
+	set<uint32_t> getBundleStreamIDs(const vector<Bundle*>& bundleSamples);
+	FlowTable<pkt_tuple, Stream3> ft2;
+	StreamSorter streamSorter;
+	ProgramConfig cfg;
+};
+
+#endif /* _STREAMEXTRACT_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/streamsorter.cpp b/VNFs/DPPD-PROX/tools/flow_extract/streamsorter.cpp
new file mode 100644
index 00000000..65c645e1
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/streamsorter.cpp
@@ -0,0 +1,203 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+
+#include "mappedfile.hpp"
+#include "memreader.hpp"
+#include "streamsorter.hpp"
+#include "path.hpp"
+#include "allocator.hpp"
+#include "pcapreader.hpp"
+#include "progress.hpp"
+
+StreamSorter::StreamSorter(size_t flowTableSize, const string& workingDirectory, size_t memoryLimit)
+	: flowTableSize(flowTableSize),
+	  workingDirectory(workingDirectory),
+	  allocator(memoryLimit, 1024*10),
+	  streamID(0)
+{
+}
+
+void StreamSorter::sort(const string &inputPcapFilePath, const string &outputBinFilePath)
+{
+	setTempFileName();
+	sortChunks(inputPcapFilePath);
+	mergeChunks(outputBinFilePath);
+}
+
+void StreamSorter::sortChunks(const string &inputPcapFilePath)
+{
+	ofstream outputTempFile;
+
+	outputTempFile.open(tempFilePath.c_str());
+
+	if (!outputTempFile.is_open())
+		return ;
+
+	PcapReader pr;
+	PcapPkt pkt;
+
+	if (pr.open(inputPcapFilePath)) {
+		pr.getError();
+		return;
+	}
+	PcapPkt::allocator = &allocator;
+
+	Progress progress(pr.end());
+	uint32_t packetDetail = progress.addDetail("packet count");
+
+	ft = new FlowTable<pkt_tuple, uint32_t>(flowTableSize);
+	resetStreams();
+
+	while (pr.read(&pkt)) {
+		processPkt(pkt);
+		if (progress.couldRefresh()) {
+			progress.setProgress(pr.pos());
+			progress.setDetail(packetDetail, pr.getPktReadCount());
+			progress.refresh();
+		}
+		if (allocator.lowThresholdReached()) {
+			flushStreams(&outputTempFile);
+		}
+	}
+	progress.setProgress();
+	progress.setDetail(packetDetail, pr.getPktReadCount());
+	progress.refresh(true);
+
+	pr.close();
+	flushStreams(&outputTempFile);
+	PcapPkt::allocator = NULL;
+	outputTempFile.close();
+	delete ft;
+}
+
+void StreamSorter::resetStreams()
+{
+	streams.clear();
+}
+
+void StreamSorter::flushStreams(ofstream *outputTempFile)
+{
+	size_t flushCount = 0;
+	size_t offset = outputTempFile->tellp();
+
+	Progress progress(streams.size());
+
+	cout << endl;
+	progress.setTitle("flush ");
+	for (size_t i = 0; i < streams.size(); ++i) {
+		if (streams[i].hasFlushablePackets()) {
+			streams[i].flush(outputTempFile);
+			flushCount++;
+		}
+
+		if (progress.couldRefresh()) {
+			progress.setProgress(i);
+			progress.refresh();
+		}
+	}
+	progress.setProgress();
+	progress.refresh(true);
+
+	if (flushCount)
+		flushOffsets.push_back(offset);
+	allocator.reset();
+}
+
+Stream3 *StreamSorter::addNewStream(PcapPkt::L4Proto proto)
+{
+	streams.push_back(Stream3(streamID++, proto));
+	return &streams.back();
+}
+
+FlowTable<pkt_tuple, uint32_t>::entry* StreamSorter::getFlowEntry(const PcapPkt &pkt)
+{
+	FlowTable<pkt_tuple, uint32_t>::entry *a;
+	struct pkt_tuple pt = pkt.parsePkt();
+	Stream3 *stream = NULL;
+
+	a = ft->lookup(pt.flip());
+	if (!a) {
+		a = ft->lookup(pt);
+		if (!a) {
+			stream = addNewStream(pkt.getProto());
+
+			a = ft->insert(pt, stream->getID(), pkt.ts());
+		}
+	}
+
+	if (a->expired(pkt.ts(), streams[a->value].getTimeout())) {
+		ft->remove(a);
+
+		stream = addNewStream(pkt.getProto());
+
+		a = ft->insert(pt, stream->getID(), pkt.ts());
+	}
+	return a;
+}
+
+void StreamSorter::processPkt(const PcapPkt &pkt)
+{
+	FlowTable<pkt_tuple, uint32_t>::entry *a;
+
+	a = getFlowEntry(pkt);
+	a->tv = pkt.ts();
+	streams[a->value].addPkt(pkt);
+}
+
+void StreamSorter::mergeChunks(const string &outputBinFile)
+{
+	cout << "merging chunks: " << tempFilePath << " to " << outputBinFile << endl;
+	cout << "have " << flushOffsets.size() << " parts to merge" << endl;
+	MappedFile tempFile;
+
+	if (tempFile.open(tempFilePath)) {
+		cerr << "failed to open temp file" << endl;
+		return;
+	}
+	ofstream file;
+
+	file.open(outputBinFile.c_str());
+
+	if (!file.is_open()) {
+		cerr << "failed top open file '" << outputBinFile << "'" << endl;
+		return;
+	}
+	MemReader memReader(&tempFile, flushOffsets);
+	Stream3 stream;
+
+	Progress progress(memReader.getTotalLength());
+
+	while (memReader.read(&stream)) {
+		stream.flush(&file);
+		if (progress.couldRefresh()) {
+			progress.setProgress(memReader.consumed());
+			progress.refresh();
+		}
+	}
+
+	progress.setProgress();
+	progress.refresh(true);
+	tempFile.close();
+}
+
+void StreamSorter::setTempFileName()
+{
+	tempFilePath = Path(workingDirectory).add("/tmp").str();
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/streamsorter.hpp b/VNFs/DPPD-PROX/tools/flow_extract/streamsorter.hpp
new file mode 100644
index 00000000..a6d3d6cd
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/streamsorter.hpp
@@ -0,0 +1,47 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _STREAMSORTER_H_
+#define _STREAMSORTER_H_
+
+#include "stream3.hpp"
+#include "flowtable.hpp"
+#include "allocator.hpp"
+
+class StreamSorter {
+public:
+	StreamSorter(size_t flowTableSize, const string& workingDirectory, size_t memoryLimit);
+	void sort(const string &inputPcapFile, const string &outputBinFile);
+private:
+	void sortChunks(const string &inputPcapFilePath);
+	void mergeChunks(const string &outputBinFilePath);
+	void setTempFileName();
+	void processPkt(const PcapPkt &pkt);
+	void resetStreams();
+	FlowTable<pkt_tuple, uint32_t>::entry* getFlowEntry(const PcapPkt &pkt);
+	void flushStreams(ofstream *outputTempFile);
+	Stream3 *addNewStream(PcapPkt::L4Proto proto);
+	size_t flowTableSize;
+	FlowTable<pkt_tuple, uint32_t> *ft;
+	vector<size_t> flushOffsets;
+	vector<Stream3> streams;
+	string tempFilePath;
+	const string workingDirectory;
+	Allocator allocator;
+	uint32_t streamID;
+};
+
+#endif /* _STREAMSORTER_H_ */
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/timestamp.cpp b/VNFs/DPPD-PROX/tools/flow_extract/timestamp.cpp
new file mode 100644
index 00000000..9e91173d
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/timestamp.cpp
@@ -0,0 +1,65 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <cstdio>
+#include <iostream>
+#include <iomanip>
+
+#include "timestamp.hpp"
+
+Timestamp Timestamp::operator-(const Timestamp& other) const
+{
+	uint64_t sec;
+	uint64_t nsec;
+
+	if (other.m_nsec <= m_nsec) {
+		nsec = m_nsec - other.m_nsec;
+		sec = m_sec - other.m_sec;
+	} else {
+		nsec = (1000000000 + m_nsec) - other.m_nsec;
+		sec = m_sec - 1 - other.m_sec;
+	}
+
+	return Timestamp(sec, nsec);
+}
+
+bool Timestamp::operator>(const Timestamp& other)
+{
+	return m_sec > other.m_sec ||
+		(m_sec == other.m_sec && m_nsec > other.m_nsec);
+}
+
+bool Timestamp::operator<(const Timestamp& other)
+{
+	return m_sec < other.m_sec ||
+		(m_sec == other.m_sec && m_nsec < other.m_nsec);
+}
+
+ostream& operator<<(ostream& stream, const Timestamp& ts)
+{
+	stream << ts.m_sec << "." << setw(9) << setfill('0') << ts.m_nsec;
+	return stream;
+}
+
+double operator/(double d, const Timestamp &denominator)
+{
+	return d * 1000000000 / (denominator.m_sec * 1000000000 + denominator.m_nsec);
+}
+
+bool Timestamp::operator==(const Timestamp &other) const
+{
+	return m_sec == other.m_sec && m_nsec == other.m_nsec;
+}
diff --git a/VNFs/DPPD-PROX/tools/flow_extract/timestamp.hpp b/VNFs/DPPD-PROX/tools/flow_extract/timestamp.hpp
new file mode 100644
index 00000000..cf8ec5d4
--- /dev/null
+++ b/VNFs/DPPD-PROX/tools/flow_extract/timestamp.hpp
@@ -0,0 +1,45 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _TIMESTAMP_H_
+#define _TIMESTAMP_H_
+
+#include <iostream>
+
+#include <sys/time.h>
+#include <inttypes.h>
+
+using namespace std;
+
+class Timestamp {
+public:
+	Timestamp(const uint64_t sec, const uint64_t nsec) : m_sec(sec), m_nsec(nsec) {}
+	Timestamp() {}
+	Timestamp(const struct timeval& tv) : m_sec(tv.tv_sec), m_nsec(tv.tv_usec) {}
+	Timestamp operator-(const Timestamp& other) const;
+	bool operator==(const Timestamp &other) const;
+	friend double operator/(double d, const Timestamp &denominator);
+	bool operator>(const Timestamp& other);
+	bool operator<(const Timestamp& other);
+	uint64_t sec() const {return m_sec;}
+	uint64_t nsec() const {return m_nsec;}
+	friend ostream& operator<<(ostream& stream, const Timestamp& ts);
+private:
+	uint64_t m_sec;
+	uint64_t m_nsec;
+};
+
+#endif /* _TIMESTAMP_H_ */
diff --git a/VNFs/DPPD-PROX/tx_pkt.c b/VNFs/DPPD-PROX/tx_pkt.c
new file mode 100644
index 00000000..c6f6010c
--- /dev/null
+++ b/VNFs/DPPD-PROX/tx_pkt.c
@@ -0,0 +1,665 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include <rte_ethdev.h>
+#include <rte_version.h>
+
+#include "rx_pkt.h"
+#include "tx_pkt.h"
+#include "task_base.h"
+#include "stats.h"
+#include "prefetch.h"
+#include "prox_assert.h"
+#include "log.h"
+#include "mbuf_utils.h"
+
+static void buf_pkt_single(struct task_base *tbase, struct rte_mbuf *mbuf, const uint8_t out)
+{
+	const uint16_t prod = tbase->ws_mbuf->idx[out].prod++;
+	tbase->ws_mbuf->mbuf[out][prod & WS_MBUF_MASK] = mbuf;
+}
+
+static inline void buf_pkt_all(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		if (unlikely(out[j] >= OUT_HANDLED)) {
+			rte_pktmbuf_free(mbufs[j]);
+			if (out[j] == OUT_HANDLED)
+				TASK_STATS_ADD_DROP_HANDLED(&tbase->aux->stats, 1);
+			else
+				TASK_STATS_ADD_DROP_DISCARD(&tbase->aux->stats, 1);
+		}
+		else {
+			buf_pkt_single(tbase, mbufs[j], out[j]);
+		}
+	}
+}
+#define MAX_PMD_TX 32
+
+/* The following help functions also report stats. Therefore we need
+   to pass the task_base struct. */
+static inline int txhw_drop(const struct port_queue *port_queue, struct rte_mbuf **mbufs, uint16_t n_pkts, __attribute__((unused)) struct task_base *tbase)
+{
+	uint16_t ntx;
+	int ret;
+
+	/* TX vector mode can't transmit more than 32 packets */
+	if (n_pkts > MAX_PMD_TX) {
+		ntx = rte_eth_tx_burst(port_queue->port, port_queue->queue, mbufs, MAX_PMD_TX);
+		ntx += rte_eth_tx_burst(port_queue->port, port_queue->queue, mbufs + ntx, n_pkts - ntx);
+	} else {
+		ntx = rte_eth_tx_burst(port_queue->port, port_queue->queue, mbufs, n_pkts);
+	}
+
+	TASK_STATS_ADD_TX(&tbase->aux->stats, ntx);
+	ret =  n_pkts - ntx;
+	if (ntx < n_pkts) {
+		TASK_STATS_ADD_DROP_TX_FAIL(&tbase->aux->stats, n_pkts - ntx);
+		if (tbase->tx_pkt == tx_pkt_bw) {
+			uint32_t drop_bytes = 0;
+			do {
+				drop_bytes += mbuf_wire_size(mbufs[ntx]);
+				rte_pktmbuf_free(mbufs[ntx++]);
+			} while (ntx < n_pkts);
+			TASK_STATS_ADD_DROP_BYTES(&tbase->aux->stats, drop_bytes);
+		}
+		else {
+			do {
+				rte_pktmbuf_free(mbufs[ntx++]);
+			} while (ntx < n_pkts);
+		}
+	}
+	return ret;
+}
+
+static inline int txhw_no_drop(const struct port_queue *port_queue, struct rte_mbuf **mbufs, uint16_t n_pkts, __attribute__((unused)) struct task_base *tbase)
+{
+	uint16_t ret;
+	uint16_t n = n_pkts;
+
+	TASK_STATS_ADD_TX(&tbase->aux->stats, n_pkts);
+
+	do {
+		ret = rte_eth_tx_burst(port_queue->port, port_queue->queue, mbufs, n_pkts);
+		mbufs += ret;
+		n_pkts -= ret;
+	}
+	while (n_pkts);
+	return (n != ret);
+}
+
+static inline int ring_enq_drop(struct rte_ring *ring, struct rte_mbuf *const *mbufs, uint16_t n_pkts, __attribute__((unused)) struct task_base *tbase)
+{
+	int ret = 0;
+	/* return 0 on succes, -ENOBUFS on failure */
+	// Rings can be single or multiproducer (ctrl rings are multi producer)
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+	if (unlikely(rte_ring_enqueue_bulk(ring, (void *const *)mbufs, n_pkts))) {
+#else
+	if (unlikely(rte_ring_enqueue_bulk(ring, (void *const *)mbufs, n_pkts, NULL) == 0)) {
+#endif
+		ret = n_pkts;
+		if (tbase->tx_pkt == tx_pkt_bw) {
+			uint32_t drop_bytes = 0;
+			for (uint16_t i = 0; i < n_pkts; ++i) {
+				drop_bytes += mbuf_wire_size(mbufs[i]);
+				rte_pktmbuf_free(mbufs[i]);
+			}
+			TASK_STATS_ADD_DROP_BYTES(&tbase->aux->stats, drop_bytes);
+			TASK_STATS_ADD_DROP_TX_FAIL(&tbase->aux->stats, n_pkts);
+		}
+		else {
+			for (uint16_t i = 0; i < n_pkts; ++i)
+				rte_pktmbuf_free(mbufs[i]);
+			TASK_STATS_ADD_DROP_TX_FAIL(&tbase->aux->stats, n_pkts);
+		}
+	}
+	else {
+		TASK_STATS_ADD_TX(&tbase->aux->stats, n_pkts);
+	}
+	return ret;
+}
+
+static inline int ring_enq_no_drop(struct rte_ring *ring, struct rte_mbuf *const *mbufs, uint16_t n_pkts, __attribute__((unused)) struct task_base *tbase)
+{
+	int i = 0;
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+	while (rte_ring_enqueue_bulk(ring, (void *const *)mbufs, n_pkts)) {
+#else
+	while (rte_ring_enqueue_bulk(ring, (void *const *)mbufs, n_pkts, NULL) == 0) {
+#endif
+		i++;
+	};
+	TASK_STATS_ADD_TX(&tbase->aux->stats, n_pkts);
+	return (i != 0);
+}
+
+void flush_queues_hw(struct task_base *tbase)
+{
+	uint16_t prod, cons;
+
+	for (uint8_t i = 0; i < tbase->tx_params_hw.nb_txports; ++i) {
+		prod = tbase->ws_mbuf->idx[i].prod;
+		cons = tbase->ws_mbuf->idx[i].cons;
+
+		if (prod != cons) {
+			tbase->ws_mbuf->idx[i].prod = 0;
+			tbase->ws_mbuf->idx[i].cons = 0;
+			txhw_drop(&tbase->tx_params_hw.tx_port_queue[i], tbase->ws_mbuf->mbuf[i] + (cons & WS_MBUF_MASK), prod - cons, tbase);
+		}
+	}
+
+	tbase->flags &= ~FLAG_TX_FLUSH;
+}
+
+void flush_queues_sw(struct task_base *tbase)
+{
+	uint16_t prod, cons;
+
+	for (uint8_t i = 0; i < tbase->tx_params_sw.nb_txrings; ++i) {
+		prod = tbase->ws_mbuf->idx[i].prod;
+		cons = tbase->ws_mbuf->idx[i].cons;
+
+		if (prod != cons) {
+			tbase->ws_mbuf->idx[i].prod = 0;
+			tbase->ws_mbuf->idx[i].cons = 0;
+			ring_enq_drop(tbase->tx_params_sw.tx_rings[i], tbase->ws_mbuf->mbuf[i] + (cons & WS_MBUF_MASK), prod - cons, tbase);
+		}
+	}
+	tbase->flags &= ~FLAG_TX_FLUSH;
+}
+
+void flush_queues_no_drop_hw(struct task_base *tbase)
+{
+	uint16_t prod, cons;
+
+	for (uint8_t i = 0; i < tbase->tx_params_hw.nb_txports; ++i) {
+		prod = tbase->ws_mbuf->idx[i].prod;
+		cons = tbase->ws_mbuf->idx[i].cons;
+
+		if (prod != cons) {
+			tbase->ws_mbuf->idx[i].prod = 0;
+			tbase->ws_mbuf->idx[i].cons = 0;
+			txhw_no_drop(&tbase->tx_params_hw.tx_port_queue[i], tbase->ws_mbuf->mbuf[i] + (cons & WS_MBUF_MASK), prod - cons, tbase);
+		}
+	}
+
+	tbase->flags &= ~FLAG_TX_FLUSH;
+}
+
+void flush_queues_no_drop_sw(struct task_base *tbase)
+{
+	uint16_t prod, cons;
+
+	for (uint8_t i = 0; i < tbase->tx_params_sw.nb_txrings; ++i) {
+		prod = tbase->ws_mbuf->idx[i].prod;
+		cons = tbase->ws_mbuf->idx[i].cons;
+
+		if (prod != cons) {
+			tbase->ws_mbuf->idx[i].prod = 0;
+			tbase->ws_mbuf->idx[i].cons = 0;
+			ring_enq_no_drop(tbase->tx_params_sw.tx_rings[i], tbase->ws_mbuf->mbuf[i] + (cons & WS_MBUF_MASK), prod - cons, tbase);
+		}
+	}
+	tbase->flags &= ~FLAG_TX_FLUSH;
+}
+
+/* "try" functions try to send packets to sw/hw w/o failing or blocking;
+   They return if ring/queue is full and are used by aggregators.
+   "try" functions do not have drop/no drop flavors
+   They are only implemented in never_discard mode (as by default they
+   use only one outgoing ring. */
+uint16_t tx_try_self(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	if (n_pkts < 64) {
+		tx_pkt_never_discard_self(tbase, mbufs, n_pkts, NULL);
+		return n_pkts;
+	} else {
+		tx_pkt_never_discard_self(tbase, mbufs, 64, NULL);
+		return 64;
+	}
+}
+
+uint16_t tx_try_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	const int bulk_size = 64;
+	uint16_t ret = bulk_size, sent = 0, n_bulks;
+	n_bulks = n_pkts >> __builtin_ctz(bulk_size);
+
+	for (int i = 0; i < n_bulks; i++) {
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+		ret = rte_ring_enqueue_burst(tbase->tx_params_sw.tx_rings[0], (void *const *)mbufs, bulk_size);
+#else
+		ret = rte_ring_enqueue_burst(tbase->tx_params_sw.tx_rings[0], (void *const *)mbufs, bulk_size, NULL);
+#endif
+		mbufs += ret;
+		sent += ret;
+		if (ret != bulk_size)
+			break;
+	}
+	if ((ret == bulk_size) && (n_pkts & (bulk_size - 1))) {
+#if RTE_VERSION < RTE_VERSION_NUM(17,5,0,1)
+		ret = rte_ring_enqueue_burst(tbase->tx_params_sw.tx_rings[0], (void *const *)mbufs, (n_pkts & (bulk_size - 1)));
+#else
+		ret = rte_ring_enqueue_burst(tbase->tx_params_sw.tx_rings[0], (void *const *)mbufs, (n_pkts & (bulk_size - 1)), NULL);
+#endif
+		mbufs += ret;
+		sent += ret;
+	}
+	TASK_STATS_ADD_TX(&tbase->aux->stats, sent);
+	return sent;
+}
+
+uint16_t tx_try_hw1(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
+{
+	const struct port_queue *port_queue = &tbase->tx_params_hw.tx_port_queue[0];
+	const int bulk_size = 64;
+	uint16_t ret = bulk_size, n_bulks, sent = 0;
+	n_bulks = n_pkts >>  __builtin_ctz(bulk_size);
+
+	for (int i = 0; i < n_bulks; i++) {
+		ret = rte_eth_tx_burst(port_queue->port, port_queue->queue, mbufs, bulk_size);
+		mbufs += ret;
+		sent += ret;
+		if (ret != bulk_size)
+			break;
+	}
+	if ((ret == bulk_size) && (n_pkts & (bulk_size - 1))) {
+		ret = rte_eth_tx_burst(port_queue->port, port_queue->queue, mbufs, (n_pkts & (bulk_size - 1)));
+		mbufs += ret;
+		sent += ret;
+	}
+	TASK_STATS_ADD_TX(&tbase->aux->stats, sent);
+	return sent;
+}
+
+int tx_pkt_no_drop_never_discard_hw1_lat_opt(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, __attribute__((unused)) uint8_t *out)
+{
+	return txhw_no_drop(&tbase->tx_params_hw.tx_port_queue[0], mbufs, n_pkts, tbase);
+}
+
+int tx_pkt_no_drop_never_discard_hw1_thrpt_opt(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, __attribute__((unused)) uint8_t *out)
+{
+	static uint8_t fake_out[MAX_PKT_BURST] = {0};
+	int ret = 0;
+	if (n_pkts == MAX_PKT_BURST) {
+		// First xmit what was queued
+        	uint16_t prod, cons;
+
+               	prod = tbase->ws_mbuf->idx[0].prod;
+               	cons = tbase->ws_mbuf->idx[0].cons;
+
+		if ((uint16_t)(prod - cons)){
+                	tbase->flags &= ~FLAG_TX_FLUSH;
+                	tbase->ws_mbuf->idx[0].prod = 0;
+                	tbase->ws_mbuf->idx[0].cons = 0;
+                	ret+= txhw_no_drop(&tbase->tx_params_hw.tx_port_queue[0], tbase->ws_mbuf->mbuf[0] + (cons & WS_MBUF_MASK), (uint16_t)(prod - cons), tbase);
+		}
+		ret+= txhw_no_drop(&tbase->tx_params_hw.tx_port_queue[0], mbufs, n_pkts, tbase);
+	} else {
+		ret+= tx_pkt_no_drop_hw(tbase, mbufs, n_pkts, fake_out);
+	}
+	return ret;
+}
+
+int tx_pkt_never_discard_hw1_lat_opt(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, __attribute__((unused)) uint8_t *out)
+{
+	return txhw_drop(&tbase->tx_params_hw.tx_port_queue[0], mbufs, n_pkts, tbase);
+}
+
+int tx_pkt_never_discard_hw1_thrpt_opt(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, __attribute__((unused)) uint8_t *out)
+{
+	static uint8_t fake_out[MAX_PKT_BURST] = {0};
+	int ret = 0;
+	if (n_pkts == MAX_PKT_BURST) {
+		// First xmit what was queued
+        	uint16_t prod, cons;
+
+               	prod = tbase->ws_mbuf->idx[0].prod;
+               	cons = tbase->ws_mbuf->idx[0].cons;
+
+		if ((uint16_t)(prod - cons)){
+                	tbase->flags &= ~FLAG_TX_FLUSH;
+                	tbase->ws_mbuf->idx[0].prod = 0;
+                	tbase->ws_mbuf->idx[0].cons = 0;
+                	ret+= txhw_drop(&tbase->tx_params_hw.tx_port_queue[0], tbase->ws_mbuf->mbuf[0] + (cons & WS_MBUF_MASK), (uint16_t)(prod - cons), tbase);
+		}
+		ret+= txhw_drop(&tbase->tx_params_hw.tx_port_queue[0], mbufs, n_pkts, tbase);
+	} else {
+		ret+= tx_pkt_hw(tbase, mbufs, n_pkts, fake_out);
+	}
+	return ret;
+}
+
+/* Transmit to hw using tx_params_hw_sw structure
+   This function is used  to transmit to hw when tx_params_hw_sw should be used
+   i.e. when the task needs to transmit both to hw and sw */
+int tx_pkt_no_drop_never_discard_hw1_no_pointer(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, __attribute__((unused)) uint8_t *out)
+{
+	txhw_no_drop(&tbase->tx_params_hw_sw.tx_port_queue, mbufs, n_pkts, tbase);
+	return 0;
+}
+
+int tx_pkt_no_drop_never_discard_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, __attribute__((unused)) uint8_t *out)
+{
+	return ring_enq_no_drop(tbase->tx_params_sw.tx_rings[0], mbufs, n_pkts, tbase);
+}
+
+int tx_pkt_never_discard_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, __attribute__((unused)) uint8_t *out)
+{
+	return ring_enq_drop(tbase->tx_params_sw.tx_rings[0], mbufs, n_pkts, tbase);
+}
+
+static uint16_t tx_pkt_free_dropped(__attribute__((unused)) struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out)
+{
+	uint64_t v = 0;
+	uint16_t i;
+	/* The most probable and most important optimize case is if
+	   the no packets should be dropped. */
+	for (i = 0; i + 8 < n_pkts; i += 8) {
+		v |= *((uint64_t*)(&out[i]));
+	}
+	for (; i < n_pkts; ++i) {
+		v |= out[i];
+	}
+
+	if (unlikely(v)) {
+		/* At least some packets need to be dropped, so the
+		   mbufs array needs to be updated. */
+		uint16_t n_kept = 0;
+		uint16_t n_discard = 0;
+		for (uint16_t i = 0; i < n_pkts; ++i) {
+			if (unlikely(out[i] >= OUT_HANDLED)) {
+				rte_pktmbuf_free(mbufs[i]);
+				n_discard += out[i] == OUT_DISCARD;
+				continue;
+			}
+			mbufs[n_kept++] = mbufs[i];
+		}
+		TASK_STATS_ADD_DROP_DISCARD(&tbase->aux->stats, n_discard);
+		TASK_STATS_ADD_DROP_HANDLED(&tbase->aux->stats, n_pkts - n_kept - n_discard);
+		return n_kept;
+	}
+	return n_pkts;
+}
+
+int tx_pkt_no_drop_hw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out)
+{
+	const uint16_t n_kept = tx_pkt_free_dropped(tbase, mbufs, n_pkts, out);
+	int ret = 0;
+
+	if (likely(n_kept))
+		ret = txhw_no_drop(&tbase->tx_params_hw.tx_port_queue[0], mbufs, n_kept, tbase);
+	return ret;
+}
+
+int tx_pkt_no_drop_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out)
+{
+	const uint16_t n_kept = tx_pkt_free_dropped(tbase, mbufs, n_pkts, out);
+	int ret = 0;
+
+	if (likely(n_kept))
+		ret = ring_enq_no_drop(tbase->tx_params_sw.tx_rings[0], mbufs, n_kept, tbase);
+	return ret;
+}
+
+int tx_pkt_hw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out)
+{
+	const uint16_t n_kept = tx_pkt_free_dropped(tbase, mbufs, n_pkts, out);
+
+	if (likely(n_kept))
+		return txhw_drop(&tbase->tx_params_hw.tx_port_queue[0], mbufs, n_kept, tbase);
+	return n_pkts;
+}
+
+int tx_pkt_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out)
+{
+	const uint16_t n_kept = tx_pkt_free_dropped(tbase, mbufs, n_pkts, out);
+
+	if (likely(n_kept))
+		return ring_enq_drop(tbase->tx_params_sw.tx_rings[0], mbufs, n_kept, tbase);
+	return 0;
+}
+
+int tx_pkt_self(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out)
+{
+	const uint16_t n_kept = tx_pkt_free_dropped(tbase, mbufs, n_pkts, out);
+
+	TASK_STATS_ADD_TX(&tbase->aux->stats, n_kept);
+	tbase->ws_mbuf->idx[0].nb_rx = n_kept;
+	struct rte_mbuf **tx_mbuf = tbase->ws_mbuf->mbuf[0] + (tbase->ws_mbuf->idx[0].prod & WS_MBUF_MASK);
+	for (uint16_t i = 0; i < n_kept; ++i) {
+		tx_mbuf[i] = mbufs[i];
+	}
+	return 0;
+}
+
+int tx_pkt_never_discard_self(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, __attribute__((unused)) uint8_t *out)
+{
+	TASK_STATS_ADD_TX(&tbase->aux->stats, n_pkts);
+	tbase->ws_mbuf->idx[0].nb_rx = n_pkts;
+	struct rte_mbuf **tx_mbuf = tbase->ws_mbuf->mbuf[0] + (tbase->ws_mbuf->idx[0].prod & WS_MBUF_MASK);
+	for (uint16_t i = 0; i < n_pkts; ++i) {
+		tx_mbuf[i] = mbufs[i];
+	}
+	return 0;
+}
+
+int tx_pkt_no_drop_hw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	int ret = 0;
+	buf_pkt_all(tbase, mbufs, n_pkts, out);
+
+	const uint8_t nb_bufs = tbase->tx_params_hw.nb_txports;
+	uint16_t prod, cons;
+
+	for (uint8_t i = 0; i < nb_bufs; ++i) {
+		prod = tbase->ws_mbuf->idx[i].prod;
+		cons = tbase->ws_mbuf->idx[i].cons;
+
+		if (((uint16_t)(prod - cons)) >= MAX_PKT_BURST) {
+			tbase->flags &= ~FLAG_TX_FLUSH;
+			tbase->ws_mbuf->idx[i].cons = cons + MAX_PKT_BURST;
+			ret+= txhw_no_drop(&tbase->tx_params_hw.tx_port_queue[i], tbase->ws_mbuf->mbuf[i] + (cons & WS_MBUF_MASK), MAX_PKT_BURST, tbase);
+		}
+	}
+	return ret;
+}
+
+int tx_pkt_no_drop_sw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	int ret = 0;
+	buf_pkt_all(tbase, mbufs, n_pkts, out);
+
+	const uint8_t nb_bufs = tbase->tx_params_sw.nb_txrings;
+	uint16_t prod, cons;
+
+	for (uint8_t i = 0; i < nb_bufs; ++i) {
+		prod = tbase->ws_mbuf->idx[i].prod;
+		cons = tbase->ws_mbuf->idx[i].cons;
+
+		if (((uint16_t)(prod - cons)) >= MAX_PKT_BURST) {
+			tbase->flags &= ~FLAG_TX_FLUSH;
+			tbase->ws_mbuf->idx[i].cons = cons + MAX_PKT_BURST;
+			ret += ring_enq_no_drop(tbase->tx_params_sw.tx_rings[i], tbase->ws_mbuf->mbuf[i] + (cons & WS_MBUF_MASK), MAX_PKT_BURST, tbase);
+		}
+	}
+	return ret;
+}
+
+int tx_pkt_hw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	int ret = 0;
+	buf_pkt_all(tbase, mbufs, n_pkts, out);
+
+	const uint8_t nb_bufs = tbase->tx_params_hw.nb_txports;
+	uint16_t prod, cons;
+
+	for (uint8_t i = 0; i < nb_bufs; ++i) {
+		prod = tbase->ws_mbuf->idx[i].prod;
+		cons = tbase->ws_mbuf->idx[i].cons;
+
+		if (((uint16_t)(prod - cons)) >= MAX_PKT_BURST) {
+			tbase->flags &= ~FLAG_TX_FLUSH;
+			tbase->ws_mbuf->idx[i].cons = cons + MAX_PKT_BURST;
+			ret += txhw_drop(&tbase->tx_params_hw.tx_port_queue[i], tbase->ws_mbuf->mbuf[i] + (cons & WS_MBUF_MASK), MAX_PKT_BURST, tbase);
+		}
+	}
+	return ret;
+}
+
+int tx_pkt_sw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	int ret = 0;
+	buf_pkt_all(tbase, mbufs, n_pkts, out);
+
+	const uint8_t nb_bufs = tbase->tx_params_sw.nb_txrings;
+	uint16_t prod, cons;
+	for (uint8_t i = 0; i < nb_bufs; ++i) {
+		prod = tbase->ws_mbuf->idx[i].prod;
+		cons = tbase->ws_mbuf->idx[i].cons;
+
+		if (((uint16_t)(prod - cons)) >= MAX_PKT_BURST) {
+			tbase->flags &= ~FLAG_TX_FLUSH;
+			tbase->ws_mbuf->idx[i].cons = cons + MAX_PKT_BURST;
+			ret+= ring_enq_drop(tbase->tx_params_sw.tx_rings[i], tbase->ws_mbuf->mbuf[i] + (cons & WS_MBUF_MASK), MAX_PKT_BURST, tbase);
+		}
+	}
+	return ret;
+}
+
+int tx_pkt_trace(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	int ret = 0;
+	if (tbase->aux->task_rt_dump.cur_trace == 0) {
+		// No packet received since dumping...
+		// So the transmitted packets should not be linked to received packets
+		tbase->aux->task_rt_dump.n_print_tx = tbase->aux->task_rt_dump.n_trace;
+		tbase->aux->task_rt_dump.n_trace = 0;
+		task_base_del_rx_pkt_function(tbase, rx_pkt_trace);
+		return tx_pkt_dump(tbase, mbufs, n_pkts, out);
+	}
+	plog_info("Tracing %d pkts\n", tbase->aux->task_rt_dump.cur_trace);
+
+	for (uint32_t i = 0; i < tbase->aux->task_rt_dump.cur_trace; ++i) {
+		struct rte_mbuf tmp;
+		/* For each packet being transmitted, find which
+		   buffer represent the packet as it was before
+		   processing. */
+		uint32_t j = 0;
+		uint32_t len = sizeof(tbase->aux->task_rt_dump.pkt_mbuf_addr)/sizeof(tbase->aux->task_rt_dump.pkt_mbuf_addr[0]);
+		for (;j < len; ++j) {
+			if (tbase->aux->task_rt_dump.pkt_mbuf_addr[j] == mbufs[i])
+				break;
+		}
+		if (j == len) {
+			plog_info("Trace RX: missing!\n");
+		}
+		else {
+#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
+			tmp.data_off = 0;
+#endif
+			rte_pktmbuf_data_len(&tmp) = tbase->aux->task_rt_dump.pkt_cpy_len[j];
+			rte_pktmbuf_pkt_len(&tmp) = tbase->aux->task_rt_dump.pkt_cpy_len[j];
+			tmp.buf_addr = tbase->aux->task_rt_dump.pkt_cpy[j];
+			plogd_info(&tmp, "Trace RX: ");
+		}
+
+		if (out) {
+			if (out[i] != 0xFF)
+				plogd_info(mbufs[i], "Trace TX[%d]: ", out[i]);
+			else
+				plogd_info(mbufs[i], "Trace Dropped: ");
+		} else
+			plogd_info(mbufs[i], "Trace TX: ");
+	}
+	ret = tbase->aux->tx_pkt_orig(tbase, mbufs, n_pkts, out);
+
+	/* Unset by TX when n_trace = 0 */
+	if (0 == tbase->aux->task_rt_dump.n_trace) {
+		tbase->tx_pkt = tbase->aux->tx_pkt_orig;
+		tbase->aux->tx_pkt_orig = NULL;
+		task_base_del_rx_pkt_function(tbase, rx_pkt_trace);
+	}
+	return ret;
+}
+
+int tx_pkt_dump(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	uint32_t n_dump = tbase->aux->task_rt_dump.n_print_tx;
+	int ret = 0;
+
+	n_dump = n_pkts < n_dump? n_pkts : n_dump;
+	for (uint32_t i = 0; i < n_dump; ++i) {
+		if (out)
+			plogd_info(mbufs[i], "TX[%d]: ", out[i]);
+		else
+			plogd_info(mbufs[i], "TX: ");
+	}
+	tbase->aux->task_rt_dump.n_print_tx -= n_dump;
+
+	ret = tbase->aux->tx_pkt_orig(tbase, mbufs, n_pkts, out);
+
+	if (0 == tbase->aux->task_rt_dump.n_print_tx) {
+		tbase->tx_pkt = tbase->aux->tx_pkt_orig;
+		tbase->aux->tx_pkt_orig = NULL;
+	}
+	return ret;
+}
+
+/* Gather the distribution of the number of packets that have been
+   xmitted from one TX call. Since the value is only modified by the
+   task that xmits the packet, no atomic operation is needed. */
+int tx_pkt_distr(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	tbase->aux->tx_bucket[n_pkts]++;
+	return tbase->aux->tx_pkt_orig(tbase, mbufs, n_pkts, out);
+}
+
+int tx_pkt_bw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	uint32_t tx_bytes = 0;
+	uint32_t drop_bytes = 0;
+
+	for (uint16_t i = 0; i < n_pkts; ++i) {
+		if (!out || out[i] < OUT_HANDLED)
+			tx_bytes += mbuf_wire_size(mbufs[i]);
+		else
+			drop_bytes += mbuf_wire_size(mbufs[i]);
+	}
+
+	TASK_STATS_ADD_TX_BYTES(&tbase->aux->stats, tx_bytes);
+	TASK_STATS_ADD_DROP_BYTES(&tbase->aux->stats, drop_bytes);
+	return tbase->aux->tx_pkt_orig(tbase, mbufs, n_pkts, out);
+}
+
+int tx_pkt_drop_all(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
+{
+	for (uint16_t j = 0; j < n_pkts; ++j) {
+		rte_pktmbuf_free(mbufs[j]);
+	}
+	if (out == NULL)
+		TASK_STATS_ADD_DROP_HANDLED(&tbase->aux->stats, n_pkts);
+	else {
+		for (uint16_t j = 0; j < n_pkts; ++j) {
+			if (out[j] == OUT_HANDLED)
+				TASK_STATS_ADD_DROP_HANDLED(&tbase->aux->stats, 1);
+			else
+				TASK_STATS_ADD_DROP_DISCARD(&tbase->aux->stats, 1);
+		}
+	}
+	return n_pkts;
+}
diff --git a/VNFs/DPPD-PROX/tx_pkt.h b/VNFs/DPPD-PROX/tx_pkt.h
new file mode 100644
index 00000000..798797ab
--- /dev/null
+++ b/VNFs/DPPD-PROX/tx_pkt.h
@@ -0,0 +1,82 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _TX_PKT_H_
+#define _TX_PKT_H_
+
+#include <inttypes.h>
+
+struct task_base;
+struct rte_mbuf;
+
+void flush_queues_hw(struct task_base *tbase);
+void flush_queues_sw(struct task_base *tbase);
+
+void flush_queues_no_drop_hw(struct task_base *tbase);
+void flush_queues_no_drop_sw(struct task_base *tbase);
+
+/* The following four transmit functions always send packets to the
+   single output unless the packet should be dropped. These functions
+   are used if (1) the task is only sending to one destination and
+   (2), packets can potentially be dropped (as specified by the out
+   parameter, which is either NO_PORT_AVAIL or 0). */
+int tx_pkt_no_drop_hw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_no_drop_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_hw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+
+/* The following four transmit functions are used if (1) the task is
+   only sending to one destination and (2), packets are never dropped
+   by the task (the out parameter is ignored). */
+int tx_pkt_no_drop_never_discard_hw1_lat_opt(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_no_drop_never_discard_hw1_thrpt_opt(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_no_drop_never_discard_hw1_no_pointer(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_no_drop_never_discard_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_never_discard_hw1_lat_opt(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_never_discard_hw1_thrpt_opt(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_never_discard_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+
+/* The two "self" transmit functions are used if the task is
+   transmitting to another task running on the same core and the
+   destination task ID is one higher than the current task. The never_discard
+   version of the function ignores the out parameter and should
+   therefor only be used if the task never discards packets.*/
+int tx_pkt_self(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+int tx_pkt_never_discard_self(struct task_base *tbase, struct rte_mbuf **mbufs, const uint16_t n_pkts, uint8_t *out);
+
+/* The following four tarnsmit functions are the most general. They
+   are used if (1) packets can be dropped and (2) there are multiple
+   outputs in the task. */
+int tx_pkt_no_drop_hw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+int tx_pkt_no_drop_sw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+int tx_pkt_hw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+int tx_pkt_sw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+
+int tx_pkt_trace(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+int tx_pkt_dump(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+int tx_pkt_distr(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+int tx_pkt_bw(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+
+uint16_t tx_try_sw1(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+uint16_t tx_try_hw1(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+uint16_t tx_try_self(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts);
+
+/* When there are no output ports, this function is configured as the
+   tx function. This tx function can be used to make each task a
+   sink. */
+int tx_pkt_drop_all(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out);
+
+#endif /* _TX_PKT_H_ */
diff --git a/VNFs/DPPD-PROX/version.h b/VNFs/DPPD-PROX/version.h
new file mode 100644
index 00000000..b906b14b
--- /dev/null
+++ b/VNFs/DPPD-PROX/version.h
@@ -0,0 +1,34 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _VERSION_H_
+#define _VERSION_H_
+
+#define STRINGIFY(s) #s
+#define SSTR(s) STRINGIFY(s)
+
+/* PROGRAM_NAME defined through Makefile */
+#define VERSION_MAJOR 0
+#define VERSION_MINOR 39
+#define VERSION_REV   0
+
+#if VERSION_REV > 0
+#define VERSION_STR "v" SSTR(VERSION_MAJOR) "." SSTR(VERSION_MINOR) "." SSTR(VERSION_REV)
+#else
+#define VERSION_STR "v" SSTR(VERSION_MAJOR) "." SSTR(VERSION_MINOR)
+#endif
+
+#endif /* _VERSION_H_ */
diff --git a/VNFs/DPPD-PROX/vxlangpe_nsh.h b/VNFs/DPPD-PROX/vxlangpe_nsh.h
new file mode 100644
index 00000000..2e7cfc76
--- /dev/null
+++ b/VNFs/DPPD-PROX/vxlangpe_nsh.h
@@ -0,0 +1,44 @@
+/*
+// Copyright (c) 2010-2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef _VXLANGPE_NSH_H_
+#define _VXLANGPE_NSH_H_
+
+struct nsh_hdr {
+	uint16_t version :2;
+	uint16_t oa_flag :1;
+	uint16_t cm_flag :1;
+	uint16_t reserved :6;
+	uint16_t length :6;
+	uint8_t md_type;
+	uint8_t next_proto;
+	uint32_t sfp_index :24;
+	uint32_t sf_index :8;
+	uint32_t ctx_1;
+	uint32_t ctx_2;
+	uint32_t ctx_3;
+	uint32_t ctx_4;
+} __attribute__((__packed__));
+
+struct vxlan_gpe_hdr {
+	uint8_t flag_0;
+	uint8_t flag_1;
+	uint8_t reserved;
+	uint8_t next_proto;
+	uint32_t vni_res;
+} __attribute__((__packed__));
+
+#endif /* _VXLANGPE_NSH_H_ */