4 from socket import AF_INET, AF_INET6, inet_pton
6 from framework import VppTestCase, VppTestRunner
7 from vpp_neighbor import VppNeighbor, find_nbr
8 from vpp_ip_route import VppIpRoute, VppRoutePath, find_route
10 from scapy.packet import Raw
11 from scapy.layers.l2 import Ether, ARP, Dot1Q
12 from scapy.layers.inet import IP, UDP
13 from scapy.contrib.mpls import MPLS
15 # not exported by scapy, so redefined here
16 arp_opts = {"who-has": 1, "is-at": 2}
19 class ARPTestCase(VppTestCase):
23 super(ARPTestCase, self).setUp()
25 # create 3 pg interfaces
26 self.create_pg_interfaces(range(4))
28 # pg0 configured with ip4 and 6 addresses used for input
29 # pg1 configured with ip4 and 6 addresses used for output
30 # pg2 is unnumbered to pg0
31 for i in self.pg_interfaces:
36 self.pg0.resolve_arp()
41 # pg3 in a different VRF
42 self.pg3.set_table_ip4(1)
46 super(ARPTestCase, self).tearDown()
47 self.pg0.unconfig_ip4()
48 self.pg0.unconfig_ip6()
50 self.pg1.unconfig_ip4()
51 self.pg1.unconfig_ip6()
53 self.pg3.unconfig_ip4()
55 for i in self.pg_interfaces:
58 def verify_arp_req(self, rx, smac, sip, dip):
60 self.assertEqual(ether.dst, "ff:ff:ff:ff:ff:ff")
61 self.assertEqual(ether.src, smac)
64 self.assertEqual(arp.hwtype, 1)
65 self.assertEqual(arp.ptype, 0x800)
66 self.assertEqual(arp.hwlen, 6)
67 self.assertEqual(arp.plen, 4)
68 self.assertEqual(arp.op, arp_opts["who-has"])
69 self.assertEqual(arp.hwsrc, smac)
70 self.assertEqual(arp.hwdst, "00:00:00:00:00:00")
71 self.assertEqual(arp.psrc, sip)
72 self.assertEqual(arp.pdst, dip)
74 def verify_arp_resp(self, rx, smac, dmac, sip, dip):
76 self.assertEqual(ether.dst, dmac)
77 self.assertEqual(ether.src, smac)
80 self.assertEqual(arp.hwtype, 1)
81 self.assertEqual(arp.ptype, 0x800)
82 self.assertEqual(arp.hwlen, 6)
83 self.assertEqual(arp.plen, 4)
84 self.assertEqual(arp.op, arp_opts["is-at"])
85 self.assertEqual(arp.hwsrc, smac)
86 self.assertEqual(arp.hwdst, dmac)
87 self.assertEqual(arp.psrc, sip)
88 self.assertEqual(arp.pdst, dip)
90 def verify_arp_vrrp_resp(self, rx, smac, dmac, sip, dip):
92 self.assertEqual(ether.dst, dmac)
93 self.assertEqual(ether.src, smac)
96 self.assertEqual(arp.hwtype, 1)
97 self.assertEqual(arp.ptype, 0x800)
98 self.assertEqual(arp.hwlen, 6)
99 self.assertEqual(arp.plen, 4)
100 self.assertEqual(arp.op, arp_opts["is-at"])
101 self.assertNotEqual(arp.hwsrc, smac)
102 self.assertTrue("00:00:5e:00:01" in arp.hwsrc or
103 "00:00:5E:00:01" in arp.hwsrc)
104 self.assertEqual(arp.hwdst, dmac)
105 self.assertEqual(arp.psrc, sip)
106 self.assertEqual(arp.pdst, dip)
108 def verify_ip(self, rx, smac, dmac, sip, dip):
110 self.assertEqual(ether.dst, dmac)
111 self.assertEqual(ether.src, smac)
114 self.assertEqual(ip.src, sip)
115 self.assertEqual(ip.dst, dip)
117 def verify_ip_o_mpls(self, rx, smac, dmac, label, sip, dip):
119 self.assertEqual(ether.dst, dmac)
120 self.assertEqual(ether.src, smac)
123 self.assertTrue(mpls.label, label)
126 self.assertEqual(ip.src, sip)
127 self.assertEqual(ip.dst, dip)
129 def send_and_assert_no_replies(self, intf, pkts, remark):
130 intf.add_stream(pkts)
131 self.pg_enable_capture(self.pg_interfaces)
134 for i in self.pg_interfaces:
135 i.get_capture(0, timeout=timeout)
136 i.assert_nothing_captured(remark=remark)
143 # Generate some hosts on the LAN
145 self.pg1.generate_remote_hosts(11)
148 # Send IP traffic to one of these unresolved hosts.
149 # expect the generation of an ARP request
151 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
152 IP(src=self.pg0.remote_ip4, dst=self.pg1._remote_hosts[1].ip4) /
153 UDP(sport=1234, dport=1234) /
156 self.pg0.add_stream(p)
157 self.pg_enable_capture(self.pg_interfaces)
160 rx = self.pg1.get_capture(1)
162 self.verify_arp_req(rx[0],
165 self.pg1._remote_hosts[1].ip4)
168 # And a dynamic ARP entry for host 1
170 dyn_arp = VppNeighbor(self,
171 self.pg1.sw_if_index,
172 self.pg1.remote_hosts[1].mac,
173 self.pg1.remote_hosts[1].ip4)
174 dyn_arp.add_vpp_config()
177 # now we expect IP traffic forwarded
179 dyn_p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
180 IP(src=self.pg0.remote_ip4,
181 dst=self.pg1._remote_hosts[1].ip4) /
182 UDP(sport=1234, dport=1234) /
185 self.pg0.add_stream(dyn_p)
186 self.pg_enable_capture(self.pg_interfaces)
189 rx = self.pg1.get_capture(1)
191 self.verify_ip(rx[0],
193 self.pg1.remote_hosts[1].mac,
195 self.pg1._remote_hosts[1].ip4)
198 # And a Static ARP entry for host 2
200 static_arp = VppNeighbor(self,
201 self.pg1.sw_if_index,
202 self.pg1.remote_hosts[2].mac,
203 self.pg1.remote_hosts[2].ip4,
205 static_arp.add_vpp_config()
207 static_p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
208 IP(src=self.pg0.remote_ip4,
209 dst=self.pg1._remote_hosts[2].ip4) /
210 UDP(sport=1234, dport=1234) /
213 self.pg0.add_stream(static_p)
214 self.pg_enable_capture(self.pg_interfaces)
217 rx = self.pg1.get_capture(1)
219 self.verify_ip(rx[0],
221 self.pg1.remote_hosts[2].mac,
223 self.pg1._remote_hosts[2].ip4)
226 # flap the link. dynamic ARPs get flush, statics don't
228 self.pg1.admin_down()
231 self.pg0.add_stream(static_p)
232 self.pg_enable_capture(self.pg_interfaces)
234 rx = self.pg1.get_capture(1)
236 self.verify_ip(rx[0],
238 self.pg1.remote_hosts[2].mac,
240 self.pg1._remote_hosts[2].ip4)
242 self.pg0.add_stream(dyn_p)
243 self.pg_enable_capture(self.pg_interfaces)
246 rx = self.pg1.get_capture(1)
247 self.verify_arp_req(rx[0],
250 self.pg1._remote_hosts[1].ip4)
253 # Send an ARP request from one of the so-far unlearned remote hosts
255 p = (Ether(dst="ff:ff:ff:ff:ff:ff",
256 src=self.pg1._remote_hosts[3].mac) /
258 hwsrc=self.pg1._remote_hosts[3].mac,
259 pdst=self.pg1.local_ip4,
260 psrc=self.pg1._remote_hosts[3].ip4))
262 self.pg1.add_stream(p)
263 self.pg_enable_capture(self.pg_interfaces)
266 rx = self.pg1.get_capture(1)
267 self.verify_arp_resp(rx[0],
269 self.pg1._remote_hosts[3].mac,
271 self.pg1._remote_hosts[3].ip4)
274 # VPP should have learned the mapping for the remote host
276 self.assertTrue(find_nbr(self,
277 self.pg1.sw_if_index,
278 self.pg1._remote_hosts[3].ip4))
280 # Fire in an ARP request before the interface becomes IP enabled
282 self.pg2.generate_remote_hosts(4)
284 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg2.remote_mac) /
286 hwsrc=self.pg2.remote_mac,
287 pdst=self.pg1.local_ip4,
288 psrc=self.pg2.remote_hosts[3].ip4))
289 pt = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg2.remote_mac) /
292 hwsrc=self.pg2.remote_mac,
293 pdst=self.pg1.local_ip4,
294 psrc=self.pg2.remote_hosts[3].ip4))
295 self.send_and_assert_no_replies(self.pg2, p,
296 "interface not IP enabled")
299 # Make pg2 un-numbered to pg1
301 self.pg2.set_unnumbered(self.pg1.sw_if_index)
304 # We should respond to ARP requests for the unnumbered to address
305 # once an attached route to the source is known
307 self.send_and_assert_no_replies(
309 "ARP req for unnumbered address - no source")
311 attached_host = VppIpRoute(self, self.pg2.remote_hosts[3].ip4, 32,
312 [VppRoutePath("0.0.0.0",
313 self.pg2.sw_if_index)])
314 attached_host.add_vpp_config()
316 self.pg2.add_stream(p)
317 self.pg_enable_capture(self.pg_interfaces)
320 rx = self.pg2.get_capture(1)
321 self.verify_arp_resp(rx[0],
325 self.pg2.remote_hosts[3].ip4)
327 self.pg2.add_stream(pt)
328 self.pg_enable_capture(self.pg_interfaces)
331 rx = self.pg2.get_capture(1)
332 self.verify_arp_resp(rx[0],
336 self.pg2.remote_hosts[3].ip4)
339 # A neighbor entry that has no associated FIB-entry
341 arp_no_fib = VppNeighbor(self,
342 self.pg1.sw_if_index,
343 self.pg1.remote_hosts[4].mac,
344 self.pg1.remote_hosts[4].ip4,
346 arp_no_fib.add_vpp_config()
349 # check we have the neighbor, but no route
351 self.assertTrue(find_nbr(self,
352 self.pg1.sw_if_index,
353 self.pg1._remote_hosts[4].ip4))
354 self.assertFalse(find_route(self,
355 self.pg1._remote_hosts[4].ip4,
358 # pg2 is unnumbered to pg1, so we can form adjacencies out of pg2
359 # from within pg1's subnet
361 arp_unnum = VppNeighbor(self,
362 self.pg2.sw_if_index,
363 self.pg1.remote_hosts[5].mac,
364 self.pg1.remote_hosts[5].ip4)
365 arp_unnum.add_vpp_config()
367 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
368 IP(src=self.pg0.remote_ip4,
369 dst=self.pg1._remote_hosts[5].ip4) /
370 UDP(sport=1234, dport=1234) /
373 self.pg0.add_stream(p)
374 self.pg_enable_capture(self.pg_interfaces)
377 rx = self.pg2.get_capture(1)
379 self.verify_ip(rx[0],
381 self.pg1.remote_hosts[5].mac,
383 self.pg1._remote_hosts[5].ip4)
386 # ARP requests from hosts in pg1's subnet sent on pg2 are replied to
387 # with the unnumbered interface's address as the source
389 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg2.remote_mac) /
391 hwsrc=self.pg2.remote_mac,
392 pdst=self.pg1.local_ip4,
393 psrc=self.pg1.remote_hosts[6].ip4))
395 self.pg2.add_stream(p)
396 self.pg_enable_capture(self.pg_interfaces)
399 rx = self.pg2.get_capture(1)
400 self.verify_arp_resp(rx[0],
404 self.pg1.remote_hosts[6].ip4)
407 # An attached host route out of pg2 for an undiscovered hosts generates
408 # an ARP request with the unnumbered address as the source
410 att_unnum = VppIpRoute(self, self.pg1.remote_hosts[7].ip4, 32,
411 [VppRoutePath("0.0.0.0",
412 self.pg2.sw_if_index)])
413 att_unnum.add_vpp_config()
415 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
416 IP(src=self.pg0.remote_ip4,
417 dst=self.pg1._remote_hosts[7].ip4) /
418 UDP(sport=1234, dport=1234) /
421 self.pg0.add_stream(p)
422 self.pg_enable_capture(self.pg_interfaces)
425 rx = self.pg2.get_capture(1)
427 self.verify_arp_req(rx[0],
430 self.pg1._remote_hosts[7].ip4)
432 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg2.remote_mac) /
434 hwsrc=self.pg2.remote_mac,
435 pdst=self.pg1.local_ip4,
436 psrc=self.pg1.remote_hosts[7].ip4))
438 self.pg2.add_stream(p)
439 self.pg_enable_capture(self.pg_interfaces)
442 rx = self.pg2.get_capture(1)
443 self.verify_arp_resp(rx[0],
447 self.pg1.remote_hosts[7].ip4)
450 # An attached host route as yet unresolved out of pg2 for an
451 # undiscovered host, an ARP requests begets a response.
453 att_unnum1 = VppIpRoute(self, self.pg1.remote_hosts[8].ip4, 32,
454 [VppRoutePath("0.0.0.0",
455 self.pg2.sw_if_index)])
456 att_unnum1.add_vpp_config()
458 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg2.remote_mac) /
460 hwsrc=self.pg2.remote_mac,
461 pdst=self.pg1.local_ip4,
462 psrc=self.pg1.remote_hosts[8].ip4))
464 self.pg2.add_stream(p)
465 self.pg_enable_capture(self.pg_interfaces)
468 rx = self.pg2.get_capture(1)
469 self.verify_arp_resp(rx[0],
473 self.pg1.remote_hosts[8].ip4)
476 # Send an ARP request from one of the so-far unlearned remote hosts
479 p = (Ether(dst="ff:ff:ff:ff:ff:ff",
480 src=self.pg1._remote_hosts[9].mac) /
483 hwsrc=self.pg1._remote_hosts[9].mac,
484 pdst=self.pg1.local_ip4,
485 psrc=self.pg1._remote_hosts[9].ip4))
487 self.pg1.add_stream(p)
488 self.pg_enable_capture(self.pg_interfaces)
491 rx = self.pg1.get_capture(1)
492 self.verify_arp_resp(rx[0],
494 self.pg1._remote_hosts[9].mac,
496 self.pg1._remote_hosts[9].ip4)
499 # Add a hierachy of routes for a host in the sub-net.
500 # Should still get an ARP resp since the cover is attached
502 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg1.remote_mac) /
504 hwsrc=self.pg1.remote_mac,
505 pdst=self.pg1.local_ip4,
506 psrc=self.pg1.remote_hosts[10].ip4))
508 r1 = VppIpRoute(self, self.pg1.remote_hosts[10].ip4, 30,
509 [VppRoutePath(self.pg1.remote_hosts[10].ip4,
510 self.pg1.sw_if_index)])
513 self.pg1.add_stream(p)
514 self.pg_enable_capture(self.pg_interfaces)
516 rx = self.pg1.get_capture(1)
517 self.verify_arp_resp(rx[0],
521 self.pg1.remote_hosts[10].ip4)
523 r2 = VppIpRoute(self, self.pg1.remote_hosts[10].ip4, 32,
524 [VppRoutePath(self.pg1.remote_hosts[10].ip4,
525 self.pg1.sw_if_index)])
528 self.pg1.add_stream(p)
529 self.pg_enable_capture(self.pg_interfaces)
531 rx = self.pg1.get_capture(1)
532 self.verify_arp_resp(rx[0],
536 self.pg1.remote_hosts[10].ip4)
539 # add an ARP entry that's not on the sub-net and so whose
540 # adj-fib fails the refinement check. then send an ARP request
543 a1 = VppNeighbor(self,
544 self.pg0.sw_if_index,
549 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg0.remote_mac) /
551 hwsrc=self.pg0.remote_mac,
552 psrc="100.100.100.50",
553 pdst=self.pg0.remote_ip4))
554 self.send_and_assert_no_replies(self.pg0, p,
555 "ARP req for from failed adj-fib")
559 # 1 - don't respond to ARP request for address not within the
560 # interface's sub-net
561 # 1b - nor within the unnumbered subnet
562 # 1c - nor within the subnet of a different interface
564 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg0.remote_mac) /
566 hwsrc=self.pg0.remote_mac,
568 psrc=self.pg0.remote_ip4))
569 self.send_and_assert_no_replies(self.pg0, p,
570 "ARP req for non-local destination")
571 self.assertFalse(find_nbr(self,
572 self.pg0.sw_if_index,
575 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg2.remote_mac) /
577 hwsrc=self.pg2.remote_mac,
579 psrc=self.pg1.remote_hosts[7].ip4))
580 self.send_and_assert_no_replies(
582 "ARP req for non-local destination - unnum")
584 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg0.remote_mac) /
586 hwsrc=self.pg0.remote_mac,
587 pdst=self.pg1.local_ip4,
588 psrc=self.pg1.remote_ip4))
589 self.send_and_assert_no_replies(self.pg0, p,
590 "ARP req diff sub-net")
591 self.assertFalse(find_nbr(self,
592 self.pg0.sw_if_index,
593 self.pg1.remote_ip4))
596 # 2 - don't respond to ARP request from an address not within the
597 # interface's sub-net
598 # 2b - to a prxied address
599 # 2c - not within a differents interface's sub-net
600 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg0.remote_mac) /
602 hwsrc=self.pg0.remote_mac,
604 pdst=self.pg0.local_ip4))
605 self.send_and_assert_no_replies(self.pg0, p,
606 "ARP req for non-local source")
607 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg2.remote_mac) /
609 hwsrc=self.pg2.remote_mac,
611 pdst=self.pg0.local_ip4))
612 self.send_and_assert_no_replies(
614 "ARP req for non-local source - unnum")
615 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg0.remote_mac) /
617 hwsrc=self.pg0.remote_mac,
618 psrc=self.pg1.remote_ip4,
619 pdst=self.pg0.local_ip4))
620 self.send_and_assert_no_replies(self.pg0, p,
621 "ARP req for non-local source 2c")
624 # 3 - don't respond to ARP request from an address that belongs to
627 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg0.remote_mac) /
629 hwsrc=self.pg0.remote_mac,
630 psrc=self.pg0.local_ip4,
631 pdst=self.pg0.local_ip4))
632 self.send_and_assert_no_replies(self.pg0, p,
633 "ARP req for non-local source")
636 # 4 - don't respond to ARP requests that has mac source different
637 # from ARP request HW source
640 p = (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg0.remote_mac) /
642 hwsrc="00:00:00:DE:AD:BE",
643 psrc=self.pg0.remote_ip4,
644 pdst=self.pg0.local_ip4))
645 self.send_and_assert_no_replies(self.pg0, p,
646 "ARP req for non-local source")
651 dyn_arp.remove_vpp_config()
652 static_arp.remove_vpp_config()
653 self.pg2.unset_unnumbered(self.pg1.sw_if_index)
655 # need this to flush the adj-fibs
656 self.pg2.unset_unnumbered(self.pg1.sw_if_index)
657 self.pg2.admin_down()
658 self.pg1.admin_down()
660 def test_proxy_arp(self):
663 self.pg1.generate_remote_hosts(2)
666 # Proxy ARP rewquest packets for each interface
668 arp_req_pg0 = (Ether(src=self.pg0.remote_mac,
669 dst="ff:ff:ff:ff:ff:ff") /
671 hwsrc=self.pg0.remote_mac,
673 psrc=self.pg0.remote_ip4))
674 arp_req_pg0_tagged = (Ether(src=self.pg0.remote_mac,
675 dst="ff:ff:ff:ff:ff:ff") /
678 hwsrc=self.pg0.remote_mac,
680 psrc=self.pg0.remote_ip4))
681 arp_req_pg1 = (Ether(src=self.pg1.remote_mac,
682 dst="ff:ff:ff:ff:ff:ff") /
684 hwsrc=self.pg1.remote_mac,
686 psrc=self.pg1.remote_ip4))
687 arp_req_pg2 = (Ether(src=self.pg2.remote_mac,
688 dst="ff:ff:ff:ff:ff:ff") /
690 hwsrc=self.pg2.remote_mac,
692 psrc=self.pg1.remote_hosts[1].ip4))
693 arp_req_pg3 = (Ether(src=self.pg3.remote_mac,
694 dst="ff:ff:ff:ff:ff:ff") /
696 hwsrc=self.pg3.remote_mac,
698 psrc=self.pg3.remote_ip4))
701 # Configure Proxy ARP for 10.10.10.0 -> 10.10.10.124
703 self.vapi.proxy_arp_add_del(inet_pton(AF_INET, "10.10.10.2"),
704 inet_pton(AF_INET, "10.10.10.124"))
707 # No responses are sent when the interfaces are not enabled for proxy
710 self.send_and_assert_no_replies(self.pg0, arp_req_pg0,
711 "ARP req from unconfigured interface")
712 self.send_and_assert_no_replies(self.pg2, arp_req_pg2,
713 "ARP req from unconfigured interface")
716 # Make pg2 un-numbered to pg1
719 self.pg2.set_unnumbered(self.pg1.sw_if_index)
721 self.send_and_assert_no_replies(self.pg2, arp_req_pg2,
722 "ARP req from unnumbered interface")
725 # Enable each interface to reply to proxy ARPs
727 for i in self.pg_interfaces:
731 # Now each of the interfaces should reply to a request to a proxied
734 self.pg0.add_stream(arp_req_pg0)
735 self.pg_enable_capture(self.pg_interfaces)
738 rx = self.pg0.get_capture(1)
739 self.verify_arp_resp(rx[0],
745 self.pg0.add_stream(arp_req_pg0_tagged)
746 self.pg_enable_capture(self.pg_interfaces)
749 rx = self.pg0.get_capture(1)
750 self.verify_arp_resp(rx[0],
756 self.pg1.add_stream(arp_req_pg1)
757 self.pg_enable_capture(self.pg_interfaces)
760 rx = self.pg1.get_capture(1)
761 self.verify_arp_resp(rx[0],
767 self.pg2.add_stream(arp_req_pg2)
768 self.pg_enable_capture(self.pg_interfaces)
771 rx = self.pg2.get_capture(1)
772 self.verify_arp_resp(rx[0],
776 self.pg1.remote_hosts[1].ip4)
779 # A request for an address out of the configured range
781 arp_req_pg1_hi = (Ether(src=self.pg1.remote_mac,
782 dst="ff:ff:ff:ff:ff:ff") /
784 hwsrc=self.pg1.remote_mac,
786 psrc=self.pg1.remote_ip4))
787 self.send_and_assert_no_replies(self.pg1, arp_req_pg1_hi,
788 "ARP req out of range HI")
789 arp_req_pg1_low = (Ether(src=self.pg1.remote_mac,
790 dst="ff:ff:ff:ff:ff:ff") /
792 hwsrc=self.pg1.remote_mac,
794 psrc=self.pg1.remote_ip4))
795 self.send_and_assert_no_replies(self.pg1, arp_req_pg1_low,
796 "ARP req out of range Low")
799 # Request for an address in the proxy range but from an interface
802 self.send_and_assert_no_replies(self.pg3, arp_req_pg3,
803 "ARP req from different VRF")
806 # Disable Each interface for proxy ARP
807 # - expect none to respond
809 for i in self.pg_interfaces:
812 self.send_and_assert_no_replies(self.pg0, arp_req_pg0,
813 "ARP req from disable")
814 self.send_and_assert_no_replies(self.pg1, arp_req_pg1,
815 "ARP req from disable")
816 self.send_and_assert_no_replies(self.pg2, arp_req_pg2,
817 "ARP req from disable")
820 # clean up on interface 2
822 self.pg2.unset_unnumbered(self.pg1.sw_if_index)
828 # Interface 2 does not yet have ip4 config
830 self.pg2.config_ip4()
831 self.pg2.generate_remote_hosts(2)
834 # Add a reoute with out going label via an ARP unresolved next-hop
836 ip_10_0_0_1 = VppIpRoute(self, "10.0.0.1", 32,
837 [VppRoutePath(self.pg2.remote_hosts[1].ip4,
838 self.pg2.sw_if_index,
840 ip_10_0_0_1.add_vpp_config()
843 # packets should generate an ARP request
845 p = (Ether(src=self.pg0.remote_mac,
846 dst=self.pg0.local_mac) /
847 IP(src=self.pg0.remote_ip4, dst="10.0.0.1") /
848 UDP(sport=1234, dport=1234) /
851 self.pg0.add_stream(p)
852 self.pg_enable_capture(self.pg_interfaces)
855 rx = self.pg2.get_capture(1)
856 self.verify_arp_req(rx[0],
859 self.pg2._remote_hosts[1].ip4)
862 # now resolve the neighbours
864 self.pg2.configure_ipv4_neighbors()
867 # Now packet should be properly MPLS encapped.
868 # This verifies that MPLS link-type adjacencies are completed
869 # when the ARP entry resolves
871 self.pg0.add_stream(p)
872 self.pg_enable_capture(self.pg_interfaces)
875 rx = self.pg2.get_capture(1)
876 self.verify_ip_o_mpls(rx[0],
878 self.pg2.remote_hosts[1].mac,
882 self.pg2.unconfig_ip4()
884 def test_arp_vrrp(self):
885 """ ARP reply with VRRP virtual src hw addr """
888 # IP packet destined for pg1 remote host arrives on pg0 resulting
889 # in an ARP request for the address of the remote host on pg1
891 p0 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
892 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
893 UDP(sport=1234, dport=1234) /
896 self.pg0.add_stream(p0)
897 self.pg_enable_capture(self.pg_interfaces)
900 rx1 = self.pg1.get_capture(1)
902 self.verify_arp_req(rx1[0],
908 # ARP reply for address of pg1 remote host arrives on pg1 with
909 # the hw src addr set to a value in the VRRP IPv4 range of
912 p1 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
913 ARP(op="is-at", hwdst=self.pg1.local_mac,
914 hwsrc="00:00:5e:00:01:09", pdst=self.pg1.local_ip4,
915 psrc=self.pg1.remote_ip4))
917 self.pg1.add_stream(p1)
918 self.pg_enable_capture(self.pg_interfaces)
922 # IP packet destined for pg1 remote host arrives on pg0 again.
923 # VPP should have an ARP entry for that address now and the packet
924 # should be sent out pg1.
926 self.pg0.add_stream(p0)
927 self.pg_enable_capture(self.pg_interfaces)
930 rx1 = self.pg1.get_capture(1)
932 self.verify_ip(rx1[0],
938 self.pg1.admin_down()
941 def test_arp_duplicates(self):
942 """ ARP Duplicates"""
945 # Generate some hosts on the LAN
947 self.pg1.generate_remote_hosts(3)
950 # Add host 1 on pg1 and pg2
952 arp_pg1 = VppNeighbor(self,
953 self.pg1.sw_if_index,
954 self.pg1.remote_hosts[1].mac,
955 self.pg1.remote_hosts[1].ip4)
956 arp_pg1.add_vpp_config()
957 arp_pg2 = VppNeighbor(self,
958 self.pg2.sw_if_index,
960 self.pg1.remote_hosts[1].ip4)
961 arp_pg2.add_vpp_config()
964 # IP packet destined for pg1 remote host arrives on pg1 again.
966 p = (Ether(dst=self.pg0.local_mac,
967 src=self.pg0.remote_mac) /
968 IP(src=self.pg0.remote_ip4,
969 dst=self.pg1.remote_hosts[1].ip4) /
970 UDP(sport=1234, dport=1234) /
973 self.pg0.add_stream(p)
974 self.pg_enable_capture(self.pg_interfaces)
977 rx1 = self.pg1.get_capture(1)
979 self.verify_ip(rx1[0],
981 self.pg1.remote_hosts[1].mac,
983 self.pg1.remote_hosts[1].ip4)
986 # remove the duplicate on pg1
987 # packet stream shoud generate ARPs out of pg1
989 arp_pg1.remove_vpp_config()
991 self.pg0.add_stream(p)
992 self.pg_enable_capture(self.pg_interfaces)
995 rx1 = self.pg1.get_capture(1)
997 self.verify_arp_req(rx1[0],
1000 self.pg1.remote_hosts[1].ip4)
1005 arp_pg1.add_vpp_config()
1007 self.pg0.add_stream(p)
1008 self.pg_enable_capture(self.pg_interfaces)
1011 rx1 = self.pg1.get_capture(1)
1013 self.verify_ip(rx1[0],
1015 self.pg1.remote_hosts[1].mac,
1016 self.pg0.remote_ip4,
1017 self.pg1.remote_hosts[1].ip4)
1020 if __name__ == '__main__':
1021 unittest.main(testRunner=VppTestRunner)