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): # Get test parameters self.exp_iface = self.test_params['exp_iface'] self.timeout = self.test_params['timeout'] self.packet_timing = self.test_params['packet_timing'] self.ether_type = self.test_params['ether_type'] self.interval_count = int(self.test_params['interval_count']) if self.interval_count < 1: self.interval_count = 3 # Make sure the interval count is odd, so that we only look at one median interval if self.interval_count % 2 == 0: self.interval_count += 1 # Generate a packet. exp_pkt = simple_eth_packet(eth_type=self.ether_type) exp_pkt = exp_pkt / ("0" * 64) # Ignore fields with value unknown masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "src") masked_exp_pkt.set_do_not_care(14 * 8, 110 * 8) # Flush packets in dataplane self.dataplane.flush() # Check that packet timing matches the expected value. current_pkt_timing = self.getMedianInterval(masked_exp_pkt) self.assertTrue( abs(current_pkt_timing - float(self.packet_timing)) < 0.1, "Bad packet timing: %.2f seconds while expected timing is %d seconds from port %s out of %d intervals" % (current_pkt_timing, self.packet_timing, self.exp_iface, self.interval_count))
def runTest(self): self.table_add(table="MyIC_tbl_fwd", keys=[4], action=1, data=[5]) pkt = Ether() / self.RandomHeader() mask = Mask(pkt) mask.set_do_not_care_scapy(self.RandomHeader, "f1") mask.set_do_not_care_scapy(self.RandomHeader, "f2") mask.set_do_not_care_scapy(self.RandomHeader, "f3") sequence = [[], [], []] for _ in range(10): testutils.send_packet(self, PORT0, pkt) (_, recv_pkt) = testutils.verify_packet_any_port( self, mask, ALL_PORTS) recv_pkt = Ether(recv_pkt) self.verify_range(value=recv_pkt[self.RandomHeader].f1, min_value=0x80_00_00_01, max_value=0x80_00_00_05) sequence[0].append(recv_pkt[self.RandomHeader].f1) self.verify_range(value=recv_pkt[self.RandomHeader].f2, min_value=0, max_value=127) sequence[1].append(recv_pkt[self.RandomHeader].f2) self.verify_range(value=recv_pkt[self.RandomHeader].f3, min_value=256, max_value=259) sequence[2].append(recv_pkt[self.RandomHeader].f3) logger.info("f1 sequence: {}".format(sequence[0])) logger.info("f2 sequence: {}".format(sequence[1])) logger.info("f3 sequence: {}".format(sequence[2]))
def test_vlan_tc1_send_untagged( ptfadapter, work_vlan_ports_list, toggle_all_simulator_ports_to_rand_selected_tor_m): """ Test case #1 Verify packets egress without tag from ports whose PVID same with ingress port Verify packets egress with tag from ports who include VLAN ID but PVID different from ingress port. """ logger.info("Test case #1 starting ...") for vlan_port in work_vlan_ports_list: pkt = build_icmp_packet(0) logger.info("Send untagged packet from {} ...".format( vlan_port["port_index"][0])) logger.info( pkt.sprintf("%Ether.src% %IP.src% -> %Ether.dst% %IP.dst%")) if vlan_port['pvid'] != 0: testutils.send(ptfadapter, vlan_port["port_index"][0], pkt) verify_icmp_packets(ptfadapter, work_vlan_ports_list, vlan_port, vlan_port["pvid"]) else: exp_pkt = Mask(pkt) exp_pkt.set_do_not_care_scapy(scapy.Dot1Q, "vlan") dst_ports = [] for port in work_vlan_ports_list: dst_ports += port["port_index"] if port != vlan_port else [] testutils.send(ptfadapter, vlan_port["port_index"][0], pkt) logger.info("Check on " + str(dst_ports) + "...") testutils.verify_no_packet_any(ptfadapter, exp_pkt, dst_ports)
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 verify_icmp_packets(ptfadapter, vlan_ports_list, vlan_port, vlan_id): untagged_pkt = build_icmp_packet(0) tagged_pkt = build_icmp_packet(vlan_id) untagged_dst_ports = [] tagged_dst_ports = [] untagged_dst_pc_ports = [] tagged_dst_pc_ports = [] # vlan priority attached to packets is determined by the port, so we ignore it here masked_tagged_pkt = Mask(tagged_pkt) masked_tagged_pkt.set_do_not_care_scapy(scapy.Dot1Q, "prio") logger.info("Verify untagged packets from ports " + str(vlan_port["port_index"][0])) for port in vlan_ports_list: if vlan_port["port_index"] == port["port_index"]: # Skip src port continue if port["pvid"] == vlan_id: if len(port["port_index"]) > 1: untagged_dst_pc_ports.append(port["port_index"]) else: untagged_dst_ports += port["port_index"] elif vlan_id in map(int, port["permit_vlanid"].keys()): if len(port["port_index"]) > 1: tagged_dst_pc_ports.append(port["port_index"]) else: tagged_dst_ports += port["port_index"] verify_packets_with_portchannel(test=ptfadapter, pkt=untagged_pkt, ports=untagged_dst_ports, portchannel_ports=untagged_dst_pc_ports) verify_packets_with_portchannel(test=ptfadapter, pkt=masked_tagged_pkt, ports=tagged_dst_ports, portchannel_ports=tagged_dst_pc_ports)
def check_ipv6_route(self, in_port, sport, dport, ip_src, ip_dst, dst_port_list): ''' @summary: Check IPv6 route works. @param source_port_index: index of port to use for sending packet to switch @param dest_ip_addr: destination IP to build packet with. @param dst_port_list: list of ports on which to expect packet to come back from the switch @return Boolean ''' src_mac = self.dataplane.get_mac(0, 0) pkt = simple_tcpv6_packet(eth_dst=self.router_mac, eth_src=src_mac, ipv6_dst=ip_dst, ipv6_src=ip_src, tcp_sport=sport, tcp_dport=dport, ipv6_hlim=64) exp_pkt = simple_tcpv6_packet(eth_src=self.router_mac, ipv6_dst=ip_dst, ipv6_src=ip_src, tcp_sport=sport, tcp_dport=dport, ipv6_hlim=63) masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") send_packet(self, in_port, pkt) logging.info("Sending packet from port " + str(in_port) + " to " + ip_dst) return verify_packet_any_port(self, masked_exp_pkt, dst_port_list)
def FromServer(self, test): rv = True try: pkt_len = self.DEFAULT_PKT_LEN if test['vlan'] != 0: tagged = True pkt_len += 4 else: tagged = False vni = int(test['vni']) if 'dst_vni' in test: vni = int(test['dst_vni']) pkt = simple_tcp_packet( pktlen=pkt_len, eth_dst=self.dut_mac, eth_src=self.ptf_mac_addrs['eth%d' % test['port']], dl_vlan_enable=tagged, vlan_vid=test['vlan'], ip_dst=test['dst'], ip_src=test['src'], ip_id=105, ip_ttl=64) exp_pkt = simple_tcp_packet( eth_dst=test['mac'], eth_src=self.dut_mac, ip_dst=test['dst'], ip_src=test['src'], ip_id=105, ip_ttl=63) udp_sport = 1234 # Use entropy_hash(pkt) udp_dport = self.vxlan_port encap_pkt = simple_vxlan_packet( eth_src=self.dut_mac, eth_dst=self.random_mac, ip_id=0, ip_src=self.loopback_ip, ip_dst=test['host'], ip_ttl=64, udp_sport=udp_sport, udp_dport=udp_dport, with_udp_chksum=False, vxlan_vni=vni, inner_frame=exp_pkt) encap_pkt[IP].flags = 0x2 send_packet(self, test['port'], str(pkt)) masked_exp_pkt = Mask(encap_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "src") masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") masked_exp_pkt.set_do_not_care_scapy(scapy.UDP, "sport") log_str = "Sending packet from port " + str('eth%d' % test['port']) + " to " + test['dst'] logging.info(log_str) verify_packet_any_port(self, masked_exp_pkt, self.net_ports) finally: print
def create_ipv6_packets(self, ip_src, sport, dport, dest_ip_addr, destination_port_list, src_mac): ''' @summary: Check IPv4 route works. @param ip_src: source IP to build packet with. @sport: source tcp port @dport: destination tcp port @param dest_ip_addr: destination IP to build packet with. @param destination_port_list: list of ports on which to expect packet to come back from the switch @return Boolean ''' pkt = simple_tcpv6_packet(eth_dst=self.router_mac, eth_src=src_mac, ipv6_dst=dest_ip_addr, ipv6_src=ip_src, tcp_sport=sport, tcp_dport=dport, ipv6_hlim=64) exp_pkt = simple_tcpv6_packet(eth_dst=self.dataplane.get_mac(0, 0), eth_src=src_mac, ipv6_dst=dest_ip_addr, ipv6_src=ip_src, tcp_sport=sport, tcp_dport=dport, ipv6_hlim=63) masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "src") return (pkt, masked_exp_pkt)
def test_vlan_tc3_send_invalid_vid(ptfadapter, vlan_ports_list): """ Test case #3 Send packets with invalid VLAN ID Verify no port can receive these pacekts """ logger.info("Test case #3 starting ...") invalid_tagged_pkt = build_icmp_packet(4095) masked_invalid_tagged_pkt = Mask(invalid_tagged_pkt) masked_invalid_tagged_pkt.set_do_not_care_scapy(scapy.Dot1Q, "vlan") for vlan_port in vlan_ports_list: src_port = vlan_port["port_index"] dst_ports = [ port["port_index"] for port in vlan_ports_list if port != vlan_port ] logger.info("Send invalid tagged packet " + " from " + str(src_port) + "...") logger.info( invalid_tagged_pkt.sprintf( "%Ether.src% %IP.src% -> %Ether.dst% %IP.dst%")) testutils.send(ptfadapter, src_port, invalid_tagged_pkt) logger.info("Check on " + str(dst_ports) + "...") testutils.verify_no_packet_any(ptfadapter, masked_invalid_tagged_pkt, dst_ports)
def check_ipv4_route(self, src_port, dst_ip_addr, dst_port_list): ''' @summary: Check IPv4 route works. @param src_port: index of port to use for sending packet to switch @param dest_ip_addr: destination IP to build packet with. @param dst_port_list: list of ports on which to expect packet to come back from the switch ''' sport = random.randint(0, 65535) dport = random.randint(0, 65535) ip_src = "10.0.0.1" ip_dst = dst_ip_addr src_mac = self.dataplane.get_mac(0, 0) pkt = simple_tcp_packet(eth_dst=self.router_mac, eth_src=src_mac, ip_src=ip_src, ip_dst=ip_dst, tcp_sport=sport, tcp_dport=dport, ip_ttl=64) exp_pkt = simple_tcp_packet(eth_src=self.router_mac, ip_src=ip_src, ip_dst=ip_dst, tcp_sport=sport, tcp_dport=dport, ip_ttl=63) masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") send_packet(self, src_port, pkt) logging.info("Sending packet from port " + str(src_port) + " to " + ip_dst) return verify_packet_any_port(self, masked_exp_pkt, dst_port_list)
def check_ip_dir_bcast(self, dst_bcast_ip, dst_port_list): ''' @summary: Check directed broadcast IP forwarding and receiving on all member ports. ''' ip_src = self.TEST_SRC_IP ip_dst = dst_bcast_ip src_mac = self.dataplane.get_mac(0, 0) bcast_mac = self.BROADCAST_MAC pkt = simple_ip_packet(eth_dst=self.router_mac, eth_src=src_mac, ip_src=ip_src, ip_dst=ip_dst) exp_pkt = simple_ip_packet(eth_dst=bcast_mac, eth_src=self.router_mac, ip_src=ip_src, ip_dst=ip_dst) masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "chksum") masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "ttl") src_port = random.choice([port for port in self.src_ports if port not in dst_port_list]) send_packet(self, src_port, pkt) logging.info("Sending packet from port " + str(src_port) + " to " + ip_dst) pkt_count = count_matched_packets_all_ports(self, masked_exp_pkt, dst_port_list) ''' Check if broadcast packet is received on all member ports of vlan ''' logging.info("Received " + str(pkt_count) + " broadcast packets, expecting " + str(len(dst_port_list))) assert (pkt_count == len(dst_port_list)) return
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 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 runTest(self): vlan_ports_list = self.vlan_ports_list vlan_intf_list = self.vlan_intf_list # Test case #3 # Send packets with invalid VLAN ID # Verify no port can receive these pacekts self.log("Test case #3 starting ...") invalid_tagged_pkt = self.build_icmp_packet(4095) masked_invalid_tagged_pkt = Mask(invalid_tagged_pkt) masked_invalid_tagged_pkt.set_do_not_care_scapy(scapy.Dot1Q, "vlan") for vlan_port in vlan_ports_list: src_port = vlan_port["port_index"] dst_ports = [ port["port_index"] for port in vlan_ports_list if port != vlan_port ] self.log("Send invalid tagged packet " + " from " + str(src_port) + "...") self.log( invalid_tagged_pkt.sprintf( "%Ether.src% %IP.src% -> %Ether.dst% %IP.dst%")) send(self, src_port, invalid_tagged_pkt) self.log("Check on " + str(dst_ports) + "...") verify_no_packet_any(self, masked_invalid_tagged_pkt, dst_ports)
def send_and_verify(self, dst_ip, expected_ports, src_port, outer_pkt='ipv4', triple_encap=False): ''' @summary: This function builds encap packet, send and verify their arrival. @dst_ip: the destination ip for the inner IP header @expected_ports: list of ports that a packet can arrived from @src_port: the physical port that the packet will be sent from @triple_encap: True to send triple encapsulated packet ''' pkt, exp_pkt = self.create_encap_packet(dst_ip, outer_pkt, triple_encap) masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "src") #send and verify the return packets send_packet(self, src_port, pkt) logging.info(".....Sending packet from port" + str(src_port) + " to " + dst_ip + ", Triple_encap: " + str(triple_encap)) matched, received = verify_packet_any_port(self, masked_exp_pkt, expected_ports) assert received return matched, received
def send_recv_eth(ptfadapter, source_ports, source_mac, dest_ports, dest_mac, src_vlan, dst_vlan): """ send ethernet packet and verify it on dest_port :param ptfadapter: PTF adapter object :param source_port: source port :param source_mac: source MAC :param dest_port: destination port to receive packet on :param dest_mac: destination MAC :param vlan_id: VLAN id :return: """ pkt = simple_eth_packet( eth_dst=dest_mac, eth_src=source_mac, vlan_vid=src_vlan ) exp_pkt = simple_eth_packet( eth_dst=dest_mac, eth_src=source_mac, vlan_vid=dst_vlan ) if dst_vlan: # expect to receive tagged packet: # sonic device might modify the 802.1p field, # need to use Mask to ignore the priority field. exp_pkt = Mask(exp_pkt) exp_pkt.set_do_not_care_scapy(scapy.Dot1Q, "prio") logger.debug('send packet src port {} smac: {} dmac: {} vlan: {} verifying on dst port {}'.format( source_ports, source_mac, dest_mac, src_vlan, dest_ports)) testutils.send(ptfadapter, source_ports[0], pkt) testutils.verify_packet_any_port(ptfadapter, exp_pkt, dest_ports, timeout=FDB_WAIT_EXPECTED_PACKET_TIMEOUT)
def runTest(self): self.dst_addr = self.test_params['dst_addr'] self.src_iface = int(self.test_params['src_iface']) self.check_pkts_iface = int(self.test_params['check_pkts_iface']) self.num_of_pkts = int(self.test_params['num_of_pkts']) self.dut_mac = self.test_params['dut_mac'] slash_index = self.dst_addr.find("/") if slash_index != -1: self.dst_addr = self.dst_addr[:slash_index] # Generate packet (use DUT MAC address as next-hop-mac). pkt = simple_icmp_packet(eth_dst=self.dut_mac, ip_dst=self.dst_addr) # Generate expected packet (ignore MAC addresses). exp_pkt = simple_icmp_packet(ip_ttl=63, ip_dst=self.dst_addr) masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "src") # Send packets and verify it on dst port. i = 0 while i < int(self.num_of_pkts): send_packet(self, self.src_iface, pkt) verify_packet(self, masked_exp_pkt, self.check_pkts_iface) i += 1
def runTest(self): ecn = 1 dscp = self.queue_index tos = dscp << 2 tos |= ecn dst_port_list = range(0, 32) sport = random.randint(0, 65535) dport = random.randint(0, 65535) src_mac = self.dataplane.get_mac(0, 0) pkt = simple_tcp_packet(eth_dst=self.router_mac, eth_src=src_mac, ip_src=self.ip_src, ip_dst=self.ip_dst, ip_tos=tos, tcp_sport=sport, tcp_dport=dport, ip_ttl=64) exp_pkt = simple_tcp_packet(eth_src=self.router_mac, ip_src=self.ip_src, ip_dst=self.ip_dst, ip_tos=tos, tcp_sport=sport, tcp_dport=dport, ip_ttl=63) masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") send_packet(self, self.port_src, pkt, self.pkt_count) if self.wd_action == 'drop': return verify_no_packet_any(self, masked_exp_pkt, dst_port_list) else: return verify_packet_any_port(self, masked_exp_pkt, dst_port_list)
def testDhcpPacketForwarding(self, duthost, testPorts, ptfadapter, pktInfo): """ Validates that DHCP Discover/Offer/Request/Ack (DORA) packets are forwarded through T1 devices Args: duthost(Ansible Fixture): instance of SonicHost class of DUT testPorts(Ansible Fixture, dict): contains downstream/upstream test ports information ptfadapter(Ansible Fixture): instance of PTF Adapter pktInfo(Pytest Params<dict>): test parameters containing information on which ports used for sending/receiving DHCP packet and DHCP packet to send """ ptfadapter.dataplane.flush() dhcpPacket = pktInfo["pktGen"](duthost.facts["router_mac"]) testutils.send(ptfadapter, random.choice(testPorts[pktInfo["txDir"]]), dhcpPacket) # Update fields of the forwarded packet dhcpPacket[scapy.Ether].src = duthost.facts["router_mac"] dhcpPacket[ scapy.IP].ttl = dhcpPacket[scapy.IP].ttl - duthost.ttl_decr_value expectedDhcpPacket = Mask(dhcpPacket) expectedDhcpPacket.set_do_not_care_scapy(scapy.Ether, "dst") expectedDhcpPacket.set_do_not_care_scapy(scapy.IP, "chksum") _, receivedPacket = testutils.verify_packet_any_port( ptfadapter, expectedDhcpPacket, ports=testPorts[pktInfo["rxDir"]]) logger.info("Received packet: %s", scapy.Ether(receivedPacket).summary())
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 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 send_recv_eth(duthost, ptfadapter, source_ports, source_mac, dest_ports, dest_mac, src_vlan, dst_vlan): """ send ethernet packet and verify it on dest_port :param ptfadapter: PTF adapter object :param source_port: source port :param source_mac: source MAC :param dest_port: destination port to receive packet on :param dest_mac: destination MAC :param vlan_id: VLAN id :return: """ pkt = simple_eth_packet(eth_dst=dest_mac, eth_src=source_mac, vlan_vid=src_vlan) exp_pkt = simple_eth_packet(eth_dst=dest_mac, eth_src=source_mac, vlan_vid=dst_vlan) if dst_vlan: # expect to receive tagged packet: # sonic device might modify the 802.1p field, # need to use Mask to ignore the priority field. exp_pkt = Mask(exp_pkt) exp_pkt.set_do_not_care_scapy(scapy.Dot1Q, "prio") logger.debug( 'send packet src port {} smac: {} dmac: {} vlan: {} verifying on dst port {}' .format(source_ports, source_mac, dest_mac, src_vlan, dest_ports)) # fdb test will send lots of pkts between paired ports, it's hard to guarantee there is no congestion # on server side during this period. So tolerant to retry 3 times before complain the assert. retry_count = 3 for _ in range(retry_count): try: ptfadapter.dataplane.flush() testutils.send(ptfadapter, source_ports[0], pkt) if len(dest_ports) == 1: testutils.verify_packet( ptfadapter, exp_pkt, dest_ports[0], timeout=FDB_WAIT_EXPECTED_PACKET_TIMEOUT) else: testutils.verify_packet_any_port( ptfadapter, exp_pkt, dest_ports, timeout=FDB_WAIT_EXPECTED_PACKET_TIMEOUT) break except: pass else: result = duthost.command("show mac", module_ignore_errors=True) logger.debug("Show mac results {}".format(result['stdout'])) pytest_assert( False, "Expected packet was not received on ports {}" "Dest MAC in fdb is {}".format( dest_ports, dest_mac.lower() in result['stdout'].lower()))
def test_tagged_arp_pkt(ptfadapter, vlan_ports_list, duthosts, rand_one_dut_hostname, toggle_all_simulator_ports_to_rand_selected_tor): """ Send tagged GARP packets from each port. Verify packets egress without tag from ports whose PVID same with ingress port. Verify packets egress with tag from ports who include VLAN ID but PVID different from ingress port. verify show arp command on DUT. """ duthost = duthosts[rand_one_dut_hostname] for vlan_port in vlan_ports_list: port_index = vlan_port["port_index"][0] # Send GARP packets to switch to populate the arp table with dummy MACs for each port # Totally 10 dummy MACs for each port, send 1 packet for each dummy MAC # ARP table will be cleaned up before each iteration, so there won't be any conflict MAC and IP dummy_macs = ['{}:{:02x}:{:02x}'.format(DUMMY_MAC_PREFIX, port_index&0xFF, i+1) for i in range(DUMMY_ARP_COUNT)] dummy_ips = ['{}.{:d}.{:d}'.format(DUMMY_IP_PREFIX, port_index&0xFF, i+1) for i in range(DUMMY_ARP_COUNT)] for permit_vlanid in map(int, vlan_port["permit_vlanid"]): logger.info('Test ARP: interface %s, VLAN %u' % (vlan_port["dev"], permit_vlanid)) # Perform ARP clean up arp_cleanup(duthost) for i in range(DUMMY_ARP_COUNT): pkt = build_arp_packet(permit_vlanid, dummy_macs[i], dummy_ips[i]) exp_untagged_pkt = build_arp_packet(0, dummy_macs[i], dummy_ips[i]) # vlan priority attached to packets is determined by the port, so we ignore it here exp_tagged_pkt = Mask(pkt) exp_tagged_pkt.set_do_not_care_scapy(scapy.Dot1Q, "prio") logger.info("Send tagged({}) packet from {} ...".format(permit_vlanid, port_index)) testutils.send(ptfadapter, port_index, pkt) verify_arp_packets(ptfadapter, vlan_ports_list, vlan_port, permit_vlanid, exp_untagged_pkt, exp_tagged_pkt) res = duthost.command('show arp') assert res['rc'] == 0 logger.info('"show arp" output on DUT:\n{}'.format(pprint.pformat(res['stdout_lines']))) arp_cnt = 0 for l in res['stdout_lines']: # Address MacAddress Iface Vlan items = l.split() if len(items) != 4: continue # Vlan must be number if not items[3].isdigit(): continue arp_cnt += 1 ip = items[0] mac = items[1] ifname = items[2] vlan_id = int(items[3]) assert ip in dummy_ips assert mac in dummy_macs # 'show arp' command gets iface from FDB table, # if 'show arp' command was earlier than FDB table update, ifname would be '-' if ifname == '-': logger.info('Ignore unknown iface...') else: assert ifname == vlan_port["dev"] assert vlan_id == permit_vlanid assert arp_cnt == DUMMY_ARP_COUNT
def send_and_check_mirror_packets(self, setup, mirror_session, ptfadapter, duthost, mirror_packet, src_port=None, dest_ports=None, expect_recv=True): expected_mirror_packet = self._get_expected_mirror_packet( mirror_session, setup, duthost, mirror_packet) if not src_port: src_port = self._get_random_src_port(setup) if not dest_ports: dest_ports = [ self._get_monitor_port(setup, mirror_session, duthost) ] ptfadapter.dataplane.flush() testutils.send(ptfadapter, src_port, mirror_packet) if expect_recv: _, received_packet = testutils.verify_packet_any_port( ptfadapter, expected_mirror_packet, ports=dest_ports) logging.info("Received packet: %s", packet.Ether(received_packet).summary()) inner_packet = self._extract_mirror_payload( received_packet, len(mirror_packet)) logging.info("Received inner packet: %s", inner_packet.summary()) inner_packet = Mask(inner_packet) # For egress mirroring, we expect the DUT to have modified the packet # before forwarding it. Specifically: # # - In L2 the SMAC and DMAC will change. # - In L3 the TTL and checksum will change. # # We know what the TTL and SMAC should be after going through the pipeline, # but DMAC and checksum are trickier. For now, update the TTL and SMAC, and # mask off the DMAC and IP Checksum to verify the packet contents. if self.mirror_type() == "egress": mirror_packet[packet.IP].ttl -= 1 mirror_packet[packet.Ether].src = setup["router_mac"] inner_packet.set_do_not_care_scapy(packet.Ether, "dst") inner_packet.set_do_not_care_scapy(packet.IP, "chksum") logging.info("Expected inner packet: %s", mirror_packet.summary()) pytest_assert(inner_packet.pkt_match(mirror_packet), "Mirror payload does not match received packet") else: testutils.verify_no_packet_any(ptfadapter, expected_mirror_packet, dest_ports)
def runTest(self): pkt = simple_tcpv6_packet(ipv6_src='2001::1', ipv6_dst='2001::2') exp_pkt = simple_tcpv6_packet(ipv6_src='2001::2', ipv6_dst='2001::1') mask = Mask(exp_pkt) mask.set_do_not_care_scapy(TCP, 'chksum') send_packet(self, (0, 1), pkt) verify_packets(self, mask, device_number=0, ports=[2])
def runTest(self): pkt = simple_ip_packet(ip_src="192.168.1.1", ip_tos=10) exp_pkt = simple_ip_packet(ip_src="192.168.1.1", ip_tos=255) mask = Mask(exp_pkt) mask.set_do_not_care_scapy(IP, 'chksum') send_packet(self, (0, 1), pkt) verify_packets(self, mask, device_number=0, ports=[2])
def check_ip_mtu(self): """Check unicast IP forwarding in DUT works for MAX MTU.""" ip_src = self.src_host_ip ip_dst = self.dst_host_ip src_mac = self.dataplane.get_mac(0, self.src_ptf_port_list[0]) if self.version == 4: pkt = simple_ip_packet(pktlen=self.pktlen, eth_dst=self.router_mac, eth_src=src_mac, ip_src=ip_src, ip_dst=ip_dst, ip_ttl=64) exp_pkt = simple_ip_packet(pktlen=self.pktlen, eth_src=self.router_mac_dst, ip_src=ip_src, ip_dst=ip_dst, ip_ttl=63) masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") else: pkt = simple_ipv6ip_packet(pktlen=self.pktlen, eth_dst=self.router_mac, eth_src=src_mac, ipv6_src=ip_src, ipv6_dst=ip_dst, ipv6_hlim=64) exp_pkt = simple_ipv6ip_packet(pktlen=self.pktlen, eth_src=self.router_mac_dst, ipv6_src=ip_src, ipv6_dst=ip_dst, ipv6_hlim=63) masked_exp_pkt = Mask(exp_pkt) masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst") src_port = self.src_ptf_port_list[0] send_packet(self, src_port, pkt) logging.info("Sending packet from port " + str(src_port) + " to " + ip_dst) dst_port_list = self.dst_ptf_port_list (matched_index, received) = verify_packet_any_port(self, masked_exp_pkt, dst_port_list) assert received matched_port = dst_port_list[matched_index] logging.info("Received packet at " + str(matched_port)) return
def runTest(self): pkt = Ether() / IP(src="192.168.1.1") / TCP() / "Ala ma kota" exp_pkt = Ether() / IP(src="192.168.1.1", proto=55) / TCP() / "Ala ma kota" mask = Mask(exp_pkt) mask.set_do_not_care_scapy(IP, 'chksum') send_packet(self, (0, 1), pkt) verify_packets(self, mask, device_number=0, ports=[2])
def runSendReceiveTest(self, pkt2send, src_port, destination_ports): """ @summary Send packet and verify it is received/not received on the expected ports """ testutils.send_packet(self, src_port, pkt2send) (index, rcv_pkt, received) = self.receivePacketOnPorts(destination_ports) self.tests_total += 1 if not received: return False scapy_pkt = scapy.Ether(rcv_pkt) if scapy.IP not in scapy_pkt: return False if self.expected_dst_mac and scapy_pkt.dst != self.expected_dst_mac: return False if scapy_pkt[scapy.IP].src != self.session_src_ip: return False if scapy_pkt[scapy.IP].dst != self.session_dst_ip: return False if scapy_pkt[scapy.IP].ttl != self.session_ttl: return False # TODO: Fanout modifies DSCP. TOS value is olways 0. #if (scapy_pkt[scapy.IP].tos >> 2) != self.session_dscp: # return False payload = str(scapy_pkt[scapy.GRE].payload) if self.hwsku in [ "ACS-MSN2700", "ACS-MSN2100", "ACS-MSN2410", "ACS-MSN2740", "Mellanox-SN2700" ]: payload = str(scapy_pkt[scapy.GRE].payload)[22:] if self.asic_type in ["barefoot"]: payload = str(scapy_pkt[scapy.GRE].payload)[12:] inner_pkt = scapy.Ether(payload) masked_inner_pkt = Mask(inner_pkt) if scapy.IP in inner_pkt: masked_inner_pkt.set_do_not_care_scapy(scapy.IP, "chksum") if scapy.TCP in inner_pkt: masked_inner_pkt.set_do_not_care_scapy(scapy.TCP, "chksum") return dataplane.match_exp_pkt(masked_inner_pkt, pkt2send)
def runTest(self): print "Sending L2 packet - port 1 -> port 2 [trunk vlan=10])" switch_init(self.client) vlan_id = 10 port1 = port_list[1] port2 = port_list[2] mac1 = '00:11:11:11:11:11' mac2 = '00:22:22:22:22:22' mac_action = 1 self.client.sai_thrift_create_vlan(vlan_id) vlan_port1 = sai_thrift_vlan_port_t(port_id=port1, tagging_mode=1) vlan_port2 = sai_thrift_vlan_port_t(port_id=port2, tagging_mode=0) self.client.sai_thrift_add_ports_to_vlan(vlan_id, [vlan_port1, vlan_port2]) sai_thrift_create_fdb(self.client, vlan_id, mac1, port1, mac_action) sai_thrift_create_fdb(self.client, vlan_id, mac2, port2, mac_action) pkt = simple_tcp_packet(eth_dst='00:11:11:11:11:11', eth_src='00:22:22:22:22:22', ip_dst='10.0.0.1', ip_id=102, ip_ttl=64) exp_pkt = simple_tcp_packet(eth_dst='00:11:11:11:11:11', eth_src='00:22:22:22:22:22', ip_dst='10.0.0.1', dl_vlan_enable=True, vlan_vid=10, ip_id=102, ip_ttl=64, pktlen=104) # illustrates how to use a mask even if no impact here m = Mask(exp_pkt) m.set_do_not_care_scapy(IP, 'ttl') try: send_packet(self, 2, pkt) verify_packets(self, m, [1]) finally: sai_thrift_delete_fdb(self.client, vlan_id, mac1, port1) sai_thrift_delete_fdb(self.client, vlan_id, mac2, port2) self.client.sai_thrift_remove_ports_from_vlan(vlan_id, [vlan_port1, vlan_port2]) self.client.sai_thrift_delete_vlan(vlan_id)
def runTest(self): print switch_init(self.client) port1 = port_list[0] port2 = port_list[1] port3 = port_list[2] monitor_port=port1 source_port=port2 mac3='00:00:00:00:00:33' mac2='00:00:00:00:00:22' mirror_type=SAI_MIRROR_TYPE_LOCAL sai_thrift_create_fdb(self.client, 2, mac3, port3, 1) sai_thrift_create_fdb(self.client, 2, mac2, port2, 1) # Put ports under test in VLAN 2 self.client.sai_thrift_create_vlan(2) vlan_member1 = sai_thrift_create_vlan_member(self.client, 2, port1, SAI_VLAN_PORT_TAGGED) vlan_member1a = sai_thrift_create_vlan_member(self.client, 1, port1, SAI_VLAN_PORT_TAGGED) vlan_member2 = sai_thrift_create_vlan_member(self.client, 2, port2, SAI_VLAN_PORT_TAGGED) vlan_member2a = sai_thrift_create_vlan_member(self.client, 1, port2, SAI_VLAN_PORT_TAGGED) vlan_member3 = sai_thrift_create_vlan_member(self.client, 2, port3, SAI_VLAN_PORT_TAGGED) vlan_member3a = sai_thrift_create_vlan_member(self.client, 1, port3, SAI_VLAN_PORT_TAGGED) # Remove ports from default VLAN self.client.sai_thrift_remove_vlan_member(vlan_member1a) self.client.sai_thrift_remove_vlan_member(vlan_member2a) self.client.sai_thrift_remove_vlan_member(vlan_member3a) # Set PVID attr_value = sai_thrift_attribute_value_t(u16=2) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_PORT_VLAN_ID, value=attr_value) self.client.sai_thrift_set_port_attribute(port1, attr) self.client.sai_thrift_set_port_attribute(port2, attr) self.client.sai_thrift_set_port_attribute(port3, attr) spanid=sai_thrift_create_mirror_session(self.client,mirror_type=mirror_type,port=monitor_port,vlan=1,vlan_priority=0,vlan_tpid=0,src_mac=None,dst_mac=None,addr_family=0,src_ip=None,dst_ip=None,encap_type=0,protocol=0,ttl=0,tos=0,gre_type=0) attrb_value = sai_thrift_attribute_value_t(objlist=sai_thrift_object_list_t(count=1,object_id_list=[spanid])) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_INGRESS_MIRROR_SESSION, value=attrb_value) self.client.sai_thrift_set_port_attribute(port2, attr) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_EGRESS_MIRROR_SESSION, value=attrb_value) self.client.sai_thrift_set_port_attribute(port2, attr) pkt = simple_tcp_packet(eth_dst='00:00:00:00:00:33', eth_src='00:22:22:22:22:22', ip_dst='10.0.0.1', dl_vlan_enable=True, vlan_vid=2, ip_id=101, ip_ttl=64) exp_pkt = simple_tcp_packet(eth_dst='00:00:00:00:00:33', eth_src='00:22:22:22:22:22', ip_dst='10.0.0.1', dl_vlan_enable=True, vlan_vid=2, ip_id=101, ip_ttl=64) pkt2 = simple_tcp_packet(eth_dst='00:00:00:00:00:22', eth_src='00:33:33:33:33:33', ip_dst='10.0.0.1', dl_vlan_enable=True, vlan_vid=2, ip_id=101, ip_ttl=64, pktlen=104) exp_pkt2 = simple_tcp_packet(eth_dst='00:00:00:00:00:22', eth_src='00:33:33:33:33:33', ip_dst='10.0.0.1', dl_vlan_enable=True, vlan_vid=2,#use vlan_vid field if packets are expected to be monitored on client side otherwise not needed ip_id=101, ip_ttl=64, pktlen=104) m=Mask(exp_pkt2) m.set_do_not_care_scapy(ptf.packet.IP,'id') m.set_do_not_care_scapy(ptf.packet.IP,'chksum') try: # in tuple: 0 is device number, 2 is port number # this tuple uniquely identifies a port # for ingress mirroring print "Checking INGRESS Local Mirroring" print "Sending packet port 2 -> port 3 (00:22:22:22:22:22 -> 00:00:00:00:00:33)" send_packet(self, 1, pkt) verify_packets(self, exp_pkt, ports=[0,2]) # for egress mirroring print "Checking EGRESS Local Mirroring" print "Sending packet port 3 -> port 2 (00:33:33:33:33:33 -> 00:00:00:00:00:22)" send_packet(self, 2, pkt2) verify_each_packet_on_each_port(self, [m,pkt2], ports=[0,1]) finally: sai_thrift_delete_fdb(self.client, 2, mac3, port3) sai_thrift_delete_fdb(self.client, 2, mac2, port2) # Remove ports from mirror destination attrb_value = sai_thrift_attribute_value_t(objlist=sai_thrift_object_list_t(count=0,object_id_list=[spanid])) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_INGRESS_MIRROR_SESSION, value=attrb_value) self.client.sai_thrift_set_port_attribute(port2, attr) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_EGRESS_MIRROR_SESSION, value=attrb_value) self.client.sai_thrift_set_port_attribute(port2, attr) # Now you can remove destination self.client.sai_thrift_remove_mirror_session(spanid) # Remove ports from VLAN 2 self.client.sai_thrift_remove_vlan_member(vlan_member1) self.client.sai_thrift_remove_vlan_member(vlan_member2) self.client.sai_thrift_remove_vlan_member(vlan_member3) self.client.sai_thrift_delete_vlan(2) # Add ports back to default VLAN vlan_member1a = sai_thrift_create_vlan_member(self.client, 1, port1, SAI_VLAN_PORT_UNTAGGED) vlan_member2a = sai_thrift_create_vlan_member(self.client, 1, port2, SAI_VLAN_PORT_UNTAGGED) vlan_member3a = sai_thrift_create_vlan_member(self.client, 1, port3, SAI_VLAN_PORT_UNTAGGED) attr_value = sai_thrift_attribute_value_t(u16=1) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_PORT_VLAN_ID, value=attr_value) self.client.sai_thrift_set_port_attribute(port1, attr) self.client.sai_thrift_set_port_attribute(port2, attr) self.client.sai_thrift_set_port_attribute(port3, attr)
def runTest(self): print switch_init(self.client) port1=port_list[0] #From where we expect encapsulated packet port2=port_list[1] #From where we send normal ip packet mac1 = '00:05:06:00:00:00' # port1 l2 entry mac2 = '00:05:06:00:00:02' vr_mac='00:00:08:08:08:08' mac_action=1 vlan_id=0 #expecting to use unused vlans addr_family_ipv4=SAI_IP_ADDR_FAMILY_IPV4 tunnel_src_ip_addr='2.2.2.2' #src for outer ip encap_ip_addr='10.10.1.1' #egress enighbhor ingress_ip_addr='20.20.1.1' #ingress neighbor tunnel_ip_addr_route='1.1.1.0' #to reach tunnel nhop tunnel_ip_mask_route='255.255.255.0' ingress_nhop_ip_addr='20.20.1.1' egress_nhop_ip_addr='10.10.1.1' ip_addr_ingress_route='20.20.1.0' ip_mask_ingress_route='255.255.255.0' ip_addr_encap_route='10.10.1.0' ip_mask_encap_route='255.255.255.0' initiator_ip_addr='10.10.1.1' #tunnel dest ip(outer header) neighbor_mac_ingress='00:05:06:00:00:02' neighbor_mac_encap='00:05:06:00:00:00' #egress side ip_addr_decap_src='10.10.1.1' ip_addr_decap_dst='2.2.2.2' ######################################################################## #Creating Virtual router ####################################################################### vr_id=sai_thrift_create_virtual_router(self.client, 1, 1) #creating a underlay interface in loopback underlay_if = sai_thrift_create_router_interface(self.client, type=SAI_ROUTER_INTERFACE_TYPE_LOOPBACK, port_oid=0, vr_oid=vr_id, vlan_oid=vlan_id, v4_enabled=1, v6_enabled=1, mac='') #creating an overlay interface in loopback overlay_if = sai_thrift_create_router_interface(self.client, type=SAI_ROUTER_INTERFACE_TYPE_LOOPBACK, port_oid=0, vr_oid=vr_id, vlan_oid=vlan_id, v4_enabled=1, v6_enabled=1, mac='') #creating a tunnel tunnel_id=sai_thrift_create_tunnel(self.client, tunnel_type=SAI_TUNNEL_TYPE_IPINIP, addr_family=addr_family_ipv4, ip_addr=tunnel_src_ip_addr, underlay_if=underlay_if, overlay_if=overlay_if, encap_ttl_mode=SAI_TUNNEL_TTL_MODE_PIPE_MODEL, encap_dscp_mode=SAI_TUNNEL_DSCP_MODE_PIPE_MODEL, encap_dscp_val=50) ############################################################################## # Egress configurations # create router interface, # create neighbor # create route # ############################################################################## #encap router interface encap_if_id=sai_thrift_create_router_interface(self.client, vr_oid=vr_id, type=SAI_ROUTER_INTERFACE_TYPE_PORT, port_oid=port1, vlan_oid=vlan_id, v4_enabled = 1, v6_enabled = 1, mac='') #egress(encap side) neighbor (ip=10.10.1.1 , mac=00:05:06:00:00:00 ) sai_thrift_create_neighbor(self.client, addr_family=addr_family_ipv4, rif_id=encap_if_id, ip_addr=encap_ip_addr, dmac=neighbor_mac_encap) #egress(encap) nhop and route create sai_thrift_create_route(self.client, vr_id=vr_id, addr_family=addr_family_ipv4, ip_addr=ip_addr_encap_route, ip_mask=ip_mask_encap_route, nhop=encap_if_id) ############################################################################### # Ingress configurations # create router interface, # create neighbor # create nhop # create route # ############################################################################## #ingress router interface ingress_if_id=sai_thrift_create_router_interface(self.client,vr_oid=vr_id,type=SAI_ROUTER_INTERFACE_TYPE_PORT,port_oid=port2,vlan_oid=vlan_id,v4_enabled=1,v6_enabled = 1, mac='') #ingress neighbor neighbor (ip=20.20.1.1 , mac = 00:05:06:00:00:02) sai_thrift_create_neighbor(self.client, addr_family=addr_family_ipv4, rif_id=ingress_if_id, ip_addr=ingress_ip_addr, dmac=neighbor_mac_ingress) #adding tunnel and route initiator_id=sai_thrift_create_nhop(self.client, addr_family=addr_family_ipv4, ip_addr=initiator_ip_addr, rif_id=tunnel_id , is_tunnel=1) sai_thrift_create_route(self.client,vr_id=vr_id, addr_family=addr_family_ipv4, ip_addr=tunnel_ip_addr_route, ip_mask=tunnel_ip_mask_route, nhop=initiator_id) #Packet to be send pkt = simple_tcp_packet(eth_dst=router_mac, eth_src='00:00:00:00:00:01', ip_src='20.20.1.2', ip_dst='1.1.1.1', ip_id=1, ip_ttl=64) #expected packet inner IP header inner_hdr = simple_tcp_packet(eth_dst=router_mac, eth_src='00:00:00:00:00:01', ip_src='20.20.1.2', ip_dst='1.1.1.1', ip_id=1, ip_ttl=63) exp_pkt = simple_ipv4ip_packet(eth_dst='00:05:06:00:00:00', eth_src=router_mac, ip_dst='10.10.1.1', ip_src='2.2.2.2', ip_id=0,#mask the indentifier during check because it differs every time.better chech with wireshark ip_tos=0xc8, ip_ttl=63, inner_frame=inner_hdr['IP'] ) #masking packet m=Mask(exp_pkt) m.set_do_not_care_scapy(ptf.packet.IP, 'id') m.set_do_not_care_scapy(ptf.packet.IP, 'chksum') try: # in tuple: 0 is device number, 1 is port number # this tuple uniquely identifies a port send_packet(self, 1, pkt) verify_packets(self, m, [0]) finally: sai_thrift_remove_route(self.client,vr_id,addr_family_ipv4,tunnel_ip_addr_route,tunnel_ip_mask_route,initiator_id) self.client.sai_thrift_remove_next_hop(initiator_id) sai_thrift_remove_route(self.client,vr_id,addr_family_ipv4,ip_addr_encap_route,ip_mask_encap_route,encap_if_id) sai_thrift_remove_neighbor(self.client,addr_family_ipv4,rif_id=ingress_if_id,ip_addr=ingress_ip_addr,dmac=neighbor_mac_ingress) sai_thrift_remove_neighbor(self.client,addr_family_ipv4,rif_id=encap_if_id,ip_addr=encap_ip_addr,dmac=neighbor_mac_encap) self.client.sai_thrift_remove_router_interface(ingress_if_id) self.client.sai_thrift_remove_router_interface(encap_if_id) self.client.sai_thrift_remove_tunnel(tunnel_id) self.client.sai_thrift_remove_router_interface(underlay_if) self.client.sai_thrift_remove_router_interface(overlay_if) self.client.sai_thrift_remove_virtual_router(vr_id)
def runTest(self): print switch_init(self.client) port1 = port_list[0] port2 = port_list[1] port3 = port_list[2] mac3='00:00:00:00:00:33' mac2='00:00:00:00:00:22' monitor_port=port1 source_port=port2 mirror_type=SAI_MIRROR_TYPE_ENHANCED_REMOTE vlan=0x2 vlan_tpid=0x8100 vlan_pri=0x6 src_mac='00:00:00:00:11:22' dst_mac='00:00:00:00:11:33' encap_type=SAI_MIRROR_L3_GRE_TUNNEL ip_version=0x4 tos=0x3c ttl=0xf0 gre_type=0x88be src_ip='17.18.19.0' dst_ip='33.19.20.0' addr_family=0 sai_thrift_create_fdb(self.client, 3, mac3, port3, 1) sai_thrift_create_fdb(self.client, 3, mac2, port2, 1) # Put ports under test in VLAN 3 self.client.sai_thrift_create_vlan(3) vlan_member1 = sai_thrift_create_vlan_member(self.client, 3, port1, SAI_VLAN_PORT_TAGGED) vlan_member1a = sai_thrift_create_vlan_member(self.client, 1, port1, SAI_VLAN_PORT_TAGGED) vlan_member2 = sai_thrift_create_vlan_member(self.client, 3, port2, SAI_VLAN_PORT_TAGGED) vlan_member2a = sai_thrift_create_vlan_member(self.client, 1, port2, SAI_VLAN_PORT_TAGGED) vlan_member3 = sai_thrift_create_vlan_member(self.client, 3, port3, SAI_VLAN_PORT_TAGGED) vlan_member3a = sai_thrift_create_vlan_member(self.client, 1, port3, SAI_VLAN_PORT_TAGGED) # Remove ports from default VLAN self.client.sai_thrift_remove_vlan_member(vlan_member1a) self.client.sai_thrift_remove_vlan_member(vlan_member2a) self.client.sai_thrift_remove_vlan_member(vlan_member3a) # Set PVID attr_value = sai_thrift_attribute_value_t(u16=3) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_PORT_VLAN_ID, value=attr_value) self.client.sai_thrift_set_port_attribute(port1, attr) self.client.sai_thrift_set_port_attribute(port2, attr) self.client.sai_thrift_set_port_attribute(port3, attr) erspanid=sai_thrift_create_mirror_session(self.client,mirror_type=mirror_type,port=monitor_port,vlan=vlan,vlan_priority=vlan_pri,vlan_tpid=vlan_tpid,src_mac=src_mac,dst_mac=dst_mac,addr_family=addr_family,src_ip=src_ip,dst_ip=dst_ip,encap_type=encap_type,protocol=ip_version,ttl=ttl,tos=tos,gre_type=gre_type) #attrb_value = sai_thrift_attribute_value_t(oid=erspanid) attrb_value = sai_thrift_attribute_value_t(objlist=sai_thrift_object_list_t(count=1,object_id_list=[erspanid])) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_INGRESS_MIRROR_SESSION, value=attrb_value) self.client.sai_thrift_set_port_attribute(port2, attr) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_EGRESS_MIRROR_SESSION, value=attrb_value) self.client.sai_thrift_set_port_attribute(port2, attr) pkt = simple_tcp_packet(eth_dst='00:00:00:00:00:33', eth_src='00:22:22:22:22:22', ip_dst='10.0.0.1', dl_vlan_enable=True, vlan_vid=3, ip_id=101, ip_ttl=64) pkt2 = simple_tcp_packet(eth_dst='00:00:00:00:00:22', eth_src='00:33:33:33:33:33', dl_vlan_enable=True, vlan_vid=3, ip_dst='10.0.0.1', ip_id=101, ip_ttl=64) pkt3 = simple_tcp_packet(eth_dst='00:00:00:00:00:22', eth_src='00:33:33:33:33:33', dl_vlan_enable=True, vlan_vid=3, ip_dst='10.0.0.1', ip_id=101, ip_ttl=64) exp_pkt1= simple_gre_packet(pktlen=142, eth_dst='00:00:00:00:11:33', eth_src='00:00:00:00:11:22', dl_vlan_enable=True, vlan_vid=2, ip_id=0, ip_ttl=240, ip_tos=0x3c, ip_ihl=5, ip_src='17.18.19.0', ip_dst='33.19.20.0', inner_frame=pkt ) exp_pkt2= simple_gre_packet(pktlen=142, eth_dst='00:00:00:00:11:33', eth_src='00:00:00:00:11:22', dl_vlan_enable=True, vlan_vid=2, ip_id=0, ip_ttl=240, ip_tos=0x3c, ip_ihl=5, ip_src='17.18.19.0', ip_dst='33.19.20.0', inner_frame=pkt3 ) m1=Mask(exp_pkt1) m2=Mask(exp_pkt2) m1.set_do_not_care_scapy(ptf.packet.IP,'tos') m1.set_do_not_care_scapy(ptf.packet.IP,'frag') m1.set_do_not_care_scapy(ptf.packet.IP,'flags') m1.set_do_not_care_scapy(ptf.packet.IP,'chksum') m1.set_do_not_care_scapy(ptf.packet.GRE,'proto') m2.set_do_not_care_scapy(ptf.packet.IP,'tos') m2.set_do_not_care_scapy(ptf.packet.IP,'frag') m2.set_do_not_care_scapy(ptf.packet.IP,'flags') m2.set_do_not_care_scapy(ptf.packet.IP,'chksum') m2.set_do_not_care_scapy(ptf.packet.GRE,'proto') n=Mask(pkt2) n.set_do_not_care_scapy(ptf.packet.IP,'len') n.set_do_not_care_scapy(ptf.packet.IP,'chksum') try: # in tuple: 0 is device number, 2 is port number # this tuple uniquely identifies a port # for ingress mirroring print "Checking INGRESS ERSPAN Mirroring" print "Sending packet port 2 -> port 3 (00:22:22:22:22:22 -> 00:00:00:00:00:33)" send_packet(self, 1, pkt) verify_each_packet_on_each_port(self, [m1,pkt], ports=[0,2])#FIXME need to properly implement # for egress mirroring print "Checking EGRESS ERSPAN Mirroring" print "Sending packet port 3 -> port 2 (00:33:33:33:33:33 -> 00:00:00:00:00:22)" send_packet(self, 2, pkt2) verify_each_packet_on_each_port(self, [pkt2,m2], ports=[1,0])#FIXME need to properly implement finally: sai_thrift_delete_fdb(self.client, 3, mac2, port2) sai_thrift_delete_fdb(self.client, 3, mac3, port3) # Remove ports from mirror destination attrb_value = sai_thrift_attribute_value_t(objlist=sai_thrift_object_list_t(count=0,object_id_list=[erspanid])) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_INGRESS_MIRROR_SESSION, value=attrb_value) self.client.sai_thrift_set_port_attribute(port2, attr) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_EGRESS_MIRROR_SESSION, value=attrb_value) self.client.sai_thrift_set_port_attribute(port2, attr) # Now you can remove destination self.client.sai_thrift_remove_mirror_session(erspanid) # Remove ports from VLAN 3 self.client.sai_thrift_remove_vlan_member(vlan_member1) self.client.sai_thrift_remove_vlan_member(vlan_member2) self.client.sai_thrift_remove_vlan_member(vlan_member3) self.client.sai_thrift_delete_vlan(3) # Add ports back to default VLAN vlan_member1a = sai_thrift_create_vlan_member(self.client, 1, port1, SAI_VLAN_PORT_UNTAGGED) vlan_member2a = sai_thrift_create_vlan_member(self.client, 1, port2, SAI_VLAN_PORT_UNTAGGED) vlan_member3a = sai_thrift_create_vlan_member(self.client, 1, port3, SAI_VLAN_PORT_UNTAGGED) attr_value = sai_thrift_attribute_value_t(u16=1) attr = sai_thrift_attribute_t(id=SAI_PORT_ATTR_PORT_VLAN_ID, value=attr_value) self.client.sai_thrift_set_port_attribute(port1, attr) self.client.sai_thrift_set_port_attribute(port2, attr) self.client.sai_thrift_set_port_attribute(port3, attr)