diff --git a/omec/omec-user-plane/files/__init__.py b/omec/omec-user-plane/files/__init__.py
new file mode 100644
index 0000000..7e94051
--- /dev/null
+++ b/omec/omec-user-plane/files/__init__.py
@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2020-present Open Networking Foundation
+# Copyright(c) 2019 Intel Corporation
\ No newline at end of file
diff --git a/omec/omec-user-plane/files/route_control.py b/omec/omec-user-plane/files/route_control.py
new file mode 100755
index 0000000..11621d6
--- /dev/null
+++ b/omec/omec-user-plane/files/route_control.py
@@ -0,0 +1,524 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2020-present Open Networking Foundation
+# Copyright(c) 2019 Intel Corporation
+
+import argparse
+import signal
+import sys
+import time
+
+# for retrieving neighbor info
+from pyroute2 import IPDB, IPRoute
+
+from scapy.all import *
+
+try:
+    from pybess.bess import *
+except ImportError:
+    print('Cannot import the API module (pybess)')
+    raise
+
+MAX_RETRIES = 5
+SLEEP_S = 2
+
+
+class NeighborEntry:
+    def __init__(self):
+        self.neighbor_ip = None
+        self.iface = None
+        self.iprange = None
+        self.prefix_len = None
+        self.route_count = 0
+        self.gate_idx = 0
+        self.macstr = None
+
+    def __str__(self):
+        return ('{neigh: %s, iface: %s, ip-range: %s/%s}' %
+                (self.neighbor_ip, self.iface, self.iprange, self.prefix_len))
+
+
+def mac2hex(mac):
+    return int(mac.replace(':', ''), 16)
+
+
+def send_ping(neighbor_ip):
+    send(IP(dst=neighbor_ip) / ICMP())
+
+
+def send_arp(neighbor_ip, src_mac, iface):
+    pkt = Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(pdst=neighbor_ip, hwsrc=src_mac)
+    pkt.show()
+    hexdump(pkt)
+    sendp(pkt, iface=iface)
+
+
+def fetch_mac(dip):
+    ip = ''
+    _mac = ''
+    neighbors = ipr.get_neighbours(dst=dip)
+    for i in range(len(neighbors)):
+        for att in neighbors[i]['attrs']:
+            if 'NDA_DST' in att and dip == att[1]:
+                # ('NDA_DST', dip)
+                ip = att[1]
+            if 'NDA_LLADDR' in att:
+                # ('NDA_LLADDR', _mac)
+                _mac = att[1]
+                return _mac
+
+
+def link_modules(server, module, next_module, ogate=0, igate=0):
+    print('Linking {} module'.format(next_module))
+
+    # Pause bess first
+    bess.pause_all()
+    # Connect module to next_module
+    for _ in range(MAX_RETRIES):
+        try:
+            server.connect_modules(module, next_module, ogate, igate)
+        except BESS.Error as e:
+            bess.resume_all()
+            if e.code == errno.EBUSY:
+                break
+            else:
+                return  #raise
+        except Exception as e:
+            print(
+                'Error connecting module {}:{}->{}:{}: {}. Retrying in {} secs...'
+                .format(module, ogate, igate, next_module, e, SLEEP_S))
+            time.sleep(SLEEP_S)
+        else:
+            bess.resume_all()
+            break
+    else:
+        bess.resume_all()
+        print('BESS module connection ({}:{}->{}:{}) failure.'.format(
+            module, ogate, igate, next_module))
+        return
+        #raise Exception('BESS module connection ({}:{}->{}:{}) failure.'.
+        #                format(module, ogate, igate, next_module))
+
+
+def link_route_module(server, gateway_mac, item):
+    iprange = item.iprange
+    prefix_len = item.prefix_len
+    route_module = item.iface + 'Routes'
+    last_module = item.iface + 'FastPO'
+    gateway_mac_str = '{:X}'.format(gateway_mac)
+    print('Adding route entry {}/{} for {}'.format(iprange, prefix_len,
+                                                   route_module))
+
+    print('Trying to retrieve neighbor entry {} from neighbor cache'.format(
+        item.neighbor_ip))
+    neighbor_exists = neighborcache.get(item.neighbor_ip)
+
+    # How many gates does this module have?
+    # If entry does not exist, then initialize it
+    if not modgatecnt.get(route_module):
+        modgatecnt[route_module] = 0
+
+    # Compute likely index
+    if neighbor_exists:
+        # No need to create a new Update module
+        gate_idx = neighbor_exists.gate_idx
+    else:
+        # Need to create a new Update module,
+        # so get gate_idx from gate count
+        gate_idx = modgatecnt[route_module]
+
+    # Pause bess first
+    bess.pause_all()
+    # Pass routing entry to bessd's route module
+    for _ in range(MAX_RETRIES):
+        try:
+            server.run_module_command(route_module, 'add',
+                                      'IPLookupCommandAddArg', {
+                                          'prefix': iprange,
+                                          'prefix_len': int(prefix_len),
+                                          'gate': gate_idx
+                                      })
+        except:
+            print('Error adding route entry {}/{} in {}. Retrying in {}sec...'.
+                  format(iprange, prefix_len, route_module, SLEEP_S))
+            time.sleep(SLEEP_S)
+        else:
+            bess.resume_all()
+            break
+    else:
+        bess.resume_all()
+        print('BESS route entry ({}/{}) insertion failure in module {}'.format(
+            iprange, prefix_len, route_module))
+        return
+        #raise Exception('BESS route entry ({}/{}) insertion failure in module {}'.
+        #                format(iprange, prefix_len, route_module))
+
+    if not neighbor_exists:
+        print('Neighbor does not exist')
+        # Create Update module
+        update_module = route_module + 'DstMAC' + gateway_mac_str
+
+        # Pause bess first
+        bess.pause_all()
+        for _ in range(MAX_RETRIES):
+            try:
+                server.create_module('Update', update_module, {
+                    'fields': [{
+                        'offset': 0,
+                        'size': 6,
+                        'value': gateway_mac
+                    }]
+                })
+            except BESS.Error as e:
+                bess.resume_all()
+                if e.code == errno.EEXIST:
+                    break
+                else:
+                    return  #raise
+            except Exception as e:
+                print(
+                    'Error creating update module {}: {}. Retrying in {} secs...'
+                    .format(update_module, e, SLEEP_S))
+                time.sleep(SLEEP_S)
+            else:
+                bess.resume_all()
+                break
+        else:
+            bess.resume_all()
+            print('BESS module {} creation failure.'.format(update_module))
+            return  #raise Exception('BESS module {} creation failure.'.
+            #        format(update_module))
+
+        print('Update module created')
+
+        # Connect Update module to route module
+        link_modules(server, route_module, update_module, gate_idx, 0)
+
+        # Connect Update module to dpdk_out module
+        link_modules(server, update_module, last_module, 0, 0)
+
+        # Add a new neighbor in neighbor cache
+        neighborcache[item.neighbor_ip] = item
+
+        # Add a record of the affliated gate id
+        item.gate_idx = gate_idx
+
+        # Set the mac str
+        item.macstr = gateway_mac_str
+
+        # Increment global gate count number
+        modgatecnt[route_module] += 1
+
+        neighbor_exists = item
+
+    else:
+        print('Neighbor already exists')
+
+    # Finally increment route count
+    neighborcache[item.neighbor_ip].route_count += 1
+
+
+def del_route_entry(server, item):
+    iprange = item.iprange
+    prefix_len = item.prefix_len
+    route_module = item.iface + 'Routes'
+    last_module = item.iface + 'FastPO'
+
+    neighbor_exists = neighborcache.get(item.neighbor_ip)
+    if neighbor_exists:
+        # Pause bess first
+        bess.pause_all()
+        # Delete routing entry from bessd's route module
+        for i in range(MAX_RETRIES):
+            try:
+                server.run_module_command(route_module, 'delete',
+                                          'IPLookupCommandDeleteArg', {
+                                              'prefix': iprange,
+                                              'prefix_len': int(prefix_len)
+                                          })
+            except:
+                print(
+                    'Error while deleting route entry for {}. Retrying in {} sec...'
+                    .format(route_module, SLEEP_S))
+                time.sleep(SLEEP_S)
+            else:
+                bess.resume_all()
+                break
+        else:
+            bess.resume_all()
+            print('Route entry deletion failure.')
+            return
+            #raise Exception('Route entry deletion failure.')
+
+        print('Route entry {}/{} deleted from {}'.format(
+            iprange, prefix_len, route_module))
+
+        # Decrementing route count for the registered neighbor
+        neighbor_exists.route_count -= 1
+
+        # If route count is 0, then delete the whole module
+        if neighbor_exists.route_count == 0:
+            update_module = route_module + 'DstMAC' + neighbor_exists.macstr
+            # Pause bess first
+            bess.pause_all()
+            for i in range(MAX_RETRIES):
+                try:
+                    server.destroy_module(update_module)
+                except:
+                    print('Error destroying module {}. Retrying in {}sec...'.
+                          format(update_module, SLEEP_S))
+                    time.sleep(SLEEP_S)
+                else:
+                    bess.resume_all()
+                    break
+            else:
+                bess.resume_all()
+                print('Module {} deletion failure.'.format(update_module))
+                return
+                #raise Exception('Module {} deletion failure.'.
+                #                format(update_module))
+
+            print('Module {} destroyed'.format(update_module))
+
+            # Delete entry from the neighbor cache
+            del neighborcache[item.neighbor_ip]
+            print('Deleting item from neighborcache')
+            del neighbor_exists
+        else:
+            print('Route count for {}  decremented to {}'.format(
+                item.neighbor_ip, neighbor_exists.route_count))
+            neighborcache[item.neighbor_ip] = neighbor_exists
+    else:
+        print('Neighbor {} does not exist'.format(item.neighbor_ip))
+
+
+def probe_addr(item, src_mac):
+    # Store entry if entry does not exist in ARP cache
+    arpcache[item.neighbor_ip] = item
+    print('Adding entry {} in arp probe table'.format(item))
+
+    # Probe ARP request by sending ping
+    send_ping(item.neighbor_ip)
+
+    # Probe ARP request
+    ##send_arp(neighbor_ip, src_mac, item.iface)
+
+
+def parse_new_route(msg):
+    item = NeighborEntry()
+    # Fetch prefix_len
+    item.prefix_len = msg['dst_len']
+    # Default route
+    if item.prefix_len is 0:
+        item.iprange = '0.0.0.0'
+
+    for att in msg['attrs']:
+        if 'RTA_DST' in att:
+            # Fetch IP range
+            # ('RTA_DST', iprange)
+            item.iprange = att[1]
+        if 'RTA_GATEWAY' in att:
+            # Fetch gateway MAC address
+            # ('RTA_GATEWAY', neighbor_ip)
+            item.neighbor_ip = att[1]
+            _mac = fetch_mac(att[1])
+            if not _mac:
+                gateway_mac = 0
+            else:
+                gateway_mac = mac2hex(_mac)
+        if 'RTA_OIF' in att:
+            # Fetch interface name
+            # ('RTA_OIF', iface)
+            item.iface = ipdb.interfaces[int(att[1])].ifname
+
+    if not item.iface in args.i or not item.iprange or not item.neighbor_ip:
+        # Neighbor info is invalid
+        del item
+        return
+
+    # Fetch prefix_len
+    item.prefix_len = msg['dst_len']
+
+    # if mac is 0, send ARP request
+    if gateway_mac == 0:
+        print('Adding entry {} in arp probe table'.format(item.iface))
+        probe_addr(item, ipdb.interfaces[item.iface].address)
+
+    else:  # if gateway_mac is set
+        print('Linking module {}Routes with {}FastPO (Dest MAC: {})'.format(
+            item.iface, item.iface, _mac))
+
+        link_route_module(bess, gateway_mac, item)
+
+
+def parse_new_neighbor(msg):
+    for att in msg['attrs']:
+        if 'NDA_DST' in att:
+            # ('NDA_DST', neighbor_ip)
+            neighbor_ip = att[1]
+        if 'NDA_LLADDR' in att:
+            # ('NDA_LLADDR', neighbor_mac)
+            gateway_mac = att[1]
+
+    item = arpcache.get(neighbor_ip)
+    if item:
+        print('Linking module {}Routes with {}FastPO (Dest MAC: {})'.format(
+            item.iface, item.iface, gateway_mac))
+
+        # Add route entry, and add item in the registered neighbor cache
+        link_route_module(bess, mac2hex(gateway_mac), item)
+
+        # Remove entry from unresolved arp cache
+        del arpcache[neighbor_ip]
+
+
+def parse_del_route(msg):
+    item = NeighborEntry()
+    for att in msg['attrs']:
+        if 'RTA_DST' in att:
+            # Fetch IP range
+            # ('RTA_DST', iprange)
+            item.iprange = att[1]
+        if 'RTA_GATEWAY' in att:
+            # Fetch gateway MAC address
+            # ('RTA_GATEWAY', neighbor_ip)
+            item.neighbor_ip = att[1]
+        if 'RTA_OIF' in att:
+            # Fetch interface name
+            # ('RTA_OIF', iface)
+            item.iface = ipdb.interfaces[int(att[1])].ifname
+
+    if not item.iface in args.i or not item.iprange or not item.neighbor_ip:
+        # Neighbor info is invalid
+        del item
+        return
+
+    # Fetch prefix_len
+    item.prefix_len = msg['dst_len']
+
+    del_route_entry(bess, item)
+
+    # Delete item
+    del item
+
+
+def netlink_event_listener(ipdb, netlink_message, action):
+
+    # If you get a netlink message, parse it
+    msg = netlink_message
+
+    if action == 'RTM_NEWROUTE':
+        parse_new_route(msg)
+
+    if action == 'RTM_NEWNEIGH':
+        parse_new_neighbor(msg)
+
+    if action == 'RTM_DELROUTE':
+        parse_del_route(msg)
+
+
+def bootstrap_routes():
+    routes = ipr.get_routes()
+    for i in routes:
+        if i['event'] == 'RTM_NEWROUTE':
+            parse_new_route(i)
+
+
+def connect_bessd():
+    print('Connecting to BESS daemon...'),
+    # Connect to BESS (assuming host=localhost, port=10514 (default))
+    for i in range(MAX_RETRIES):
+        try:
+            if not bess.is_connected():
+                bess.connect(grpc_url=args.ip + ':' + args.port)
+        except BESS.RPCError:
+            print(
+                'Error connecting to BESS daemon. Retrying in {}sec...'.format(
+                    SLEEP_S))
+            time.sleep(SLEEP_S)
+        else:
+            break
+    else:
+        raise Exception('BESS connection failure.')
+
+    print('Done.')
+
+
+def reconfigure(number, frame):
+    print('Received: {} Reloading routes'.format(number))
+    # clear arpcache
+    for ip in list(arpcache):
+        item = arpcache.get(ip)
+        del item
+    arpcache.clear()
+    for ip in list(neighborcache):
+        item = neighborcache.get(ip)
+        del item
+    neighborcache.clear()
+    for modname in list(modgatecnt):
+        item = modgatecnt.get(modname)
+        del item
+    modgatecnt.clear()
+    bootstrap_routes()
+    signal.pause()
+
+
+def cleanup(number, frame):
+    ipdb.unregister_callback(event_callback)
+    print('Received: {} Exiting'.format(number))
+    sys.exit()
+
+
+def main():
+    global arpcache, neighborcache, modgatecnt, ipdb, event_callback, bess, ipr
+    # for holding unresolved ARP queries
+    arpcache = {}
+    # for holding list of registered neighbors
+    neighborcache = {}
+    # for holding gate count per route module
+    modgatecnt = {}
+    # for interacting with kernel
+    ipdb = IPDB()
+    ipr = IPRoute()
+    # for bess client
+    bess = BESS()
+
+    # connect to bessd
+    connect_bessd()
+
+    # program current routes
+    #bootstrap_routes()
+
+    # listen for netlink events
+    print('Registering netlink event listener callback...'),
+    event_callback = ipdb.register_callback(netlink_event_listener)
+    print('Done.')
+
+    signal.signal(signal.SIGHUP, reconfigure)
+    signal.signal(signal.SIGINT, cleanup)
+    signal.signal(signal.SIGTERM, cleanup)
+    signal.pause()
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description='Basic IPv4 Routing Controller')
+    parser.add_argument('-i',
+                        type=str,
+                        nargs='+',
+                        help='interface(s) to control')
+    parser.add_argument('--ip',
+                        type=str,
+                        default='localhost',
+                        help='BESSD address')
+    parser.add_argument('--port', type=str, default='10514', help='BESSD port')
+
+    # for holding command-line arguments
+    global args
+    args = parser.parse_args()
+
+    if args.i:
+        main()
+    # if interface list is empty, print help menu and quit
+    else:
+        print(parser.print_help())
diff --git a/omec/omec-user-plane/files/spgwu.bess b/omec/omec-user-plane/files/spgwu.bess
new file mode 100644
index 0000000..ebb47ef
--- /dev/null
+++ b/omec/omec-user-plane/files/spgwu.bess
@@ -0,0 +1,369 @@
+# vim: syntax=py
+# -*- mode: python -*-
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2020-present Open Networking Foundation
+# Copyright(c) 2019 Intel Corporation
+
+# for errnos
+import errno
+from conf.utils import *
+
+
+# ====================================================
+#       Parameters
+# ====================================================
+
+
+conf_file = get_env('CONF_FILE', 'conf/spgwu.json')
+conf = get_json_conf(conf_file, False)
+
+# Maximum number of flows to manage ip frags for re-assembly
+max_ip_defrag_flows = None
+try:
+    max_ip_defrag_flows = int(conf["max_ip_defrag_flows"])
+except ValueError:
+    print('Invalid value for max_ip_defrag_flows. Not installing IPDefrag module.')
+except KeyError:
+    print('max_ip_defrag_flows value not set. Not installing IPDefrag module.')
+
+# ====================================================
+#       Port Helpers
+# ====================================================
+
+
+MAX_GATES = 8192
+dpdk_ports = {}
+
+
+def scan_dpdk_ports():
+    idx = 0
+    while True:
+        try:
+            intf = PMDPort(name="Port {}".format(idx), port_id=idx)
+            if intf:
+                # Need to declare mac so that we don't lose key during destroy_port
+                mac = intf.mac_addr
+                dpdk_ports[mac] = idx
+                bess.destroy_port(intf.name)
+        except bess.Error as e:
+            if e.code == errno.ENODEV:
+                break
+            else:
+                raise
+        idx += 1
+    return True if dpdk_ports else False
+
+
+class Port:
+    def __init__(self, name):
+        self.name = name
+        self.wid = None
+        self.fpi = None
+        self.fpo = None
+        self.bpf = None
+        self.bpfgate = 0
+        self.routes_table = None
+
+    def bpf_gate(self):
+        if self.bpfgate < MAX_GATES - 2:
+            self.bpfgate += 1
+            return self.bpfgate
+        else:
+            raise Exception('Port {}: Out of BPF gates to allocate'.format(self.name))
+
+    def detect_mode(self):
+        # default case
+        mode = "unselected"
+
+        try:
+            peer_by_interface(self.name)
+            mode = "dpdk"
+        except:
+            mode = "linux"
+        return mode
+
+    def init_fastpath(self, **kwargs):
+        # Initialize PMDPort and RX/TX modules
+        name = self.name
+        fast = PMDPort(name="{}Fast".format(name), **kwargs)
+        self.fpi = __bess_module__("{}FastPI".format(name), 'PortInc', port=fast.name)
+        self.fpo = __bess_module__("{}FastPO".format(name), 'PortOut', port=fast.name)
+
+        # Initialize BPF to classify incoming traffic to go to kernel and/or pipeline
+        self.bpf = __bess_module__("{}FastBPF".format(name), 'BPF')
+        self.bpf.clear()
+
+        # Default drop when no matches
+        if max_ip_defrag_flows is not None:
+            ipdefrag = __bess_module__("{}Defrag".format(name), 'IPDefrag', num_flows=max_ip_defrag_flows, numa=0)
+            self.fpi -> ipdefrag:1 -> self.bpf:0 -> Sink()
+            ipdefrag:0 -> Sink()
+        else:
+            self.fpi -> self.bpf:0 -> Sink()
+
+        # Initialize route module
+        self.rtr = __bess_module__("{}Routes".format(name), 'IPLookup')
+
+        # Default route goes to Sink
+        self.rtr.add(prefix='0.0.0.0', prefix_len=0, gate=MAX_GATES-1)
+        self.rtr:(MAX_GATES-1) -> Sink()
+
+        # Attach fastpath to worker's root TC
+        self.fpi.attach_task(wid=self.wid)
+
+    def setup_port(self, idx, workers):
+        # Pick the worker handling this port
+        self.wid = idx % workers
+
+        name = self.name
+        wid = self.wid
+        print('Setting up port {} on worker {}'.format(name,wid))
+
+        # Detect the mode of this interface - DPDK/AF_XDP/AF_PACKET
+        mode = self.detect_mode()
+
+        if mode == 'linux':
+            try:
+                # Initialize kernel fastpath.
+                # AF_XDP requires that num_rx_qs == num_tx_qs
+                kwargs = {"vdev" : "net_af_xdp{},iface={},start_queue=0,queue_count={}"
+                          .format(idx, name, workers), "num_out_q": workers, "num_inc_q": workers}
+                self.init_fastpath(**kwargs)
+            except:
+                print('Failed to create AF_XDP socket for {}. Creating AF_PACKET socket instead.'.format(name))
+                kwargs = {"vdev" : "net_af_packet{},iface={},qpairs={}".format(idx, name, workers), "num_out_q": workers}
+                self.init_fastpath(**kwargs)
+
+        elif mode == 'dpdk':
+            # if port list is empty, scan for dpdk_ports first
+            if not dpdk_ports and scan_dpdk_ports() == False:
+                print('Registered dpdk ports do not exist.')
+                sys.exit()
+            # Initialize DPDK fastpath
+            fidx = dpdk_ports.get(mac_by_interface(name))
+            if fidx is None:
+                raise Exception('Registered port for {} not detected!'.format(name))
+            kwargs = {"port_id" : fidx, "num_out_q": workers}
+            self.init_fastpath( **kwargs)
+
+            # Initialize kernel slowpath port and RX/TX modules
+            try:
+                peer = peer_by_interface(name)
+                vdev = "net_af_packet{},iface={}".format(idx, peer)
+                slow = PMDPort(name="{}Slow".format(name), vdev=vdev)
+                spi = __bess_module__("{}SlowPI".format(name), 'PortInc', port=slow.name)
+                spo = __bess_module__("{}SlowPO".format(name), 'PortOut', port=slow.name)
+                qspo = __bess_module__("{}QSlowPO".format(name), 'Queue')
+
+                # host_ip_filter: tcpdump -i foo 'dst host 198.19.0.1 or 198.18.0.1' -d
+                # Should always be set to lowest priority
+                HostGate = MAX_GATES - 1
+                ips = ips_by_interface(name)
+                host_ip_filter = {"priority": -HostGate, "filter": "dst host "
+                                + " or ".join(str(x) for x in ips), "gate": HostGate}
+
+                self.bpf.add(filters=[host_ip_filter])
+
+                # Direct control traffic from DPDK to kernel
+                self.bpf:HostGate -> qspo -> spo
+
+                # Direct control traffic from kernel to DPDK
+                spi -> self.fpo
+
+                tc = 'slow{}'.format(wid)
+                try:
+                    bess.add_tc(tc, policy='round_robin', wid=wid)
+                except Exception as e:
+                    if e.errmsg == "Name '{}' already exists".format(tc):
+                        pass
+                    else:
+                        raise e
+                # Limit scheduling slow path RX/TX to 1000 times/second each
+                for mod in spi, qspo:
+                    bess.add_tc(mod.name,
+                            parent=tc,
+                            policy='rate_limit',
+                            resource='count',
+                            limit={'count': 1000})
+                    mod.attach_task(mod.name)
+            except Exception as e:
+                print('Mirror veth interface: {} misconfigured: {}'.format(name, e))
+        else:
+            raise Exception('Invalid mode selected.')
+
+
+# ====================================================
+#       Validate
+# ====================================================
+
+
+# CIDRs
+enb_cidr = conf["enb_cidr"]
+ue_cidr = conf["ue_cidr"]
+
+cidrs = [enb_cidr, ue_cidr]
+for cidr in cidrs:
+    if validate_cidr(cidr) is False:
+        exit(1, 'Invalid {}'.format(cidr))
+
+# ====================================================
+#       Core Setup
+# ====================================================
+
+
+# Initialize workers
+workers = 1
+try:
+    workers = int(conf["workers"])
+except ValueError:
+    print('Invalid workers value! Re-setting # of workers to 1.')
+
+cores = get_process_affinity()
+for wid in xrange(workers):
+    bess.add_worker(wid=wid, core=int(cores[wid % len(cores)]))
+
+# ====================================================
+#       Port Setup
+# ====================================================
+
+
+interfaces = ["s1u", "sgi"]
+ports = {}
+for idx, interface in enumerate(interfaces):
+    port = Port(conf[interface]["ifname"])
+    if port.name in ports:
+        continue
+    port.setup_port(idx, workers)
+    ports[port.name] = port
+
+s1u_ifname = conf["s1u"]["ifname"]
+sgi_ifname = conf["sgi"]["ifname"]
+
+# ====================================================
+#       Downlink Pipeline
+# ====================================================
+
+s1uRoutes = ports[s1u_ifname].rtr
+
+# Maximum number of sessions to manage
+try:
+    max_sessions = int(conf["max_sessions"])
+except ValueError:
+    print('Invalid max_sessions value!')
+
+# Setting filter to detect UE subnet
+sgiFastBPF = ports[sgi_ifname].bpf
+UEGate = ports[sgi_ifname].bpf_gate()
+ue_filter = {"priority": -UEGate,
+             "filter": "ip dst net {}".format(ue_cidr), "gate": UEGate}
+sgiFastBPF.add(filters=[ue_filter])
+
+sgiFastBPF:UEGate \
+    -> EtherTrim::GenericDecap(bytes=14) \
+    -> GTPUEncap::GtpuEncap(s1u_sgw_ip=ip2long(ips_by_interface(s1u_ifname)[0]), num_subscribers=max_sessions):1 \
+    -> S1UEtherAdd::GenericEncap(fields=[
+        {'size': 6, 'value': {'value_int': 0x0}},
+        {'size': 6, 'value': {'value_int': mac2hex(mac_by_interface(s1u_ifname))}},
+        {'size': 2, 'value': {'value_int': 0x0800}}]) \
+    -> OuterUDPCsum::L4Checksum() \
+    -> OuterIPCsum::IPChecksum() \
+    -> s1uRoutes
+
+# Drop unknown packets
+GTPUEncap:0 -> Sink()
+
+
+# ====================================================
+#       Uplink Pipeline
+# ====================================================
+
+
+# Setting filter to detect gtpu traffic
+# src net 11.1.1.0 mask 255.255.255.0           # check eNB subnet
+# and dst host 11.1.1.1                         # check S/PGWU IP
+# and udp dst port 2152                         # check GTPU port
+# and (udp[28:4] & 0xffffff00) = 0x10000000     # check UE subnet
+s1uFastBPF = ports[s1u_ifname].bpf
+check_enb_subnet = "src net {} ".format(enb_cidr)
+check_spgwu_ip = " and dst host " + \
+    " or ".join(str(x) for x in ips_by_interface(s1u_ifname))
+check_gtpu_port = " and udp dst port 2152"
+check_ue_subnet = " and (udp[28:4] & 0x{}) = 0x{}".format(
+    cidr2mask(ue_cidr), ip2hex(cidr2block(ue_cidr)[0]))
+check_gtpu_msg_echo = " and udp[9] = 0x1"
+
+GTPUEchoGate = ports[s1u_ifname].bpf_gate()
+uplink_echo_filter = {"priority": -GTPUEchoGate, "filter": check_enb_subnet +
+                      check_spgwu_ip + check_gtpu_port +
+                      check_gtpu_msg_echo, "gate": GTPUEchoGate}
+s1uFastBPF.add(filters=[uplink_echo_filter])
+
+GTPUGate = ports[s1u_ifname].bpf_gate()
+uplink_filter = {"priority": -GTPUGate, "filter": check_enb_subnet +
+               check_spgwu_ip + check_gtpu_port, "gate": GTPUGate}
+s1uFastBPF.add(filters=[uplink_filter])
+
+sgiRoutes = ports[sgi_ifname].rtr
+
+s1uFastBPF:GTPUGate -> EtherDecapTrim::GenericDecap(bytes=14) -> GTPUDecap::GtpuDecap(ename="GTPUEncap"):1 \
+    -> SGIEtherAdd::GenericEncap(fields=[
+        {'size': 6, 'value': {'value_int': 0x0}},
+        {'size': 6, 'value': {'value_int': mac2hex(mac_by_interface(sgi_ifname))}},
+        {'size': 2, 'value': {'value_int': 0x0800}}]) \
+    -> sgiRoutes
+
+s1uFastBPF:GTPUEchoGate \
+	-> GTPUEcho::GtpuEcho(s1u_sgw_ip=ip2long(ips_by_interface(s1u_ifname)[0])):1 \
+        -> EthSwap::MACSwap() \
+        -> 1:OuterUDPCsum
+
+# Drop unknown packets
+GTPUEcho:0 -> Sink()
+GTPUDecap:0 -> Sink()
+
+
+# ====================================================
+#       SIM_TEST
+# ====================================================
+
+import time
+
+def sim_start_test():
+    start_teid = 0xf0000000
+    start_ue_ip = 0x10000001
+    start_enb_ip = 0x0b010181
+    NG4T_MAX_UE_RAN = 500000
+    NG4T_MAX_ENB_RAN = 80
+
+    for i in range(max_sessions):
+
+        # NG4T-based formula to calculate enodeB IP address against a given UE IP address
+        # il_trafficgen also uses the same scheme
+        # See SimuCPEnbv4Teid(...) in ngic code for more details
+        ue_of_ran = i % NG4T_MAX_UE_RAN
+        ran = i / NG4T_MAX_UE_RAN
+        enb_of_ran = ue_of_ran % NG4T_MAX_ENB_RAN
+        enb_idx = ran * NG4T_MAX_ENB_RAN + enb_of_ran
+
+        GTPUEncap.add(teid=start_teid+i, eteid=i+1, ueaddr=start_ue_ip+i, enodeb_ip=start_enb_ip+enb_idx)
+
+def sim_end_test():
+    start_ue_ip = 0x10000001
+
+    for i in range(max_sessions):
+        GTPUEncap.remove(ueaddr=start_ue_ip+i)
+
+    GTPUEncap.show_records()
+
+### Uncomment the following lines to test with il_trafficgen ###
+# Start the test
+#sim_start_test()
+# Wait for 30 seconds before deleting the session info entries (optional)
+#time.sleep(30)
+#sim_end_test()
+
+# Finally send SIGHUP to route_control daemon on reload
+# TODO: behavior is unspecified if route_control.py pid is not found
+route_control_pid = getpythonpid('route_control.py')
+if route_control_pid:
+    os.kill(route_control_pid, signal.SIGHUP)
diff --git a/omec/omec-user-plane/files/utils.py b/omec/omec-user-plane/files/utils.py
new file mode 100644
index 0000000..860a65d
--- /dev/null
+++ b/omec/omec-user-plane/files/utils.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2020-present Open Networking Foundation
+# Copyright(c) 2019 Intel Corporation
+
+import os
+import signal
+import socket
+import sys
+
+import iptools
+import json
+import psutil
+from pyroute2 import IPDB
+
+
+def exit(code, msg):
+    print(msg)
+    sys.exit(code)
+
+
+def getpid(process_name):
+    for proc in psutil.process_iter(attrs=['pid', 'name']):
+        if process_name == proc.info['name']:
+            return proc.info['pid']
+
+
+def getpythonpid(process_name):
+    for proc in psutil.process_iter(attrs=['pid', 'cmdline']):
+        if len(proc.info['cmdline']) < 2:
+            continue
+        if process_name in proc.info['cmdline'][1] and 'python' in proc.info['cmdline'][0]:
+            return proc.info['pid']
+    return
+
+
+def get_json_conf(path, dump):
+    conf = json.loads(open(path).read())
+    if dump:
+        print(json.dumps(conf, indent=4, sort_keys=True))
+    return conf
+
+
+def get_env(varname, default=None):
+    try:
+        var = os.environ[varname]
+        return var
+    except KeyError:
+        if default is not None:
+            return '{}'.format(default)
+        else:
+            exit(1, 'Empty env var {}'.format(varname))
+
+
+def ips_by_interface(name):
+    ipdb = IPDB()
+    return [ipobj[0] for ipobj in ipdb.interfaces[name]['ipaddr'].ipv4]
+
+
+def mac_by_interface(name):
+    ipdb = IPDB()
+    return ipdb.interfaces[name]['address']
+
+
+def mac2hex(mac):
+    return int(mac.replace(':', ''), 16)
+
+
+def peer_by_interface(name):
+    ipdb = IPDB()
+    try:
+        peer_idx = ipdb.interfaces[name]['link']
+        peer_name = ipdb.interfaces[peer_idx]['ifname']
+    except:
+        raise Exception('veth interface {} does not exist'.format(name))
+    else:
+        return peer_name
+
+
+def aton(ip):
+    return socket.inet_aton(ip)
+
+
+def validate_cidr(cidr):
+    return iptools.ipv4.validate_cidr(cidr)
+
+
+def cidr2mask(cidr):
+    _, prefix = cidr.split('/')
+    return format(0xffffffff << (32 - int(prefix)), '08x')
+
+
+def cidr2block(cidr):
+    return iptools.ipv4.cidr2block(cidr)
+
+
+def ip2hex(ip):
+    return iptools.ipv4.ip2hex(ip)
+
+
+def ip2long(ip):
+    return iptools.ipv4.ip2long(ip)
+
+
+def get_process_affinity():
+    return psutil.Process().cpu_affinity()