test/test_dhcp.py

   1 #!/usr/bin/env python
   2
   3 import unittest
   4 import socket
   5
   6 from framework import VppTestCase, VppTestRunner
   7
   8 from scapy.layers.l2 import Ether, getmacbyip
   9 from scapy.layers.inet import IP, UDP, ICMP
  10 from scapy.layers.inet6 import IPv6, in6_getnsmac, in6_mactoifaceid
  11 from scapy.layers.dhcp import DHCP, BOOTP, DHCPTypes
  12 from scapy.layers.dhcp6 import DHCP6, DHCP6_Solicit, DHCP6_RelayForward, \
  13     DHCP6_RelayReply, DHCP6_Advertise, DHCP6OptRelayMsg, DHCP6OptIfaceId, \
  14     DHCP6OptStatusCode, DHCP6OptVSS, DHCP6OptClientLinkLayerAddr
  15 from socket import AF_INET, AF_INET6
  16 from scapy.utils import inet_pton, inet_ntop
  17 from scapy.utils6 import in6_ptop
  18
  19 DHCP4_CLIENT_PORT = 68
  20 DHCP4_SERVER_PORT = 67
  21 DHCP6_CLIENT_PORT = 547
  22 DHCP6_SERVER_PORT = 546
  23
  24
  25 def mk_ll_addr(mac):
  26
  27     euid = in6_mactoifaceid(mac)
  28     addr = "fe80::" + euid
  29     return addr
  30
  31
  32 class TestDHCP(VppTestCase):
  33     """ DHCP Test Case """
  34
  35     def setUp(self):
  36         super(TestDHCP, self).setUp()
  37
  38         # create 3 pg interfaces
  39         self.create_pg_interfaces(range(4))
  40
  41         # pg0 and 1 are IP configured in VRF 0 and 1.
  42         # pg2 and 3 are non IP-configured in VRF 0 and 1
  43         table_id = 0
  44         for i in self.pg_interfaces[:2]:
  45             i.admin_up()
  46             i.set_table_ip4(table_id)
  47             i.set_table_ip6(table_id)
  48             i.config_ip4()
  49             i.resolve_arp()
  50             i.config_ip6()
  51             i.resolve_ndp()
  52             table_id += 1
  53
  54         table_id = 0
  55         for i in self.pg_interfaces[2:]:
  56             i.admin_up()
  57             i.set_table_ip4(table_id)
  58             i.set_table_ip6(table_id)
  59             table_id += 1
  60
  61     def tearDown(self):
  62         super(TestDHCP, self).tearDown()
  63         for i in self.pg_interfaces:
  64             i.unconfig_ip4()
  65             i.unconfig_ip6()
  66             i.admin_down()
  67
  68     def send_and_assert_no_replies(self, intf, pkts, remark):
  69         intf.add_stream(pkts)
  70         self.pg_enable_capture(self.pg_interfaces)
  71         self.pg_start()
  72         for i in self.pg_interfaces:
  73             i.assert_nothing_captured(remark=remark)
  74
  75     def validate_relay_options(self, pkt, intf, ip_addr, fib_id, oui):
  76         dhcp = pkt[DHCP]
  77         found = 0
  78         data = []
  79
  80         for i in dhcp.options:
  81             if type(i) is tuple:
  82                 if i[0] == "relay_agent_Information":
  83                     #
  84                     # There are two sb-options present - each of length 6.
  85                     #
  86                     data = i[1]
  87                     if oui != 0:
  88                         self.assertEqual(len(data), 24)
  89                     else:
  90                         self.assertEqual(len(data), 12)
  91
  92                     #
  93                     # First sub-option is ID 1, len 4, then encoded
  94                     #  sw_if_index. This test uses low valued indicies
  95                     # so [2:4] are 0.
  96                     # The ID space is VPP internal - so no matching value
  97                     # scapy
  98                     #
  99                     self.assertEqual(ord(data[0]), 1)
 100                     self.assertEqual(ord(data[1]), 4)
 101                     self.assertEqual(ord(data[2]), 0)
 102                     self.assertEqual(ord(data[3]), 0)
 103                     self.assertEqual(ord(data[4]), 0)
 104                     self.assertEqual(ord(data[5]), intf._sw_if_index)
 105
 106                     #
 107                     # next sub-option is the IP address of the client side
 108                     # interface.
 109                     # sub-option ID=5, length (of a v4 address)=4
 110                     #
 111                     claddr = socket.inet_pton(AF_INET, ip_addr)
 112
 113                     self.assertEqual(ord(data[6]), 5)
 114                     self.assertEqual(ord(data[7]), 4)
 115                     self.assertEqual(data[8], claddr[0])
 116                     self.assertEqual(data[9], claddr[1])
 117                     self.assertEqual(data[10], claddr[2])
 118                     self.assertEqual(data[11], claddr[3])
 119
 120                     if oui != 0:
 121                         # sub-option 151 encodes the 3 byte oui
 122                         # and the 4 byte fib_id
 123                         self.assertEqual(ord(data[12]), 151)
 124                         self.assertEqual(ord(data[13]), 8)
 125                         self.assertEqual(ord(data[14]), 1)
 126                         self.assertEqual(ord(data[15]), 0)
 127                         self.assertEqual(ord(data[16]), 0)
 128                         self.assertEqual(ord(data[17]), oui)
 129                         self.assertEqual(ord(data[18]), 0)
 130                         self.assertEqual(ord(data[19]), 0)
 131                         self.assertEqual(ord(data[20]), 0)
 132                         self.assertEqual(ord(data[21]), fib_id)
 133
 134                         # VSS control sub-option
 135                         self.assertEqual(ord(data[22]), 152)
 136                         self.assertEqual(ord(data[23]), 0)
 137
 138                     found = 1
 139         self.assertTrue(found)
 140
 141         return data
 142
 143     def verify_dhcp_offer(self, pkt, intf):
 144         ether = pkt[Ether]
 145         self.assertEqual(ether.dst, "ff:ff:ff:ff:ff:ff")
 146         self.assertEqual(ether.src, intf.local_mac)
 147
 148         ip = pkt[IP]
 149         self.assertEqual(ip.dst, "255.255.255.255")
 150         self.assertEqual(ip.src, intf.local_ip4)
 151
 152         udp = pkt[UDP]
 153         self.assertEqual(udp.dport, DHCP4_CLIENT_PORT)
 154         self.assertEqual(udp.sport, DHCP4_SERVER_PORT)
 155
 156         dhcp = pkt[DHCP]
 157         is_offer = False
 158         for o in dhcp.options:
 159             if type(o) is tuple:
 160                 if o[0] == "message-type" \
 161                    and DHCPTypes[o[1]] == "offer":
 162                     is_offer = True
 163         self.assertTrue(is_offer)
 164
 165         data = self.validate_relay_options(pkt, intf, intf.local_ip4, 0, 0)
 166
 167     def verify_dhcp_discover(self, pkt, intf, src_intf=None, fib_id=0, oui=0):
 168         ether = pkt[Ether]
 169         self.assertEqual(ether.dst, intf.remote_mac)
 170         self.assertEqual(ether.src, intf.local_mac)
 171
 172         ip = pkt[IP]
 173         self.assertEqual(ip.dst, intf.remote_ip4)
 174         self.assertEqual(ip.src, intf.local_ip4)
 175
 176         udp = pkt[UDP]
 177         self.assertEqual(udp.dport, DHCP4_SERVER_PORT)
 178         self.assertEqual(udp.sport, DHCP4_CLIENT_PORT)
 179
 180         dhcp = pkt[DHCP]
 181
 182         is_discover = False
 183         for o in dhcp.options:
 184             if type(o) is tuple:
 185                 if o[0] == "message-type" \
 186                    and DHCPTypes[o[1]] == "discover":
 187                     is_discover = True
 188         self.assertTrue(is_discover)
 189
 190         data = self.validate_relay_options(pkt, src_intf,
 191                                            src_intf.local_ip4,
 192                                            fib_id, oui)
 193         return data
 194
 195     def verify_dhcp6_solicit(self, pkt, intf,
 196                              peer_ip, peer_mac,
 197                              fib_id=0,
 198                              oui=0):
 199         ether = pkt[Ether]
 200         self.assertEqual(ether.dst, intf.remote_mac)
 201         self.assertEqual(ether.src, intf.local_mac)
 202
 203         ip = pkt[IPv6]
 204         self.assertEqual(in6_ptop(ip.dst), in6_ptop(intf.remote_ip6))
 205         self.assertEqual(in6_ptop(ip.src), in6_ptop(intf.local_ip6))
 206
 207         udp = pkt[UDP]
 208         self.assertEqual(udp.dport, DHCP6_CLIENT_PORT)
 209         self.assertEqual(udp.sport, DHCP6_SERVER_PORT)
 210
 211         relay = pkt[DHCP6_RelayForward]
 212         self.assertEqual(in6_ptop(relay.peeraddr), in6_ptop(peer_ip))
 213         oid = pkt[DHCP6OptIfaceId]
 214         cll = pkt[DHCP6OptClientLinkLayerAddr]
 215         self.assertEqual(cll.optlen, 8)
 216         self.assertEqual(cll.lltype, 1)
 217         self.assertEqual(cll.clladdr, peer_mac)
 218
 219         if fib_id != 0:
 220             vss = pkt[DHCP6OptVSS]
 221             self.assertEqual(vss.optlen, 8)
 222             self.assertEqual(vss.type, 1)
 223             # the OUI and FIB-id are really 3 and 4 bytes resp.
 224             # but the tested range is small
 225             self.assertEqual(ord(vss.data[0]), 0)
 226             self.assertEqual(ord(vss.data[1]), 0)
 227             self.assertEqual(ord(vss.data[2]), oui)
 228             self.assertEqual(ord(vss.data[3]), 0)
 229             self.assertEqual(ord(vss.data[4]), 0)
 230             self.assertEqual(ord(vss.data[5]), 0)
 231             self.assertEqual(ord(vss.data[6]), fib_id)
 232
 233         # the relay message should be an encoded Solicit
 234         msg = pkt[DHCP6OptRelayMsg]
 235         sol = DHCP6_Solicit()
 236         self.assertEqual(msg.optlen, len(str(sol)))
 237         self.assertEqual(str(sol), (str(msg[1]))[:msg.optlen])
 238
 239     def verify_dhcp6_advert(self, pkt, intf, peer):
 240         ether = pkt[Ether]
 241         self.assertEqual(ether.dst, "ff:ff:ff:ff:ff:ff")
 242         self.assertEqual(ether.src, intf.local_mac)
 243
 244         ip = pkt[IPv6]
 245         self.assertEqual(in6_ptop(ip.dst), in6_ptop(peer))
 246         self.assertEqual(in6_ptop(ip.src), in6_ptop(intf.local_ip6))
 247
 248         udp = pkt[UDP]
 249         self.assertEqual(udp.dport, DHCP6_SERVER_PORT)
 250         self.assertEqual(udp.sport, DHCP6_CLIENT_PORT)
 251
 252         # not sure why this is not decoding
 253         # adv = pkt[DHCP6_Advertise]
 254
 255     def test_dhcp_proxy(self):
 256         """ DHCPv4 Proxy """
 257
 258         #
 259         # Verify no response to DHCP request without DHCP config
 260         #
 261         p_disc_vrf0 = (Ether(dst="ff:ff:ff:ff:ff:ff",
 262                              src=self.pg2.remote_mac) /
 263                        IP(src="0.0.0.0", dst="255.255.255.255") /
 264                        UDP(sport=DHCP4_CLIENT_PORT,
 265                            dport=DHCP4_SERVER_PORT) /
 266                        BOOTP(op=1) /
 267                        DHCP(options=[('message-type', 'discover'), ('end')]))
 268         pkts_disc_vrf0 = [p_disc_vrf0]
 269         p_disc_vrf1 = (Ether(dst="ff:ff:ff:ff:ff:ff",
 270                              src=self.pg3.remote_mac) /
 271                        IP(src="0.0.0.0", dst="255.255.255.255") /
 272                        UDP(sport=DHCP4_CLIENT_PORT,
 273                            dport=DHCP4_SERVER_PORT) /
 274                        BOOTP(op=1) /
 275                        DHCP(options=[('message-type', 'discover'), ('end')]))
 276         pkts_disc_vrf1 = [p_disc_vrf0]
 277
 278         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
 279                                         "DHCP with no configuration")
 280         self.send_and_assert_no_replies(self.pg3, pkts_disc_vrf1,
 281                                         "DHCP with no configuration")
 282
 283         #
 284         # Enable DHCP proxy in VRF 0
 285         #
 286         server_addr = self.pg0.remote_ip4n
 287         src_addr = self.pg0.local_ip4n
 288
 289         self.vapi.dhcp_proxy_config(server_addr,
 290                                     src_addr,
 291                                     rx_table_id=0)
 292
 293         #
 294         # Discover packets from the client are dropped because there is no
 295         # IP address configured on the client facing interface
 296         #
 297         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
 298                                         "Discover DHCP no relay address")
 299
 300         #
 301         # Inject a response from the server
 302         #  dropped, because there is no IP addrees on the
 303         #  client interfce to fill in the option.
 304         #
 305         p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 306              IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
 307              UDP(sport=DHCP4_SERVER_PORT, dport=DHCP4_SERVER_PORT) /
 308              BOOTP(op=1) /
 309              DHCP(options=[('message-type', 'offer'), ('end')]))
 310         pkts = [p]
 311
 312         self.send_and_assert_no_replies(self.pg2, pkts,
 313                                         "Offer DHCP no relay address")
 314
 315         #
 316         # configure an IP address on the client facing interface
 317         #
 318         self.pg2.config_ip4()
 319
 320         #
 321         # Try again with a discover packet
 322         # Rx'd packet should be to the server address and from the configured
 323         # source address
 324         # UDP source ports are unchanged
 325         # we've no option 82 config so that should be absent
 326         #
 327         self.pg2.add_stream(pkts_disc_vrf0)
 328         self.pg_enable_capture(self.pg_interfaces)
 329         self.pg_start()
 330
 331         rx = self.pg0.get_capture(1)
 332         rx = rx[0]
 333
 334         option_82 = self.verify_dhcp_discover(rx, self.pg0, src_intf=self.pg2)
 335
 336         #
 337         # Create an DHCP offer reply from the server with a correctly formatted
 338         # option 82. i.e. send back what we just captured
 339         # The offer, sent mcast to the client, still has option 82.
 340         #
 341         p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 342              IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
 343              UDP(sport=DHCP4_SERVER_PORT, dport=DHCP4_SERVER_PORT) /
 344              BOOTP(op=1) /
 345              DHCP(options=[('message-type', 'offer'),
 346                            ('relay_agent_Information', option_82),
 347                            ('end')]))
 348         pkts = [p]
 349
 350         self.pg0.add_stream(pkts)
 351         self.pg_enable_capture(self.pg_interfaces)
 352         self.pg_start()
 353
 354         rx = self.pg2.get_capture(1)
 355         rx = rx[0]
 356
 357         self.verify_dhcp_offer(rx, self.pg2)
 358
 359         #
 360         # Bogus Option 82:
 361         #
 362         # 1. not our IP address = not checked by VPP? so offer is replayed
 363         #    to client
 364         bad_ip = option_82[0:8] + chr(33) + option_82[9:]
 365
 366         p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 367              IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
 368              UDP(sport=DHCP4_SERVER_PORT, dport=DHCP4_SERVER_PORT) /
 369              BOOTP(op=1) /
 370              DHCP(options=[('message-type', 'offer'),
 371                            ('relay_agent_Information', bad_ip),
 372                            ('end')]))
 373         pkts = [p]
 374         self.send_and_assert_no_replies(self.pg0, pkts,
 375                                         "DHCP offer option 82 bad address")
 376
 377         # 2. Not a sw_if_index VPP knows
 378         bad_if_index = option_82[0:2] + chr(33) + option_82[3:]
 379
 380         p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 381              IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
 382              UDP(sport=DHCP4_SERVER_PORT, dport=DHCP4_SERVER_PORT) /
 383              BOOTP(op=1) /
 384              DHCP(options=[('message-type', 'offer'),
 385                            ('relay_agent_Information', bad_if_index),
 386                            ('end')]))
 387         pkts = [p]
 388         self.send_and_assert_no_replies(self.pg0, pkts,
 389                                         "DHCP offer option 82 bad if index")
 390
 391         #
 392         # Send a DHCP request in VRF 1. should be dropped.
 393         #
 394         self.send_and_assert_no_replies(self.pg3, pkts_disc_vrf1,
 395                                         "DHCP with no configuration VRF 1")
 396
 397         #
 398         # Delete the DHCP config in VRF 0
 399         # Should now drop requests.
 400         #
 401         self.vapi.dhcp_proxy_config(server_addr,
 402                                     src_addr,
 403                                     rx_table_id=0,
 404                                     is_add=0)
 405
 406         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
 407                                         "DHCP config removed VRF 0")
 408         self.send_and_assert_no_replies(self.pg3, pkts_disc_vrf1,
 409                                         "DHCP config removed VRF 1")
 410
 411         #
 412         # Add DHCP config for VRF 1
 413         #
 414         server_addr = self.pg1.remote_ip4n
 415         src_addr = self.pg1.local_ip4n
 416         self.vapi.dhcp_proxy_config(server_addr,
 417                                     src_addr,
 418                                     rx_table_id=1,
 419                                     server_table_id=1)
 420
 421         #
 422         # Confim DHCP requests ok in VRF 1.
 423         #  - dropped on IP config on client interface
 424         #
 425         self.send_and_assert_no_replies(self.pg3, pkts_disc_vrf1,
 426                                         "DHCP config removed VRF 1")
 427
 428         #
 429         # configure an IP address on the client facing interface
 430         #
 431         self.pg3.config_ip4()
 432
 433         self.pg3.add_stream(pkts_disc_vrf1)
 434         self.pg_enable_capture(self.pg_interfaces)
 435         self.pg_start()
 436
 437         rx = self.pg1.get_capture(1)
 438         rx = rx[0]
 439         self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3)
 440
 441         #
 442         # Add VSS config
 443         #  table=1, fib=id=1, oui=4
 444         self.vapi.dhcp_proxy_set_vss(1, 1, 4)
 445
 446         self.pg3.add_stream(pkts_disc_vrf1)
 447         self.pg_enable_capture(self.pg_interfaces)
 448         self.pg_start()
 449
 450         rx = self.pg1.get_capture(1)
 451         rx = rx[0]
 452         self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3,
 453                                   fib_id=1, oui=4)
 454
 455         #
 456         # Remove the VSS config
 457         #  relayed DHCP has default vlaues in the option.
 458         #
 459         self.vapi.dhcp_proxy_set_vss(1, 1, 4, is_add=0)
 460
 461         self.pg3.add_stream(pkts_disc_vrf1)
 462         self.pg_enable_capture(self.pg_interfaces)
 463         self.pg_start()
 464
 465         rx = self.pg1.get_capture(1)
 466         rx = rx[0]
 467         self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3)
 468
 469         #
 470         # remove DHCP config to cleanup
 471         #
 472         self.vapi.dhcp_proxy_config(server_addr,
 473                                     src_addr,
 474                                     rx_table_id=1,
 475                                     server_table_id=11,
 476                                     is_add=0)
 477
 478         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
 479                                         "DHCP cleanup VRF 0")
 480         self.send_and_assert_no_replies(self.pg3, pkts_disc_vrf1,
 481                                         "DHCP cleanup VRF 1")
 482
 483     def test_dhcp6_proxy(self):
 484         """ DHCPv6 Proxy"""
 485         #
 486         # Verify no response to DHCP request without DHCP config
 487         #
 488         dhcp_solicit_dst = "ff02::1:2"
 489         dhcp_solicit_src_vrf0 = mk_ll_addr(self.pg2.remote_mac)
 490         dhcp_solicit_src_vrf1 = mk_ll_addr(self.pg3.remote_mac)
 491         server_addr_vrf0 = self.pg0.remote_ip6n
 492         src_addr_vrf0 = self.pg0.local_ip6n
 493         server_addr_vrf1 = self.pg1.remote_ip6n
 494         src_addr_vrf1 = self.pg1.local_ip6n
 495
 496         dmac = in6_getnsmac(inet_pton(socket.AF_INET6, dhcp_solicit_dst))
 497         p_solicit_vrf0 = (Ether(dst=dmac, src=self.pg2.remote_mac) /
 498                           IPv6(src=dhcp_solicit_src_vrf0,
 499                                dst=dhcp_solicit_dst) /
 500                           UDP(sport=DHCP6_SERVER_PORT,
 501                               dport=DHCP6_CLIENT_PORT) /
 502                           DHCP6_Solicit())
 503         pkts_solicit_vrf0 = [p_solicit_vrf0]
 504         p_solicit_vrf1 = (Ether(dst=dmac, src=self.pg3.remote_mac) /
 505                           IPv6(src=dhcp_solicit_src_vrf1,
 506                                dst=dhcp_solicit_dst) /
 507                           UDP(sport=DHCP6_SERVER_PORT,
 508                               dport=DHCP6_CLIENT_PORT) /
 509                           DHCP6_Solicit())
 510         pkts_solicit_vrf1 = [p_solicit_vrf1]
 511
 512         self.send_and_assert_no_replies(self.pg2, pkts_solicit_vrf0,
 513                                         "DHCP with no configuration")
 514         self.send_and_assert_no_replies(self.pg3, pkts_solicit_vrf1,
 515                                         "DHCP with no configuration")
 516
 517         #
 518         # DHCPv6 config in VRF 0.
 519         # Packets still dropped because the client facing interface has no
 520         # IPv6 config
 521         #
 522         self.vapi.dhcp_proxy_config(server_addr_vrf0,
 523                                     src_addr_vrf0,
 524                                     rx_table_id=0,
 525                                     server_table_id=0,
 526                                     is_ipv6=1)
 527
 528         self.send_and_assert_no_replies(self.pg2, pkts_solicit_vrf0,
 529                                         "DHCP with no configuration")
 530         self.send_and_assert_no_replies(self.pg3, pkts_solicit_vrf1,
 531                                         "DHCP with no configuration")
 532
 533         #
 534         # configure an IP address on the client facing interface
 535         #
 536         self.pg2.config_ip6()
 537
 538         #
 539         # Now the DHCP requests are relayed to the server
 540         #
 541         self.pg2.add_stream(pkts_solicit_vrf0)
 542         self.pg_enable_capture(self.pg_interfaces)
 543         self.pg_start()
 544
 545         rx = self.pg0.get_capture(1)
 546         rx = rx[0]
 547         self.verify_dhcp6_solicit(rx, self.pg0,
 548                                   dhcp_solicit_src_vrf0,
 549                                   self.pg2.remote_mac)
 550
 551         #
 552         # Exception cases for rejected relay responses
 553         #
 554
 555         # 1 - not a relay reply
 556         p_adv_vrf0 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 557                       IPv6(dst=self.pg0.local_ip6, src=self.pg0.remote_ip6) /
 558                       UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
 559                       DHCP6_Advertise())
 560         pkts_adv_vrf0 = [p_adv_vrf0]
 561         self.send_and_assert_no_replies(self.pg2, pkts_adv_vrf0,
 562                                         "DHCP6 not a relay reply")
 563
 564         # 2 - no relay message option
 565         p_adv_vrf0 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 566                       IPv6(dst=self.pg0.local_ip6, src=self.pg0.remote_ip6) /
 567                       UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
 568                       DHCP6_RelayReply() /
 569                       DHCP6_Advertise())
 570         pkts_adv_vrf0 = [p_adv_vrf0]
 571         self.send_and_assert_no_replies(self.pg2, pkts_adv_vrf0,
 572                                         "DHCP not a relay message")
 573
 574         # 3 - no circuit ID
 575         p_adv_vrf0 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 576                       IPv6(dst=self.pg0.local_ip6, src=self.pg0.remote_ip6) /
 577                       UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
 578                       DHCP6_RelayReply() /
 579                       DHCP6OptRelayMsg(optlen=0) /
 580                       DHCP6_Advertise())
 581         pkts_adv_vrf0 = [p_adv_vrf0]
 582         self.send_and_assert_no_replies(self.pg2, pkts_adv_vrf0,
 583                                         "DHCP6 no circuit ID")
 584         # 4 - wrong circuit ID
 585         p_adv_vrf0 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 586                       IPv6(dst=self.pg0.local_ip6, src=self.pg0.remote_ip6) /
 587                       UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
 588                       DHCP6_RelayReply() /
 589                       DHCP6OptIfaceId(optlen=4, ifaceid='\x00\x00\x00\x05') /
 590                       DHCP6OptRelayMsg(optlen=0) /
 591                       DHCP6_Advertise())
 592         pkts_adv_vrf0 = [p_adv_vrf0]
 593         self.send_and_assert_no_replies(self.pg2, pkts_adv_vrf0,
 594                                         "DHCP6 wrong circuit ID")
 595
 596         #
 597         # Send the relay response (the advertisement)
 598         #   - no peer address
 599         p_adv_vrf0 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 600                       IPv6(dst=self.pg0.local_ip6, src=self.pg0.remote_ip6) /
 601                       UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
 602                       DHCP6_RelayReply() /
 603                       DHCP6OptIfaceId(optlen=4, ifaceid='\x00\x00\x00\x03') /
 604                       DHCP6OptRelayMsg(optlen=0) /
 605                       DHCP6_Advertise(trid=1) /
 606                       DHCP6OptStatusCode(statuscode=0))
 607         pkts_adv_vrf0 = [p_adv_vrf0]
 608
 609         self.pg0.add_stream(pkts_adv_vrf0)
 610         self.pg_enable_capture(self.pg_interfaces)
 611         self.pg_start()
 612
 613         rx = self.pg2.get_capture(1)
 614         rx = rx[0]
 615         self.verify_dhcp6_advert(rx, self.pg2, "::")
 616
 617         #
 618         # Send the relay response (the advertisement)
 619         #   - with peer address
 620         p_adv_vrf0 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
 621                       IPv6(dst=self.pg0.local_ip6, src=self.pg0.remote_ip6) /
 622                       UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
 623                       DHCP6_RelayReply(peeraddr=dhcp_solicit_src_vrf0) /
 624                       DHCP6OptIfaceId(optlen=4, ifaceid='\x00\x00\x00\x03') /
 625                       DHCP6OptRelayMsg(optlen=0) /
 626                       DHCP6_Advertise(trid=1) /
 627                       DHCP6OptStatusCode(statuscode=0))
 628         pkts_adv_vrf0 = [p_adv_vrf0]
 629
 630         self.pg0.add_stream(pkts_adv_vrf0)
 631         self.pg_enable_capture(self.pg_interfaces)
 632         self.pg_start()
 633
 634         rx = self.pg2.get_capture(1)
 635         rx = rx[0]
 636         self.verify_dhcp6_advert(rx, self.pg2, dhcp_solicit_src_vrf0)
 637
 638         #
 639         # Add all the config for VRF 1
 640         #
 641         self.vapi.dhcp_proxy_config(server_addr_vrf1,
 642                                     src_addr_vrf1,
 643                                     rx_table_id=1,
 644                                     server_table_id=1,
 645                                     is_ipv6=1)
 646         self.pg3.config_ip6()
 647
 648         #
 649         # VRF 1 solicit
 650         #
 651         self.pg3.add_stream(pkts_solicit_vrf1)
 652         self.pg_enable_capture(self.pg_interfaces)
 653         self.pg_start()
 654
 655         rx = self.pg1.get_capture(1)
 656         rx = rx[0]
 657         self.verify_dhcp6_solicit(rx, self.pg1,
 658                                   dhcp_solicit_src_vrf1,
 659                                   self.pg3.remote_mac)
 660
 661         #
 662         # VRF 1 Advert
 663         #
 664         p_adv_vrf1 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
 665                       IPv6(dst=self.pg1.local_ip6, src=self.pg1.remote_ip6) /
 666                       UDP(sport=DHCP6_SERVER_PORT, dport=DHCP6_SERVER_PORT) /
 667                       DHCP6_RelayReply(peeraddr=dhcp_solicit_src_vrf1) /
 668                       DHCP6OptIfaceId(optlen=4, ifaceid='\x00\x00\x00\x04') /
 669                       DHCP6OptRelayMsg(optlen=0) /
 670                       DHCP6_Advertise(trid=1) /
 671                       DHCP6OptStatusCode(statuscode=0))
 672         pkts_adv_vrf1 = [p_adv_vrf1]
 673
 674         self.pg1.add_stream(pkts_adv_vrf1)
 675         self.pg_enable_capture(self.pg_interfaces)
 676         self.pg_start()
 677
 678         rx = self.pg3.get_capture(1)
 679         rx = rx[0]
 680         self.verify_dhcp6_advert(rx, self.pg3, dhcp_solicit_src_vrf1)
 681
 682         #
 683         # Add VSS config
 684         #  table=1, fib=id=1, oui=4
 685         self.vapi.dhcp_proxy_set_vss(1, 1, 4, is_ip6=1)
 686
 687         self.pg3.add_stream(pkts_solicit_vrf1)
 688         self.pg_enable_capture(self.pg_interfaces)
 689         self.pg_start()
 690
 691         rx = self.pg1.get_capture(1)
 692         rx = rx[0]
 693         self.verify_dhcp6_solicit(rx, self.pg1,
 694                                   dhcp_solicit_src_vrf1,
 695                                   self.pg3.remote_mac,
 696                                   fib_id=1,
 697                                   oui=4)
 698
 699         #
 700         # Remove the VSS config
 701         #  relayed DHCP has default vlaues in the option.
 702         #
 703         self.vapi.dhcp_proxy_set_vss(1, 1, 4, is_ip6=1, is_add=0)
 704
 705         self.pg3.add_stream(pkts_solicit_vrf1)
 706         self.pg_enable_capture(self.pg_interfaces)
 707         self.pg_start()
 708
 709         rx = self.pg1.get_capture(1)
 710         rx = rx[0]
 711         self.verify_dhcp6_solicit(rx, self.pg1,
 712                                   dhcp_solicit_src_vrf1,
 713                                   self.pg3.remote_mac)
 714
 715         #
 716         # Cleanup
 717         #
 718         self.vapi.dhcp_proxy_config(server_addr_vrf1,
 719                                     src_addr_vrf1,
 720                                     rx_table_id=1,
 721                                     server_table_id=1,
 722                                     is_ipv6=1,
 723                                     is_add=0)
 724         self.vapi.dhcp_proxy_config(server_addr_vrf1,
 725                                     src_addr_vrf1,
 726                                     rx_table_id=0,
 727                                     server_table_id=0,
 728                                     is_ipv6=1,
 729                                     is_add=0)
 730
 731 if __name__ == '__main__':
 732     unittest.main(testRunner=VppTestRunner)