Clean up script to generate LW46 bindings / MAP-E rules.

Change-Id: I3a3949e728f4e4875efddd4f02a55746c998a5ed
Signed-off-by: Ole Troan <ot@cisco.com>

4 files changed, 53 insertions, 785 deletions

diff --git a/vnet/vnet/map/examples/gen-rules.py b/vnet/vnet/map/examples/gen-rules.py
index d6746f79af4..ba6dde09aa8 100755
--- a/vnet/vnet/map/examples/gen-rules.py
+++ b/vnet/vnet/map/examples/gen-rules.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python3.4
+#!/usr/bin/env python3
 
 # Copyright (c) 2015 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,194 +20,83 @@ import sys
 # map add domain ip4-pfx <pfx> ip6-pfx ::/0 ip6-src <ip6-src> ea-bits-len 0 psid-offset 6 psid-len 6
 # map add rule index <0> psid <psid> ip6-dst <ip6-dst>
 
+def_ip4_pfx = '192.0.2.0/24'
+def_ip6_pfx = '2001:db8::/32'
+def_ip6_src = '2001:db8::1'
+def_psid_offset = 6
+def_psid_len = 6
+def_ea_bits_len = 14
+
+
 parser = argparse.ArgumentParser(description='MAP VPP configuration generator')
 parser.add_argument('-t', action="store", dest="mapmode")
+parser.add_argument('--ip4-prefix', action="store", dest="ip4_pfx", default=def_ip4_pfx)
+parser.add_argument('--ip6-prefix', action="store", dest="ip6_pfx", default=def_ip6_pfx)
+parser.add_argument('--ip6-src', action="store", dest="ip6_src", default=def_ip6_src)
+parser.add_argument('--psid-len', action="store", dest="psid_len", default=def_psid_len)
+parser.add_argument('--psid-offset', action="store", dest="psid_offset", default=def_psid_offset)
+parser.add_argument('--ea-bits-len', action="store", dest="ea_bits_len", default=def_ea_bits_len)
 args = parser.parse_args()
 
-#
-# 1:1 Shared IPv4 address, shared BR, Terastream
-#
-def terastream():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/22')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
-    psid_len = 6
-    ip6_src = ipaddress.ip_address('cccc:bbbb::')
-    for i in range(ip4_pfx.num_addresses):
-        if not i % 64:
-            ip6_src = ip6_src + 1
-        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx ::/0 ip6-src " + str(ip6_src) +
-              " ea-bits-len 0 psid-offset 0 psid-len", psid_len)
-        for psid in range(0x1 << psid_len):
-            print("map add rule index", i, "psid", psid, "ip6-dst", ip6_dst[(i * (0x1<<psid_len)) + psid])
 
 #
-# 1:1 Shared IPv4 address, shared BR, OTE
+# Algorithmic mapping Shared IPv4 address
 #
-def oteshared11():
-    ip4_pfx = ipaddress.ip_network('2.84.63.0/24')
-    dst = list(ipaddress.ip_network('2a02:580:8c00::/40').subnets(new_prefix=56))
-    psid_len = 6
-    ip6_src = ipaddress.ip_address('2a02::')
-    for i in range(ip4_pfx.num_addresses):
-        if not i % 64:
-            ip6_src = ip6_src + 1
-        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx ::/0 ip6-src " + str(ip6_src) +
-              " ea-bits-len 0 psid-offset 6 psid-len", psid_len)
-        for psid in range(0x1 << psid_len):
-            enduserprefix = list(dst.pop(0).subnets(new_prefix=64))[255-1]
-            print("map add rule index", i, "psid", psid, "ip6-dst", enduserprefix[(i * (0x1<<psid_len)) + psid])
-
+def algo(ip4_pfx_str, ip6_pfx_str, ip6_src_str, psid_len, ea_bits_len, ip6_src_ecmp = False):
+    print("map add domain ip4-pfx " + ip4_pfx_str + " ip6-pfx " + ip6_pfx_str + " ip6-src " + ip6_src_str +
+          " ea-bits-len " + str(ea_bits_len) + " psid-offset 6 psid-len " + str(psid_len))
 
 #
-# 1:1 Shared IPv4 address, shared BR, Terastream
+# 1:1 Full IPv4 address
 #
-def confdterastream():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/22')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
-    psid_len = 6
-    ip6_src = ipaddress.ip_address('cccc:bbbb::')
-    for i in range(ip4_pfx.num_addresses):
-        if not i % 64:
-            ip6_src = ip6_src + 1
-        print("vpp softwire softwire-instances softwire-instance", i, "br-ipv6 " + str(ip6_src) + " ipv6-prefix ::/0" + " ipv4-prefix " + str(ip4_pfx[i]) +
-              "/32 ea-len 0 psid-offset 6 psid-len", psid_len)
-#        print("vpp softwire softwire-instances softwire-instance", i, "ipv4-pfx " + str(ip4_pfx[i]) +  "/32 ipv6-pfx ::/0 br-ipv6 " + str(ip6_src) +
-#              " ea-len 0 psid-offset 6 psid-len", psid_len)
-        for psid in range(0x1 << psid_len):
-            print("binding", psid, "ipv6-addr", ip6_dst[(i * (0x1<<psid_len)) + psid])
-
-def shared11br_yang():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/16')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
-    psid_len = 6
-    for i in range(ip4_pfx.num_addresses):
-        print("vpp softwire softwire-instances softwire-instance " + str(i) + " ipv4-prefix " + str(ip4_pfx[i]) + "/32 " +
-                "ipv6-prefix ::/0 ea-len 0 psid-offset 6 tunnel-mtu 1234 psid-len", psid_len)
-        #print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx ::/0 ip6-shared-src cccc:bbbb::1",
-        #      "ea-bits-len 0 psid-offset 6 psid-len", psid_len)
-        for psid in range(0x1 << psid_len):
-            # print("map add rule index", i, "psid", psid, "ip6-dst", ip6_dst[(i * (0x1<<psid_len)) + psid])
-            print("binding", psid, "ipv6-addr", ip6_dst[(i * (0x1<<psid_len)) + psid])
+def lw46(ip4_pfx_str, ip6_pfx_str, ip6_src_str, psid_len, ea_bits_len, ip6_src_ecmp = False):
+    ip4_pfx = ipaddress.ip_network(ip4_pfx_str)
+    ip6_src = ipaddress.ip_address(ip6_src_str)
+    ip6_dst = ipaddress.ip_network(ip6_pfx_str)
+    psid_len = 0
+    mod = ip4_pfx.num_addresses / 1024
 
-def shared11br_xml():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/32')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
-    ip6_src = ipaddress.ip_address('cccc:bbbb::')
-    psid_len = 6
-    print('<vpp xmlns="http://www.cisco.com/yang/cisco-vpp"><softwire><softwire-instances>');
-    count = 1024;
     for i in range(ip4_pfx.num_addresses):
-        if not i % 64:
+        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx " + str(ip6_dst[i]) + "/128 ip6-src",
+              ip6_src, "ea-bits-len 0 psid-offset 0 psid-len 0")
+        if ip6_src_ecmp and not i % mod:
             ip6_src = ip6_src + 1
-        if count == 0:
-            break;
-        count = count - 1;
-        print('<softwire-instance>')
-        print('  <id>'+ str(i)+ '</id>')
-        print('  <ipv4-prefix>'+ str(ip4_pfx[i])+ '/32</ipv4-prefix>')
-        print('  <ipv6-prefix>::/0</ipv6-prefix>')
-        print('  <ea-len>0</ea-len>')
-        print('  <psid-offset>0</psid-offset>')
-        print('  <psid-len>'+ str(psid_len) + '</psid-len>')
-        for psid in range(0x1 << psid_len):
-            print('  <binding>')
-            print('    <psid>', psid, '</psid>')
-            print('    <ipv6-addr>'+ str(ip6_dst[(i * (0x1<<psid_len)) + psid]) + '</ipv6-addr>')
-            print('  </binding>')
-        print('</softwire-instance>')
-    print('</softwire-instances></softwire>')
-    print('</vpp>')
-
-#
-# 1:1 Shared IPv4 address, shared BR
-#
-def shared11br():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/16')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
-    psid_len = 6
-    for i in range(ip4_pfx.num_addresses):
-        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx ::/0 ip6-shared-src cccc:bbbb::1",
-              "ea-bits-len 0 psid-offset 6 psid-len", psid_len)
-        for psid in range(0x1 << psid_len):
-            print("map add rule index", i, "psid", psid, "ip6-dst", ip6_dst[(i * (0x1<<psid_len)) + psid])
 
 #
-# 1:1 Shared IPv4 address, shared BR
+# 1:1 Shared IPv4 address, shared BR (16) VPP CLI
 #
-def shared11br():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/16')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
-    psid_len = 6
-    for i in range(ip4_pfx.num_addresses):
-        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx ::/0 ip6-shared-src cccc:bbbb::1",
-              "ea-bits-len 0 psid-offset 6 psid-len", psid_len)
-        for psid in range(0x1 << psid_len):
-            print("map add rule index", i, "psid", psid, "ip6-dst", ip6_dst[(i * (0x1<<psid_len)) + psid])
+def lw46_shared(ip4_pfx_str, ip6_pfx_str, ip6_src_str, psid_len, ea_bits_len, ip6_src_ecmp = False):
+    ip4_pfx = ipaddress.ip_network(ip4_pfx_str)
+    ip6_src = ipaddress.ip_address(ip6_src_str)
+    ip6_dst = ipaddress.ip_network(ip6_pfx_str)
 
+    mod = ip4_pfx.num_addresses / 1024
 
-#
-# 1:1 Shared IPv4 address
-#
-def shared11():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/16')
-    ip6_src = ipaddress.ip_network('cccc:bbbb::/64')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
-    psid_len = 6
     for i in range(ip4_pfx.num_addresses):
-        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx ::/0 ip6-src", ip6_src[i],
-              "ea-bits-len 0 psid-offset 6 psid-len", psid_len)
+        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx ::/0 ip6-src " + str(ip6_src) +
+              " ea-bits-len 0 psid-offset 0 psid-len", psid_len)
         for psid in range(0x1 << psid_len):
             print("map add rule index", i, "psid", psid, "ip6-dst", ip6_dst[(i * (0x1<<psid_len)) + psid])
+        if ip6_src_ecmp and not i % mod:
+            ip6_src = ip6_src + 1
 
 #
-# 1:1 Shared IPv4 address small
+# 1:1 Shared IPv4 address, shared BR
 #
-def smallshared11():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/24')
-    ip6_src = ipaddress.ip_network('cccc:bbbb::/64')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
+def lw46_shared_b(ip4_pfx_str, ip6_pfx_str, ip6_src_str, psid_len, ea_bits_len, ip6_src_ecmp = False):
+    ip4_pfx = ipaddress.ip_network(ip4_pfx_str)
+    ip6_src = ipaddress.ip_address(ip6_src_str)
+    ip6_dst = list(ipaddress.ip_network(ip6_pfx_str).subnets(new_prefix=56))
     psid_len = 6
-    for i in range(ip4_pfx.num_addresses):
-        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx ::/0 ip6-src", ip6_src[i],
-              "ea-bits-len 0 psid-offset 6 psid-len", psid_len)
-        for psid in range(0x1 << psid_len):
-            print("map add rule index", i, "psid", psid, "ip6-dst", ip6_dst[(i * (0x1<<psid_len)) + psid])
 
-#
-# 1:1 Full IPv4 address
-#
-def full11():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/16')
-    ip6_src = ipaddress.ip_network('cccc:bbbb::/64')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
-    psid_len = 0
-    for i in range(ip4_pfx.num_addresses):
-        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx " + str(ip6_dst[i]) + "/128 ip6-src", ip6_src[i],
-              "ea-bits-len 0 psid-offset 0 psid-len 0")
-def full11br():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/16')
-    ip6_dst = ipaddress.ip_network('bbbb::/32')
-    psid_len = 0
-    for i in range(ip4_pfx.num_addresses):
-        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx " + str(ip6_dst[i]) + "/128 ip6-shared-src cccc:bbbb::1",
-              "ea-bits-len 0 psid-offset 0 psid-len 0")
-
-#
-# Algorithmic mapping Shared IPv4 address
-#
-def algo():
-    print("map add domain ip4-pfx 20.0.0.0/24 ip6-pfx bbbb::/32 ip6-src cccc:bbbb::1 ea-bits-len 16 psid-offset 6 psid-len 8")
-    print("map add domain ip4-pfx 20.0.1.0/24 ip6-pfx bbbb:1::/32 ip6-src cccc:bbbb::2 ea-bits-len 8 psid-offset 0 psid-len 0")
-
-#
-# IP4 forwarding
-#
-def ip4():
-    ip4_pfx = ipaddress.ip_network('20.0.0.0/16')
     for i in range(ip4_pfx.num_addresses):
-        print("ip route add " + str(ip4_pfx[i]) +  "/32 via 172.16.0.2")
-
-
-globals()[args.mapmode]()
-
+        if not i % 64:
+            ip6_src = ip6_src + 1
+        print("map add domain ip4-pfx " + str(ip4_pfx[i]) +  "/32 ip6-pfx ::/0 ip6-src " + str(ip6_src) +
+              " ea-bits-len 0 psid-offset 6 psid-len", psid_len)
+        for psid in range(0x1 << psid_len):
+            enduserprefix = list(ip6_dst.pop(0).subnets(new_prefix=64))[255-1]
+            print("map add rule index", i, "psid", psid, "ip6-dst", enduserprefix[(i * (0x1<<psid_len)) + psid])
 
+globals()[args.mapmode](args.ip4_pfx, args.ip6_pfx, args.ip6_src, args.psid_len, args.psid_offset,
+                        args.ea_bits_len)
diff --git a/vnet/vnet/map/examples/map-test.py b/vnet/vnet/map/examples/map-test.py
deleted file mode 100755
index 01f377fb6ee..00000000000
--- a/vnet/vnet/map/examples/map-test.py
+++ /dev/null
@@ -1,214 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2015 Cisco and/or its affiliates.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at:
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT 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, time
-from scapy.all import *
-
-import mapalgs
-
-
-ifname = "vpp-tap"
-
-loc_v4_mac = "aa:aa:aa:aa:aa:a4"
-loc_v6_mac = "aa:aa:aa:aa:aa:a6"
-vpp_mac = "aa:aa:aa:aa:00:00"
-
-map_t = 1
-
-fragsize = 0
-map_mtu = 200
-
-def mac_to_vppmac(mac):
-    mac = mac.replace(':', '')
-    return mac[0:4]+"."+mac[4:8]+"."+mac[8:12]
-
-
-map = mapalgs.MapCalc( rulev6 = 'bbbb::/32',
-                     rulev4 = '20.0.0.0/24',
-                     ratio = 256);
-
-dmr = mapalgs.DmrCalc('cccc:bbbb::/96')
-
-
-ICMP_TYPES_CODES = {
-    0: 0,
-    3: 15,
-    4: 0,
-    5: 3,
-    6: 0,
-    8: 0,
-    9: 0,
-    10: 0,
-    11: 1,
-    12: 2,
-    13: 0,
-    14: 0,
-    15: 0,
-    16: 0,
-    17: 0,
-    18: 0
-}
-
-ICMP6_TYPES_CODES = {
-    1: 7,
-    2: 0,
-    3: 1,
-    4: 3,
-}
-
-def net_conf():
-    c = ""
-    c += "tap connect "+ifname+" hwaddr "+mac_to_vppmac(vpp_mac)+" \n"
-    c += "set int state tap-0 up \n"
-    c += "set ip6 neighbor tap-0 2001:f00d::1 "+mac_to_vppmac(loc_v6_mac)+" \n"
-    c += "set ip  arp      tap-0 10.0.0.1     "+mac_to_vppmac(loc_v4_mac)+" \n"
-    c += "ip route add ::/0  via 2001:f00d::1 tap-0 \n"
-    c += "ip route add 0.0.0.0/0 via 10.0.0.1 tap-0 \n"
-    return c
-
-def conf():
-    c = net_conf()
-    c += "map add domain ip4-pfx 20.0.0.0/24 ip6-pfx bbbb::/32 ea-bits-len 16 psid-offset 6 psid-len 8"
-    if map_mtu != 0:
-        c += " mtu "+str(map_mtu)
-    if map_t:
-        c += " ip6-src cccc:bbbb::/96 map-t"
-    else:
-        c += " ip6-src cccc:bbbb::ffff"
-
-    c += "\n"
-    return c
-
-def send_packet(ip_header, ip_content):
-    print("Send packet")
-    if fragsize != 0:
-        if ip_header.version == 4:
-            frags = fragment(ip_header/ip_content, fragsize=fragsize)
-            for f in frags:
-                print("Fragmented IPv4 packet")
-                sendp(Ether(dst=vpp_mac, src=loc_v4_mac)/f, iface=ifname)
-        elif ip_header.version == 6:
-            frags = fragment6(ip_header/IPv6ExtHdrFragment()/ip_content, fragsize)
-            for f in frags:
-                print("Fragmented IPv6 packet")
-                sendp(Ether(dst=vpp_mac, src=loc_v6_mac)/f, iface=ifname)
-    else:
-        sendp(Ether(dst=vpp_mac)/ip_header/ip_content, iface=ifname)
-
-def send_packet_frag_inner(packet, inner_header, inner_content):
-    print("Send packet with inner ICMP packet")
-    if fragsize != 0:
-        if packet.version == 4:
-            frags = fragment(inner_header/inner_content, fragsize=fragsize)
-            for f in frags:
-                print("Fragmented IPv4 inner packet")
-                sendp(Ether(dst=vpp_mac, src=loc_v4_mac)/packet/f, iface=ifname)
-        elif packet.version == 6:
-            frags = fragment6(inner_header/IPv6ExtHdrFragment()/inner_content, fragsize)
-            for f in frags:
-                print("Fragmented IPv6 inner packet")
-                sendp(Ether(dst=vpp_mac, src=loc_v6_mac)/packet/f, iface=ifname)
-    else:
-        sendp(Ether(dst=vpp_mac)/packet/inner_header/inner_content, iface=ifname)
-
-
-def sendv6udp(src, dst, port):
-    psid = map.gen_psid(port)
-    ceaddr = str(map.get_mapce_addr(src, psid))
-    dst = str(dmr.embed_6052addr(dst))
-    send_packet(IPv6(dst=dst, src=ceaddr), UDP(sport=port)/('X'*900))
-
-def sendv6tcp(src, dst, port):
-    psid = map.gen_psid(port)
-    ceaddr = str(map.get_mapce_addr(src, psid))
-    dst = str(dmr.embed_6052addr(dst))
-    send_packet(IPv6(dst=dst, src=ceaddr), TCP(sport=port)/('X'*900))
-
-def sendv4udp(src, dst, port):
-    send_packet(IP(dst=dst, src=src), UDP(dport=port)/('X'*900))
-
-def sendv4tcp(src, dst, port):
-    send_packet(IP(dst=dst, src=src), TCP(dport=port)/('X'*900))
-
-def sendv6ping(src, dst, id):
-    psid = map.gen_psid(id)
-    ceaddr = str(map.get_mapce_addr(src, psid))
-    dst = str(dmr.embed_6052addr(dst))
-    send_packet(IPv6(dst=dst, src=ceaddr), ICMPv6EchoRequest(id=id, data='A'*500))
-    send_packet(IPv6(dst=dst, src=ceaddr), ICMPv6EchoReply(id=id, data='A'*500))
-
-def sendv4ping(src, dst, id):
-    send_packet(IP(dst=dst, src=src), ICMP(id=id, type=0)/('X'*500))
-    send_packet(IP(dst=dst, src=src), ICMP(id=id, type=8)/('X'*500))
-
-def sendv4icmperr(src, dst, type, code, port, inner_src, inner_dst, payload_length):
-    inner = IP(dst=inner_dst, src=inner_src)/TCP(sport=port, dport=8888)/('X'*payload_length)
-    send_packet_frag_inner(IP(dst=dst, src=src)/ICMP(type=type, code=code), IP(dst=inner_dst, src=inner_src), TCP(sport=port, dport=8888)/('X'*payload_length))
-    #send_packet(IP(dst=dst, src=src)/ICMP(type=type, code=code)/inner)
-
-def sendv6icmperr(src, dst, type, code, port, payload_length):
-    psid = map.gen_psid(port)
-    src = str(map.get_mapce_addr(src, psid))
-    dst = str(dmr.embed_6052addr(dst))
-    inner_header = IPv6(dst=src, src=dst)
-    inner_content = TCP(sport=8888, dport=port)/('X'*payload_length)
-    send_packet_frag_inner(IPv6(dst=dst, src=src)/ICMPv6DestUnreach(type=type, code=code), inner_header, inner_content)
-    #send_packet(IPv6(dst=dst, src=src)/ICMPv6DestUnreach(type=type, code=code)/inner)
-
-def sendv4icmp_errors(src, dst, port, inner_src, inner_dst, payload_length):
-    for type in ICMP_TYPES_CODES:
-        for code in range(0, ICMP_TYPES_CODES[type] + 1):
-            sendv4icmperr(src, dst, type, code, port, inner_src, inner_dst, payload_length)
-        #sendv4icmperr(src, dst, type, ICMP_TYPES_CODES[type] + 2, port, inner_src, inner_dst, payload_length)
-        #sendv4icmperr(src, dst, type, 255, port, inner_src, inner_dst, payload_length)
-    #sendv4icmperr(src, dst, 1, 0, port, inner_src, inner_dst, payload_length)
-    #sendv4icmperr(src, dst, 2, 10, port, inner_src, inner_dst, payload_length)
-    #sendv4icmperr(src, dst, 255, 255, port, inner_src, inner_dst, payload_length)
-
-    #TODO: Check wrong paramater with different pointer values
-
-def sendv6icmp_errors(src, dst, port, payload_length):
-    for type in ICMP6_TYPES_CODES:
-        for code in range(0, ICMP6_TYPES_CODES[type] + 1):
-            sendv6icmperr(src, dst, type, code, port, payload_length)
-        #sendv6icmperr(src, dst, type, ICMP6_TYPES_CODES[type] + 2, port, payload_length)
-        #sendv6icmperr(src, dst, type, 255, port, payload_length)
-
-
-def traffic():
-    delay = 2.0
-    while 1:
-        #sendp(Ether(dst="bb:bb:bb:bb:bb:b4")/IP(dst="20.0.0.1")/UDP(chksum=0)/('X'*900), iface="vpp-tapv4")
-        #sendp(Ether(dst="bb:bb:bb:bb:bb:b6")/IPv6(dst="cccc:bbbb::a000:0001")/ICMPv6EchoRequest()/('X'*900), iface="vpp-tapv6")
-        #sendp(Ether(dst="bb:bb:bb:bb:bb:b6")/IPv6(dst="cccc:bbbb::a000:0001")/UDP()/('X'*900), iface="vpp-tapv6")
-        sendv6udp("20.0.0.1", "10.0.0.1", 12001)
-        sendv6tcp("20.0.0.1", "10.0.0.1", 12002)
-        sendv4udp("10.0.0.1", "20.0.0.1", 12003)
-        sendv4tcp("10.0.0.1", "20.0.0.1", 12004)
-        sendv6ping("20.0.0.1", "10.0.0.1", 12005)
-        sendv4ping("10.0.0.1", "20.0.0.1", 12006)
-        sendv4icmp_errors("10.0.0.1", "20.0.0.1", 12006, "20.0.0.1", "10.0.0.1", 500)
-        sendv4icmp_errors("10.0.0.1", "20.0.0.1", 12006, "20.0.0.1", "10.0.0.1", 1500)
-        sendv6icmp_errors("20.0.0.1", "10.0.0.1", 12006, 500)
-        time.sleep(delay)
-        delay *= 0.9
-
-if len(sys.argv) <= 1:
-    print("Usage: conf|traffic")
-    exit(1)
-
-if sys.argv[1] == "conf":
-    print(conf())
-elif sys.argv[1] == "traffic":
-    traffic()
\ No newline at end of file
diff --git a/vnet/vnet/map/examples/mapalgs.py b/vnet/vnet/map/examples/mapalgs.py
deleted file mode 100644
index 50a0ed0a3ee..00000000000
--- a/vnet/vnet/map/examples/mapalgs.py
+++ /dev/null
@@ -1,327 +0,0 @@
-#!/usr/bin/env python3
-
-# The MIT License (MIT)
-#
-# Copyright (c) 2015 
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-# File included from https://github.com/ejordangottlieb/pyswmap
-# Thanks to jordan ;)
-# - Pierre
-#
-
-# There is still a great deal of work required on this module.  Please
-# use with caution.  
-# -Jordan 
-
-import sys
-from ipaddress import (
-        IPv6Address,
-        IPv6Network,
-        ip_network,
-        ip_address,
-        )
-from math import (
-        log,
-        )
-
-class MapCalc(object):
-
-    def __init__(self,**bmr):
-        #rulev6,rulev4):
-        self.portranges = False
-
-        # Validate and set BMR and BMR derived values 
-        self._check_bmr_values(bmr)
-
-    def _check_bmr_values(self,bmr):
-        # Assume these values have not been supplied.  Validate later.
-        self.ealen = False
-        self.ratio = False
-
-        # Validate that a proper PSID Offset has been set
-        if 'psidoffset' not in bmr:
-            # Set Default PSID Offset of 6 if it is not set 
-            self.psidoffset = 6
-        else:
-            self.psidoffset = self._psid_offset(bmr['psidoffset'])
-
-        # Validate that a proper IPv4 rule prefix is defined
-        if 'rulev4' not in bmr:
-            print("The rule IPv4 prefix has not been set")
-            sys.exit(1)
-        else:
-            self.rulev4 = self._ipv4_rule(bmr['rulev4'])
-
-        # Validate that a proper IPv6 rule prefix is defined
-        if 'rulev6' not in bmr:
-            print("The rule IPv6 prefix has not been set")
-            sys.exit(1)
-        else:
-            self.rulev6 = self._ipv6_rule(bmr['rulev6'])
-
-        # Check if EA length was passed
-        if 'ealen' not in bmr:
-            self.ealen = False
-        else:
-            self.ealen = bmr['ealen']
-            self.ratio = self._calc_ratio(bmr['ealen'])
-
-        # Check if sharing ratio was passed or calculated by _calc_ratio
-        if 'ratio' not in bmr:
-            # Skip if we have already calculated ratio
-            if not (self.ratio):
-                self.ratio = False
-        else:
-            if (self.ealen):
-                # Check to see if supplied EA length contradicts supplied ratio
-                if ( bmr['ratio'] != self.ratio ):
-                    eavalue = "EA value {}".format(self.ealen)
-                    sharingratio = "sharing ratio {}".format(bmr['ratio'])
-                    print("Supplied {} and {} are contradictory".format(
-                                                                  eavalue,
-                                                                  sharingratio)
-                         )
-                    sys.exit(1)
-            else:
-                self.ratio = bmr['ratio']
-                self.ealen = self._calc_ea(bmr['ratio'])
-
-        # EA length or sharing ratio must be set
-        if not ( self.ealen or self.ratio):
-            print("The BMR must include an EA length or sharing ratio")
-            sys.exit(1)
-
-        # Since we have not hit an exception we can calculate the port bits
-        self.portbits = self._calc_port_bits()
-
-    def _ipv4_rule(self,rulev4):
-        try:
-            self.rulev4mask = ip_network(
-                        rulev4,
-                        strict=False
-                        ).prefixlen
-        except ValueError: 
-            print("Invalid IPv4 prefix {}".format(rulev4))
-            sys.exit(1)
-
-        self.rulev4object = ip_network(rulev4)
-
-        return rulev4
-
-    def _ipv6_rule(self,rulev6):
-        try:
-            self.rulev6mask = IPv6Network(
-                        rulev6,
-                        strict=False
-                        ).prefixlen
-        except ValueError:
-            print("Invalid IPv6 prefix {}".format(rulev6))
-            sys.exit(1)
-
-        return rulev6
-
-    def _psid_offset(self,psidoffset):
-        PSIDOFFSET_MAX = 6
-        if psidoffset in range(0,PSIDOFFSET_MAX+1):
-            return psidoffset
-        else:
-            print("Invalid PSID Offset value: {}".format(psidoffset))
-            sys.exit(1)
-
-    def _psid_range(self,x):
-        rset = []
-        for i in range(0,x+1):
-            rset.append(2**i)
-        return rset
-
-    def _calc_port_bits(self):
-        portbits = 16 - self.psidoffset - self.psidbits
-        return portbits
-
-    def _calc_ea(self,ratio):
-        if ratio not in ( self._psid_range(16) ):
-            print("Invalid ratio {}".format(ratio))
-            print("Ratio between 2 to the power of 0 thru 16")
-            sys.exit(1)
-
-        if ( 1 == ratio):
-            self.psidbits = 0
-        else:
-            self.psidbits = int(log(ratio,2))
-        ealen = self.psidbits + ( 32 - self.rulev4mask )
-        return ealen
-
-    def _calc_ratio(self,ealen):
-        maskbits = 32 - self.rulev4mask
-        if ( ealen < maskbits ):
-            print("EA of {} incompatible with rule IPv4 prefix {}".format(
-              ealen,
-              self.rulev4,
-              )
-            )
-            print("EA length must be at least {} bits".format(
-              maskbits,
-              )
-            )
-            sys.exit(1)
-
-        self.psidbits = ealen - ( 32 - self.rulev4mask )
-        if ( self.psidbits > 16):
-            print("EA length of {} is too large".format(
-              ealen,
-              )
-            )
-            print("EA should not exceed {} for rule IPv4 prefix {}".format(
-              maskbits + 16,
-              self.rulev4,
-              )
-            )
-            sys.exit(1)
-        ratio = 2**self.psidbits
-        return ratio
-
-    def gen_psid(self,portnum):
-        if ( portnum < self.start_port() ):
-            print("port value is less than allowed by PSID Offset")
-            sys.exit(1)
-        psid = (portnum & ((2**self.psidbits - 1) << self.portbits))
-        psid = psid >> self.portbits
-        return psid
-
-    def port_ranges(self):
-        return 2**self.psidoffset - 1
-
-    def start_port(self):
-        if self.psidoffset == 0: return 0  
-        return 2**(16 - self.psidoffset)
-
-    def port_list(self,psid):
-        startrange = psid * (2**self.portbits) + self.start_port()
-        increment = (2**self.psidbits) * (2**self.portbits)
-        portlist = [ ]
-        for port in range(startrange,startrange + 2**self.portbits):
-            if port >= 65536: continue
-            portlist.append(port)
-        for x in range(1,self.port_ranges()):
-            startrange += increment
-            for port in range(startrange,startrange + 2**self.portbits):
-                portlist.append(port)
-        return portlist
-
-    def ipv4_index(self,ipv4addr):
-        if ip_address(ipv4addr) in ip_network(self.rulev4):
-            x = ip_address(ipv4addr)
-            y = ip_network(self.rulev4,strict=False).network_address
-            self.ipv4addr = x
-            return ( int(x) - int(y) )
-        else:
-            print("Error: IPv4 address {} not in Rule IPv4 subnet {}".format(
-                  ipv4add,
-                  ip_network(self.rulev4,strict=False).network_address))
-            sys.exit(1)
-
-    def _calc_ipv6bit_pos(self):
-        addroffset = 128 - (self.rulev6mask + ( self.ealen - self.psidbits))
-        psidshift = 128 - ( self.rulev6mask + self.ealen )
-        return [addroffset,psidshift]
-
-    def _append_map_eabits(self,ipv4index,addroffset,psidshift,psid):
-        rulev6base = IPv6Network(self.rulev6,strict=False).network_address
-        map_prefix = int(rulev6base) | ( ipv4index << addroffset )
-        map_fullprefix = map_prefix | ( psid << psidshift)
-        return map_fullprefix
-        
-
-    def get_mapce_addr(self,ipv4addr,psid):
-        ipv4index = self.ipv4_index(ipv4addr)
-        (addroffset,psidshift) = self._calc_ipv6bit_pos()
-        map_fullprefix = self._append_map_eabits(ipv4index,
-                                                 addroffset,
-                                                 psidshift,
-                                                 psid)
-        mapv4iid = map_fullprefix | ( int(self.ipv4addr) << 16 )
-        map_full_address = mapv4iid | psid
-        mapce_address = "{}".format(IPv6Address(map_full_address))
-        return mapce_address
-
-    def get_mapce_prefix(self,ipv4addr,psid):
-        ipv4index = self.ipv4_index(ipv4addr)
-        (addroffset,psidshift) = self._calc_ipv6bit_pos()
-        map_fullprefix = self._append_map_eabits(ipv4index,
-                                                 addroffset,
-                                                 psidshift,
-                                                 psid)
-        mapce_prefix = "{}/{}".format(
-                                   IPv6Address(map_fullprefix),
-                                   self.rulev6mask + self.ealen
-                                )
-        return mapce_prefix
-
-    def get_map_ipv4(self,mapce_address):
-        ipv4 = (int(IPv6Address(mapce_address)) & ( 0xffffffff << 16 )) >> 16
-        return ip_address(ipv4)
-            
-
-
-class DmrCalc(object):
-
-    def __init__(self,dmr):
-
-        # Validate and set BMR and BMR derived values 
-        self.dmrprefix = self._check_dmr_prefix(dmr)
-
-    def embed_6052addr(self,ipv4addr):
-
-        try:
-            ipv4addrint = int(ip_address(ipv4addr))
-        except ValueError:
-            print("Invalid IPv4 address {}".format(ipv4addr))
-            sys.exit(1)
-
-        if ( self.dmrprefix.prefixlen == 64 ):
-            ipv6int = ipv4addrint << 24
-            ipv6int += int(self.dmrprefix.network_address)
-            return IPv6Address(ipv6int)
-
-        if ( self.dmrprefix.prefixlen == 96 ):
-            ipv6int = ipv4addrint
-            ipv6int += int(self.dmrprefix.network_address)
-            return IPv6Address(ipv6int)
-
-    def _check_dmr_prefix(self,dmrprefix):
-        try:
-            self.dmrmask = IPv6Network(
-                        dmrprefix,
-                        strict=False
-                        ).prefixlen
-        except ValueError:
-            print("Invalid IPv6 prefix {}".format(prefix))
-            sys.exit(1)
-
-        if self.dmrmask not in (32,40,48,56,64,96):
-            print("Invalid prefix mask /{}".format(self.dmrmask))
-            sys.exit(1)
-
-        return IPv6Network(dmrprefix)
-
-if __name__ == "__main__":
-    m = DmrCalc('fd80::/48')
-    print(m.dmrprefix)
diff --git a/vnet/vnet/map/examples/mt-test.py b/vnet/vnet/map/examples/mt-test.py
deleted file mode 100644
index 62d269c7a13..00000000000
--- a/vnet/vnet/map/examples/mt-test.py
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009-2014 Cisco and/or its affiliates.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at:
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT 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
-import time
-from scapy.all import *
-from Queue import *
-
-iface = 'veth1'
-
-class SnifferThread(threading.Thread) :
-    def __init__(self,q,iface,flt,timeout) :
-        threading.Thread.__init__(self)
-        self.q = q
-        self.iface = iface
-        self.timeout = timeout
-        self.flt = flt
-        print("Sniffers reporting for service on ",self.iface)
- 
-    def run(self) :
-        conf.iface=self.iface
-        conf.iface6=self.iface
-
-        r = sniff(filter=self.flt,iface=self.iface,timeout=self.timeout,prn=lambda x: x.summary())
-        self.q.put(r)
-
-
-
-# New "SR" function
-#   Fire off thread with filter and expected answer packet(s).
-# Fire off sniffer thread, main thread sends packet
-#   Returns true if found
-
-def sr2(answer, *args, **kwargs):
-    q = Queue()
-    print("Creating SnifferThreadWorkerThread")
-    flt='ip proto 41'
-    iface='veth1'
-    sniffer = SnifferThread(q,iface,flt,1)
-    sniffer.setDaemon(True)
-    sniffer.start()
-
-    print "Sending packet:"
-    send(*args, **kwargs)
-    sniffer.join()
-    ps = q.get()
-    
-#    ps.summary()
-    print "Number of packets sniffed:", len(ps)
-
-    for p in ps:
-        ip = p.getlayer(1)
-        print "Comparing", ip.summary(), "and", answer.summary()
-        if ip == answer:
-            print "We have a match!!"
-            return True
-    return False
-
-aip6 = IPv6(dst='2002:0a0a:0a0a::12')/ICMPv6EchoRequest()
-answer= IP(src="10.0.0.100",dst="10.10.10.10",ttl=63)/aip6
-packet = IPv6(dst='2002:0a0a:0a0a::12')/ICMPv6EchoRequest()
-
-# From IPv6
-sr2(answer, packet,iface='veth1')
-
-#From IPv4
-packet = IP(src='10.10.10.10',dst='10.0.0.100')/IPv6(src='2002:0a0a:0a0a::12',dst='1::2')/ICMPv6EchoRequest()
-sr2(answer, packet,iface='veth1')