IP Flow Hash Config fixes
[vpp.git] / test / test_dhcp.py
index 04ab2e1..03c749d 100644 (file)
@@ -2,8 +2,11 @@
 
 import unittest
 import socket
+import struct
 
 from framework import VppTestCase, VppTestRunner
+from vpp_neighbor import VppNeighbor
+from util import mk_ll_addr
 
 from scapy.layers.l2 import Ether, getmacbyip
 from scapy.layers.inet import IP, UDP, ICMP
@@ -11,7 +14,7 @@ from scapy.layers.inet6 import IPv6, in6_getnsmac, in6_mactoifaceid
 from scapy.layers.dhcp import DHCP, BOOTP, DHCPTypes
 from scapy.layers.dhcp6 import DHCP6, DHCP6_Solicit, DHCP6_RelayForward, \
     DHCP6_RelayReply, DHCP6_Advertise, DHCP6OptRelayMsg, DHCP6OptIfaceId, \
-    DHCP6OptStatusCode, DHCP6OptVSS, DHCP6OptClientLinkLayerAddr
+    DHCP6OptStatusCode, DHCP6OptVSS, DHCP6OptClientLinkLayerAddr, DHCP6_Request
 from socket import AF_INET, AF_INET6
 from scapy.utils import inet_pton, inet_ntop
 from scapy.utils6 import in6_ptop
@@ -22,13 +25,6 @@ DHCP6_CLIENT_PORT = 547
 DHCP6_SERVER_PORT = 546
 
 
-def mk_ll_addr(mac):
-
-    euid = in6_mactoifaceid(mac)
-    addr = "fe80::" + euid
-    return addr
-
-
 class TestDHCP(VppTestCase):
     """ DHCP Test Case """
 
@@ -58,6 +54,13 @@ class TestDHCP(VppTestCase):
             i.set_table_ip6(table_id)
             table_id += 1
 
+    def tearDown(self):
+        super(TestDHCP, self).tearDown()
+        for i in self.pg_interfaces:
+            i.unconfig_ip4()
+            i.unconfig_ip6()
+            i.admin_down()
+
     def send_and_assert_no_replies(self, intf, pkts, remark):
         intf.add_stream(pkts)
         self.pg_enable_capture(self.pg_interfaces)
@@ -65,7 +68,7 @@ class TestDHCP(VppTestCase):
         for i in self.pg_interfaces:
             i.assert_nothing_captured(remark=remark)
 
-    def validate_option_82(self, pkt, intf, ip_addr):
+    def validate_relay_options(self, pkt, intf, ip_addr, fib_id, oui):
         dhcp = pkt[DHCP]
         found = 0
         data = []
@@ -77,7 +80,10 @@ class TestDHCP(VppTestCase):
                     # There are two sb-options present - each of length 6.
                     #
                     data = i[1]
-                    self.assertEqual(len(data), 12)
+                    if oui != 0:
+                        self.assertEqual(len(data), 24)
+                    else:
+                        self.assertEqual(len(data), 12)
 
                     #
                     # First sub-option is ID 1, len 4, then encoded
@@ -107,12 +113,30 @@ class TestDHCP(VppTestCase):
                     self.assertEqual(data[10], claddr[2])
                     self.assertEqual(data[11], claddr[3])
 
+                    if oui != 0:
+                        # sub-option 151 encodes the 3 byte oui
+                        # and the 4 byte fib_id
+                        self.assertEqual(ord(data[12]), 151)
+                        self.assertEqual(ord(data[13]), 8)
+                        self.assertEqual(ord(data[14]), 1)
+                        self.assertEqual(ord(data[15]), 0)
+                        self.assertEqual(ord(data[16]), 0)
+                        self.assertEqual(ord(data[17]), oui)
+                        self.assertEqual(ord(data[18]), 0)
+                        self.assertEqual(ord(data[19]), 0)
+                        self.assertEqual(ord(data[20]), 0)
+                        self.assertEqual(ord(data[21]), fib_id)
+
+                        # VSS control sub-option
+                        self.assertEqual(ord(data[22]), 152)
+                        self.assertEqual(ord(data[23]), 0)
+
                     found = 1
         self.assertTrue(found)
 
         return data
 
-    def verify_dhcp_offer(self, pkt, intf, check_option_82=True):
+    def verify_dhcp_offer(self, pkt, intf, fib_id=0, oui=0):
         ether = pkt[Ether]
         self.assertEqual(ether.dst, "ff:ff:ff:ff:ff:ff")
         self.assertEqual(ether.src, intf.local_mac)
@@ -134,17 +158,22 @@ class TestDHCP(VppTestCase):
                     is_offer = True
         self.assertTrue(is_offer)
 
-        if check_option_82:
-            data = self.validate_option_82(pkt, intf, intf.local_ip4)
+        data = self.validate_relay_options(pkt, intf, intf.local_ip4,
+                                           fib_id, oui)
+
+    def verify_dhcp_discover(self, pkt, intf, src_intf=None, fib_id=0, oui=0,
+                             dst_mac=None, dst_ip=None):
+        if not dst_mac:
+            dst_mac = intf.remote_mac
+        if not dst_ip:
+            dst_ip = intf.remote_ip4
 
-    def verify_dhcp_discover(self, pkt, intf, src_intf=None,
-                             option_82_present=True):
         ether = pkt[Ether]
-        self.assertEqual(ether.dst, intf.remote_mac)
+        self.assertEqual(ether.dst, dst_mac)
         self.assertEqual(ether.src, intf.local_mac)
 
         ip = pkt[IP]
-        self.assertEqual(ip.dst, intf.remote_ip4)
+        self.assertEqual(ip.dst, dst_ip)
         self.assertEqual(ip.src, intf.local_ip4)
 
         udp = pkt[UDP]
@@ -161,24 +190,28 @@ class TestDHCP(VppTestCase):
                     is_discover = True
         self.assertTrue(is_discover)
 
-        if option_82_present:
-            data = self.validate_option_82(pkt, src_intf, src_intf.local_ip4)
-            return data
-        else:
-            for i in dhcp.options:
-                if type(i) is tuple:
-                    self.assertNotEqual(i[0], "relay_agent_Information")
+        data = self.validate_relay_options(pkt, src_intf,
+                                           src_intf.local_ip4,
+                                           fib_id, oui)
+        return data
 
     def verify_dhcp6_solicit(self, pkt, intf,
                              peer_ip, peer_mac,
                              fib_id=0,
-                             oui=0):
+                             oui=0,
+                             dst_mac=None,
+                             dst_ip=None):
+        if not dst_mac:
+            dst_mac = intf.remote_mac
+        if not dst_ip:
+            dst_ip = in6_ptop(intf.remote_ip6)
+
         ether = pkt[Ether]
-        self.assertEqual(ether.dst, intf.remote_mac)
+        self.assertEqual(ether.dst, dst_mac)
         self.assertEqual(ether.src, intf.local_mac)
 
         ip = pkt[IPv6]
-        self.assertEqual(in6_ptop(ip.dst), in6_ptop(intf.remote_ip6))
+        self.assertEqual(in6_ptop(ip.dst), dst_ip)
         self.assertEqual(in6_ptop(ip.src), in6_ptop(intf.local_ip6))
 
         udp = pkt[UDP]
@@ -193,18 +226,19 @@ class TestDHCP(VppTestCase):
         self.assertEqual(cll.lltype, 1)
         self.assertEqual(cll.clladdr, peer_mac)
 
-        vss = pkt[DHCP6OptVSS]
-        self.assertEqual(vss.optlen, 8)
-        self.assertEqual(vss.type, 1)
-        # the OUI and FIB-id are really 3 and 4 bytes resp.
-        # but the tested range is small
-        self.assertEqual(ord(vss.data[0]), 0)
-        self.assertEqual(ord(vss.data[1]), 0)
-        self.assertEqual(ord(vss.data[2]), oui)
-        self.assertEqual(ord(vss.data[3]), 0)
-        self.assertEqual(ord(vss.data[4]), 0)
-        self.assertEqual(ord(vss.data[5]), 0)
-        self.assertEqual(ord(vss.data[6]), fib_id)
+        if fib_id != 0:
+            vss = pkt[DHCP6OptVSS]
+            self.assertEqual(vss.optlen, 8)
+            self.assertEqual(vss.type, 1)
+            # the OUI and FIB-id are really 3 and 4 bytes resp.
+            # but the tested range is small
+            self.assertEqual(ord(vss.data[0]), 0)
+            self.assertEqual(ord(vss.data[1]), 0)
+            self.assertEqual(ord(vss.data[2]), oui)
+            self.assertEqual(ord(vss.data[3]), 0)
+            self.assertEqual(ord(vss.data[4]), 0)
+            self.assertEqual(ord(vss.data[5]), 0)
+            self.assertEqual(ord(vss.data[6]), fib_id)
 
         # the relay message should be an encoded Solicit
         msg = pkt[DHCP6OptRelayMsg]
@@ -267,29 +301,16 @@ class TestDHCP(VppTestCase):
                                     rx_table_id=0)
 
         #
-        # Now a DHCP request on pg2, which is in the same VRF
-        # as the DHCP config, will result in a relayed DHCP
-        # message to the [fake] server
-        #
-        self.pg2.add_stream(pkts_disc_vrf0)
-        self.pg_enable_capture(self.pg_interfaces)
-        self.pg_start()
-
-        rx = self.pg0.get_capture(1)
-        rx = rx[0]
-
-        #
-        # Rx'd packet should be to the server address and from the configured
-        # source address
-        # UDP source ports are unchanged
-        # we've no option 82 config so that should be absent
+        # Discover packets from the client are dropped because there is no
+        # IP address configured on the client facing interface
         #
-        self.verify_dhcp_discover(rx, self.pg0, option_82_present=False)
+        self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
+                                        "Discover DHCP no relay address")
 
         #
         # Inject a response from the server
-        #  VPP will only relay the offer if option 82 is present.
-        #  so this one is dropped
+        #  dropped, because there is no IP addrees on the
+        #  client interfce to fill in the option.
         #
         p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
              IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
@@ -298,24 +319,8 @@ class TestDHCP(VppTestCase):
              DHCP(options=[('message-type', 'offer'), ('end')]))
         pkts = [p]
 
-        self.send_and_assert_no_replies(self.pg0, pkts,
-                                        "DHCP offer no option 82")
-
-        #
-        # Configure sending option 82 in relayed messages
-        #
-        self.vapi.dhcp_proxy_config(server_addr,
-                                    src_addr,
-                                    rx_table_id=0,
-                                    insert_circuit_id=1)
-
-        #
-        # Send a request:
-        #  again dropped, but ths time because there is no IP addrees on the
-        #  clinet interfce to fill in the option.
-        #
-        self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
-                                        "DHCP no relay address")
+        self.send_and_assert_no_replies(self.pg2, pkts,
+                                        "Offer DHCP no relay address")
 
         #
         # configure an IP address on the client facing interface
@@ -376,15 +381,8 @@ class TestDHCP(VppTestCase):
                            ('relay_agent_Information', bad_ip),
                            ('end')]))
         pkts = [p]
-
-        self.pg0.add_stream(pkts)
-        self.pg_enable_capture(self.pg_interfaces)
-        self.pg_start()
-        rx = self.pg2.get_capture(1)
-        rx = rx[0]
-
-        self.verify_dhcp_offer(rx, self.pg2, check_option_82=False)
-        self.pg0.assert_nothing_captured(remark="")
+        self.send_and_assert_no_replies(self.pg0, pkts,
+                                        "DHCP offer option 82 bad address")
 
         # 2. Not a sw_if_index VPP knows
         bad_if_index = option_82[0:2] + chr(33) + option_82[3:]
@@ -413,8 +411,7 @@ class TestDHCP(VppTestCase):
         self.vapi.dhcp_proxy_config(server_addr,
                                     src_addr,
                                     rx_table_id=0,
-                                    is_add=0,
-                                    insert_circuit_id=1)
+                                    is_add=0)
 
         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
                                         "DHCP config removed VRF 0")
@@ -429,8 +426,7 @@ class TestDHCP(VppTestCase):
         self.vapi.dhcp_proxy_config(server_addr,
                                     src_addr,
                                     rx_table_id=1,
-                                    server_table_id=1,
-                                    insert_circuit_id=1)
+                                    server_table_id=1)
 
         #
         # Confim DHCP requests ok in VRF 1.
@@ -452,6 +448,156 @@ class TestDHCP(VppTestCase):
         rx = rx[0]
         self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3)
 
+        #
+        # Add VSS config
+        #  table=1, fib=id=1, oui=4
+        self.vapi.dhcp_proxy_set_vss(1, 1, 4)
+
+        self.pg3.add_stream(pkts_disc_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(1)
+        rx = rx[0]
+        self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3,
+                                  fib_id=1, oui=4)
+
+        #
+        # Add a second DHCP server in VRF 1
+        #  expect clients messages to be relay to both configured servers
+        #
+        self.pg1.generate_remote_hosts(2)
+        server_addr2 = socket.inet_pton(AF_INET, self.pg1.remote_hosts[1].ip4)
+
+        self.vapi.dhcp_proxy_config(server_addr2,
+                                    src_addr,
+                                    rx_table_id=1,
+                                    server_table_id=1,
+                                    is_add=1)
+
+        #
+        # We'll need an ARP entry for the server to send it packets
+        #
+        arp_entry = VppNeighbor(self,
+                                self.pg1.sw_if_index,
+                                self.pg1.remote_hosts[1].mac,
+                                self.pg1.remote_hosts[1].ip4)
+        arp_entry.add_vpp_config()
+
+        #
+        # Send a discover from the client. expect two relayed messages
+        # The frist packet is sent to the second server
+        # We're not enforcing that here, it's just the way it is.
+        #
+        self.pg3.add_stream(pkts_disc_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(2)
+
+        option_82 = self.verify_dhcp_discover(
+            rx[0], self.pg1,
+            src_intf=self.pg3,
+            dst_mac=self.pg1.remote_hosts[1].mac,
+            dst_ip=self.pg1.remote_hosts[1].ip4,
+            fib_id=1, oui=4)
+        self.verify_dhcp_discover(rx[1], self.pg1, src_intf=self.pg3,
+                                  fib_id=1, oui=4)
+
+        #
+        # Send both packets back. Client gets both.
+        #
+        p1 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
+              IP(src=self.pg1.remote_ip4, dst=self.pg1.local_ip4) /
+              UDP(sport=DHCP4_SERVER_PORT, dport=DHCP4_SERVER_PORT) /
+              BOOTP(op=1) /
+              DHCP(options=[('message-type', 'offer'),
+                            ('relay_agent_Information', option_82),
+                            ('end')]))
+        p2 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
+              IP(src=self.pg1.remote_hosts[1].ip4, dst=self.pg1.local_ip4) /
+              UDP(sport=DHCP4_SERVER_PORT, dport=DHCP4_SERVER_PORT) /
+              BOOTP(op=1) /
+              DHCP(options=[('message-type', 'offer'),
+                            ('relay_agent_Information', option_82),
+                            ('end')]))
+        pkts = [p1, p2]
+
+        self.pg1.add_stream(pkts)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg3.get_capture(2)
+
+        self.verify_dhcp_offer(rx[0], self.pg3, fib_id=1, oui=4)
+        self.verify_dhcp_offer(rx[1], self.pg3, fib_id=1, oui=4)
+
+        #
+        # Ensure offers from non-servers are dropeed
+        #
+        p2 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
+              IP(src="8.8.8.8", dst=self.pg1.local_ip4) /
+              UDP(sport=DHCP4_SERVER_PORT, dport=DHCP4_SERVER_PORT) /
+              BOOTP(op=1) /
+              DHCP(options=[('message-type', 'offer'),
+                            ('relay_agent_Information', option_82),
+                            ('end')]))
+        self.send_and_assert_no_replies(self.pg1, p2,
+                                        "DHCP offer from non-server")
+
+        #
+        # Ensure only the discover is sent to multiple servers
+        #
+        p_req_vrf1 = (Ether(dst="ff:ff:ff:ff:ff:ff",
+                            src=self.pg3.remote_mac) /
+                      IP(src="0.0.0.0", dst="255.255.255.255") /
+                      UDP(sport=DHCP4_CLIENT_PORT,
+                          dport=DHCP4_SERVER_PORT) /
+                      BOOTP(op=1) /
+                      DHCP(options=[('message-type', 'request'),
+                                    ('end')]))
+
+        self.pg3.add_stream(p_req_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(1)
+
+        #
+        # Remove the second DHCP server
+        #
+        self.vapi.dhcp_proxy_config(server_addr2,
+                                    src_addr,
+                                    rx_table_id=1,
+                                    server_table_id=1,
+                                    is_add=0)
+
+        #
+        # Test we can still relay with the first
+        #
+        self.pg3.add_stream(pkts_disc_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(1)
+        rx = rx[0]
+        self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3,
+                                  fib_id=1, oui=4)
+
+        #
+        # Remove the VSS config
+        #  relayed DHCP has default vlaues in the option.
+        #
+        self.vapi.dhcp_proxy_set_vss(1, 1, 4, is_add=0)
+
+        self.pg3.add_stream(pkts_disc_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(1)
+        rx = rx[0]
+        self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3)
+
         #
         # remove DHCP config to cleanup
         #
@@ -459,7 +605,6 @@ class TestDHCP(VppTestCase):
                                     src_addr,
                                     rx_table_id=1,
                                     server_table_id=1,
-                                    insert_circuit_id=1,
                                     is_add=0)
 
         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
@@ -487,18 +632,16 @@ class TestDHCP(VppTestCase):
                           UDP(sport=DHCP6_SERVER_PORT,
                               dport=DHCP6_CLIENT_PORT) /
                           DHCP6_Solicit())
-        pkts_solicit_vrf0 = [p_solicit_vrf0]
         p_solicit_vrf1 = (Ether(dst=dmac, src=self.pg3.remote_mac) /
                           IPv6(src=dhcp_solicit_src_vrf1,
                                dst=dhcp_solicit_dst) /
                           UDP(sport=DHCP6_SERVER_PORT,
                               dport=DHCP6_CLIENT_PORT) /
                           DHCP6_Solicit())
-        pkts_solicit_vrf1 = [p_solicit_vrf1]
 
-        self.send_and_assert_no_replies(self.pg2, pkts_solicit_vrf0,
+        self.send_and_assert_no_replies(self.pg2, p_solicit_vrf0,
                                         "DHCP with no configuration")
-        self.send_and_assert_no_replies(self.pg3, pkts_solicit_vrf1,
+        self.send_and_assert_no_replies(self.pg3, p_solicit_vrf1,
                                         "DHCP with no configuration")
 
         #
@@ -510,12 +653,11 @@ class TestDHCP(VppTestCase):
                                     src_addr_vrf0,
                                     rx_table_id=0,
                                     server_table_id=0,
-                                    insert_circuit_id=1,
                                     is_ipv6=1)
 
-        self.send_and_assert_no_replies(self.pg2, pkts_solicit_vrf0,
+        self.send_and_assert_no_replies(self.pg2, p_solicit_vrf0,
                                         "DHCP with no configuration")
-        self.send_and_assert_no_replies(self.pg3, pkts_solicit_vrf1,
+        self.send_and_assert_no_replies(self.pg3, p_solicit_vrf1,
                                         "DHCP with no configuration")
 
         #
@@ -526,13 +668,13 @@ class TestDHCP(VppTestCase):
         #
         # Now the DHCP requests are relayed to the server
         #
-        self.pg2.add_stream(pkts_solicit_vrf0)
+        self.pg2.add_stream(p_solicit_vrf0)
         self.pg_enable_capture(self.pg_interfaces)
         self.pg_start()
 
         rx = self.pg0.get_capture(1)
-        rx = rx[0]
-        self.verify_dhcp6_solicit(rx, self.pg0,
+
+        self.verify_dhcp6_solicit(rx[0], self.pg0,
                                   dhcp_solicit_src_vrf0,
                                   self.pg2.remote_mac)
 
@@ -545,8 +687,7 @@ class TestDHCP(VppTestCase):
                       IPv6(dst=self.pg0.local_ip6, src=self.pg0.remote_ip6) /
                       UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
                       DHCP6_Advertise())
-        pkts_adv_vrf0 = [p_adv_vrf0]
-        self.send_and_assert_no_replies(self.pg2, pkts_adv_vrf0,
+        self.send_and_assert_no_replies(self.pg2, p_adv_vrf0,
                                         "DHCP6 not a relay reply")
 
         # 2 - no relay message option
@@ -555,8 +696,7 @@ class TestDHCP(VppTestCase):
                       UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
                       DHCP6_RelayReply() /
                       DHCP6_Advertise())
-        pkts_adv_vrf0 = [p_adv_vrf0]
-        self.send_and_assert_no_replies(self.pg2, pkts_adv_vrf0,
+        self.send_and_assert_no_replies(self.pg2, p_adv_vrf0,
                                         "DHCP not a relay message")
 
         # 3 - no circuit ID
@@ -566,8 +706,7 @@ class TestDHCP(VppTestCase):
                       DHCP6_RelayReply() /
                       DHCP6OptRelayMsg(optlen=0) /
                       DHCP6_Advertise())
-        pkts_adv_vrf0 = [p_adv_vrf0]
-        self.send_and_assert_no_replies(self.pg2, pkts_adv_vrf0,
+        self.send_and_assert_no_replies(self.pg2, p_adv_vrf0,
                                         "DHCP6 no circuit ID")
         # 4 - wrong circuit ID
         p_adv_vrf0 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
@@ -577,8 +716,7 @@ class TestDHCP(VppTestCase):
                       DHCP6OptIfaceId(optlen=4, ifaceid='\x00\x00\x00\x05') /
                       DHCP6OptRelayMsg(optlen=0) /
                       DHCP6_Advertise())
-        pkts_adv_vrf0 = [p_adv_vrf0]
-        self.send_and_assert_no_replies(self.pg2, pkts_adv_vrf0,
+        self.send_and_assert_no_replies(self.pg2, p_adv_vrf0,
                                         "DHCP6 wrong circuit ID")
 
         #
@@ -599,8 +737,8 @@ class TestDHCP(VppTestCase):
         self.pg_start()
 
         rx = self.pg2.get_capture(1)
-        rx = rx[0]
-        self.verify_dhcp6_advert(rx, self.pg2, "::")
+
+        self.verify_dhcp6_advert(rx[0], self.pg2, "::")
 
         #
         # Send the relay response (the advertisement)
@@ -620,8 +758,8 @@ class TestDHCP(VppTestCase):
         self.pg_start()
 
         rx = self.pg2.get_capture(1)
-        rx = rx[0]
-        self.verify_dhcp6_advert(rx, self.pg2, dhcp_solicit_src_vrf0)
+
+        self.verify_dhcp6_advert(rx[0], self.pg2, dhcp_solicit_src_vrf0)
 
         #
         # Add all the config for VRF 1
@@ -630,20 +768,19 @@ class TestDHCP(VppTestCase):
                                     src_addr_vrf1,
                                     rx_table_id=1,
                                     server_table_id=1,
-                                    insert_circuit_id=1,
                                     is_ipv6=1)
         self.pg3.config_ip6()
 
         #
         # VRF 1 solicit
         #
-        self.pg3.add_stream(pkts_solicit_vrf1)
+        self.pg3.add_stream(p_solicit_vrf1)
         self.pg_enable_capture(self.pg_interfaces)
         self.pg_start()
 
         rx = self.pg1.get_capture(1)
-        rx = rx[0]
-        self.verify_dhcp6_solicit(rx, self.pg1,
+
+        self.verify_dhcp6_solicit(rx[0], self.pg1,
                                   dhcp_solicit_src_vrf1,
                                   self.pg3.remote_mac)
 
@@ -665,21 +802,21 @@ class TestDHCP(VppTestCase):
         self.pg_start()
 
         rx = self.pg3.get_capture(1)
-        rx = rx[0]
-        self.verify_dhcp6_advert(rx, self.pg3, dhcp_solicit_src_vrf1)
+
+        self.verify_dhcp6_advert(rx[0], self.pg3, dhcp_solicit_src_vrf1)
 
         #
         # Add VSS config
         #  table=1, fib=id=1, oui=4
         self.vapi.dhcp_proxy_set_vss(1, 1, 4, is_ip6=1)
 
-        self.pg3.add_stream(pkts_solicit_vrf1)
+        self.pg3.add_stream(p_solicit_vrf1)
         self.pg_enable_capture(self.pg_interfaces)
         self.pg_start()
 
         rx = self.pg1.get_capture(1)
-        rx = rx[0]
-        self.verify_dhcp6_solicit(rx, self.pg1,
+
+        self.verify_dhcp6_solicit(rx[0], self.pg1,
                                   dhcp_solicit_src_vrf1,
                                   self.pg3.remote_mac,
                                   fib_id=1,
@@ -691,31 +828,165 @@ class TestDHCP(VppTestCase):
         #
         self.vapi.dhcp_proxy_set_vss(1, 1, 4, is_ip6=1, is_add=0)
 
-        self.pg3.add_stream(pkts_solicit_vrf1)
+        self.pg3.add_stream(p_solicit_vrf1)
         self.pg_enable_capture(self.pg_interfaces)
         self.pg_start()
 
         rx = self.pg1.get_capture(1)
-        rx = rx[0]
-        self.verify_dhcp6_solicit(rx, self.pg1,
+
+        self.verify_dhcp6_solicit(rx[0], self.pg1,
                                   dhcp_solicit_src_vrf1,
                                   self.pg3.remote_mac)
 
         #
-        # Cleanup
+        # Add a second DHCP server in VRF 1
+        #  expect clients messages to be relay to both configured servers
         #
-        self.vapi.dhcp_proxy_config(server_addr_vrf1,
+        self.pg1.generate_remote_hosts(2)
+        server_addr2 = socket.inet_pton(AF_INET6, self.pg1.remote_hosts[1].ip6)
+
+        self.vapi.dhcp_proxy_config(server_addr2,
+                                    src_addr_vrf1,
+                                    rx_table_id=1,
+                                    server_table_id=1,
+                                    is_ipv6=1)
+
+        #
+        # We'll need an ND entry for the server to send it packets
+        #
+        nd_entry = VppNeighbor(self,
+                               self.pg1.sw_if_index,
+                               self.pg1.remote_hosts[1].mac,
+                               self.pg1.remote_hosts[1].ip6,
+                               af=AF_INET6)
+        nd_entry.add_vpp_config()
+
+        #
+        # Send a discover from the client. expect two relayed messages
+        # The frist packet is sent to the second server
+        # We're not enforcing that here, it's just the way it is.
+        #
+        self.pg3.add_stream(p_solicit_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(2)
+
+        self.verify_dhcp6_solicit(rx[0], self.pg1,
+                                  dhcp_solicit_src_vrf1,
+                                  self.pg3.remote_mac)
+        self.verify_dhcp6_solicit(rx[1], self.pg1,
+                                  dhcp_solicit_src_vrf1,
+                                  self.pg3.remote_mac,
+                                  dst_mac=self.pg1.remote_hosts[1].mac,
+                                  dst_ip=self.pg1.remote_hosts[1].ip6)
+
+        #
+        # Send both packets back. Client gets both.
+        #
+        p1 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
+              IPv6(dst=self.pg1.local_ip6, src=self.pg1.remote_ip6) /
+              UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
+              DHCP6_RelayReply(peeraddr=dhcp_solicit_src_vrf1) /
+              DHCP6OptIfaceId(optlen=4, ifaceid='\x00\x00\x00\x04') /
+              DHCP6OptRelayMsg(optlen=0) /
+              DHCP6_Advertise(trid=1) /
+              DHCP6OptStatusCode(statuscode=0))
+        p2 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_hosts[1].mac) /
+              IPv6(dst=self.pg1.local_ip6, src=self.pg1._remote_hosts[1].ip6) /
+              UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
+              DHCP6_RelayReply(peeraddr=dhcp_solicit_src_vrf1) /
+              DHCP6OptIfaceId(optlen=4, ifaceid='\x00\x00\x00\x04') /
+              DHCP6OptRelayMsg(optlen=0) /
+              DHCP6_Advertise(trid=1) /
+              DHCP6OptStatusCode(statuscode=0))
+
+        pkts = [p1, p2]
+
+        self.pg1.add_stream(pkts)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg3.get_capture(2)
+
+        self.verify_dhcp6_advert(rx[0], self.pg3, dhcp_solicit_src_vrf1)
+        self.verify_dhcp6_advert(rx[1], self.pg3, dhcp_solicit_src_vrf1)
+
+        #
+        # Ensure only solicit messages are duplicated
+        #
+        p_request_vrf1 = (Ether(dst=dmac, src=self.pg3.remote_mac) /
+                          IPv6(src=dhcp_solicit_src_vrf1,
+                               dst=dhcp_solicit_dst) /
+                          UDP(sport=DHCP6_SERVER_PORT,
+                              dport=DHCP6_CLIENT_PORT) /
+                          DHCP6_Request())
+
+        self.pg3.add_stream(p_request_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(1)
+
+        #
+        # Test we drop DHCP packets from addresses that are not configured as
+        # DHCP servers
+        #
+        p2 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_hosts[1].mac) /
+              IPv6(dst=self.pg1.local_ip6, src="3001::1") /
+              UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
+              DHCP6_RelayReply(peeraddr=dhcp_solicit_src_vrf1) /
+              DHCP6OptIfaceId(optlen=4, ifaceid='\x00\x00\x00\x04') /
+              DHCP6OptRelayMsg(optlen=0) /
+              DHCP6_Advertise(trid=1) /
+              DHCP6OptStatusCode(statuscode=0))
+        self.send_and_assert_no_replies(self.pg1, p2,
+                                        "DHCP6 not from server")
+
+        #
+        # Remove the second DHCP server
+        #
+        self.vapi.dhcp_proxy_config(server_addr2,
                                     src_addr_vrf1,
                                     rx_table_id=1,
                                     server_table_id=1,
-                                    insert_circuit_id=1,
                                     is_ipv6=1,
                                     is_add=0)
+
+        #
+        # Test we can still relay with the first
+        #
+        self.pg3.add_stream(p_solicit_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(1)
+
+        self.verify_dhcp6_solicit(rx[0], self.pg1,
+                                  dhcp_solicit_src_vrf1,
+                                  self.pg3.remote_mac)
+
+        #
+        # Cleanup
+        #
         self.vapi.dhcp_proxy_config(server_addr_vrf1,
                                     src_addr_vrf1,
+                                    rx_table_id=1,
+                                    server_table_id=1,
+                                    is_ipv6=1,
+                                    is_add=0)
+        self.vapi.dhcp_proxy_config(server_addr_vrf0,
+                                    src_addr_vrf0,
+                                    rx_table_id=0,
+                                    server_table_id=0,
+                                    is_ipv6=1,
+                                    is_add=0)
+
+        # duplicate delete
+        self.vapi.dhcp_proxy_config(server_addr_vrf0,
+                                    src_addr_vrf0,
                                     rx_table_id=0,
                                     server_table_id=0,
-                                    insert_circuit_id=1,
                                     is_ipv6=1,
                                     is_add=0)