def test_reply_qinq(self, port_number): intf = 'iif%d' % port_number stag = 10 ctag = 20 self.client.add_interface(intf) self.client.add_ip(intf, stag, ctag, 0x01020304) src_mac = self.my_mac[port_number] packet = simple_arp_packet( pktlen=42, eth_src=src_mac, ip_snd='1.2.3.1', ip_tgt='1.2.3.4', hw_snd=src_mac, hw_tgt='00:00:00:00:00:00', ) tagged_packet = self.insert_tags(packet, stag, ctag) testutils.send_packet(self, (0, port_number), tagged_packet) self.client.del_ip(intf, stag, ctag) self.client.del_interface(intf) exp_packet = simple_arp_packet(pktlen=42, eth_dst=src_mac, eth_src=self.remote_mac[port_number], arp_op=2, ip_snd='1.2.3.4', ip_tgt='1.2.3.1', hw_snd=self.remote_mac[port_number], hw_tgt=src_mac) tagged_exp_packet = self.insert_tags(exp_packet, stag, ctag) testutils.verify_packet(self, tagged_exp_packet, port_number)
def pingFromServers(self): packet = simple_tcp_packet( eth_dst=self.dut_mac, ip_src=self.from_server_src_addr, ip_dst=self.from_server_dst_addr, tcp_dport=5000 ) exp_packet = simple_tcp_packet( ip_src=self.from_server_src_addr, ip_dst=self.from_server_dst_addr, ip_ttl=63, tcp_dport=5000, ) exp_packet = Mask(exp_packet) exp_packet.set_do_not_care_scapy(scapy.Ether,"src") exp_packet.set_do_not_care_scapy(scapy.Ether,"dst") raw_packet = str(packet) for i in xrange(self.nr_pc_pkts): testutils.send_packet(self, self.from_server_src_port, raw_packet) total_rcv_pkt_cnt = testutils.count_matched_packets_all_ports(self, exp_packet, self.from_server_dst_ports, timeout=self.TIMEOUT) self.log("Send %5d Received %5d servers->t1" % (self.nr_pc_pkts, total_rcv_pkt_cnt), True) return total_rcv_pkt_cnt
def runTest(self): target = gc.Target(device_id=0, pipe_id=0xffff) # Get bfrt_info and set it as part of the test bfrt_info = self.interface.bfrt_info_get(p4_program_name) # Set default output port table_output_port = bfrt_info.table_get("SwitchIngress.output_port") action_data = table_output_port.make_data( action_name="SwitchIngress.set_output_port", data_field_list_in=[gc.DataTuple(name="port_id", val=swports[1])]) table_output_port.default_entry_set(target=target, data=action_data) # Set a default entry in the rewrite table so all packets get # their checksum updated. table_translate = bfrt_info.table_get("SwitchIngress.translate") action_data = table_translate.make_data( action_name="SwitchIngress.snupat", data_field_list_in=[ gc.DataTuple(name="src_addr", val=gc.ipv4_to_bytes("4.3.2.1")), gc.DataTuple(name="src_port", val=gc.to_bytes(0x4321, 2)), gc.DataTuple(name="update", val=0x0) ], ) table_translate.default_entry_set(target=target, data=action_data) try: ipkt = testutils.simple_udp_packet(eth_dst='11:11:11:11:11:11', eth_src='00:00:00:00:00:00', ip_src='1.2.3.4', ip_dst='100.99.98.97', ip_id=101, ip_ttl=64, udp_sport=0x1234, udp_dport=0xabcd, with_udp_chksum=True) epkt = testutils.simple_udp_packet(eth_dst='11:11:11:11:11:11', eth_src='00:00:00:00:00:00', ip_src='4.3.2.1', ip_dst='100.99.98.97', ip_id=101, ip_ttl=64, udp_sport=0x4321, udp_dport=0xabcd, with_udp_chksum=False) # We expect the packet to have the same TCP checksum as the packet # we sent in. Calling str forces scapy to calculate the checksum # for the given layer. epkt[scapy.all.IP].chksum = ipkt[scapy.all.IP].__class__( str(ipkt[scapy.all.IP])).chksum epkt[scapy.all.UDP].chksum = ipkt[scapy.all.UDP].__class__( str(ipkt[scapy.all.UDP])).chksum testutils.send_packet(self, swports[0], ipkt) testutils.verify_packet(self, epkt, swports[1]) finally: table_output_port.default_entry_reset(target) table_translate.default_entry_reset(target)
def ping0(self, eth_dst, ip_src, ip_dst, from_port, to_ports, msg): packet = simple_tcp_packet(eth_dst=eth_dst, ip_src=ip_src, ip_dst=ip_dst, tcp_dport=5000) exp_packet = simple_tcp_packet( ip_src=ip_src, ip_dst=ip_dst, ip_ttl=63, tcp_dport=5000, ) exp_packet = Mask(exp_packet) exp_packet.set_do_not_care_scapy(scapy.Ether, "src") exp_packet.set_do_not_care_scapy(scapy.Ether, "dst") for i in xrange(self.nr_pkts): testutils.send_packet(self, from_port, str(packet)) total_rcv_pkt_cnt = testutils.count_matched_packets_all_ports( self, exp_packet, to_ports) self.log( "Send %5d Received %5d %s" % (self.nr_pkts, total_rcv_pkt_cnt, msg), True) return total_rcv_pkt_cnt
def runControlPacketInTest(self, pppoed_pkt, line_mapped=True): s_tag = vlan_id_outer = 888 c_tag = vlan_id_inner = 777 self.setup_bng() # If a line mapping is not provided, we expect packets to be processed # with line ID 0 (e.g. counters updated at index 0). line_id = 0 if line_mapped: line_id = 99 self.set_upstream_line_map( s_tag=s_tag, c_tag=c_tag, line_id=line_id) pppoed_pkt = pkt_add_vlan(pppoed_pkt, vlan_vid=vlan_id_inner) pppoed_pkt = pkt_add_vlan(pppoed_pkt, vlan_vid=vlan_id_outer) old_terminated = self.read_pkt_count_upstream("terminated", line_id) old_dropped = self.read_pkt_count_upstream("dropped", line_id) old_control = self.read_pkt_count_upstream("control", line_id) testutils.send_packet(self, self.port1, str(pppoed_pkt)) self.verify_packet_in(pppoed_pkt, self.port1) testutils.verify_no_other_packets(self) new_terminated = self.read_pkt_count_upstream("terminated", line_id) new_dropped = self.read_pkt_count_upstream("dropped", line_id) new_control = self.read_pkt_count_upstream("control", line_id) # Only control plane packets. self.assertEqual(new_terminated, old_terminated) self.assertEqual(new_dropped, old_dropped) self.assertEqual(new_control, old_control + 1)
def copp_test(self, packet, count, send_intf, recv_intf): start_time = datetime.datetime.now() for i in xrange(count): testutils.send_packet(self, send_intf, packet) end_time = datetime.datetime.now() total_rcv_pkt_cnt = 0 while True: (rcv_device, rcv_port, rcv_pkt, pkt_time) = dp_poll(self, device_number=recv_intf[0], port_number=recv_intf[1], timeout=1) if rcv_pkt is not None: if match_exp_pkt(packet, rcv_pkt): total_rcv_pkt_cnt += 1 else: break time_delta = end_time - start_time time_delta_ms = (time_delta.microseconds + time_delta.seconds * 10**6) / 10**3 tx_pps = int(count / (float(time_delta_ms) / 1000)) rx_pps = int(total_rcv_pkt_cnt / (float(time_delta_ms) / 1000)) return total_rcv_pkt_cnt, time_delta, time_delta_ms, tx_pps, rx_pps
def runTest(self): target = gc.Target(device_id=0, pipe_id=0xffff) # Get bfrt_info and set it as part of the test bfrt_info = self.interface.bfrt_info_get(p4_program_name) # Set default output port table_output_port = bfrt_info.table_get("SwitchIngress.output_port") action_data = table_output_port.make_data( action_name="SwitchIngress.set_output_port", data_field_list_in=[gc.DataTuple(name="port_id", val=swports[1])]) table_output_port.default_entry_set(target=target, data=action_data) try: ipkt = testutils.simple_tcp_packet(eth_dst='11:11:11:11:11:11', eth_src='22:33:44:55:66:77', ip_src='1.2.3.4', ip_dst='100.99.98.97', ip_id=101, ip_ttl=64, tcp_sport=0x1234, tcp_dport=0xabcd, with_tcp_chksum=True) epkt = ipkt testutils.send_packet(self, swports[0], ipkt) testutils.verify_packet(self, epkt, swports[1]) finally: table_output_port.default_entry_reset(target)
def runTest(self): ig_ports = [swports[1], swports[2]] eg_ports = [swports[2], swports[1]] ip2 = "10.0.2.1" ip1 = "10.0.1.1" mac2 = "00:00:00:00:00:02" mac1 = "00:00:00:00:00:01" # send pkt and verify sent pkt = testutils.simple_tcp_packet(eth_dst=mac2, eth_src=mac1, ip_dst=ip2, with_tcp_chksum=False) exp_pkt = pkt logger.info("Sending packet on port %d", ig_ports[0]) testutils.send_packet(self, ig_ports[0], str(pkt)) logger.info("Expecting packet on port %d", eg_ports[0]) testutils.verify_packets(self, exp_pkt, [eg_ports[0]]) # send pkt and verify sent pkt = testutils.simple_tcp_packet(eth_dst=mac1, eth_src=mac2, ip_dst=ip1, with_tcp_chksum=False) exp_pkt = pkt logger.info("Sending packet on port %d", ig_ports[1]) testutils.send_packet(self, ig_ports[1], str(pkt)) logger.info("Expecting packet on port %d", eg_ports[1]) testutils.verify_packets(self, exp_pkt, [eg_ports[1]])
def runTest(self): def check_counters(device, port): counters = self.dataplane.get_nn_counters(device, port) self.assertIsNotNone(counters) self.assertTrue(type(counters) is tuple) self.assertEqual(len(counters), 2) return counters counters_01_b = check_counters(0, 1) counters_11_b = check_counters(1, 1) print "Counters:" print " (0, 1) %d:%d" % counters_01_b print " (1, 1) %d:%d" % counters_11_b pkt = "ab" * 20 testutils.send_packet(self, (0, 1), str(pkt)) print "packet sent" testutils.verify_packet(self, pkt, (1, 1)) counters_01_e = check_counters(0, 1) counters_11_e = check_counters(1, 1) print "Counters:" print " (0, 1) %d:%d" % counters_01_e print " (1, 1) %d:%d" % counters_11_e self.assertTrue(counters_01_e[1] > counters_01_b[1]) self.assertTrue(counters_11_e[0] > counters_11_b[0])
def checkRegularRegularLAGtoVLAN(self, acc_port, net_port, test, wu): src_mac = self.random_mac dst_mac = self.dut_mac src_ip = test['src_ip'] dst_ip = test['vlan_ip_prefixes'][acc_port] packet = simple_tcp_packet( eth_dst=dst_mac, eth_src=src_mac, ip_src=src_ip, ip_dst=dst_ip, ) exp_packet = simple_tcp_packet( eth_dst=self.ptf_mac_addrs['eth%d' % acc_port], eth_src=dst_mac, ip_src=src_ip, ip_dst=dst_ip, ip_ttl = 63, ) self.dataplane.flush() for i in xrange(self.nr): testutils.send_packet(self, net_port, packet) # We don't care if expected packet is received during warming up if not wu: nr_rcvd = count_matched_packets_helper(self, exp_packet, self.nr, acc_port, timeout=20) else: nr_rcvd = 0 rv = nr_rcvd == self.nr out = "" if not rv: arg = self.nr, nr_rcvd, str(net_port), str(acc_port), src_mac, dst_mac, src_ip, dst_ip out = "sent = %d rcvd = %d | src_port=%s dst_port=%s | src_mac=%s dst_mac=%s src_ip=%s dst_ip=%s" % arg return rv, out
def runTest(self): ig_ports = [swports[1], swports[2]] eg_ports = [swports[2], swports[1]] ip2 = "2001:0000:0000::0000:0000:0002" ip1 = "2001:0000:0000::0000:0000:0001" mac2 = "00:00:00:00:00:02" mac1 = "00:00:00:00:00:01" # send pkt and verify sent pkt = testutils.simple_tcpv6_packet(eth_dst=mac2, eth_src=mac1, ipv6_dst=ip2) exp_pkt = pkt logger.info("Sending packet on port %d", ig_ports[0]) testutils.send_packet(self, ig_ports[0], str(pkt)) logger.info("Expecting packet on port %d", eg_ports[0]) testutils.verify_packets(self, exp_pkt, [eg_ports[0]]) # send pkt and verify sent pkt = testutils.simple_tcpv6_packet(eth_dst=mac1, eth_src=mac2, ipv6_dst=ip1) exp_pkt = pkt logger.info("Sending packet on port %d", ig_ports[1]) testutils.send_packet(self, ig_ports[1], str(pkt)) logger.info("Expecting packet on port %d", eg_ports[1]) testutils.verify_packets(self, exp_pkt, [eg_ports[1]])
def runTest(self): target = gc.Target(device_id=0, pipe_id=0xffff) # Get bfrt_info and set it as part of the test bfrt_info = self.interface.bfrt_info_get(p4_program_name) # Set default output port ipv4_match_regular = bfrt_info.table_get("SwitchIngress.ipv4_match_regular") action_data = ipv4_match_regular.make_data( action_name="SwitchIngress.set_output_port", data_field_list_in=[gc.DataTuple(name="port_id", val=swports[0])] ) ipv4_match_regular.default_entry_set( target=target, data=action_data) try: ipkt = testutils.simple_udp_packet(eth_dst='11:11:11:11:11:11', eth_src='22:22:22:22:22:22', ip_src='1.2.3.4', ip_dst='100.99.98.97', ip_id=101, ip_ttl=64, udp_sport=0x1234, udp_dport=0xabcd) testutils.send_packet(self, swports[0], ipkt) testutils.verify_packet(self, ipkt, swports[0]) finally: ipv4_match_regular.default_entry_reset(target)
def runBridgingTest(self, tagged1, tagged2, pkt): vlan_id = 10 mac_src = pkt[Ether].src mac_dst = pkt[Ether].dst self.setup_port(self.port1, vlan_id, tagged1) self.setup_port(self.port2, vlan_id, tagged2) # miss on filtering.fwd_classifier => bridging self.add_bridging_entry(vlan_id, mac_src, MAC_MASK, 10) self.add_bridging_entry(vlan_id, mac_dst, MAC_MASK, 20) self.add_next_output(10, self.port1) self.add_next_output(20, self.port2) exp_pkt = pkt_decrement_ttl(pkt.copy()) pkt2 = pkt_mac_swap(pkt.copy()) exp_pkt2 = pkt_decrement_ttl(pkt2.copy()) if tagged1: pkt = pkt_add_vlan(pkt, vlan_vid=vlan_id) exp_pkt2 = pkt_add_vlan(exp_pkt2, vlan_vid=vlan_id) if tagged2: pkt2 = pkt_add_vlan(pkt2, vlan_vid=vlan_id) exp_pkt = pkt_add_vlan(exp_pkt, vlan_vid=vlan_id) testutils.send_packet(self, self.port1, str(pkt)) testutils.send_packet(self, self.port2, str(pkt2)) testutils.verify_each_packet_on_each_port(self, [exp_pkt, exp_pkt2], [self.port2, self.port1])
def mux_sim_check_upstream(upper_tor_host, lower_tor_host, ptfadapter, ptf_arp_tgt_ip, ptf_arp_pkt, ptf_port_index): # Send dummy ARP packets from PTF to ToR. Ensure that ARP is learned on both ToRs failed = False reason = '' host = None upper_tor_host.shell("ip neigh flush all") lower_tor_host.shell("ip neigh flush all") testutils.send_packet(ptfadapter, ptf_port_index, ptf_arp_pkt) upper_tor_arp_table = upper_tor_host.switch_arptable( )['ansible_facts']['arptable']['v4'] lower_tor_arp_table = lower_tor_host.switch_arptable( )['ansible_facts']['arptable']['v4'] if ptf_arp_tgt_ip not in upper_tor_arp_table: failed = True reason = 'Packet from PTF not received on upper ToR {}'.format( upper_tor_host) host = upper_tor_host.hostname return failed, reason, host if ptf_arp_tgt_ip not in lower_tor_arp_table: failed = True reason = 'Packet from PTF not received on lower ToR {}'.format( lower_tor_host) host = lower_tor_host.hostname return failed, reason, host
def runTest(self): in_dmac = 'ee:30:ca:9d:1e:00' in_smac = 'ee:cd:00:7e:70:00' ip_dst_addr = '10.1.0.1' ig_port = 1 eg_port = 2 l2ptr = 58 bd = 9 out_dmac = '02:13:57:ab:cd:ef' out_smac = '00:11:22:33:44:55' # Before adding any table entries, the default behavior for # sending in an IPv4 packet is to drop it. pkt = tu.simple_tcp_packet(eth_src=in_smac, eth_dst=in_dmac, ip_dst=ip_dst_addr, ip_ttl=64) tu.send_packet(self, ig_port, pkt) tu.verify_no_other_packets(self) # Add a set of table entries that the packet should match, and # be forwarded out with the desired dest and source MAC # addresses. self.table_add(self.key_ipv4_da_lpm(ip_dst_addr, 32), self.act_set_l2ptr(l2ptr)) self.table_add(self.key_mac_da(l2ptr), self.act_set_bd_dmac_intf(bd, out_dmac, eg_port)) self.table_add(self.key_send_frame(bd), self.act_rewrite_mac(out_smac)) # Check that the entry is hit, expected source and dest MAC # have been written into output packet, TTL has been # decremented, and that no other packets are received. exp_pkt = tu.simple_tcp_packet(eth_src=out_smac, eth_dst=out_dmac, ip_dst=ip_dst_addr, ip_ttl=63) tu.send_packet(self, ig_port, pkt) tu.verify_packets(self, exp_pkt, [eg_port])
def checkOriginalFlow(self): """ @summary: Send traffic & check how many original packets are received @return: count: number of original packets received """ exp_pkt = self.base_pkt.copy() exp_pkt['Ethernet'].src = self.router_mac exp_pkt['IP'].ttl = self.base_pkt['IP'].ttl - 1 masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") self.dataplane.flush() count = 0 testutils.send_packet(self, self.src_port, str(self.base_pkt), count=self.NUM_OF_TOTAL_PACKETS) for i in range(0, self.NUM_OF_TOTAL_PACKETS): (rcv_device, rcv_port, rcv_pkt, pkt_time) = testutils.dp_poll(self, timeout=0.1, exp_pkt=masked_exp_pkt) if rcv_pkt is not None: count += 1 elif count == 0: assert_str = "The first original packet is not recieved" assert count > 0, assert_str # Fast failure without waiting for full iteration else: break # No more packets available logger.info("Recieved {} original packets".format(count)) return count
def test_arp_garp_enabled(rand_selected_dut, garp_enabled, ip_and_intf_info, intfs_for_test, config_facts, ptfadapter): """ Send a gratuitous ARP (GARP) packet from the PTF to the DUT The DUT should learn the (previously unseen) ARP info from the packet """ pytest_require(garp_enabled, 'Gratuitous ARP not enabled for this device') duthost = rand_selected_dut ptf_intf_ipv4_addr = ip_and_intf_info[0] arp_request_ip = increment_ipv4_addr(ptf_intf_ipv4_addr) arp_src_mac = '00:00:07:08:09:0a' _, _, intf1_index, _, = intfs_for_test pkt = testutils.simple_arp_packet(pktlen=60, eth_dst='ff:ff:ff:ff:ff:ff', eth_src=arp_src_mac, vlan_pcp=0, arp_op=2, ip_snd=arp_request_ip, ip_tgt=arp_request_ip, hw_snd=arp_src_mac, hw_tgt='ff:ff:ff:ff:ff:ff' ) clear_dut_arp_cache(duthost) logger.info("Sending GARP for target {} from PTF interface {}".format(arp_request_ip, intf1_index)) testutils.send_packet(ptfadapter, intf1_index, pkt) vlan_intfs = config_facts['VLAN_INTERFACE'].keys() switch_arptable = duthost.switch_arptable()['ansible_facts'] pytest_assert(switch_arptable['arptable']['v4'][arp_request_ip]['macaddress'].lower() == arp_src_mac.lower()) pytest_assert(switch_arptable['arptable']['v4'][arp_request_ip]['interface'] in vlan_intfs)
def checkRegularRegularLAGtoVLAN(self, acc_port, net_port, test): src_mac = self.random_mac dst_mac = self.dut_mac src_ip = test['src_ip'] dst_ip = test['vlan_ip_prefix'] % acc_port packet = simple_tcp_packet( eth_dst=dst_mac, eth_src=src_mac, ip_src=src_ip, ip_dst=dst_ip, ) exp_packet = simple_tcp_packet( eth_dst=self.ptf_mac_addrs['eth%d' % acc_port], eth_src=dst_mac, ip_src=src_ip, ip_dst=dst_ip, ip_ttl=63, ) for i in xrange(self.nr): testutils.send_packet(self, net_port, packet) nr_rcvd = testutils.count_matched_packets(self, exp_packet, acc_port, timeout=0.2) rv = nr_rcvd == self.nr out = "" if not rv: arg = self.nr, nr_rcvd, str(net_port), str( acc_port), src_mac, dst_mac, src_ip, dst_ip out = "sent = %d rcvd = %d | src_port=%s dst_port=%s | src_mac=%s dst_mac=%s src_ip=%s dst_ip=%s" % arg return rv, out
def runTest(self): mac_addr_mask = ":".join(["ff"] * 6) vlan_id = 10 self.set_internal_vlan(self.port1, False, 0, 0, vlan_id) self.set_internal_vlan(self.port2, False, 0, 0, vlan_id) # miss on filtering.fwd_classifier => bridging self.add_bridging_entry(vlan_id, HOST1_MAC, mac_addr_mask, 10) self.add_bridging_entry(vlan_id, HOST2_MAC, mac_addr_mask, 20) self.add_next_hop(10, self.port1) self.add_next_hop(20, self.port2) self.set_egress_vlan_pop(self.port1, vlan_id) self.set_egress_vlan_pop(self.port2, vlan_id) pkt_1to2 = testutils.simple_tcp_packet(eth_src=HOST1_MAC, eth_dst=HOST2_MAC, ip_ttl=64) exp_pkt_1to2 = testutils.simple_tcp_packet(eth_src=HOST1_MAC, eth_dst=HOST2_MAC, ip_ttl=63) testutils.send_packet(self, self.port1, str(pkt_1to2)) testutils.verify_packets(self, exp_pkt_1to2, [self.port2]) pkt_2to1 = testutils.simple_tcp_packet(eth_src=HOST2_MAC, eth_dst=HOST1_MAC, ip_ttl=64) exp_pkt_2to1 = testutils.simple_tcp_packet(eth_src=HOST2_MAC, eth_dst=HOST1_MAC, ip_ttl=63) testutils.send_packet(self, self.port2, str(pkt_2to1)) testutils.verify_packets(self, exp_pkt_2to1, [self.port1])
def test(self, pkt): mcast_group_id = 10 mcast_ports = [self.port1, self.port2, self.port3] self.add_mcast_group(group_id=mcast_group_id, ports=mcast_ports) self.add_l2_ternary_entry(eth_dst=MAC_BROADCAST, eth_dst_mask=MAC_FULL_MASK, mcast_group_id=mcast_group_id) self.add_l2_ternary_entry(eth_dst=MAC_MULTICAST, eth_dst_mask=MAC_MULTICAST_MASK, mcast_group_id=mcast_group_id) self.add_acl_cpu_entry(eth_type=ARP_ETH_TYPE, clone=True) self.add_acl_cpu_entry(eth_type=IPV6_ETH_TYPE, ip_proto=ICMPV6_IP_PROTO, icmp_type=NS_ICMPV6_TYPE, clone=True) self.add_clone_session(CPU_CLONE_SESSION_ID, [self.cpu_port]) for inport in mcast_ports: testutils.send_packet(self, inport, str(pkt)) # Pkt should be received on CPU and on all ports # except the ingress one. self.verify_packet_in(exp_pkt=pkt, exp_in_port=inport) verify_ports = set(mcast_ports) verify_ports.discard(inport) for port in verify_ports: testutils.verify_packet(self, pkt, port) testutils.verify_no_other_packets(self)
def checkRegularRegularVLANtoLAG(self, acc_port, pc_ports, dst_ip, test): src_mac = self.ptf_mac_addrs['eth%d' % acc_port] dst_mac = self.dut_mac src_ip = test['vlan_ip_prefix'] % acc_port packet = simple_tcp_packet( eth_dst=dst_mac, eth_src=src_mac, ip_src=src_ip, ip_dst=dst_ip, ) exp_packet = simple_tcp_packet( eth_dst=self.random_mac, eth_src=dst_mac, ip_src=src_ip, ip_dst=dst_ip, ip_ttl=63, ) exp_packet = Mask(exp_packet) exp_packet.set_do_not_care_scapy(scapy.Ether, "dst") for i in xrange(self.nr): testutils.send_packet(self, acc_port, packet) nr_rcvd = testutils.count_matched_packets_all_ports(self, exp_packet, pc_ports, timeout=0.2) rv = nr_rcvd == self.nr out = "" if not rv: arg = self.nr, nr_rcvd, str(acc_port), str( pc_ports), src_mac, dst_mac, src_ip, dst_ip out = "sent = %d rcvd = %d | src_port=%s dst_ports=%s | src_mac=%s dst_mac=%s src_ip=%s dst_ip=%s" % arg return rv, out
def server_send_reply_relay_reply(self): # Form and send DHCPv6 RELAY-REPLY encapsulating REPLY packet reply_relay_reply_packet = self.create_dhcp_reply_relay_reply_packet() reply_relay_reply_packet.src = self.dataplane.get_mac( 0, self.server_port_indices[0]) testutils.send_packet(self, self.server_port_indices[0], reply_relay_reply_packet)
def doRunTest(self, pkt, sid_list): if IPv6 not in pkt or Ether not in pkt: self.fail("Cannot do IPv6 test with packet that is not IPv6") # l2_my_station -> srv6_transit -> l3_table -> l2_exact_table self.add_l2_my_station_entry(SWITCH1_MAC) sid_len = len(sid_list) getattr(self, "add_srv6_transit_%dsegment_entry" % sid_len)(pkt[IPv6].dst, 128, *sid_list) self.add_l3_ecmp_entry(sid_list[0], 128, [SWITCH2_MAC]) self.add_l2_exact_entry(SWITCH2_MAC, self.port2) exp_pkt = Ether(src=SWITCH1_MAC, dst=SWITCH2_MAC) exp_pkt /= IPv6(dst=sid_list[0], src=pkt[IPv6].src, hlim=63) exp_pkt /= IPv6ExtHdrSegmentRouting(nh=pkt[IPv6].nh, addresses=sid_list[::-1], len=sid_len * 2, segleft=sid_len - 1, lastentry=sid_len - 1) exp_pkt /= pkt[IPv6].payload if ICMPv6EchoRequest in exp_pkt: # FIXME: the P4 pipeline should calculate correct ICMPv6 checksum exp_pkt[ICMPv6EchoRequest].cksum = pkt[ICMPv6EchoRequest].cksum testutils.send_packet(self, self.port1, str(pkt)) testutils.verify_packet(self, exp_pkt, self.port2)
def runTest(self): vlan_id = 10 self.set_internal_vlan(self.port1, False, 0, 0, vlan_id) self.set_forwarding_type(self.port1, SWITCH_MAC, 0x800, FORWARDING_TYPE_UNICAST_IPV4) self.add_forwarding_unicast_v4_entry(HOST2_IPV4, 24, 300) grp_id = 66 mbrs = { 2: (self.port2, SWITCH_MAC, HOST2_MAC), 3: (self.port3, SWITCH_MAC, HOST3_MAC), } self.add_next_hop_L3_group(300, grp_id, mbrs) self.set_egress_vlan_pop(self.port2, vlan_id) self.set_egress_vlan_pop(self.port3, vlan_id) pkt_from1 = testutils.simple_tcp_packet(eth_src=HOST1_MAC, eth_dst=SWITCH_MAC, ip_src=HOST1_IPV4, ip_dst=HOST2_IPV4, ip_ttl=64) exp_pkt_to2 = testutils.simple_tcp_packet(eth_src=SWITCH_MAC, eth_dst=HOST2_MAC, ip_src=HOST1_IPV4, ip_dst=HOST2_IPV4, ip_ttl=64) exp_pkt_to3 = testutils.simple_tcp_packet(eth_src=SWITCH_MAC, eth_dst=HOST3_MAC, ip_src=HOST1_IPV4, ip_dst=HOST2_IPV4, ip_ttl=64) testutils.send_packet(self, self.port1, str(pkt_from1)) testutils.verify_any_packet_any_port(self, [exp_pkt_to2, exp_pkt_to3], [self.port2, self.port3])
def runTest(self): vlan_id = 10 self.set_internal_vlan(self.port1, False, 0, 0, vlan_id) self.set_forwarding_type(self.port1, SWITCH_MAC, 0x800, FORWARDING_TYPE_UNICAST_IPV4) self.add_forwarding_unicast_v4_entry(HOST2_IPV4, 24, 500) grp_id = 77 mpls_label = 0xaba mbrs = {2: (self.port2, SWITCH_MAC, HOST2_MAC, mpls_label)} self.add_next_hop_mpls_v4_group(500, grp_id, mbrs) self.set_egress_vlan_pop(self.port2, vlan_id) pkt_1to2 = testutils.simple_tcp_packet(eth_src=HOST1_MAC, eth_dst=SWITCH_MAC, ip_src=HOST1_IPV4, ip_dst=HOST2_IPV4, ip_ttl=64) exp_pkt_1to2 = testutils.simple_mpls_packet(eth_src=SWITCH_MAC, eth_dst=HOST2_MAC, mpls_tags=[{ "label": mpls_label, "tc": 0, "s": 1, "ttl": DEFAULT_MPLS_TTL }], inner_frame=pkt_1to2[IP:]) testutils.send_packet(self, self.port1, str(pkt_1to2)) testutils.verify_packets(self, exp_pkt_1to2, [self.port2])
def checkOriginalFlow(self): """ @summary: Send traffic & check how many original packets are received @return: count: number of original packets received """ exp_pkt = self.base_pkt.copy() exp_pkt['Ethernet'].src = self.router_mac exp_pkt['IP'].ttl = self.base_pkt['IP'].ttl - 1 masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") self.dataplane.flush() count = 0 for i in range(0, self.NUM_OF_TOTAL_PACKETS): testutils.send_packet(self, self.src_port, self.base_pkt) (rcv_device, rcv_port, rcv_pkt, pkt_time) = testutils.dp_poll(self, timeout=0.1, exp_pkt=masked_exp_pkt) if rcv_pkt is not None: count += 1 elif count == 0: print "The first original packet is not recieved" assert False # Fast failure without waiting for full iteration print "Recieved " + str(count) + " original packets" return count
def runTest(self): ip_dst_addr = "10.0.0.1" ip_dst_addr_str = ipv4_to_binary(ip_dst_addr) ig_port = self.swports(1) eg_port = self.swports(2) # port is 9-bit in v1model, i.e. 2 bytes eg_port_str = stringify(eg_port, 2) smac = "\xee\xcd\x00\x7e\x70\x00" dmac = "\xee\x30\xca\x9d\x1e\x00" # we do not care about the src mac address or the src IP address pkt = testutils.simple_tcp_packet(eth_dst=smac, ip_dst=ip_dst_addr, ip_ttl=64) # no forwarding entry: packet must be dropped testutils.send_packet(self, ig_port, pkt) testutils.verify_no_other_packets(self) # add a forwarding entry self.send_request_add_entry_to_action( "l3_host_fwd", [self.Exact("hdr.ipv4.dst_addr", ip_dst_addr_str)], "set_nexthop", [("port", eg_port_str), ("smac", smac), ("dmac", dmac)]) # check that the entry is hit and that no other packets are received exp_pkt = testutils.simple_tcp_packet(eth_src=smac, eth_dst=dmac, ip_dst=ip_dst_addr, ip_ttl=63) testutils.send_packet(self, ig_port, pkt) testutils.verify_packets(self, exp_pkt, [eg_port])
def checkVxlan(self, acc_port, net_port, test): rv = True inner_dst_mac = self.ptf_mac_addrs['eth%d' % acc_port] inner_src_mac = self.dut_mac inner_src_ip = test['vlan_gw'] inner_dst_ip = test['vlan_ip_prefix'] % acc_port dst_mac = self.dut_mac src_mac = self.random_mac ip_dst = self.loopback_ip inpacket = simple_arp_packet(eth_dst=inner_dst_mac, eth_src=inner_src_mac, arp_op=2, ip_snd=inner_src_ip, ip_tgt=inner_dst_ip, hw_snd=inner_src_mac, hw_tgt=inner_dst_mac) packet = simple_vxlan_packet(eth_dst=dst_mac, eth_src=src_mac, ip_src=test['src_ip'], ip_dst=ip_dst, vxlan_vni=test['vni'], inner_frame=inpacket) for i in xrange(self.nr): testutils.send_packet(self, net_port, packet) nr_rcvd = testutils.count_matched_packets(self, inpacket, acc_port, timeout=0.1) rv = rv and (nr_rcvd == self.nr) return rv
def checkRegularRegularLAGtoVLAN(self, acc_port, net_port, test): rv = True src_mac = self.random_mac dst_mac = self.dut_mac src_ip = test['src_ip'] dst_ip = test['vlan_ip_prefix'] % acc_port packet = simple_tcp_packet( eth_dst=dst_mac, eth_src=src_mac, ip_src=src_ip, ip_dst=dst_ip, ) exp_packet = simple_tcp_packet( eth_dst=self.ptf_mac_addrs['eth%d' % acc_port], eth_src=dst_mac, ip_src=src_ip, ip_dst=dst_ip, ip_ttl=63, ) for i in xrange(self.nr): testutils.send_packet(self, net_port, packet) if self.nr == 1: rv = rv and verify_packet_any_port(self, exp_packet, [acc_port]) else: rv = rv and self.nr == testutils.count_matched_packets( self, exp_packet, acc_port, timeout=0.1) return rv
def checkRegularRegularVLANtoLAG(self, acc_port, pc_ports, dst_ip, test): rv = True src_mac = self.ptf_mac_addrs['eth%d' % acc_port] dst_mac = self.dut_mac src_ip = test['vlan_ip_prefix'] % acc_port packet = simple_tcp_packet( eth_dst=dst_mac, eth_src=src_mac, ip_src=src_ip, ip_dst=dst_ip, ) exp_packet = simple_tcp_packet( eth_dst=self.random_mac, eth_src=dst_mac, ip_src=src_ip, ip_dst=dst_ip, ip_ttl=63, ) exp_packet = Mask(exp_packet) exp_packet.set_do_not_care_scapy(scapy.Ether, "dst") for i in xrange(self.nr): testutils.send_packet(self, acc_port, packet) if self.nr == 1: rv = rv and verify_packet_any_port(self, exp_packet, pc_ports) else: rv = rv and self.nr == testutils.count_matched_packets_all_ports( self, exp_packet, pc_ports, timeout=0.1) return rv
def traffic_sender_thread(self): """ @summary: Generalized Sender thread (to be used for traffic in both directions) Waits for a signal from the `traffic_sniffer_thread` before actually starting. This is to make sure that that packets are not sent before they are ready to be captured. """ logger.info("Sender waiting to send {} packets".format(len(self.packets_list))) self.sniffer_started.wait(timeout=10) sender_start = datetime.datetime.now() logger.info("Sender started at {}".format(str(sender_start))) # Signal data_plane_utils that sender and sniffer threads have begun self.io_ready_event.set() sent_packets_count = 0 for entry in self.packets_list: _, packet = entry server_addr = self.get_server_address(scapyall.Ether(str(packet))) time.sleep(self.send_interval) # the stop_early flag can be set to True by data_plane_utils to stop prematurely if self.stop_early: break testutils.send_packet(self.ptfadapter, *entry) self.packets_sent_per_server[server_addr] =\ self.packets_sent_per_server.get(server_addr, 0) + 1 sent_packets_count = sent_packets_count + 1 time.sleep(10) self.stop_sniffer_early() logger.info("Stop the sender thread gracefully after sending {} packets"\ .format(sent_packets_count)) logger.info("Sender finished running after {}".format( str(datetime.datetime.now() - sender_start)))
def runTest(self): def check_mac(device, port): mac = self.dataplane.get_mac(device, port) self.assertIsNotNone(mac) self.assertEqual(mac.count(":"), 5) check_mac(0, 1) pkt = "ab" * 20 testutils.send_packet(self, (0, 1), str(pkt)) print "packet sent" testutils.verify_packet(self, pkt, (1, 1)) check_mac(1, 1)
def copp_test(self, packet, count, send_intf, recv_intf): start_time=datetime.datetime.now() for i in xrange(count): testutils.send_packet(self, send_intf, packet) end_time=datetime.datetime.now() total_rcv_pkt_cnt = count_matched_packets(self, packet, recv_intf[1], recv_intf[0], timeout=1) time_delta = end_time - start_time time_delta_ms = (time_delta.microseconds + time_delta.seconds * 10**6) / 10**3 if time_delta_ms == 0: time_delta_ms = 1 tx_pps = int(count/(float(time_delta_ms)/1000)) rx_pps = int(total_rcv_pkt_cnt/(float(time_delta_ms)/1000)) return total_rcv_pkt_cnt, time_delta, time_delta_ms, tx_pps, rx_pps
def runTest(self): pkt = "ab" * 20 testutils.send_packet(self, (0, 1), str(pkt)) print "packet sent" testutils.verify_packet(self, pkt, (1, 1))