Fix plugin version numbers

Change-Id: Ie485e9dfa04747b5e4ba93fdeabc5802dc001d31
Signed-off-by: Damjan Marion <damarion@cisco.com>

RELEASE.md

@@ -7,14 +7,85 @@
 @page release_notes_1701 Release notes for VPP 17.01
 
 @note This release was for a while known as 16.12.
-@todo Release 17.01 needs release notes.
 
 ## Features
 
+- [Integrated November 2016 DPDK release](http://www.dpdk.org/doc/guides/rel_notes/release_16_11.html)
+
+- Complete rework of Forwarding Information Base (FIB)
+
+- Performance Improvements
+  - Improvements in DPDK input and output nodes
+  - Improvements in L2 path
+  - Improvmeents in IPv4 lookup node
+
+- Feature Arcs Improvements
+  - Consolidation of the code
+  - New feature arcs
+    - device-input
+    - interface-output
+
+- DPDK Cryptodev Support
+  - Software and Hardware Crypto Support
+
+- DPDK HQoS support
+
+- Simple Port Analyzer (SPAN)
+
+- Bidirectional Forwarding Detection
+  - Basic implementation
+
+- IPFIX Improvements
+
+- L2 GRE over IPSec tunnels
+
+- Link Layer Discovery Protocol (LLDP)
+
+- Vhost-user Improvements
+  - Performance Improvements
+  - Multiqueue
+  - Reconnect
+
+- LISP Enhancements
+  - Source/Dest control plane support
+  - L2 over LISP and GRE
+  - Map-Register/Map-Notify/RLOC-probing support
+  - L2 API improvements, overall code hardening
+
+- Plugins:
+  - New: ACL
+  - New: Flow per Packet
+  - Improved: SNAT
+    - Mutlithreading
+    - Flow export
+
+- Doxygen Enhancements
+
+- Luajit API bindings
+
+- API Refactoring
+  - file split
+  - message signatures
+
+- Python and Scapy based unit testing infrastructure
+  - Infrastructure
+  - Various tests
+
+- Packet Generator improvements
+
+- TUN/TAP jumbo frames support
+
+- Other various bug fixes and improvements
+
 ## Known issues
 
+For the full list of issues please reffer to fd.io [JIRA](https://jira.fd.io).
+
 ## Issues fixed
 
+For the full list of fixed issues please reffer to:
+- fd.io [JIRA](https://jira.fd.io)
+- git [commit log](https://git.fd.io/vpp/log/?h=stable/1701)
 
 @page release_notes_1609 Release notes for VPP 16.09
 

build-root/deb/debian/vpp-python-api.postinst

@@ -0,0 +1,5 @@
+#!/bin/sh -e
+
+# after installing python-api files
+python2_sitedir=$(python -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())")
+easy_install --install-dir=$python2_sitedir  -z $python2_sitedir/vpp_papi/vpp_papi-*.egg

build-root/deb/debian/vpp-python-api.prerm

@@ -0,0 +1,8 @@
+#!/bin/sh -e
+
+# before removing python-api files
+python2_sitedir=$(python -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())")
+easy_install --install-dir=$python2_sitedir -mxNq vpp_papi
+
+# the egg has been copied during install
+rm $python2_sitedir/vpp_papi-*.egg

build-root/scripts/csit-test-branch

@@ -1,2 +1,2 @@
 #!/bin/sh
-echo oper-161218
+echo oper-rls1701-170115

build-root/scripts/version

@@ -50,5 +50,5 @@ fi
       echo ${TAG}-${ADD}${CMT:+~${CMT}}${BLD}
     fi
   else
-    echo ${TAG}
+    echo ${TAG}-release
 fi

plugins/acl-plugin/configure.ac

@@ -1,4 +1,4 @@
-AC_INIT(acl_plugin, 1.0)
+AC_INIT(acl_plugin, 17.01)
 AC_CONFIG_MACRO_DIR([../../vpp-api/java/m4])
 LT_INIT
 AM_INIT_AUTOMAKE

plugins/ioam-plugin/configure.ac

@@ -1,4 +1,4 @@
-AC_INIT(ioam_plugin, 1.0)
+AC_INIT(ioam_plugin, 17.01)
 LT_INIT
 AC_CONFIG_MACRO_DIR([../../vpp-api/java/m4])
 AM_INIT_AUTOMAKE

plugins/snat-plugin/configure.ac

@@ -1,4 +1,4 @@
-AC_INIT(snat_plugin, 1.0)
+AC_INIT(snat_plugin, 17.01)
 AC_CONFIG_MACRO_DIR([../../vpp-api/java/m4])
 AM_INIT_AUTOMAKE
 AM_SILENT_RULES([yes])

test/template_bd.py

@@ -11,23 +11,28 @@ class BridgeDomain(object):
     __metaclass__ = ABCMeta
 
     @property
-    def frame_pg0_to_pg1(self):
-        """ Ethernet frame sent from pg0 and expected to arrive at pg1 """
+    def frame_request(self):
+        """ Ethernet frame modeling a generic request """
         return (Ether(src='00:00:00:00:00:01', dst='00:00:00:00:00:02') /
                 IP(src='1.2.3.4', dst='4.3.2.1') /
                 UDP(sport=10000, dport=20000) /
                 Raw('\xa5' * 100))
 
     @property
-    def frame_pg1_to_pg0(self):
-        """ Ethernet frame sent from pg1 and expected to arrive at pg0 """
+    def frame_reply(self):
+        """ Ethernet frame modeling a generic reply """
         return (Ether(src='00:00:00:00:00:02', dst='00:00:00:00:00:01') /
                 IP(src='4.3.2.1', dst='1.2.3.4') /
                 UDP(sport=20000, dport=10000) /
                 Raw('\xa5' * 100))
 
     @abstractmethod
-    def encapsulate(self, pkt):
+    def encap_mcast(self, pkt, src_ip, src_mac, vni):
+        """ Encapsulate mcast packet """
+        pass
+
+    @abstractmethod
+    def encapsulate(self, pkt, vni):
         """ Encapsulate packet """
         pass
 
@@ -37,17 +42,30 @@ class BridgeDomain(object):
         pass
 
     @abstractmethod
-    def check_encapsulation(self, pkt):
+    def check_encapsulation(self, pkt, vni, local_only=False):
         """ Verify the encapsulation """
         pass
 
+    def assert_eq_pkts(self, pkt1, pkt2):
+        """ Verify the Ether, IP, UDP, payload are equal in both
+        packets
+        """
+        self.assertEqual(pkt1[Ether].src, pkt2[Ether].src)
+        self.assertEqual(pkt1[Ether].dst, pkt2[Ether].dst)
+        self.assertEqual(pkt1[IP].src, pkt2[IP].src)
+        self.assertEqual(pkt1[IP].dst, pkt2[IP].dst)
+        self.assertEqual(pkt1[UDP].sport, pkt2[UDP].sport)
+        self.assertEqual(pkt1[UDP].dport, pkt2[UDP].dport)
+        self.assertEqual(pkt1[Raw], pkt2[Raw])
+
     def test_decap(self):
         """ Decapsulation test
         Send encapsulated frames from pg0
         Verify receipt of decapsulated frames on pg1
         """
 
-        encapsulated_pkt = self.encapsulate(self.frame_pg0_to_pg1)
+        encapsulated_pkt = self.encapsulate(self.frame_request,
+                                            self.single_tunnel_bd)
 
         self.pg0.add_stream([encapsulated_pkt, ])
 
@@ -61,22 +79,14 @@ class BridgeDomain(object):
                          'Invalid number of packets on '
                          'output: {}'.format(len(out)))
         pkt = out[0]
-
-        # TODO: add error messages
-        self.assertEqual(pkt[Ether].src, self.frame_pg0_to_pg1[Ether].src)
-        self.assertEqual(pkt[Ether].dst, self.frame_pg0_to_pg1[Ether].dst)
-        self.assertEqual(pkt[IP].src, self.frame_pg0_to_pg1[IP].src)
-        self.assertEqual(pkt[IP].dst, self.frame_pg0_to_pg1[IP].dst)
-        self.assertEqual(pkt[UDP].sport, self.frame_pg0_to_pg1[UDP].sport)
-        self.assertEqual(pkt[UDP].dport, self.frame_pg0_to_pg1[UDP].dport)
-        self.assertEqual(pkt[Raw], self.frame_pg0_to_pg1[Raw])
+        self.assert_eq_pkts(pkt, self.frame_request)
 
     def test_encap(self):
         """ Encapsulation test
         Send frames from pg1
         Verify receipt of encapsulated frames on pg0
         """
-        self.pg1.add_stream([self.frame_pg1_to_pg0])
+        self.pg1.add_stream([self.frame_reply])
 
         self.pg0.enable_capture()
 
@@ -88,14 +98,77 @@ class BridgeDomain(object):
                          'Invalid number of packets on '
                          'output: {}'.format(len(out)))
         pkt = out[0]
-        self.check_encapsulation(pkt)
+        self.check_encapsulation(pkt, self.single_tunnel_bd)
 
         payload = self.decapsulate(pkt)
-        # TODO: add error messages
-        self.assertEqual(payload[Ether].src, self.frame_pg1_to_pg0[Ether].src)
-        self.assertEqual(payload[Ether].dst, self.frame_pg1_to_pg0[Ether].dst)
-        self.assertEqual(payload[IP].src, self.frame_pg1_to_pg0[IP].src)
-        self.assertEqual(payload[IP].dst, self.frame_pg1_to_pg0[IP].dst)
-        self.assertEqual(payload[UDP].sport, self.frame_pg1_to_pg0[UDP].sport)
-        self.assertEqual(payload[UDP].dport, self.frame_pg1_to_pg0[UDP].dport)
-        self.assertEqual(payload[Raw], self.frame_pg1_to_pg0[Raw])
+        self.assert_eq_pkts(payload, self.frame_reply)
+
+    def test_ucast_flood(self):
+        """ Unicast flood test
+        Send frames from pg3
+        Verify receipt of encapsulated frames on pg0
+        """
+        self.pg3.add_stream([self.frame_reply])
+
+        self.pg0.enable_capture()
+
+        self.pg_start()
+
+        # Get packet from each tunnel and assert it's corectly encapsulated.
+        out = self.pg0.get_capture()
+        self.assertEqual(len(out), 10,
+                         'Invalid number of packets on '
+                         'output: {}'.format(len(out)))
+        for pkt in out:
+            self.check_encapsulation(pkt, self.ucast_flood_bd, True)
+            payload = self.decapsulate(pkt)
+            self.assert_eq_pkts(payload, self.frame_reply)
+
+    def test_mcast_flood(self):
+        """ Multicast flood test
+        Send frames from pg2
+        Verify receipt of encapsulated frames on pg0
+        """
+        self.pg2.add_stream([self.frame_reply])
+
+        self.pg0.enable_capture()
+
+        self.pg_start()
+
+        # Pick first received frame and check if it's corectly encapsulated.
+        out = self.pg0.get_capture()
+        self.assertEqual(len(out), 1,
+                         'Invalid number of packets on '
+                         'output: {}'.format(len(out)))
+        pkt = out[0]
+        self.check_encapsulation(pkt, self.mcast_flood_bd, True)
+
+        payload = self.decapsulate(pkt)
+        self.assert_eq_pkts(payload, self.frame_reply)
+
+    @staticmethod
+    def ipn_to_ip(ipn):
+        return '.'.join(str(i) for i in bytearray(ipn))
+
+    def test_mcast_rcv(self):
+        """ Multicast receive test
+        Send 20 encapsulated frames from pg0 only 10 match unicast tunnels
+        Verify receipt of 10 decap frames on pg2
+        """
+        mac = self.pg0.remote_mac
+        ip_range_start = 10
+        ip_range_end = 30
+        mcast_stream = [
+            self.encap_mcast(self.frame_request, self.ipn_to_ip(ip), mac,
+                             self.mcast_flood_bd)
+            for ip in self.ip4_range(self.pg0.remote_ip4n,
+                                     ip_range_start, ip_range_end)]
+        self.pg0.add_stream(mcast_stream)
+        self.pg2.enable_capture()
+        self.pg_start()
+        out = self.pg2.get_capture()
+        self.assertEqual(len(out), 10,
+                         'Invalid number of packets on '
+                         'output: {}'.format(len(out)))
+        for pkt in out:
+            self.assert_eq_pkts(pkt, self.frame_request)

test/test_vxlan.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 
+import socket
 import unittest
 from framework import VppTestCase, VppTestRunner
 from template_bd import BridgeDomain
@@ -7,6 +8,7 @@ from template_bd import BridgeDomain
 from scapy.layers.l2 import Ether
 from scapy.layers.inet import IP, UDP
 from scapy.layers.vxlan import VXLAN
+from scapy.utils import atol
 
 
 class TestVxlan(BridgeDomain, VppTestCase):
@@ -16,7 +18,7 @@ class TestVxlan(BridgeDomain, VppTestCase):
         BridgeDomain.__init__(self)
         VppTestCase.__init__(self, *args)
 
-    def encapsulate(self, pkt):
+    def encapsulate(self, pkt, vni):
         """
         Encapsulate the original payload frame by adding VXLAN header with its
         UDP, IP and Ethernet fields
@@ -24,7 +26,18 @@ class TestVxlan(BridgeDomain, VppTestCase):
         return (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
                 IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
                 UDP(sport=self.dport, dport=self.dport, chksum=0) /
-                VXLAN(vni=self.vni, flags=self.flags) /
+                VXLAN(vni=vni, flags=self.flags) /
+                pkt)
+
+    def encap_mcast(self, pkt, src_ip, src_mac, vni):
+        """
+        Encapsulate the original payload frame by adding VXLAN header with its
+        UDP, IP and Ethernet fields
+        """
+        return (Ether(src=src_mac, dst=self.mcast_mac4) /
+                IP(src=src_ip, dst=self.mcast_ip4) /
+                UDP(sport=self.dport, dport=self.dport, chksum=0) /
+                VXLAN(vni=vni, flags=self.flags) /
                 pkt)
 
     def decapsulate(self, pkt):
@@ -37,21 +50,66 @@ class TestVxlan(BridgeDomain, VppTestCase):
 
     # Method for checking VXLAN encapsulation.
     #
-    def check_encapsulation(self, pkt):
+    def check_encapsulation(self, pkt, vni, local_only=False):
         # TODO: add error messages
         # Verify source MAC is VPP_MAC and destination MAC is MY_MAC resolved
         #  by VPP using ARP.
         self.assertEqual(pkt[Ether].src, self.pg0.local_mac)
-        self.assertEqual(pkt[Ether].dst, self.pg0.remote_mac)
+        if not local_only:
+            self.assertEqual(pkt[Ether].dst, self.pg0.remote_mac)
         # Verify VXLAN tunnel source IP is VPP_IP and destination IP is MY_IP.
         self.assertEqual(pkt[IP].src, self.pg0.local_ip4)
-        self.assertEqual(pkt[IP].dst, self.pg0.remote_ip4)
+        if not local_only:
+            self.assertEqual(pkt[IP].dst, self.pg0.remote_ip4)
         # Verify UDP destination port is VXLAN 4789, source UDP port could be
         #  arbitrary.
         self.assertEqual(pkt[UDP].dport, type(self).dport)
         # TODO: checksum check
-        # Verify VNI, based on configuration it must be 1.
-        self.assertEqual(pkt[VXLAN].vni, type(self).vni)
+        # Verify VNI
+        self.assertEqual(pkt[VXLAN].vni, vni)
+
+    @staticmethod
+    def ip4_range(ip4n, s=10, e=20):
+        base = str(bytearray(ip4n)[:3])
+        return ((base + ip) for ip in str(bytearray(range(s, e))))
+
+    @classmethod
+    def create_vxlan_flood_test_bd(cls, vni):
+        # Create 10 ucast vxlan tunnels under bd
+        ip_range_start = 10
+        ip_range_end = 20
+        next_hop_address = cls.pg0.remote_ip4n
+        for dest_addr in cls.ip4_range(next_hop_address, ip_range_start,
+                                       ip_range_end):
+            # add host route so dest_addr will not be resolved
+            cls.vapi.ip_add_del_route(dest_addr, 32, next_hop_address)
+            r = cls.vapi.vxlan_add_del_tunnel(
+                src_addr=cls.pg0.local_ip4n,
+                dst_addr=dest_addr,
+                vni=vni)
+            cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index, bd_id=vni)
+
+    @classmethod
+    def add_del_mcast_load(cls, is_add):
+        ip_range_start = 10
+        ip_range_end = 210
+        for dest_addr in cls.ip4_range(cls.mcast_ip4n, ip_range_start,
+                                       ip_range_end):
+            vni = bytearray(dest_addr)[3]
+            cls.vapi.vxlan_add_del_tunnel(
+                src_addr=cls.pg0.local_ip4n,
+                dst_addr=dest_addr,
+                mcast_sw_if_index=1,
+                vni=vni,
+                is_add=is_add)
+
+    @classmethod
+    def add_mcast_load(cls):
+        cls.add_del_mcast_load(is_add=1)
+
+    @classmethod
+    def del_mcast_load(cls):
+        cls.add_del_mcast_load(is_add=0)
 
     # Class method to start the VXLAN test case.
     #  Overrides setUpClass method in VppTestCase class.
@@ -65,12 +123,11 @@ class TestVxlan(BridgeDomain, VppTestCase):
         try:
             cls.dport = 4789
             cls.flags = 0x8
-            cls.vni = 1
 
             # Create 2 pg interfaces.
-            cls.create_pg_interfaces(range(2))
-            cls.pg0.admin_up()
-            cls.pg1.admin_up()
+            cls.create_pg_interfaces(range(4))
+            for pg in cls.pg_interfaces:
+                pg.admin_up()
 
             # Configure IPv4 addresses on VPP pg0.
             cls.pg0.config_ip4()
@@ -78,14 +135,47 @@ class TestVxlan(BridgeDomain, VppTestCase):
             # Resolve MAC address for VPP's IP address on pg0.
             cls.pg0.resolve_arp()
 
+            # Our Multicast address
+            cls.mcast_ip4 = '239.1.1.1'
+            cls.mcast_ip4n = socket.inet_pton(socket.AF_INET, cls.mcast_ip4)
+            iplong = atol(cls.mcast_ip4)
+            cls.mcast_mac4 = "01:00:5e:%02x:%02x:%02x" % (
+                (iplong >> 16) & 0x7F, (iplong >> 8) & 0xFF, iplong & 0xFF)
+
             # Create VXLAN VTEP on VPP pg0, and put vxlan_tunnel0 and pg1
             #  into BD.
+            cls.single_tunnel_bd = 1
             r = cls.vapi.vxlan_add_del_tunnel(
                 src_addr=cls.pg0.local_ip4n,
                 dst_addr=cls.pg0.remote_ip4n,
-                vni=cls.vni)
-            cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index, bd_id=1)
-            cls.vapi.sw_interface_set_l2_bridge(cls.pg1.sw_if_index, bd_id=1)
+                vni=cls.single_tunnel_bd)
+            cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index,
+                                                bd_id=cls.single_tunnel_bd)
+            cls.vapi.sw_interface_set_l2_bridge(cls.pg1.sw_if_index,
+                                                bd_id=cls.single_tunnel_bd)
+
+            # Setup vni 2 to test multicast flooding
+            cls.mcast_flood_bd = 2
+            cls.create_vxlan_flood_test_bd(cls.mcast_flood_bd)
+            r = cls.vapi.vxlan_add_del_tunnel(
+                src_addr=cls.pg0.local_ip4n,
+                dst_addr=cls.mcast_ip4n,
+                mcast_sw_if_index=1,
+                vni=cls.mcast_flood_bd)
+            cls.vapi.sw_interface_set_l2_bridge(r.sw_if_index,
+                                                bd_id=cls.mcast_flood_bd)
+            cls.vapi.sw_interface_set_l2_bridge(cls.pg2.sw_if_index,
+                                                bd_id=cls.mcast_flood_bd)
+
+            # Add and delete mcast tunnels to check stability
+            cls.add_mcast_load()
+            cls.del_mcast_load()
+
+            # Setup vni 3 to test unicast flooding
+            cls.ucast_flood_bd = 3
+            cls.create_vxlan_flood_test_bd(cls.ucast_flood_bd)
+            cls.vapi.sw_interface_set_l2_bridge(cls.pg3.sw_if_index,
+                                                bd_id=cls.ucast_flood_bd)
         except Exception:
             super(TestVxlan, cls).tearDownClass()
             raise
@@ -97,6 +187,9 @@ class TestVxlan(BridgeDomain, VppTestCase):
         super(TestVxlan, self).tearDown()
         if not self.vpp_dead:
             self.logger.info(self.vapi.cli("show bridge-domain 1 detail"))
+            self.logger.info(self.vapi.cli("show bridge-domain 2 detail"))
+            self.logger.info(self.vapi.cli("show bridge-domain 3 detail"))
+            self.logger.info(self.vapi.cli("show vxlan tunnel"))
 
 
 if __name__ == '__main__':

vlib-api/vlibapi/api_shared.c

@@ -691,6 +691,8 @@ vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
   vl_msg_api_msg_config_t cfg;
   vl_msg_api_msg_config_t *c = &cfg;
 
+  memset (c, 0, sizeof (*c));
+
   c->id = id;
   c->name = name;
   c->handler = handler;

vlib-api/vlibmemory/memory_vlib.c

@@ -347,6 +347,8 @@ memory_api_init (char *region_name)
   vl_msg_api_msg_config_t cfg;
   vl_msg_api_msg_config_t *c = &cfg;
 
+  memset (c, 0, sizeof (*c));
+
   if ((rv = vl_map_shmem (region_name, 1 /* is_vlib */ )) < 0)
     return rv;
 
@@ -360,6 +362,7 @@ memory_api_init (char *region_name)
     c->size = sizeof(vl_api_##n##_t);                           \
     c->traced = 1; /* trace, so these msgs print */             \
     c->replay = 0; /* don't replay client create/delete msgs */ \
+    c->message_bounce = 0; /* don't bounce this message */	\
     vl_msg_api_config(c);} while (0);
 
   foreach_vlib_api_msg;

vnet/vnet/devices/virtio/vhost-user.c

@@ -2422,9 +2422,6 @@ vhost_user_delete_if (vnet_main_t * vnm, vlib_main_t * vm, u32 sw_if_index)
   // Disable and reset interface
   vhost_user_term_if (vui);
 
-  // Back to pool
-  pool_put (vum->vhost_user_interfaces, vui);
-
   // Reset renumbered iface
   if (hwif->dev_instance <
       vec_len (vum->show_dev_instance_by_real_dev_instance))
@@ -2432,6 +2429,9 @@ vhost_user_delete_if (vnet_main_t * vnm, vlib_main_t * vm, u32 sw_if_index)
 
   // Delete ethernet interface
   ethernet_delete_interface (vnm, vui->hw_if_index);
+
+  // Back to pool
+  pool_put (vum->vhost_user_interfaces, vui);
   return rv;
 }
 

vnet/vnet/dhcpv6/proxy_node.c

@@ -244,7 +244,11 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
           /* Send to DHCPV6 server via the configured FIB */
           rx_sw_if_index = sw_if_index =  vnet_buffer(b0)->sw_if_index[VLIB_RX];
           rx_fib_idx = im->fib_index_by_sw_if_index [rx_sw_if_index];
-          server_idx = dpm->dhcp6_server_index_by_rx_fib_index[rx_fib_idx];
+
+	  if (vec_len(dpm->dhcp6_server_index_by_rx_fib_index) <= rx_fib_idx)
+	    goto no_server;
+
+	  server_idx = dpm->dhcp6_server_index_by_rx_fib_index[rx_fib_idx];
 
           if (PREDICT_FALSE (pool_is_free_index (dpm->dhcp6_servers,
                                                           server_idx)))

vnet/vnet/ethernet/arp.c

@@ -1043,12 +1043,25 @@ arp_input (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 	  src_flags = fib_entry_get_flags (src_fei);
 
 	  if (!((FIB_ENTRY_FLAG_ATTACHED & src_flags) ||
-		(FIB_ENTRY_FLAG_CONNECTED & src_flags)) ||
-	      sw_if_index0 != fib_entry_get_resolving_interface (src_fei))
+		(FIB_ENTRY_FLAG_CONNECTED & src_flags)))
 	    {
+	      /*
+	       * The packet was sent from an address that is not connected nor attached
+	       * i.e. it is not from an address that is covered by a link's sub-net,
+	       * nor is it a already learned host resp.
+	       */
 	      error0 = ETHERNET_ARP_ERROR_l3_src_address_not_local;
 	      goto drop2;
 	    }
+	  if (sw_if_index0 != fib_entry_get_resolving_interface (src_fei))
+	    {
+	      /*
+	       * The interface the ARP was received on is not the interface
+	       * on which the covering prefix is configured. Maybe this is a case
+	       * for unnumbered.
+	       */
+	      is_unnum0 = 1;
+	    }
 
 	  /* Reject requests/replies with our local interface address. */
 	  if (FIB_ENTRY_FLAG_LOCAL & src_flags)

vnet/vnet/fib/fib_attached_export.c

@@ -244,6 +244,12 @@ fib_attached_export_import (fib_entry_t *fib_entry,
 {
     fib_entry_delegate_t *fed;
     fib_ae_import_t *import;
+    fib_node_index_t fei;
+
+    /*
+     * save index for later post-realloc retreival
+     */
+    fei = fib_entry_get_index(fib_entry);
 
     pool_get(fib_ae_import_pool, import);
 
@@ -292,11 +298,13 @@ fib_attached_export_import (fib_entry_t *fib_entry,
 
     /*
      * track the entry in the export table so we can update appropriately
-     * when it changes
+     * when it changes.
+     * Exporting prefixes will have allocated new fib_entry_t objects, so the pool
+     * may have realloc'd.
      */
-    import->faei_export_sibling =
-	fib_entry_cover_track(fib_entry_get(import->faei_export_entry),
-			      fib_entry_get_index(fib_entry));
+    fib_entry = fib_entry_get(fei);
+        import->faei_export_sibling =
+	  fib_entry_cover_track(fib_entry_get(import->faei_export_entry), fei);
 
     fed = fib_entry_delegate_find_or_add(fib_entry,
                                          FIB_ENTRY_DELEGATE_ATTACHED_IMPORT);

vnet/vnet/ip/ip6_neighbor.c

@@ -155,7 +155,6 @@ typedef struct
 
   /* Link local address to use (defaults to underlying physical for logical interfaces */
   ip6_address_t link_local_address;
-  u8 link_local_prefix_len;
 
 } ip6_radv_t;
 
@@ -2022,7 +2021,6 @@ ip6_neighbor_sw_interface_add_del (vnet_main_t * vnm,
 	  /* fill in default link-local address  (this may be overridden) */
 	  ip6_link_local_address_from_ethernet_address
 	    (&a->link_local_address, eth_if0->address);
-	  a->link_local_prefix_len = 64;
 
 	  mhash_init (&a->address_to_prefix_index, sizeof (uword),
 		      sizeof (ip6_address_t));
@@ -3266,9 +3264,7 @@ disable_ip6_interface (vlib_main_t * vm, u32 sw_if_index)
 	  /* essentially "disables" ipv6 on this interface */
 	  error = ip6_add_del_interface_address (vm, sw_if_index,
 						 &radv_info->
-						 link_local_address,
-						 radv_info->
-						 link_local_prefix_len,
+						 link_local_address, 128,
 						 1 /* is_del */ );
 
 	  ip6_neighbor_sw_interface_add_del (vnm, sw_if_index,
@@ -3372,7 +3368,6 @@ enable_ip6_interface (vlib_main_t * vm, u32 sw_if_index)
 		  else
 		    {
 		      radv_info->link_local_address = link_local_address;
-		      radv_info->link_local_prefix_len = 64;
 		    }
 		}
 	    }
@@ -3615,22 +3610,18 @@ set_ip6_link_local_address (vlib_main_t * vm,
       /* delete the old one */
       error = ip6_add_del_interface_address (vm, sw_if_index,
 					     &radv_info->link_local_address,
-					     radv_info->link_local_prefix_len
-					     /* address width */ ,
-					     1 /* is_del */ );
+					     128, 1 /* is_del */ );
 
       if (!error)
 	{
 	  /* add the new one */
 	  error = ip6_add_del_interface_address (vm, sw_if_index,
-						 address, address_length
-						 /* address width */ ,
+						 address, 128,
 						 0 /* is_del */ );
 
 	  if (!error)
 	    {
 	      radv_info->link_local_address = *address;
-	      radv_info->link_local_prefix_len = address_length;
 	    }
 	}
     }

vnet/vnet/lisp-cp/control.c

@@ -512,7 +512,12 @@ dp_add_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index, u32 dst_map_index)
   pool_get (lcm->fwd_entry_pool, fe);
   fe->locator_pairs = a->locator_pairs;
   gid_address_copy (&fe->reid, &a->rmt_eid);
-  gid_address_copy (&fe->leid, &a->lcl_eid);
+
+  if (is_src_dst)
+    gid_address_copy (&fe->leid, &a->lcl_eid);
+  else
+    gid_address_copy (&fe->leid, &src_map->eid);
+
   fe->is_src_dst = is_src_dst;
   hash_set (lcm->fwd_entry_by_mapping_index, dst_map_index,
 	    fe - lcm->fwd_entry_pool);

vpp-api/python/setup.py

@@ -31,4 +31,5 @@ setup (name = 'vpp_papi',
                libraries = ['pneum'],
            )],
        long_description = '''VPP Python language binding.''',
+       zip_safe = True,
 )